2 * net/switchdev/switchdev.c - Switch device API
3 * Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us>
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.
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/ip_fib.h>
18 #include <net/switchdev.h>
21 * netdev_switch_parent_id_get - Get ID of a switch
25 * Get ID of a switch this port is part of.
27 int netdev_switch_parent_id_get(struct net_device *dev,
28 struct netdev_phys_item_id *psid)
30 const struct net_device_ops *ops = dev->netdev_ops;
32 if (!ops->ndo_switch_parent_id_get)
34 return ops->ndo_switch_parent_id_get(dev, psid);
36 EXPORT_SYMBOL_GPL(netdev_switch_parent_id_get);
39 * netdev_switch_port_stp_update - Notify switch device port of STP
42 * @state: port STP state
44 * Notify switch device port of bridge port STP state change.
46 int netdev_switch_port_stp_update(struct net_device *dev, u8 state)
48 const struct net_device_ops *ops = dev->netdev_ops;
50 if (!ops->ndo_switch_port_stp_update)
52 WARN_ON(!ops->ndo_switch_parent_id_get);
53 return ops->ndo_switch_port_stp_update(dev, state);
55 EXPORT_SYMBOL_GPL(netdev_switch_port_stp_update);
57 static DEFINE_MUTEX(netdev_switch_mutex);
58 static RAW_NOTIFIER_HEAD(netdev_switch_notif_chain);
61 * register_netdev_switch_notifier - Register nofifier
64 * Register switch device notifier. This should be used by code
65 * which needs to monitor events happening in particular device.
66 * Return values are same as for atomic_notifier_chain_register().
68 int register_netdev_switch_notifier(struct notifier_block *nb)
72 mutex_lock(&netdev_switch_mutex);
73 err = raw_notifier_chain_register(&netdev_switch_notif_chain, nb);
74 mutex_unlock(&netdev_switch_mutex);
77 EXPORT_SYMBOL_GPL(register_netdev_switch_notifier);
80 * unregister_netdev_switch_notifier - Unregister nofifier
83 * Unregister switch device notifier.
84 * Return values are same as for atomic_notifier_chain_unregister().
86 int unregister_netdev_switch_notifier(struct notifier_block *nb)
90 mutex_lock(&netdev_switch_mutex);
91 err = raw_notifier_chain_unregister(&netdev_switch_notif_chain, nb);
92 mutex_unlock(&netdev_switch_mutex);
95 EXPORT_SYMBOL_GPL(unregister_netdev_switch_notifier);
98 * call_netdev_switch_notifiers - Call nofifiers
99 * @val: value passed unmodified to notifier function
101 * @info: notifier information data
103 * Call all network notifier blocks. This should be called by driver
104 * when it needs to propagate hardware event.
105 * Return values are same as for atomic_notifier_call_chain().
107 int call_netdev_switch_notifiers(unsigned long val, struct net_device *dev,
108 struct netdev_switch_notifier_info *info)
113 mutex_lock(&netdev_switch_mutex);
114 err = raw_notifier_call_chain(&netdev_switch_notif_chain, val, info);
115 mutex_unlock(&netdev_switch_mutex);
118 EXPORT_SYMBOL_GPL(call_netdev_switch_notifiers);
121 * netdev_switch_port_bridge_setlink - Notify switch device port of bridge
125 * @nlh: netlink msg with bridge port attributes
126 * @flags: bridge setlink flags
128 * Notify switch device port of bridge port attributes
130 int netdev_switch_port_bridge_setlink(struct net_device *dev,
131 struct nlmsghdr *nlh, u16 flags)
133 const struct net_device_ops *ops = dev->netdev_ops;
135 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
138 if (!ops->ndo_bridge_setlink)
141 return ops->ndo_bridge_setlink(dev, nlh, flags);
143 EXPORT_SYMBOL_GPL(netdev_switch_port_bridge_setlink);
146 * netdev_switch_port_bridge_dellink - Notify switch device port of bridge
147 * port attribute delete
150 * @nlh: netlink msg with bridge port attributes
151 * @flags: bridge setlink flags
153 * Notify switch device port of bridge port attribute delete
155 int netdev_switch_port_bridge_dellink(struct net_device *dev,
156 struct nlmsghdr *nlh, u16 flags)
158 const struct net_device_ops *ops = dev->netdev_ops;
160 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
163 if (!ops->ndo_bridge_dellink)
166 return ops->ndo_bridge_dellink(dev, nlh, flags);
168 EXPORT_SYMBOL_GPL(netdev_switch_port_bridge_dellink);
171 * ndo_dflt_netdev_switch_port_bridge_setlink - default ndo bridge setlink
172 * op for master devices
175 * @nlh: netlink msg with bridge port attributes
176 * @flags: bridge setlink flags
178 * Notify master device slaves of bridge port attributes
180 int ndo_dflt_netdev_switch_port_bridge_setlink(struct net_device *dev,
181 struct nlmsghdr *nlh, u16 flags)
183 struct net_device *lower_dev;
184 struct list_head *iter;
185 int ret = 0, err = 0;
187 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
190 netdev_for_each_lower_dev(dev, lower_dev, iter) {
191 err = netdev_switch_port_bridge_setlink(lower_dev, nlh, flags);
192 if (err && err != -EOPNOTSUPP)
198 EXPORT_SYMBOL_GPL(ndo_dflt_netdev_switch_port_bridge_setlink);
201 * ndo_dflt_netdev_switch_port_bridge_dellink - default ndo bridge dellink
202 * op for master devices
205 * @nlh: netlink msg with bridge port attributes
206 * @flags: bridge dellink flags
208 * Notify master device slaves of bridge port attribute deletes
210 int ndo_dflt_netdev_switch_port_bridge_dellink(struct net_device *dev,
211 struct nlmsghdr *nlh, u16 flags)
213 struct net_device *lower_dev;
214 struct list_head *iter;
215 int ret = 0, err = 0;
217 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
220 netdev_for_each_lower_dev(dev, lower_dev, iter) {
221 err = netdev_switch_port_bridge_dellink(lower_dev, nlh, flags);
222 if (err && err != -EOPNOTSUPP)
228 EXPORT_SYMBOL_GPL(ndo_dflt_netdev_switch_port_bridge_dellink);
230 static struct net_device *netdev_switch_get_lowest_dev(struct net_device *dev)
232 const struct net_device_ops *ops = dev->netdev_ops;
233 struct net_device *lower_dev;
234 struct net_device *port_dev;
235 struct list_head *iter;
237 /* Recusively search down until we find a sw port dev.
238 * (A sw port dev supports ndo_switch_parent_id_get).
241 if (dev->features & NETIF_F_HW_SWITCH_OFFLOAD &&
242 ops->ndo_switch_parent_id_get)
245 netdev_for_each_lower_dev(dev, lower_dev, iter) {
246 port_dev = netdev_switch_get_lowest_dev(lower_dev);
254 static struct net_device *netdev_switch_get_dev_by_nhs(struct fib_info *fi)
256 struct netdev_phys_item_id psid;
257 struct netdev_phys_item_id prev_psid;
258 struct net_device *dev = NULL;
261 /* For this route, all nexthop devs must be on the same switch. */
263 for (nhsel = 0; nhsel < fi->fib_nhs; nhsel++) {
264 const struct fib_nh *nh = &fi->fib_nh[nhsel];
269 dev = netdev_switch_get_lowest_dev(nh->nh_dev);
273 if (netdev_switch_parent_id_get(dev, &psid))
277 if (prev_psid.id_len != psid.id_len)
279 if (memcmp(prev_psid.id, psid.id, psid.id_len))
290 * netdev_switch_fib_ipv4_add - Add IPv4 route entry to switch
292 * @dst: route's IPv4 destination address
293 * @dst_len: destination address length (prefix length)
294 * @fi: route FIB info structure
297 * @tb_id: route table ID
299 * Add IPv4 route entry to switch device.
301 int netdev_switch_fib_ipv4_add(u32 dst, int dst_len, struct fib_info *fi,
302 u8 tos, u8 type, u32 tb_id)
304 struct net_device *dev;
305 const struct net_device_ops *ops;
308 /* Don't offload route if using custom ip rules or if
309 * IPv4 FIB offloading has been disabled completely.
312 #ifdef CONFIG_IP_MULTIPLE_TABLES
313 if (fi->fib_net->ipv4.fib_has_custom_rules)
317 if (fi->fib_net->ipv4.fib_offload_disabled)
320 dev = netdev_switch_get_dev_by_nhs(fi);
323 ops = dev->netdev_ops;
325 if (ops->ndo_switch_fib_ipv4_add) {
326 err = ops->ndo_switch_fib_ipv4_add(dev, htonl(dst), dst_len,
327 fi, tos, type, tb_id);
329 fi->fib_flags |= RTNH_F_EXTERNAL;
334 EXPORT_SYMBOL_GPL(netdev_switch_fib_ipv4_add);
337 * netdev_switch_fib_ipv4_del - Delete IPv4 route entry from switch
339 * @dst: route's IPv4 destination address
340 * @dst_len: destination address length (prefix length)
341 * @fi: route FIB info structure
344 * @tb_id: route table ID
346 * Delete IPv4 route entry from switch device.
348 int netdev_switch_fib_ipv4_del(u32 dst, int dst_len, struct fib_info *fi,
349 u8 tos, u8 type, u32 tb_id)
351 struct net_device *dev;
352 const struct net_device_ops *ops;
355 if (!(fi->fib_flags & RTNH_F_EXTERNAL))
358 dev = netdev_switch_get_dev_by_nhs(fi);
361 ops = dev->netdev_ops;
363 if (ops->ndo_switch_fib_ipv4_del) {
364 err = ops->ndo_switch_fib_ipv4_del(dev, htonl(dst), dst_len,
365 fi, tos, type, tb_id);
367 fi->fib_flags &= ~RTNH_F_EXTERNAL;
372 EXPORT_SYMBOL_GPL(netdev_switch_fib_ipv4_del);
375 * netdev_switch_fib_ipv4_abort - Abort an IPv4 FIB operation
377 * @fi: route FIB info structure
379 void netdev_switch_fib_ipv4_abort(struct fib_info *fi)
381 /* There was a problem installing this route to the offload
382 * device. For now, until we come up with more refined
383 * policy handling, abruptly end IPv4 fib offloading for
384 * for entire net by flushing offload device(s) of all
385 * IPv4 routes, and mark IPv4 fib offloading broken from
386 * this point forward.
389 fib_flush_external(fi->fib_net);
390 fi->fib_net->ipv4.fib_offload_disabled = true;
392 EXPORT_SYMBOL_GPL(netdev_switch_fib_ipv4_abort);