projects/linux·blob v4.0 · refs

227 lines · 6.1 KiB

1/*
2 * net/switchdev/switchdev.c - Switch device API
3 * Copyright (c) 2014 Jiri Pirko <[email protected]>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 */
10
11#include <linux/kernel.h>
12#include <linux/types.h>
13#include <linux/init.h>
14#include <linux/mutex.h>
15#include <linux/notifier.h>
16#include <linux/netdevice.h>
17#include <net/switchdev.h>
18
19/**
20 * netdev_switch_parent_id_get - Get ID of a switch
21 * @dev: port device
22 * @psid: switch ID
23 *
24 * Get ID of a switch this port is part of.
25 */
26int netdev_switch_parent_id_get(struct net_device *dev,
27 struct netdev_phys_item_id *psid)
28{
29 const struct net_device_ops *ops = dev->netdev_ops;
30
31 if (!ops->ndo_switch_parent_id_get)
32 return -EOPNOTSUPP;
33 return ops->ndo_switch_parent_id_get(dev, psid);
34}
35EXPORT_SYMBOL(netdev_switch_parent_id_get);
36
37/**
38 * netdev_switch_port_stp_update - Notify switch device port of STP
39 * state change
40 * @dev: port device
41 * @state: port STP state
42 *
43 * Notify switch device port of bridge port STP state change.
44 */
45int netdev_switch_port_stp_update(struct net_device *dev, u8 state)
46{
47 const struct net_device_ops *ops = dev->netdev_ops;
48
49 if (!ops->ndo_switch_port_stp_update)
50 return -EOPNOTSUPP;
51 WARN_ON(!ops->ndo_switch_parent_id_get);
52 return ops->ndo_switch_port_stp_update(dev, state);
53}
54EXPORT_SYMBOL(netdev_switch_port_stp_update);
55
56static DEFINE_MUTEX(netdev_switch_mutex);
57static RAW_NOTIFIER_HEAD(netdev_switch_notif_chain);
58
59/**
60 * register_netdev_switch_notifier - Register nofifier
61 * @nb: notifier_block
62 *
63 * Register switch device notifier. This should be used by code
64 * which needs to monitor events happening in particular device.
65 * Return values are same as for atomic_notifier_chain_register().
66 */
67int register_netdev_switch_notifier(struct notifier_block *nb)
68{
69 int err;
70
71 mutex_lock(&netdev_switch_mutex);
72 err = raw_notifier_chain_register(&netdev_switch_notif_chain, nb);
73 mutex_unlock(&netdev_switch_mutex);
74 return err;
75}
76EXPORT_SYMBOL(register_netdev_switch_notifier);
77
78/**
79 * unregister_netdev_switch_notifier - Unregister nofifier
80 * @nb: notifier_block
81 *
82 * Unregister switch device notifier.
83 * Return values are same as for atomic_notifier_chain_unregister().
84 */
85int unregister_netdev_switch_notifier(struct notifier_block *nb)
86{
87 int err;
88
89 mutex_lock(&netdev_switch_mutex);
90 err = raw_notifier_chain_unregister(&netdev_switch_notif_chain, nb);
91 mutex_unlock(&netdev_switch_mutex);
92 return err;
93}
94EXPORT_SYMBOL(unregister_netdev_switch_notifier);
95
96/**
97 * call_netdev_switch_notifiers - Call nofifiers
98 * @val: value passed unmodified to notifier function
99 * @dev: port device
100 * @info: notifier information data
101 *
102 * Call all network notifier blocks. This should be called by driver
103 * when it needs to propagate hardware event.
104 * Return values are same as for atomic_notifier_call_chain().
105 */
106int call_netdev_switch_notifiers(unsigned long val, struct net_device *dev,
107 struct netdev_switch_notifier_info *info)
108{
109 int err;
110
111 info->dev = dev;
112 mutex_lock(&netdev_switch_mutex);
113 err = raw_notifier_call_chain(&netdev_switch_notif_chain, val, info);
114 mutex_unlock(&netdev_switch_mutex);
115 return err;
116}
117EXPORT_SYMBOL(call_netdev_switch_notifiers);
118
119/**
120 * netdev_switch_port_bridge_setlink - Notify switch device port of bridge
121 * port attributes
122 *
123 * @dev: port device
124 * @nlh: netlink msg with bridge port attributes
125 * @flags: bridge setlink flags
126 *
127 * Notify switch device port of bridge port attributes
128 */
129int netdev_switch_port_bridge_setlink(struct net_device *dev,
130 struct nlmsghdr *nlh, u16 flags)
131{
132 const struct net_device_ops *ops = dev->netdev_ops;
133
134 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
135 return 0;
136
137 if (!ops->ndo_bridge_setlink)
138 return -EOPNOTSUPP;
139
140 return ops->ndo_bridge_setlink(dev, nlh, flags);
141}
142EXPORT_SYMBOL(netdev_switch_port_bridge_setlink);
143
144/**
145 * netdev_switch_port_bridge_dellink - Notify switch device port of bridge
146 * port attribute delete
147 *
148 * @dev: port device
149 * @nlh: netlink msg with bridge port attributes
150 * @flags: bridge setlink flags
151 *
152 * Notify switch device port of bridge port attribute delete
153 */
154int netdev_switch_port_bridge_dellink(struct net_device *dev,
155 struct nlmsghdr *nlh, u16 flags)
156{
157 const struct net_device_ops *ops = dev->netdev_ops;
158
159 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
160 return 0;
161
162 if (!ops->ndo_bridge_dellink)
163 return -EOPNOTSUPP;
164
165 return ops->ndo_bridge_dellink(dev, nlh, flags);
166}
167EXPORT_SYMBOL(netdev_switch_port_bridge_dellink);
168
169/**
170 * ndo_dflt_netdev_switch_port_bridge_setlink - default ndo bridge setlink
171 * op for master devices
172 *
173 * @dev: port device
174 * @nlh: netlink msg with bridge port attributes
175 * @flags: bridge setlink flags
176 *
177 * Notify master device slaves of bridge port attributes
178 */
179int ndo_dflt_netdev_switch_port_bridge_setlink(struct net_device *dev,
180 struct nlmsghdr *nlh, u16 flags)
181{
182 struct net_device *lower_dev;
183 struct list_head *iter;
184 int ret = 0, err = 0;
185
186 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
187 return ret;
188
189 netdev_for_each_lower_dev(dev, lower_dev, iter) {
190 err = netdev_switch_port_bridge_setlink(lower_dev, nlh, flags);
191 if (err && err != -EOPNOTSUPP)
192 ret = err;
193 }
194
195 return ret;
196}
197EXPORT_SYMBOL(ndo_dflt_netdev_switch_port_bridge_setlink);
198
199/**
200 * ndo_dflt_netdev_switch_port_bridge_dellink - default ndo bridge dellink
201 * op for master devices
202 *
203 * @dev: port device
204 * @nlh: netlink msg with bridge port attributes
205 * @flags: bridge dellink flags
206 *
207 * Notify master device slaves of bridge port attribute deletes
208 */
209int ndo_dflt_netdev_switch_port_bridge_dellink(struct net_device *dev,
210 struct nlmsghdr *nlh, u16 flags)
211{
212 struct net_device *lower_dev;
213 struct list_head *iter;
214 int ret = 0, err = 0;
215
216 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
217 return ret;
218
219 netdev_for_each_lower_dev(dev, lower_dev, iter) {
220 err = netdev_switch_port_bridge_dellink(lower_dev, nlh, flags);
221 if (err && err != -EOPNOTSUPP)
222 ret = err;
223 }
224
225 return ret;
226}
227EXPORT_SYMBOL(ndo_dflt_netdev_switch_port_bridge_dellink);