aboutsummaryrefslogtreecommitdiffstats
path: root/net/switchdev/switchdev.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/switchdev/switchdev.c')
-rw-r--r--net/switchdev/switchdev.c1022
1 files changed, 918 insertions, 104 deletions
diff --git a/net/switchdev/switchdev.c b/net/switchdev/switchdev.c
index 8c1e558db118..84f77a054025 100644
--- a/net/switchdev/switchdev.c
+++ b/net/switchdev/switchdev.c
@@ -1,6 +1,7 @@
1/* 1/*
2 * net/switchdev/switchdev.c - Switch device API 2 * net/switchdev/switchdev.c - Switch device API
3 * Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us> 3 * Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us>
4 * Copyright (c) 2014-2015 Scott Feldman <sfeldma@gmail.com>
4 * 5 *
5 * This program is free software; you can redistribute it and/or modify 6 * 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 * it under the terms of the GNU General Public License as published by
@@ -14,87 +15,362 @@
14#include <linux/mutex.h> 15#include <linux/mutex.h>
15#include <linux/notifier.h> 16#include <linux/notifier.h>
16#include <linux/netdevice.h> 17#include <linux/netdevice.h>
18#include <linux/if_bridge.h>
19#include <net/ip_fib.h>
17#include <net/switchdev.h> 20#include <net/switchdev.h>
18 21
19/** 22/**
20 * netdev_switch_parent_id_get - Get ID of a switch 23 * switchdev_port_attr_get - Get port attribute
24 *
25 * @dev: port device
26 * @attr: attribute to get
27 */
28int switchdev_port_attr_get(struct net_device *dev, struct switchdev_attr *attr)
29{
30 const struct switchdev_ops *ops = dev->switchdev_ops;
31 struct net_device *lower_dev;
32 struct list_head *iter;
33 struct switchdev_attr first = {
34 .id = SWITCHDEV_ATTR_UNDEFINED
35 };
36 int err = -EOPNOTSUPP;
37
38 if (ops && ops->switchdev_port_attr_get)
39 return ops->switchdev_port_attr_get(dev, attr);
40
41 if (attr->flags & SWITCHDEV_F_NO_RECURSE)
42 return err;
43
44 /* Switch device port(s) may be stacked under
45 * bond/team/vlan dev, so recurse down to get attr on
46 * each port. Return -ENODATA if attr values don't
47 * compare across ports.
48 */
49
50 netdev_for_each_lower_dev(dev, lower_dev, iter) {
51 err = switchdev_port_attr_get(lower_dev, attr);
52 if (err)
53 break;
54 if (first.id == SWITCHDEV_ATTR_UNDEFINED)
55 first = *attr;
56 else if (memcmp(&first, attr, sizeof(*attr)))
57 return -ENODATA;
58 }
59
60 return err;
61}
62EXPORT_SYMBOL_GPL(switchdev_port_attr_get);
63
64static int __switchdev_port_attr_set(struct net_device *dev,
65 struct switchdev_attr *attr)
66{
67 const struct switchdev_ops *ops = dev->switchdev_ops;
68 struct net_device *lower_dev;
69 struct list_head *iter;
70 int err = -EOPNOTSUPP;
71
72 if (ops && ops->switchdev_port_attr_set)
73 return ops->switchdev_port_attr_set(dev, attr);
74
75 if (attr->flags & SWITCHDEV_F_NO_RECURSE)
76 return err;
77
78 /* Switch device port(s) may be stacked under
79 * bond/team/vlan dev, so recurse down to set attr on
80 * each port.
81 */
82
83 netdev_for_each_lower_dev(dev, lower_dev, iter) {
84 err = __switchdev_port_attr_set(lower_dev, attr);
85 if (err)
86 break;
87 }
88
89 return err;
90}
91
92struct switchdev_attr_set_work {
93 struct work_struct work;
94 struct net_device *dev;
95 struct switchdev_attr attr;
96};
97
98static void switchdev_port_attr_set_work(struct work_struct *work)
99{
100 struct switchdev_attr_set_work *asw =
101 container_of(work, struct switchdev_attr_set_work, work);
102 int err;
103
104 rtnl_lock();
105 err = switchdev_port_attr_set(asw->dev, &asw->attr);
106 if (err && err != -EOPNOTSUPP)
107 netdev_err(asw->dev, "failed (err=%d) to set attribute (id=%d)\n",
108 err, asw->attr.id);
109 rtnl_unlock();
110
111 dev_put(asw->dev);
112 kfree(work);
113}
114
115static int switchdev_port_attr_set_defer(struct net_device *dev,
116 struct switchdev_attr *attr)
117{
118 struct switchdev_attr_set_work *asw;
119
120 asw = kmalloc(sizeof(*asw), GFP_ATOMIC);
121 if (!asw)
122 return -ENOMEM;
123
124 INIT_WORK(&asw->work, switchdev_port_attr_set_work);
125
126 dev_hold(dev);
127 asw->dev = dev;
128 memcpy(&asw->attr, attr, sizeof(asw->attr));
129
130 schedule_work(&asw->work);
131
132 return 0;
133}
134
135/**
136 * switchdev_port_attr_set - Set port attribute
137 *
138 * @dev: port device
139 * @attr: attribute to set
140 *
141 * Use a 2-phase prepare-commit transaction model to ensure
142 * system is not left in a partially updated state due to
143 * failure from driver/device.
144 */
145int switchdev_port_attr_set(struct net_device *dev, struct switchdev_attr *attr)
146{
147 int err;
148
149 if (!rtnl_is_locked()) {
150 /* Running prepare-commit transaction across stacked
151 * devices requires nothing moves, so if rtnl_lock is
152 * not held, schedule a worker thread to hold rtnl_lock
153 * while setting attr.
154 */
155
156 return switchdev_port_attr_set_defer(dev, attr);
157 }
158
159 /* Phase I: prepare for attr set. Driver/device should fail
160 * here if there are going to be issues in the commit phase,
161 * such as lack of resources or support. The driver/device
162 * should reserve resources needed for the commit phase here,
163 * but should not commit the attr.
164 */
165
166 attr->trans = SWITCHDEV_TRANS_PREPARE;
167 err = __switchdev_port_attr_set(dev, attr);
168 if (err) {
169 /* Prepare phase failed: abort the transaction. Any
170 * resources reserved in the prepare phase are
171 * released.
172 */
173
174 attr->trans = SWITCHDEV_TRANS_ABORT;
175 __switchdev_port_attr_set(dev, attr);
176
177 return err;
178 }
179
180 /* Phase II: commit attr set. This cannot fail as a fault
181 * of driver/device. If it does, it's a bug in the driver/device
182 * because the driver said everythings was OK in phase I.
183 */
184
185 attr->trans = SWITCHDEV_TRANS_COMMIT;
186 err = __switchdev_port_attr_set(dev, attr);
187 WARN(err, "%s: Commit of attribute (id=%d) failed.\n",
188 dev->name, attr->id);
189
190 return err;
191}
192EXPORT_SYMBOL_GPL(switchdev_port_attr_set);
193
194static int __switchdev_port_obj_add(struct net_device *dev,
195 struct switchdev_obj *obj)
196{
197 const struct switchdev_ops *ops = dev->switchdev_ops;
198 struct net_device *lower_dev;
199 struct list_head *iter;
200 int err = -EOPNOTSUPP;
201
202 if (ops && ops->switchdev_port_obj_add)
203 return ops->switchdev_port_obj_add(dev, obj);
204
205 /* Switch device port(s) may be stacked under
206 * bond/team/vlan dev, so recurse down to add object on
207 * each port.
208 */
209
210 netdev_for_each_lower_dev(dev, lower_dev, iter) {
211 err = __switchdev_port_obj_add(lower_dev, obj);
212 if (err)
213 break;
214 }
215
216 return err;
217}
218
219/**
220 * switchdev_port_obj_add - Add port object
221 *
21 * @dev: port device 222 * @dev: port device
22 * @psid: switch ID 223 * @obj: object to add
23 * 224 *
24 * Get ID of a switch this port is part of. 225 * Use a 2-phase prepare-commit transaction model to ensure
226 * system is not left in a partially updated state due to
227 * failure from driver/device.
228 *
229 * rtnl_lock must be held.
25 */ 230 */
26int netdev_switch_parent_id_get(struct net_device *dev, 231int switchdev_port_obj_add(struct net_device *dev, struct switchdev_obj *obj)
27 struct netdev_phys_item_id *psid)
28{ 232{
29 const struct net_device_ops *ops = dev->netdev_ops; 233 int err;
234
235 ASSERT_RTNL();
236
237 /* Phase I: prepare for obj add. Driver/device should fail
238 * here if there are going to be issues in the commit phase,
239 * such as lack of resources or support. The driver/device
240 * should reserve resources needed for the commit phase here,
241 * but should not commit the obj.
242 */
243
244 obj->trans = SWITCHDEV_TRANS_PREPARE;
245 err = __switchdev_port_obj_add(dev, obj);
246 if (err) {
247 /* Prepare phase failed: abort the transaction. Any
248 * resources reserved in the prepare phase are
249 * released.
250 */
251
252 obj->trans = SWITCHDEV_TRANS_ABORT;
253 __switchdev_port_obj_add(dev, obj);
254
255 return err;
256 }
30 257
31 if (!ops->ndo_switch_parent_id_get) 258 /* Phase II: commit obj add. This cannot fail as a fault
32 return -EOPNOTSUPP; 259 * of driver/device. If it does, it's a bug in the driver/device
33 return ops->ndo_switch_parent_id_get(dev, psid); 260 * because the driver said everythings was OK in phase I.
261 */
262
263 obj->trans = SWITCHDEV_TRANS_COMMIT;
264 err = __switchdev_port_obj_add(dev, obj);
265 WARN(err, "%s: Commit of object (id=%d) failed.\n", dev->name, obj->id);
266
267 return err;
34} 268}
35EXPORT_SYMBOL(netdev_switch_parent_id_get); 269EXPORT_SYMBOL_GPL(switchdev_port_obj_add);
36 270
37/** 271/**
38 * netdev_switch_port_stp_update - Notify switch device port of STP 272 * switchdev_port_obj_del - Delete port object
39 * state change 273 *
40 * @dev: port device 274 * @dev: port device
41 * @state: port STP state 275 * @obj: object to delete
276 */
277int switchdev_port_obj_del(struct net_device *dev, struct switchdev_obj *obj)
278{
279 const struct switchdev_ops *ops = dev->switchdev_ops;
280 struct net_device *lower_dev;
281 struct list_head *iter;
282 int err = -EOPNOTSUPP;
283
284 if (ops && ops->switchdev_port_obj_del)
285 return ops->switchdev_port_obj_del(dev, obj);
286
287 /* Switch device port(s) may be stacked under
288 * bond/team/vlan dev, so recurse down to delete object on
289 * each port.
290 */
291
292 netdev_for_each_lower_dev(dev, lower_dev, iter) {
293 err = switchdev_port_obj_del(lower_dev, obj);
294 if (err)
295 break;
296 }
297
298 return err;
299}
300EXPORT_SYMBOL_GPL(switchdev_port_obj_del);
301
302/**
303 * switchdev_port_obj_dump - Dump port objects
42 * 304 *
43 * Notify switch device port of bridge port STP state change. 305 * @dev: port device
306 * @obj: object to dump
44 */ 307 */
45int netdev_switch_port_stp_update(struct net_device *dev, u8 state) 308int switchdev_port_obj_dump(struct net_device *dev, struct switchdev_obj *obj)
46{ 309{
47 const struct net_device_ops *ops = dev->netdev_ops; 310 const struct switchdev_ops *ops = dev->switchdev_ops;
311 struct net_device *lower_dev;
312 struct list_head *iter;
313 int err = -EOPNOTSUPP;
314
315 if (ops && ops->switchdev_port_obj_dump)
316 return ops->switchdev_port_obj_dump(dev, obj);
48 317
49 if (!ops->ndo_switch_port_stp_update) 318 /* Switch device port(s) may be stacked under
50 return -EOPNOTSUPP; 319 * bond/team/vlan dev, so recurse down to dump objects on
51 WARN_ON(!ops->ndo_switch_parent_id_get); 320 * first port at bottom of stack.
52 return ops->ndo_switch_port_stp_update(dev, state); 321 */
322
323 netdev_for_each_lower_dev(dev, lower_dev, iter) {
324 err = switchdev_port_obj_dump(lower_dev, obj);
325 break;
326 }
327
328 return err;
53} 329}
54EXPORT_SYMBOL(netdev_switch_port_stp_update); 330EXPORT_SYMBOL_GPL(switchdev_port_obj_dump);
55 331
56static DEFINE_MUTEX(netdev_switch_mutex); 332static DEFINE_MUTEX(switchdev_mutex);
57static RAW_NOTIFIER_HEAD(netdev_switch_notif_chain); 333static RAW_NOTIFIER_HEAD(switchdev_notif_chain);
58 334
59/** 335/**
60 * register_netdev_switch_notifier - Register nofifier 336 * register_switchdev_notifier - Register notifier
61 * @nb: notifier_block 337 * @nb: notifier_block
62 * 338 *
63 * Register switch device notifier. This should be used by code 339 * Register switch device notifier. This should be used by code
64 * which needs to monitor events happening in particular device. 340 * which needs to monitor events happening in particular device.
65 * Return values are same as for atomic_notifier_chain_register(). 341 * Return values are same as for atomic_notifier_chain_register().
66 */ 342 */
67int register_netdev_switch_notifier(struct notifier_block *nb) 343int register_switchdev_notifier(struct notifier_block *nb)
68{ 344{
69 int err; 345 int err;
70 346
71 mutex_lock(&netdev_switch_mutex); 347 mutex_lock(&switchdev_mutex);
72 err = raw_notifier_chain_register(&netdev_switch_notif_chain, nb); 348 err = raw_notifier_chain_register(&switchdev_notif_chain, nb);
73 mutex_unlock(&netdev_switch_mutex); 349 mutex_unlock(&switchdev_mutex);
74 return err; 350 return err;
75} 351}
76EXPORT_SYMBOL(register_netdev_switch_notifier); 352EXPORT_SYMBOL_GPL(register_switchdev_notifier);
77 353
78/** 354/**
79 * unregister_netdev_switch_notifier - Unregister nofifier 355 * unregister_switchdev_notifier - Unregister notifier
80 * @nb: notifier_block 356 * @nb: notifier_block
81 * 357 *
82 * Unregister switch device notifier. 358 * Unregister switch device notifier.
83 * Return values are same as for atomic_notifier_chain_unregister(). 359 * Return values are same as for atomic_notifier_chain_unregister().
84 */ 360 */
85int unregister_netdev_switch_notifier(struct notifier_block *nb) 361int unregister_switchdev_notifier(struct notifier_block *nb)
86{ 362{
87 int err; 363 int err;
88 364
89 mutex_lock(&netdev_switch_mutex); 365 mutex_lock(&switchdev_mutex);
90 err = raw_notifier_chain_unregister(&netdev_switch_notif_chain, nb); 366 err = raw_notifier_chain_unregister(&switchdev_notif_chain, nb);
91 mutex_unlock(&netdev_switch_mutex); 367 mutex_unlock(&switchdev_mutex);
92 return err; 368 return err;
93} 369}
94EXPORT_SYMBOL(unregister_netdev_switch_notifier); 370EXPORT_SYMBOL_GPL(unregister_switchdev_notifier);
95 371
96/** 372/**
97 * call_netdev_switch_notifiers - Call nofifiers 373 * call_switchdev_notifiers - Call notifiers
98 * @val: value passed unmodified to notifier function 374 * @val: value passed unmodified to notifier function
99 * @dev: port device 375 * @dev: port device
100 * @info: notifier information data 376 * @info: notifier information data
@@ -103,125 +379,663 @@ EXPORT_SYMBOL(unregister_netdev_switch_notifier);
103 * when it needs to propagate hardware event. 379 * when it needs to propagate hardware event.
104 * Return values are same as for atomic_notifier_call_chain(). 380 * Return values are same as for atomic_notifier_call_chain().
105 */ 381 */
106int call_netdev_switch_notifiers(unsigned long val, struct net_device *dev, 382int call_switchdev_notifiers(unsigned long val, struct net_device *dev,
107 struct netdev_switch_notifier_info *info) 383 struct switchdev_notifier_info *info)
108{ 384{
109 int err; 385 int err;
110 386
111 info->dev = dev; 387 info->dev = dev;
112 mutex_lock(&netdev_switch_mutex); 388 mutex_lock(&switchdev_mutex);
113 err = raw_notifier_call_chain(&netdev_switch_notif_chain, val, info); 389 err = raw_notifier_call_chain(&switchdev_notif_chain, val, info);
114 mutex_unlock(&netdev_switch_mutex); 390 mutex_unlock(&switchdev_mutex);
391 return err;
392}
393EXPORT_SYMBOL_GPL(call_switchdev_notifiers);
394
395struct switchdev_vlan_dump {
396 struct switchdev_obj obj;
397 struct sk_buff *skb;
398 u32 filter_mask;
399 u16 flags;
400 u16 begin;
401 u16 end;
402};
403
404static int switchdev_port_vlan_dump_put(struct net_device *dev,
405 struct switchdev_vlan_dump *dump)
406{
407 struct bridge_vlan_info vinfo;
408
409 vinfo.flags = dump->flags;
410
411 if (dump->begin == 0 && dump->end == 0) {
412 return 0;
413 } else if (dump->begin == dump->end) {
414 vinfo.vid = dump->begin;
415 if (nla_put(dump->skb, IFLA_BRIDGE_VLAN_INFO,
416 sizeof(vinfo), &vinfo))
417 return -EMSGSIZE;
418 } else {
419 vinfo.vid = dump->begin;
420 vinfo.flags |= BRIDGE_VLAN_INFO_RANGE_BEGIN;
421 if (nla_put(dump->skb, IFLA_BRIDGE_VLAN_INFO,
422 sizeof(vinfo), &vinfo))
423 return -EMSGSIZE;
424 vinfo.vid = dump->end;
425 vinfo.flags &= ~BRIDGE_VLAN_INFO_RANGE_BEGIN;
426 vinfo.flags |= BRIDGE_VLAN_INFO_RANGE_END;
427 if (nla_put(dump->skb, IFLA_BRIDGE_VLAN_INFO,
428 sizeof(vinfo), &vinfo))
429 return -EMSGSIZE;
430 }
431
432 return 0;
433}
434
435static int switchdev_port_vlan_dump_cb(struct net_device *dev,
436 struct switchdev_obj *obj)
437{
438 struct switchdev_vlan_dump *dump =
439 container_of(obj, struct switchdev_vlan_dump, obj);
440 struct switchdev_obj_vlan *vlan = &dump->obj.u.vlan;
441 int err = 0;
442
443 if (vlan->vid_begin > vlan->vid_end)
444 return -EINVAL;
445
446 if (dump->filter_mask & RTEXT_FILTER_BRVLAN) {
447 dump->flags = vlan->flags;
448 for (dump->begin = dump->end = vlan->vid_begin;
449 dump->begin <= vlan->vid_end;
450 dump->begin++, dump->end++) {
451 err = switchdev_port_vlan_dump_put(dev, dump);
452 if (err)
453 return err;
454 }
455 } else if (dump->filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED) {
456 if (dump->begin > vlan->vid_begin &&
457 dump->begin >= vlan->vid_end) {
458 if ((dump->begin - 1) == vlan->vid_end &&
459 dump->flags == vlan->flags) {
460 /* prepend */
461 dump->begin = vlan->vid_begin;
462 } else {
463 err = switchdev_port_vlan_dump_put(dev, dump);
464 dump->flags = vlan->flags;
465 dump->begin = vlan->vid_begin;
466 dump->end = vlan->vid_end;
467 }
468 } else if (dump->end <= vlan->vid_begin &&
469 dump->end < vlan->vid_end) {
470 if ((dump->end + 1) == vlan->vid_begin &&
471 dump->flags == vlan->flags) {
472 /* append */
473 dump->end = vlan->vid_end;
474 } else {
475 err = switchdev_port_vlan_dump_put(dev, dump);
476 dump->flags = vlan->flags;
477 dump->begin = vlan->vid_begin;
478 dump->end = vlan->vid_end;
479 }
480 } else {
481 err = -EINVAL;
482 }
483 }
484
115 return err; 485 return err;
116} 486}
117EXPORT_SYMBOL(call_netdev_switch_notifiers); 487
488static int switchdev_port_vlan_fill(struct sk_buff *skb, struct net_device *dev,
489 u32 filter_mask)
490{
491 struct switchdev_vlan_dump dump = {
492 .obj = {
493 .id = SWITCHDEV_OBJ_PORT_VLAN,
494 .cb = switchdev_port_vlan_dump_cb,
495 },
496 .skb = skb,
497 .filter_mask = filter_mask,
498 };
499 int err = 0;
500
501 if ((filter_mask & RTEXT_FILTER_BRVLAN) ||
502 (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)) {
503 err = switchdev_port_obj_dump(dev, &dump.obj);
504 if (err)
505 goto err_out;
506 if (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)
507 /* last one */
508 err = switchdev_port_vlan_dump_put(dev, &dump);
509 }
510
511err_out:
512 return err == -EOPNOTSUPP ? 0 : err;
513}
118 514
119/** 515/**
120 * netdev_switch_port_bridge_setlink - Notify switch device port of bridge 516 * switchdev_port_bridge_getlink - Get bridge port attributes
121 * port attributes
122 * 517 *
123 * @dev: port device 518 * @dev: port device
124 * @nlh: netlink msg with bridge port attributes
125 * @flags: bridge setlink flags
126 * 519 *
127 * Notify switch device port of bridge port attributes 520 * Called for SELF on rtnl_bridge_getlink to get bridge port
521 * attributes.
128 */ 522 */
129int netdev_switch_port_bridge_setlink(struct net_device *dev, 523int switchdev_port_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
130 struct nlmsghdr *nlh, u16 flags) 524 struct net_device *dev, u32 filter_mask,
525 int nlflags)
131{ 526{
132 const struct net_device_ops *ops = dev->netdev_ops; 527 struct switchdev_attr attr = {
528 .id = SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS,
529 };
530 u16 mode = BRIDGE_MODE_UNDEF;
531 u32 mask = BR_LEARNING | BR_LEARNING_SYNC;
532 int err;
133 533
134 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD)) 534 err = switchdev_port_attr_get(dev, &attr);
135 return 0; 535 if (err && err != -EOPNOTSUPP)
536 return err;
537
538 return ndo_dflt_bridge_getlink(skb, pid, seq, dev, mode,
539 attr.u.brport_flags, mask, nlflags,
540 filter_mask, switchdev_port_vlan_fill);
541}
542EXPORT_SYMBOL_GPL(switchdev_port_bridge_getlink);
543
544static int switchdev_port_br_setflag(struct net_device *dev,
545 struct nlattr *nlattr,
546 unsigned long brport_flag)
547{
548 struct switchdev_attr attr = {
549 .id = SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS,
550 };
551 u8 flag = nla_get_u8(nlattr);
552 int err;
553
554 err = switchdev_port_attr_get(dev, &attr);
555 if (err)
556 return err;
557
558 if (flag)
559 attr.u.brport_flags |= brport_flag;
560 else
561 attr.u.brport_flags &= ~brport_flag;
562
563 return switchdev_port_attr_set(dev, &attr);
564}
565
566static const struct nla_policy
567switchdev_port_bridge_policy[IFLA_BRPORT_MAX + 1] = {
568 [IFLA_BRPORT_STATE] = { .type = NLA_U8 },
569 [IFLA_BRPORT_COST] = { .type = NLA_U32 },
570 [IFLA_BRPORT_PRIORITY] = { .type = NLA_U16 },
571 [IFLA_BRPORT_MODE] = { .type = NLA_U8 },
572 [IFLA_BRPORT_GUARD] = { .type = NLA_U8 },
573 [IFLA_BRPORT_PROTECT] = { .type = NLA_U8 },
574 [IFLA_BRPORT_FAST_LEAVE] = { .type = NLA_U8 },
575 [IFLA_BRPORT_LEARNING] = { .type = NLA_U8 },
576 [IFLA_BRPORT_LEARNING_SYNC] = { .type = NLA_U8 },
577 [IFLA_BRPORT_UNICAST_FLOOD] = { .type = NLA_U8 },
578};
579
580static int switchdev_port_br_setlink_protinfo(struct net_device *dev,
581 struct nlattr *protinfo)
582{
583 struct nlattr *attr;
584 int rem;
585 int err;
136 586
137 if (!ops->ndo_bridge_setlink) 587 err = nla_validate_nested(protinfo, IFLA_BRPORT_MAX,
138 return -EOPNOTSUPP; 588 switchdev_port_bridge_policy);
589 if (err)
590 return err;
591
592 nla_for_each_nested(attr, protinfo, rem) {
593 switch (nla_type(attr)) {
594 case IFLA_BRPORT_LEARNING:
595 err = switchdev_port_br_setflag(dev, attr,
596 BR_LEARNING);
597 break;
598 case IFLA_BRPORT_LEARNING_SYNC:
599 err = switchdev_port_br_setflag(dev, attr,
600 BR_LEARNING_SYNC);
601 break;
602 default:
603 err = -EOPNOTSUPP;
604 break;
605 }
606 if (err)
607 return err;
608 }
139 609
140 return ops->ndo_bridge_setlink(dev, nlh, flags); 610 return 0;
611}
612
613static int switchdev_port_br_afspec(struct net_device *dev,
614 struct nlattr *afspec,
615 int (*f)(struct net_device *dev,
616 struct switchdev_obj *obj))
617{
618 struct nlattr *attr;
619 struct bridge_vlan_info *vinfo;
620 struct switchdev_obj obj = {
621 .id = SWITCHDEV_OBJ_PORT_VLAN,
622 };
623 struct switchdev_obj_vlan *vlan = &obj.u.vlan;
624 int rem;
625 int err;
626
627 nla_for_each_nested(attr, afspec, rem) {
628 if (nla_type(attr) != IFLA_BRIDGE_VLAN_INFO)
629 continue;
630 if (nla_len(attr) != sizeof(struct bridge_vlan_info))
631 return -EINVAL;
632 vinfo = nla_data(attr);
633 vlan->flags = vinfo->flags;
634 if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
635 if (vlan->vid_begin)
636 return -EINVAL;
637 vlan->vid_begin = vinfo->vid;
638 } else if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_END) {
639 if (!vlan->vid_begin)
640 return -EINVAL;
641 vlan->vid_end = vinfo->vid;
642 if (vlan->vid_end <= vlan->vid_begin)
643 return -EINVAL;
644 err = f(dev, &obj);
645 if (err)
646 return err;
647 memset(vlan, 0, sizeof(*vlan));
648 } else {
649 if (vlan->vid_begin)
650 return -EINVAL;
651 vlan->vid_begin = vinfo->vid;
652 vlan->vid_end = vinfo->vid;
653 err = f(dev, &obj);
654 if (err)
655 return err;
656 memset(vlan, 0, sizeof(*vlan));
657 }
658 }
659
660 return 0;
141} 661}
142EXPORT_SYMBOL(netdev_switch_port_bridge_setlink);
143 662
144/** 663/**
145 * netdev_switch_port_bridge_dellink - Notify switch device port of bridge 664 * switchdev_port_bridge_setlink - Set bridge port attributes
146 * port attribute delete
147 * 665 *
148 * @dev: port device 666 * @dev: port device
149 * @nlh: netlink msg with bridge port attributes 667 * @nlh: netlink header
150 * @flags: bridge setlink flags 668 * @flags: netlink flags
151 * 669 *
152 * Notify switch device port of bridge port attribute delete 670 * Called for SELF on rtnl_bridge_setlink to set bridge port
671 * attributes.
153 */ 672 */
154int netdev_switch_port_bridge_dellink(struct net_device *dev, 673int switchdev_port_bridge_setlink(struct net_device *dev,
155 struct nlmsghdr *nlh, u16 flags) 674 struct nlmsghdr *nlh, u16 flags)
156{ 675{
157 const struct net_device_ops *ops = dev->netdev_ops; 676 struct nlattr *protinfo;
677 struct nlattr *afspec;
678 int err = 0;
158 679
159 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD)) 680 protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg),
160 return 0; 681 IFLA_PROTINFO);
682 if (protinfo) {
683 err = switchdev_port_br_setlink_protinfo(dev, protinfo);
684 if (err)
685 return err;
686 }
161 687
162 if (!ops->ndo_bridge_dellink) 688 afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg),
163 return -EOPNOTSUPP; 689 IFLA_AF_SPEC);
690 if (afspec)
691 err = switchdev_port_br_afspec(dev, afspec,
692 switchdev_port_obj_add);
164 693
165 return ops->ndo_bridge_dellink(dev, nlh, flags); 694 return err;
166} 695}
167EXPORT_SYMBOL(netdev_switch_port_bridge_dellink); 696EXPORT_SYMBOL_GPL(switchdev_port_bridge_setlink);
168 697
169/** 698/**
170 * ndo_dflt_netdev_switch_port_bridge_setlink - default ndo bridge setlink 699 * switchdev_port_bridge_dellink - Set bridge port attributes
171 * op for master devices
172 * 700 *
173 * @dev: port device 701 * @dev: port device
174 * @nlh: netlink msg with bridge port attributes 702 * @nlh: netlink header
175 * @flags: bridge setlink flags 703 * @flags: netlink flags
176 * 704 *
177 * Notify master device slaves of bridge port attributes 705 * Called for SELF on rtnl_bridge_dellink to set bridge port
706 * attributes.
178 */ 707 */
179int ndo_dflt_netdev_switch_port_bridge_setlink(struct net_device *dev, 708int switchdev_port_bridge_dellink(struct net_device *dev,
180 struct nlmsghdr *nlh, u16 flags) 709 struct nlmsghdr *nlh, u16 flags)
181{ 710{
182 struct net_device *lower_dev; 711 struct nlattr *afspec;
183 struct list_head *iter;
184 int ret = 0, err = 0;
185 712
186 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD)) 713 afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg),
187 return ret; 714 IFLA_AF_SPEC);
715 if (afspec)
716 return switchdev_port_br_afspec(dev, afspec,
717 switchdev_port_obj_del);
188 718
189 netdev_for_each_lower_dev(dev, lower_dev, iter) { 719 return 0;
190 err = netdev_switch_port_bridge_setlink(lower_dev, nlh, flags); 720}
191 if (err && err != -EOPNOTSUPP) 721EXPORT_SYMBOL_GPL(switchdev_port_bridge_dellink);
192 ret = err; 722
193 } 723/**
724 * switchdev_port_fdb_add - Add FDB (MAC/VLAN) entry to port
725 *
726 * @ndmsg: netlink hdr
727 * @nlattr: netlink attributes
728 * @dev: port device
729 * @addr: MAC address to add
730 * @vid: VLAN to add
731 *
732 * Add FDB entry to switch device.
733 */
734int switchdev_port_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
735 struct net_device *dev, const unsigned char *addr,
736 u16 vid, u16 nlm_flags)
737{
738 struct switchdev_obj obj = {
739 .id = SWITCHDEV_OBJ_PORT_FDB,
740 .u.fdb = {
741 .addr = addr,
742 .vid = vid,
743 },
744 };
745
746 return switchdev_port_obj_add(dev, &obj);
747}
748EXPORT_SYMBOL_GPL(switchdev_port_fdb_add);
749
750/**
751 * switchdev_port_fdb_del - Delete FDB (MAC/VLAN) entry from port
752 *
753 * @ndmsg: netlink hdr
754 * @nlattr: netlink attributes
755 * @dev: port device
756 * @addr: MAC address to delete
757 * @vid: VLAN to delete
758 *
759 * Delete FDB entry from switch device.
760 */
761int switchdev_port_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
762 struct net_device *dev, const unsigned char *addr,
763 u16 vid)
764{
765 struct switchdev_obj obj = {
766 .id = SWITCHDEV_OBJ_PORT_FDB,
767 .u.fdb = {
768 .addr = addr,
769 .vid = vid,
770 },
771 };
772
773 return switchdev_port_obj_del(dev, &obj);
774}
775EXPORT_SYMBOL_GPL(switchdev_port_fdb_del);
776
777struct switchdev_fdb_dump {
778 struct switchdev_obj obj;
779 struct sk_buff *skb;
780 struct netlink_callback *cb;
781 int idx;
782};
783
784static int switchdev_port_fdb_dump_cb(struct net_device *dev,
785 struct switchdev_obj *obj)
786{
787 struct switchdev_fdb_dump *dump =
788 container_of(obj, struct switchdev_fdb_dump, obj);
789 u32 portid = NETLINK_CB(dump->cb->skb).portid;
790 u32 seq = dump->cb->nlh->nlmsg_seq;
791 struct nlmsghdr *nlh;
792 struct ndmsg *ndm;
793
794 if (dump->idx < dump->cb->args[0])
795 goto skip;
796
797 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH,
798 sizeof(*ndm), NLM_F_MULTI);
799 if (!nlh)
800 return -EMSGSIZE;
801
802 ndm = nlmsg_data(nlh);
803 ndm->ndm_family = AF_BRIDGE;
804 ndm->ndm_pad1 = 0;
805 ndm->ndm_pad2 = 0;
806 ndm->ndm_flags = NTF_SELF;
807 ndm->ndm_type = 0;
808 ndm->ndm_ifindex = dev->ifindex;
809 ndm->ndm_state = NUD_REACHABLE;
810
811 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, obj->u.fdb.addr))
812 goto nla_put_failure;
813
814 if (obj->u.fdb.vid && nla_put_u16(dump->skb, NDA_VLAN, obj->u.fdb.vid))
815 goto nla_put_failure;
816
817 nlmsg_end(dump->skb, nlh);
818
819skip:
820 dump->idx++;
821 return 0;
194 822
195 return ret; 823nla_put_failure:
824 nlmsg_cancel(dump->skb, nlh);
825 return -EMSGSIZE;
196} 826}
197EXPORT_SYMBOL(ndo_dflt_netdev_switch_port_bridge_setlink);
198 827
199/** 828/**
200 * ndo_dflt_netdev_switch_port_bridge_dellink - default ndo bridge dellink 829 * switchdev_port_fdb_dump - Dump port FDB (MAC/VLAN) entries
201 * op for master devices
202 * 830 *
831 * @skb: netlink skb
832 * @cb: netlink callback
203 * @dev: port device 833 * @dev: port device
204 * @nlh: netlink msg with bridge port attributes 834 * @filter_dev: filter device
205 * @flags: bridge dellink flags 835 * @idx:
206 * 836 *
207 * Notify master device slaves of bridge port attribute deletes 837 * Delete FDB entry from switch device.
208 */ 838 */
209int ndo_dflt_netdev_switch_port_bridge_dellink(struct net_device *dev, 839int switchdev_port_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
210 struct nlmsghdr *nlh, u16 flags) 840 struct net_device *dev,
841 struct net_device *filter_dev, int idx)
211{ 842{
843 struct switchdev_fdb_dump dump = {
844 .obj = {
845 .id = SWITCHDEV_OBJ_PORT_FDB,
846 .cb = switchdev_port_fdb_dump_cb,
847 },
848 .skb = skb,
849 .cb = cb,
850 .idx = idx,
851 };
852 int err;
853
854 err = switchdev_port_obj_dump(dev, &dump.obj);
855 if (err)
856 return err;
857
858 return dump.idx;
859}
860EXPORT_SYMBOL_GPL(switchdev_port_fdb_dump);
861
862static struct net_device *switchdev_get_lowest_dev(struct net_device *dev)
863{
864 const struct switchdev_ops *ops = dev->switchdev_ops;
212 struct net_device *lower_dev; 865 struct net_device *lower_dev;
866 struct net_device *port_dev;
213 struct list_head *iter; 867 struct list_head *iter;
214 int ret = 0, err = 0;
215 868
216 if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD)) 869 /* Recusively search down until we find a sw port dev.
217 return ret; 870 * (A sw port dev supports switchdev_port_attr_get).
871 */
872
873 if (ops && ops->switchdev_port_attr_get)
874 return dev;
218 875
219 netdev_for_each_lower_dev(dev, lower_dev, iter) { 876 netdev_for_each_lower_dev(dev, lower_dev, iter) {
220 err = netdev_switch_port_bridge_dellink(lower_dev, nlh, flags); 877 port_dev = switchdev_get_lowest_dev(lower_dev);
221 if (err && err != -EOPNOTSUPP) 878 if (port_dev)
222 ret = err; 879 return port_dev;
880 }
881
882 return NULL;
883}
884
885static struct net_device *switchdev_get_dev_by_nhs(struct fib_info *fi)
886{
887 struct switchdev_attr attr = {
888 .id = SWITCHDEV_ATTR_PORT_PARENT_ID,
889 };
890 struct switchdev_attr prev_attr;
891 struct net_device *dev = NULL;
892 int nhsel;
893
894 /* For this route, all nexthop devs must be on the same switch. */
895
896 for (nhsel = 0; nhsel < fi->fib_nhs; nhsel++) {
897 const struct fib_nh *nh = &fi->fib_nh[nhsel];
898
899 if (!nh->nh_dev)
900 return NULL;
901
902 dev = switchdev_get_lowest_dev(nh->nh_dev);
903 if (!dev)
904 return NULL;
905
906 if (switchdev_port_attr_get(dev, &attr))
907 return NULL;
908
909 if (nhsel > 0) {
910 if (prev_attr.u.ppid.id_len != attr.u.ppid.id_len)
911 return NULL;
912 if (memcmp(prev_attr.u.ppid.id, attr.u.ppid.id,
913 attr.u.ppid.id_len))
914 return NULL;
915 }
916
917 prev_attr = attr;
223 } 918 }
224 919
225 return ret; 920 return dev;
921}
922
923/**
924 * switchdev_fib_ipv4_add - Add/modify switch IPv4 route entry
925 *
926 * @dst: route's IPv4 destination address
927 * @dst_len: destination address length (prefix length)
928 * @fi: route FIB info structure
929 * @tos: route TOS
930 * @type: route type
931 * @nlflags: netlink flags passed in (NLM_F_*)
932 * @tb_id: route table ID
933 *
934 * Add/modify switch IPv4 route entry.
935 */
936int switchdev_fib_ipv4_add(u32 dst, int dst_len, struct fib_info *fi,
937 u8 tos, u8 type, u32 nlflags, u32 tb_id)
938{
939 struct switchdev_obj fib_obj = {
940 .id = SWITCHDEV_OBJ_IPV4_FIB,
941 .u.ipv4_fib = {
942 .dst = dst,
943 .dst_len = dst_len,
944 .fi = fi,
945 .tos = tos,
946 .type = type,
947 .nlflags = nlflags,
948 .tb_id = tb_id,
949 },
950 };
951 struct net_device *dev;
952 int err = 0;
953
954 /* Don't offload route if using custom ip rules or if
955 * IPv4 FIB offloading has been disabled completely.
956 */
957
958#ifdef CONFIG_IP_MULTIPLE_TABLES
959 if (fi->fib_net->ipv4.fib_has_custom_rules)
960 return 0;
961#endif
962
963 if (fi->fib_net->ipv4.fib_offload_disabled)
964 return 0;
965
966 dev = switchdev_get_dev_by_nhs(fi);
967 if (!dev)
968 return 0;
969
970 err = switchdev_port_obj_add(dev, &fib_obj);
971 if (!err)
972 fi->fib_flags |= RTNH_F_OFFLOAD;
973
974 return err == -EOPNOTSUPP ? 0 : err;
975}
976EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_add);
977
978/**
979 * switchdev_fib_ipv4_del - Delete IPv4 route entry from switch
980 *
981 * @dst: route's IPv4 destination address
982 * @dst_len: destination address length (prefix length)
983 * @fi: route FIB info structure
984 * @tos: route TOS
985 * @type: route type
986 * @tb_id: route table ID
987 *
988 * Delete IPv4 route entry from switch device.
989 */
990int switchdev_fib_ipv4_del(u32 dst, int dst_len, struct fib_info *fi,
991 u8 tos, u8 type, u32 tb_id)
992{
993 struct switchdev_obj fib_obj = {
994 .id = SWITCHDEV_OBJ_IPV4_FIB,
995 .u.ipv4_fib = {
996 .dst = dst,
997 .dst_len = dst_len,
998 .fi = fi,
999 .tos = tos,
1000 .type = type,
1001 .nlflags = 0,
1002 .tb_id = tb_id,
1003 },
1004 };
1005 struct net_device *dev;
1006 int err = 0;
1007
1008 if (!(fi->fib_flags & RTNH_F_OFFLOAD))
1009 return 0;
1010
1011 dev = switchdev_get_dev_by_nhs(fi);
1012 if (!dev)
1013 return 0;
1014
1015 err = switchdev_port_obj_del(dev, &fib_obj);
1016 if (!err)
1017 fi->fib_flags &= ~RTNH_F_OFFLOAD;
1018
1019 return err == -EOPNOTSUPP ? 0 : err;
1020}
1021EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_del);
1022
1023/**
1024 * switchdev_fib_ipv4_abort - Abort an IPv4 FIB operation
1025 *
1026 * @fi: route FIB info structure
1027 */
1028void switchdev_fib_ipv4_abort(struct fib_info *fi)
1029{
1030 /* There was a problem installing this route to the offload
1031 * device. For now, until we come up with more refined
1032 * policy handling, abruptly end IPv4 fib offloading for
1033 * for entire net by flushing offload device(s) of all
1034 * IPv4 routes, and mark IPv4 fib offloading broken from
1035 * this point forward.
1036 */
1037
1038 fib_flush_external(fi->fib_net);
1039 fi->fib_net->ipv4.fib_offload_disabled = true;
226} 1040}
227EXPORT_SYMBOL(ndo_dflt_netdev_switch_port_bridge_dellink); 1041EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_abort);
generated by cgit v1.2.2 (git 2.25.0) at 2025-11-09 06:11:29 -0500