1 | // SPDX-License-Identifier: GPL-2.0 |
2 | #include <linux/kernel.h> |
3 | #include <linux/list.h> |
4 | #include <linux/netdevice.h> |
5 | #include <linux/rtnetlink.h> |
6 | #include <linux/skbuff.h> |
7 | #include <net/ip.h> |
8 | #include <net/switchdev.h> |
9 | |
10 | #include "br_private.h" |
11 | |
12 | static struct static_key_false br_switchdev_tx_fwd_offload; |
13 | |
14 | static bool nbp_switchdev_can_offload_tx_fwd(const struct net_bridge_port *p, |
15 | const struct sk_buff *skb) |
16 | { |
17 | if (!static_branch_unlikely(&br_switchdev_tx_fwd_offload)) |
18 | return false; |
19 | |
20 | return (p->flags & BR_TX_FWD_OFFLOAD) && |
21 | (p->hwdom != BR_INPUT_SKB_CB(skb)->src_hwdom); |
22 | } |
23 | |
24 | bool br_switchdev_frame_uses_tx_fwd_offload(struct sk_buff *skb) |
25 | { |
26 | if (!static_branch_unlikely(&br_switchdev_tx_fwd_offload)) |
27 | return false; |
28 | |
29 | return BR_INPUT_SKB_CB(skb)->tx_fwd_offload; |
30 | } |
31 | |
32 | void br_switchdev_frame_set_offload_fwd_mark(struct sk_buff *skb) |
33 | { |
34 | skb->offload_fwd_mark = br_switchdev_frame_uses_tx_fwd_offload(skb); |
35 | } |
36 | |
37 | /* Mark the frame for TX forwarding offload if this egress port supports it */ |
38 | void nbp_switchdev_frame_mark_tx_fwd_offload(const struct net_bridge_port *p, |
39 | struct sk_buff *skb) |
40 | { |
41 | if (nbp_switchdev_can_offload_tx_fwd(p, skb)) |
42 | BR_INPUT_SKB_CB(skb)->tx_fwd_offload = true; |
43 | } |
44 | |
45 | /* Lazily adds the hwdom of the egress bridge port to the bit mask of hwdoms |
46 | * that the skb has been already forwarded to, to avoid further cloning to |
47 | * other ports in the same hwdom by making nbp_switchdev_allowed_egress() |
48 | * return false. |
49 | */ |
50 | void nbp_switchdev_frame_mark_tx_fwd_to_hwdom(const struct net_bridge_port *p, |
51 | struct sk_buff *skb) |
52 | { |
53 | if (nbp_switchdev_can_offload_tx_fwd(p, skb)) |
54 | set_bit(nr: p->hwdom, addr: &BR_INPUT_SKB_CB(skb)->fwd_hwdoms); |
55 | } |
56 | |
57 | void nbp_switchdev_frame_mark(const struct net_bridge_port *p, |
58 | struct sk_buff *skb) |
59 | { |
60 | if (p->hwdom) |
61 | BR_INPUT_SKB_CB(skb)->src_hwdom = p->hwdom; |
62 | } |
63 | |
64 | bool nbp_switchdev_allowed_egress(const struct net_bridge_port *p, |
65 | const struct sk_buff *skb) |
66 | { |
67 | struct br_input_skb_cb *cb = BR_INPUT_SKB_CB(skb); |
68 | |
69 | return !test_bit(p->hwdom, &cb->fwd_hwdoms) && |
70 | (!skb->offload_fwd_mark || cb->src_hwdom != p->hwdom); |
71 | } |
72 | |
73 | /* Flags that can be offloaded to hardware */ |
74 | #define BR_PORT_FLAGS_HW_OFFLOAD (BR_LEARNING | BR_FLOOD | BR_PORT_MAB | \ |
75 | BR_MCAST_FLOOD | BR_BCAST_FLOOD | BR_PORT_LOCKED | \ |
76 | BR_HAIRPIN_MODE | BR_ISOLATED | BR_MULTICAST_TO_UNICAST) |
77 | |
78 | int br_switchdev_set_port_flag(struct net_bridge_port *p, |
79 | unsigned long flags, |
80 | unsigned long mask, |
81 | struct netlink_ext_ack *extack) |
82 | { |
83 | struct switchdev_attr attr = { |
84 | .orig_dev = p->dev, |
85 | }; |
86 | struct switchdev_notifier_port_attr_info info = { |
87 | .attr = &attr, |
88 | }; |
89 | int err; |
90 | |
91 | mask &= BR_PORT_FLAGS_HW_OFFLOAD; |
92 | if (!mask) |
93 | return 0; |
94 | |
95 | attr.id = SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS; |
96 | attr.u.brport_flags.val = flags; |
97 | attr.u.brport_flags.mask = mask; |
98 | |
99 | /* We run from atomic context here */ |
100 | err = call_switchdev_notifiers(val: SWITCHDEV_PORT_ATTR_SET, dev: p->dev, |
101 | info: &info.info, extack); |
102 | err = notifier_to_errno(ret: err); |
103 | if (err == -EOPNOTSUPP) |
104 | return 0; |
105 | |
106 | if (err) { |
107 | NL_SET_ERR_MSG_WEAK_MOD(extack, |
108 | "bridge flag offload is not supported" ); |
109 | return -EOPNOTSUPP; |
110 | } |
111 | |
112 | attr.id = SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS; |
113 | attr.flags = SWITCHDEV_F_DEFER; |
114 | |
115 | err = switchdev_port_attr_set(dev: p->dev, attr: &attr, extack); |
116 | if (err) { |
117 | NL_SET_ERR_MSG_WEAK_MOD(extack, |
118 | "error setting offload flag on port" ); |
119 | return err; |
120 | } |
121 | |
122 | return 0; |
123 | } |
124 | |
125 | static void br_switchdev_fdb_populate(struct net_bridge *br, |
126 | struct switchdev_notifier_fdb_info *item, |
127 | const struct net_bridge_fdb_entry *fdb, |
128 | const void *ctx) |
129 | { |
130 | const struct net_bridge_port *p = READ_ONCE(fdb->dst); |
131 | |
132 | item->addr = fdb->key.addr.addr; |
133 | item->vid = fdb->key.vlan_id; |
134 | item->added_by_user = test_bit(BR_FDB_ADDED_BY_USER, &fdb->flags); |
135 | item->offloaded = test_bit(BR_FDB_OFFLOADED, &fdb->flags); |
136 | item->is_local = test_bit(BR_FDB_LOCAL, &fdb->flags); |
137 | item->locked = false; |
138 | item->info.dev = (!p || item->is_local) ? br->dev : p->dev; |
139 | item->info.ctx = ctx; |
140 | } |
141 | |
142 | void |
143 | br_switchdev_fdb_notify(struct net_bridge *br, |
144 | const struct net_bridge_fdb_entry *fdb, int type) |
145 | { |
146 | struct switchdev_notifier_fdb_info item; |
147 | |
148 | if (test_bit(BR_FDB_LOCKED, &fdb->flags)) |
149 | return; |
150 | |
151 | /* Entries with these flags were created using ndm_state == NUD_REACHABLE, |
152 | * ndm_flags == NTF_MASTER( | NTF_STICKY), ext_flags == 0 by something |
153 | * equivalent to 'bridge fdb add ... master dynamic (sticky)'. |
154 | * Drivers don't know how to deal with these, so don't notify them to |
155 | * avoid confusing them. |
156 | */ |
157 | if (test_bit(BR_FDB_ADDED_BY_USER, &fdb->flags) && |
158 | !test_bit(BR_FDB_STATIC, &fdb->flags) && |
159 | !test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags)) |
160 | return; |
161 | |
162 | br_switchdev_fdb_populate(br, item: &item, fdb, NULL); |
163 | |
164 | switch (type) { |
165 | case RTM_DELNEIGH: |
166 | call_switchdev_notifiers(val: SWITCHDEV_FDB_DEL_TO_DEVICE, |
167 | dev: item.info.dev, info: &item.info, NULL); |
168 | break; |
169 | case RTM_NEWNEIGH: |
170 | call_switchdev_notifiers(val: SWITCHDEV_FDB_ADD_TO_DEVICE, |
171 | dev: item.info.dev, info: &item.info, NULL); |
172 | break; |
173 | } |
174 | } |
175 | |
176 | int br_switchdev_port_vlan_add(struct net_device *dev, u16 vid, u16 flags, |
177 | bool changed, struct netlink_ext_ack *extack) |
178 | { |
179 | struct switchdev_obj_port_vlan v = { |
180 | .obj.orig_dev = dev, |
181 | .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, |
182 | .flags = flags, |
183 | .vid = vid, |
184 | .changed = changed, |
185 | }; |
186 | |
187 | return switchdev_port_obj_add(dev, obj: &v.obj, extack); |
188 | } |
189 | |
190 | int br_switchdev_port_vlan_del(struct net_device *dev, u16 vid) |
191 | { |
192 | struct switchdev_obj_port_vlan v = { |
193 | .obj.orig_dev = dev, |
194 | .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, |
195 | .vid = vid, |
196 | }; |
197 | |
198 | return switchdev_port_obj_del(dev, obj: &v.obj); |
199 | } |
200 | |
201 | static int nbp_switchdev_hwdom_set(struct net_bridge_port *joining) |
202 | { |
203 | struct net_bridge *br = joining->br; |
204 | struct net_bridge_port *p; |
205 | int hwdom; |
206 | |
207 | /* joining is yet to be added to the port list. */ |
208 | list_for_each_entry(p, &br->port_list, list) { |
209 | if (netdev_phys_item_id_same(a: &joining->ppid, b: &p->ppid)) { |
210 | joining->hwdom = p->hwdom; |
211 | return 0; |
212 | } |
213 | } |
214 | |
215 | hwdom = find_next_zero_bit(addr: &br->busy_hwdoms, BR_HWDOM_MAX, offset: 1); |
216 | if (hwdom >= BR_HWDOM_MAX) |
217 | return -EBUSY; |
218 | |
219 | set_bit(nr: hwdom, addr: &br->busy_hwdoms); |
220 | joining->hwdom = hwdom; |
221 | return 0; |
222 | } |
223 | |
224 | static void nbp_switchdev_hwdom_put(struct net_bridge_port *leaving) |
225 | { |
226 | struct net_bridge *br = leaving->br; |
227 | struct net_bridge_port *p; |
228 | |
229 | /* leaving is no longer in the port list. */ |
230 | list_for_each_entry(p, &br->port_list, list) { |
231 | if (p->hwdom == leaving->hwdom) |
232 | return; |
233 | } |
234 | |
235 | clear_bit(nr: leaving->hwdom, addr: &br->busy_hwdoms); |
236 | } |
237 | |
238 | static int nbp_switchdev_add(struct net_bridge_port *p, |
239 | struct netdev_phys_item_id ppid, |
240 | bool tx_fwd_offload, |
241 | struct netlink_ext_ack *extack) |
242 | { |
243 | int err; |
244 | |
245 | if (p->offload_count) { |
246 | /* Prevent unsupported configurations such as a bridge port |
247 | * which is a bonding interface, and the member ports are from |
248 | * different hardware switches. |
249 | */ |
250 | if (!netdev_phys_item_id_same(a: &p->ppid, b: &ppid)) { |
251 | NL_SET_ERR_MSG_MOD(extack, |
252 | "Same bridge port cannot be offloaded by two physical switches" ); |
253 | return -EBUSY; |
254 | } |
255 | |
256 | /* Tolerate drivers that call switchdev_bridge_port_offload() |
257 | * more than once for the same bridge port, such as when the |
258 | * bridge port is an offloaded bonding/team interface. |
259 | */ |
260 | p->offload_count++; |
261 | |
262 | return 0; |
263 | } |
264 | |
265 | p->ppid = ppid; |
266 | p->offload_count = 1; |
267 | |
268 | err = nbp_switchdev_hwdom_set(joining: p); |
269 | if (err) |
270 | return err; |
271 | |
272 | if (tx_fwd_offload) { |
273 | p->flags |= BR_TX_FWD_OFFLOAD; |
274 | static_branch_inc(&br_switchdev_tx_fwd_offload); |
275 | } |
276 | |
277 | return 0; |
278 | } |
279 | |
280 | static void nbp_switchdev_del(struct net_bridge_port *p) |
281 | { |
282 | if (WARN_ON(!p->offload_count)) |
283 | return; |
284 | |
285 | p->offload_count--; |
286 | |
287 | if (p->offload_count) |
288 | return; |
289 | |
290 | if (p->hwdom) |
291 | nbp_switchdev_hwdom_put(leaving: p); |
292 | |
293 | if (p->flags & BR_TX_FWD_OFFLOAD) { |
294 | p->flags &= ~BR_TX_FWD_OFFLOAD; |
295 | static_branch_dec(&br_switchdev_tx_fwd_offload); |
296 | } |
297 | } |
298 | |
299 | static int |
300 | br_switchdev_fdb_replay_one(struct net_bridge *br, struct notifier_block *nb, |
301 | const struct net_bridge_fdb_entry *fdb, |
302 | unsigned long action, const void *ctx) |
303 | { |
304 | struct switchdev_notifier_fdb_info item; |
305 | int err; |
306 | |
307 | br_switchdev_fdb_populate(br, item: &item, fdb, ctx); |
308 | |
309 | err = nb->notifier_call(nb, action, &item); |
310 | return notifier_to_errno(ret: err); |
311 | } |
312 | |
313 | static int |
314 | br_switchdev_fdb_replay(const struct net_device *br_dev, const void *ctx, |
315 | bool adding, struct notifier_block *nb) |
316 | { |
317 | struct net_bridge_fdb_entry *fdb; |
318 | struct net_bridge *br; |
319 | unsigned long action; |
320 | int err = 0; |
321 | |
322 | if (!nb) |
323 | return 0; |
324 | |
325 | if (!netif_is_bridge_master(dev: br_dev)) |
326 | return -EINVAL; |
327 | |
328 | br = netdev_priv(dev: br_dev); |
329 | |
330 | if (adding) |
331 | action = SWITCHDEV_FDB_ADD_TO_DEVICE; |
332 | else |
333 | action = SWITCHDEV_FDB_DEL_TO_DEVICE; |
334 | |
335 | rcu_read_lock(); |
336 | |
337 | hlist_for_each_entry_rcu(fdb, &br->fdb_list, fdb_node) { |
338 | err = br_switchdev_fdb_replay_one(br, nb, fdb, action, ctx); |
339 | if (err) |
340 | break; |
341 | } |
342 | |
343 | rcu_read_unlock(); |
344 | |
345 | return err; |
346 | } |
347 | |
348 | static int br_switchdev_vlan_attr_replay(struct net_device *br_dev, |
349 | const void *ctx, |
350 | struct notifier_block *nb, |
351 | struct netlink_ext_ack *extack) |
352 | { |
353 | struct switchdev_notifier_port_attr_info attr_info = { |
354 | .info = { |
355 | .dev = br_dev, |
356 | .extack = extack, |
357 | .ctx = ctx, |
358 | }, |
359 | }; |
360 | struct net_bridge *br = netdev_priv(dev: br_dev); |
361 | struct net_bridge_vlan_group *vg; |
362 | struct switchdev_attr attr; |
363 | struct net_bridge_vlan *v; |
364 | int err; |
365 | |
366 | attr_info.attr = &attr; |
367 | attr.orig_dev = br_dev; |
368 | |
369 | vg = br_vlan_group(br); |
370 | if (!vg) |
371 | return 0; |
372 | |
373 | list_for_each_entry(v, &vg->vlan_list, vlist) { |
374 | if (v->msti) { |
375 | attr.id = SWITCHDEV_ATTR_ID_VLAN_MSTI; |
376 | attr.u.vlan_msti.vid = v->vid; |
377 | attr.u.vlan_msti.msti = v->msti; |
378 | |
379 | err = nb->notifier_call(nb, SWITCHDEV_PORT_ATTR_SET, |
380 | &attr_info); |
381 | err = notifier_to_errno(ret: err); |
382 | if (err) |
383 | return err; |
384 | } |
385 | } |
386 | |
387 | return 0; |
388 | } |
389 | |
390 | static int |
391 | br_switchdev_vlan_replay_one(struct notifier_block *nb, |
392 | struct net_device *dev, |
393 | struct switchdev_obj_port_vlan *vlan, |
394 | const void *ctx, unsigned long action, |
395 | struct netlink_ext_ack *extack) |
396 | { |
397 | struct switchdev_notifier_port_obj_info obj_info = { |
398 | .info = { |
399 | .dev = dev, |
400 | .extack = extack, |
401 | .ctx = ctx, |
402 | }, |
403 | .obj = &vlan->obj, |
404 | }; |
405 | int err; |
406 | |
407 | err = nb->notifier_call(nb, action, &obj_info); |
408 | return notifier_to_errno(ret: err); |
409 | } |
410 | |
411 | static int br_switchdev_vlan_replay_group(struct notifier_block *nb, |
412 | struct net_device *dev, |
413 | struct net_bridge_vlan_group *vg, |
414 | const void *ctx, unsigned long action, |
415 | struct netlink_ext_ack *extack) |
416 | { |
417 | struct net_bridge_vlan *v; |
418 | int err = 0; |
419 | u16 pvid; |
420 | |
421 | if (!vg) |
422 | return 0; |
423 | |
424 | pvid = br_get_pvid(vg); |
425 | |
426 | list_for_each_entry(v, &vg->vlan_list, vlist) { |
427 | struct switchdev_obj_port_vlan vlan = { |
428 | .obj.orig_dev = dev, |
429 | .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, |
430 | .flags = br_vlan_flags(v, pvid), |
431 | .vid = v->vid, |
432 | }; |
433 | |
434 | if (!br_vlan_should_use(v)) |
435 | continue; |
436 | |
437 | err = br_switchdev_vlan_replay_one(nb, dev, vlan: &vlan, ctx, |
438 | action, extack); |
439 | if (err) |
440 | return err; |
441 | } |
442 | |
443 | return 0; |
444 | } |
445 | |
446 | static int br_switchdev_vlan_replay(struct net_device *br_dev, |
447 | const void *ctx, bool adding, |
448 | struct notifier_block *nb, |
449 | struct netlink_ext_ack *extack) |
450 | { |
451 | struct net_bridge *br = netdev_priv(dev: br_dev); |
452 | struct net_bridge_port *p; |
453 | unsigned long action; |
454 | int err; |
455 | |
456 | ASSERT_RTNL(); |
457 | |
458 | if (!nb) |
459 | return 0; |
460 | |
461 | if (!netif_is_bridge_master(dev: br_dev)) |
462 | return -EINVAL; |
463 | |
464 | if (adding) |
465 | action = SWITCHDEV_PORT_OBJ_ADD; |
466 | else |
467 | action = SWITCHDEV_PORT_OBJ_DEL; |
468 | |
469 | err = br_switchdev_vlan_replay_group(nb, dev: br_dev, vg: br_vlan_group(br), |
470 | ctx, action, extack); |
471 | if (err) |
472 | return err; |
473 | |
474 | list_for_each_entry(p, &br->port_list, list) { |
475 | struct net_device *dev = p->dev; |
476 | |
477 | err = br_switchdev_vlan_replay_group(nb, dev, |
478 | vg: nbp_vlan_group(p), |
479 | ctx, action, extack); |
480 | if (err) |
481 | return err; |
482 | } |
483 | |
484 | if (adding) { |
485 | err = br_switchdev_vlan_attr_replay(br_dev, ctx, nb, extack); |
486 | if (err) |
487 | return err; |
488 | } |
489 | |
490 | return 0; |
491 | } |
492 | |
493 | #ifdef CONFIG_BRIDGE_IGMP_SNOOPING |
494 | struct br_switchdev_mdb_complete_info { |
495 | struct net_bridge_port *port; |
496 | struct br_ip ip; |
497 | }; |
498 | |
499 | static void br_switchdev_mdb_complete(struct net_device *dev, int err, void *priv) |
500 | { |
501 | struct br_switchdev_mdb_complete_info *data = priv; |
502 | struct net_bridge_port_group __rcu **pp; |
503 | struct net_bridge_port_group *p; |
504 | struct net_bridge_mdb_entry *mp; |
505 | struct net_bridge_port *port = data->port; |
506 | struct net_bridge *br = port->br; |
507 | |
508 | if (err) |
509 | goto err; |
510 | |
511 | spin_lock_bh(lock: &br->multicast_lock); |
512 | mp = br_mdb_ip_get(br, dst: &data->ip); |
513 | if (!mp) |
514 | goto out; |
515 | for (pp = &mp->ports; (p = mlock_dereference(*pp, br)) != NULL; |
516 | pp = &p->next) { |
517 | if (p->key.port != port) |
518 | continue; |
519 | p->flags |= MDB_PG_FLAGS_OFFLOAD; |
520 | } |
521 | out: |
522 | spin_unlock_bh(lock: &br->multicast_lock); |
523 | err: |
524 | kfree(objp: priv); |
525 | } |
526 | |
527 | static void br_switchdev_mdb_populate(struct switchdev_obj_port_mdb *mdb, |
528 | const struct net_bridge_mdb_entry *mp) |
529 | { |
530 | if (mp->addr.proto == htons(ETH_P_IP)) |
531 | ip_eth_mc_map(naddr: mp->addr.dst.ip4, buf: mdb->addr); |
532 | #if IS_ENABLED(CONFIG_IPV6) |
533 | else if (mp->addr.proto == htons(ETH_P_IPV6)) |
534 | ipv6_eth_mc_map(addr: &mp->addr.dst.ip6, buf: mdb->addr); |
535 | #endif |
536 | else |
537 | ether_addr_copy(dst: mdb->addr, src: mp->addr.dst.mac_addr); |
538 | |
539 | mdb->vid = mp->addr.vid; |
540 | } |
541 | |
542 | static void br_switchdev_host_mdb_one(struct net_device *dev, |
543 | struct net_device *lower_dev, |
544 | struct net_bridge_mdb_entry *mp, |
545 | int type) |
546 | { |
547 | struct switchdev_obj_port_mdb mdb = { |
548 | .obj = { |
549 | .id = SWITCHDEV_OBJ_ID_HOST_MDB, |
550 | .flags = SWITCHDEV_F_DEFER, |
551 | .orig_dev = dev, |
552 | }, |
553 | }; |
554 | |
555 | br_switchdev_mdb_populate(mdb: &mdb, mp); |
556 | |
557 | switch (type) { |
558 | case RTM_NEWMDB: |
559 | switchdev_port_obj_add(dev: lower_dev, obj: &mdb.obj, NULL); |
560 | break; |
561 | case RTM_DELMDB: |
562 | switchdev_port_obj_del(dev: lower_dev, obj: &mdb.obj); |
563 | break; |
564 | } |
565 | } |
566 | |
567 | static void br_switchdev_host_mdb(struct net_device *dev, |
568 | struct net_bridge_mdb_entry *mp, int type) |
569 | { |
570 | struct net_device *lower_dev; |
571 | struct list_head *iter; |
572 | |
573 | netdev_for_each_lower_dev(dev, lower_dev, iter) |
574 | br_switchdev_host_mdb_one(dev, lower_dev, mp, type); |
575 | } |
576 | |
577 | static int |
578 | br_switchdev_mdb_replay_one(struct notifier_block *nb, struct net_device *dev, |
579 | const struct switchdev_obj_port_mdb *mdb, |
580 | unsigned long action, const void *ctx, |
581 | struct netlink_ext_ack *extack) |
582 | { |
583 | struct switchdev_notifier_port_obj_info obj_info = { |
584 | .info = { |
585 | .dev = dev, |
586 | .extack = extack, |
587 | .ctx = ctx, |
588 | }, |
589 | .obj = &mdb->obj, |
590 | }; |
591 | int err; |
592 | |
593 | err = nb->notifier_call(nb, action, &obj_info); |
594 | return notifier_to_errno(ret: err); |
595 | } |
596 | |
597 | static int br_switchdev_mdb_queue_one(struct list_head *mdb_list, |
598 | enum switchdev_obj_id id, |
599 | const struct net_bridge_mdb_entry *mp, |
600 | struct net_device *orig_dev) |
601 | { |
602 | struct switchdev_obj_port_mdb *mdb; |
603 | |
604 | mdb = kzalloc(size: sizeof(*mdb), GFP_ATOMIC); |
605 | if (!mdb) |
606 | return -ENOMEM; |
607 | |
608 | mdb->obj.id = id; |
609 | mdb->obj.orig_dev = orig_dev; |
610 | br_switchdev_mdb_populate(mdb, mp); |
611 | list_add_tail(new: &mdb->obj.list, head: mdb_list); |
612 | |
613 | return 0; |
614 | } |
615 | |
616 | void br_switchdev_mdb_notify(struct net_device *dev, |
617 | struct net_bridge_mdb_entry *mp, |
618 | struct net_bridge_port_group *pg, |
619 | int type) |
620 | { |
621 | struct br_switchdev_mdb_complete_info *complete_info; |
622 | struct switchdev_obj_port_mdb mdb = { |
623 | .obj = { |
624 | .id = SWITCHDEV_OBJ_ID_PORT_MDB, |
625 | .flags = SWITCHDEV_F_DEFER, |
626 | }, |
627 | }; |
628 | |
629 | if (!pg) |
630 | return br_switchdev_host_mdb(dev, mp, type); |
631 | |
632 | br_switchdev_mdb_populate(mdb: &mdb, mp); |
633 | |
634 | mdb.obj.orig_dev = pg->key.port->dev; |
635 | switch (type) { |
636 | case RTM_NEWMDB: |
637 | complete_info = kmalloc(size: sizeof(*complete_info), GFP_ATOMIC); |
638 | if (!complete_info) |
639 | break; |
640 | complete_info->port = pg->key.port; |
641 | complete_info->ip = mp->addr; |
642 | mdb.obj.complete_priv = complete_info; |
643 | mdb.obj.complete = br_switchdev_mdb_complete; |
644 | if (switchdev_port_obj_add(dev: pg->key.port->dev, obj: &mdb.obj, NULL)) |
645 | kfree(objp: complete_info); |
646 | break; |
647 | case RTM_DELMDB: |
648 | switchdev_port_obj_del(dev: pg->key.port->dev, obj: &mdb.obj); |
649 | break; |
650 | } |
651 | } |
652 | #endif |
653 | |
654 | static int |
655 | br_switchdev_mdb_replay(struct net_device *br_dev, struct net_device *dev, |
656 | const void *ctx, bool adding, struct notifier_block *nb, |
657 | struct netlink_ext_ack *extack) |
658 | { |
659 | #ifdef CONFIG_BRIDGE_IGMP_SNOOPING |
660 | const struct net_bridge_mdb_entry *mp; |
661 | struct switchdev_obj *obj, *tmp; |
662 | struct net_bridge *br; |
663 | unsigned long action; |
664 | LIST_HEAD(mdb_list); |
665 | int err = 0; |
666 | |
667 | ASSERT_RTNL(); |
668 | |
669 | if (!nb) |
670 | return 0; |
671 | |
672 | if (!netif_is_bridge_master(dev: br_dev) || !netif_is_bridge_port(dev)) |
673 | return -EINVAL; |
674 | |
675 | br = netdev_priv(dev: br_dev); |
676 | |
677 | if (!br_opt_get(br, opt: BROPT_MULTICAST_ENABLED)) |
678 | return 0; |
679 | |
680 | /* We cannot walk over br->mdb_list protected just by the rtnl_mutex, |
681 | * because the write-side protection is br->multicast_lock. But we |
682 | * need to emulate the [ blocking ] calling context of a regular |
683 | * switchdev event, so since both br->multicast_lock and RCU read side |
684 | * critical sections are atomic, we have no choice but to pick the RCU |
685 | * read side lock, queue up all our events, leave the critical section |
686 | * and notify switchdev from blocking context. |
687 | */ |
688 | rcu_read_lock(); |
689 | |
690 | hlist_for_each_entry_rcu(mp, &br->mdb_list, mdb_node) { |
691 | struct net_bridge_port_group __rcu * const *pp; |
692 | const struct net_bridge_port_group *p; |
693 | |
694 | if (mp->host_joined) { |
695 | err = br_switchdev_mdb_queue_one(mdb_list: &mdb_list, |
696 | id: SWITCHDEV_OBJ_ID_HOST_MDB, |
697 | mp, orig_dev: br_dev); |
698 | if (err) { |
699 | rcu_read_unlock(); |
700 | goto out_free_mdb; |
701 | } |
702 | } |
703 | |
704 | for (pp = &mp->ports; (p = rcu_dereference(*pp)) != NULL; |
705 | pp = &p->next) { |
706 | if (p->key.port->dev != dev) |
707 | continue; |
708 | |
709 | err = br_switchdev_mdb_queue_one(mdb_list: &mdb_list, |
710 | id: SWITCHDEV_OBJ_ID_PORT_MDB, |
711 | mp, orig_dev: dev); |
712 | if (err) { |
713 | rcu_read_unlock(); |
714 | goto out_free_mdb; |
715 | } |
716 | } |
717 | } |
718 | |
719 | rcu_read_unlock(); |
720 | |
721 | if (adding) |
722 | action = SWITCHDEV_PORT_OBJ_ADD; |
723 | else |
724 | action = SWITCHDEV_PORT_OBJ_DEL; |
725 | |
726 | list_for_each_entry(obj, &mdb_list, list) { |
727 | err = br_switchdev_mdb_replay_one(nb, dev, |
728 | SWITCHDEV_OBJ_PORT_MDB(obj), |
729 | action, ctx, extack); |
730 | if (err == -EOPNOTSUPP) |
731 | err = 0; |
732 | if (err) |
733 | goto out_free_mdb; |
734 | } |
735 | |
736 | out_free_mdb: |
737 | list_for_each_entry_safe(obj, tmp, &mdb_list, list) { |
738 | list_del(entry: &obj->list); |
739 | kfree(SWITCHDEV_OBJ_PORT_MDB(obj)); |
740 | } |
741 | |
742 | if (err) |
743 | return err; |
744 | #endif |
745 | |
746 | return 0; |
747 | } |
748 | |
749 | static int nbp_switchdev_sync_objs(struct net_bridge_port *p, const void *ctx, |
750 | struct notifier_block *atomic_nb, |
751 | struct notifier_block *blocking_nb, |
752 | struct netlink_ext_ack *extack) |
753 | { |
754 | struct net_device *br_dev = p->br->dev; |
755 | struct net_device *dev = p->dev; |
756 | int err; |
757 | |
758 | err = br_switchdev_vlan_replay(br_dev, ctx, adding: true, nb: blocking_nb, extack); |
759 | if (err && err != -EOPNOTSUPP) |
760 | return err; |
761 | |
762 | err = br_switchdev_mdb_replay(br_dev, dev, ctx, adding: true, nb: blocking_nb, |
763 | extack); |
764 | if (err) { |
765 | /* -EOPNOTSUPP not propagated from MDB replay. */ |
766 | return err; |
767 | } |
768 | |
769 | err = br_switchdev_fdb_replay(br_dev, ctx, adding: true, nb: atomic_nb); |
770 | if (err && err != -EOPNOTSUPP) |
771 | return err; |
772 | |
773 | return 0; |
774 | } |
775 | |
776 | static void nbp_switchdev_unsync_objs(struct net_bridge_port *p, |
777 | const void *ctx, |
778 | struct notifier_block *atomic_nb, |
779 | struct notifier_block *blocking_nb) |
780 | { |
781 | struct net_device *br_dev = p->br->dev; |
782 | struct net_device *dev = p->dev; |
783 | |
784 | br_switchdev_fdb_replay(br_dev, ctx, adding: false, nb: atomic_nb); |
785 | |
786 | br_switchdev_mdb_replay(br_dev, dev, ctx, adding: false, nb: blocking_nb, NULL); |
787 | |
788 | br_switchdev_vlan_replay(br_dev, ctx, adding: false, nb: blocking_nb, NULL); |
789 | } |
790 | |
791 | /* Let the bridge know that this port is offloaded, so that it can assign a |
792 | * switchdev hardware domain to it. |
793 | */ |
794 | int br_switchdev_port_offload(struct net_bridge_port *p, |
795 | struct net_device *dev, const void *ctx, |
796 | struct notifier_block *atomic_nb, |
797 | struct notifier_block *blocking_nb, |
798 | bool tx_fwd_offload, |
799 | struct netlink_ext_ack *extack) |
800 | { |
801 | struct netdev_phys_item_id ppid; |
802 | int err; |
803 | |
804 | err = dev_get_port_parent_id(dev, ppid: &ppid, recurse: false); |
805 | if (err) |
806 | return err; |
807 | |
808 | err = nbp_switchdev_add(p, ppid, tx_fwd_offload, extack); |
809 | if (err) |
810 | return err; |
811 | |
812 | err = nbp_switchdev_sync_objs(p, ctx, atomic_nb, blocking_nb, extack); |
813 | if (err) |
814 | goto out_switchdev_del; |
815 | |
816 | return 0; |
817 | |
818 | out_switchdev_del: |
819 | nbp_switchdev_del(p); |
820 | |
821 | return err; |
822 | } |
823 | |
824 | void br_switchdev_port_unoffload(struct net_bridge_port *p, const void *ctx, |
825 | struct notifier_block *atomic_nb, |
826 | struct notifier_block *blocking_nb) |
827 | { |
828 | nbp_switchdev_unsync_objs(p, ctx, atomic_nb, blocking_nb); |
829 | |
830 | nbp_switchdev_del(p); |
831 | } |
832 | |
833 | int br_switchdev_port_replay(struct net_bridge_port *p, |
834 | struct net_device *dev, const void *ctx, |
835 | struct notifier_block *atomic_nb, |
836 | struct notifier_block *blocking_nb, |
837 | struct netlink_ext_ack *extack) |
838 | { |
839 | return nbp_switchdev_sync_objs(p, ctx, atomic_nb, blocking_nb, extack); |
840 | } |
841 | |