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
nbp_switchdev_can_offload_tx_fwd(const struct net_bridge_port * p,const struct sk_buff * skb)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
br_switchdev_frame_uses_tx_fwd_offload(struct sk_buff * skb)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
br_switchdev_frame_set_offload_fwd_mark(struct sk_buff * skb)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 */
nbp_switchdev_frame_mark_tx_fwd_offload(const struct net_bridge_port * p,struct sk_buff * skb)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 */
nbp_switchdev_frame_mark_tx_fwd_to_hwdom(const struct net_bridge_port * p,struct sk_buff * skb)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(p->hwdom, &BR_INPUT_SKB_CB(skb)->fwd_hwdoms);
55 }
56
nbp_switchdev_frame_mark(const struct net_bridge_port * p,struct sk_buff * skb)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
nbp_switchdev_allowed_egress(const struct net_bridge_port * p,const struct sk_buff * skb)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 | \
75 BR_MCAST_FLOOD | BR_BCAST_FLOOD)
76
br_switchdev_set_port_flag(struct net_bridge_port * p,unsigned long flags,unsigned long mask,struct netlink_ext_ack * extack)77 int br_switchdev_set_port_flag(struct net_bridge_port *p,
78 unsigned long flags,
79 unsigned long mask,
80 struct netlink_ext_ack *extack)
81 {
82 struct switchdev_attr attr = {
83 .orig_dev = p->dev,
84 };
85 struct switchdev_notifier_port_attr_info info = {
86 .attr = &attr,
87 };
88 int err;
89
90 mask &= BR_PORT_FLAGS_HW_OFFLOAD;
91 if (!mask)
92 return 0;
93
94 attr.id = SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS;
95 attr.u.brport_flags.val = flags;
96 attr.u.brport_flags.mask = mask;
97
98 /* We run from atomic context here */
99 err = call_switchdev_notifiers(SWITCHDEV_PORT_ATTR_SET, p->dev,
100 &info.info, extack);
101 err = notifier_to_errno(err);
102 if (err == -EOPNOTSUPP)
103 return 0;
104
105 if (err) {
106 if (extack && !extack->_msg)
107 NL_SET_ERR_MSG_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(p->dev, &attr, extack);
116 if (err) {
117 if (extack && !extack->_msg)
118 NL_SET_ERR_MSG_MOD(extack,
119 "error setting offload flag on port");
120 return err;
121 }
122
123 return 0;
124 }
125
br_switchdev_fdb_populate(struct net_bridge * br,struct switchdev_notifier_fdb_info * item,const struct net_bridge_fdb_entry * fdb,const void * ctx)126 static void br_switchdev_fdb_populate(struct net_bridge *br,
127 struct switchdev_notifier_fdb_info *item,
128 const struct net_bridge_fdb_entry *fdb,
129 const void *ctx)
130 {
131 const struct net_bridge_port *p = READ_ONCE(fdb->dst);
132
133 item->addr = fdb->key.addr.addr;
134 item->vid = fdb->key.vlan_id;
135 item->added_by_user = test_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
136 item->offloaded = test_bit(BR_FDB_OFFLOADED, &fdb->flags);
137 item->is_local = test_bit(BR_FDB_LOCAL, &fdb->flags);
138 item->info.dev = (!p || item->is_local) ? br->dev : p->dev;
139 item->info.ctx = ctx;
140 }
141
142 void
br_switchdev_fdb_notify(struct net_bridge * br,const struct net_bridge_fdb_entry * fdb,int type)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 br_switchdev_fdb_populate(br, &item, fdb, NULL);
149
150 switch (type) {
151 case RTM_DELNEIGH:
152 call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_DEVICE,
153 item.info.dev, &item.info, NULL);
154 break;
155 case RTM_NEWNEIGH:
156 call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_DEVICE,
157 item.info.dev, &item.info, NULL);
158 break;
159 }
160 }
161
br_switchdev_port_vlan_add(struct net_device * dev,u16 vid,u16 flags,struct netlink_ext_ack * extack)162 int br_switchdev_port_vlan_add(struct net_device *dev, u16 vid, u16 flags,
163 struct netlink_ext_ack *extack)
164 {
165 struct switchdev_obj_port_vlan v = {
166 .obj.orig_dev = dev,
167 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
168 .flags = flags,
169 .vid = vid,
170 };
171
172 return switchdev_port_obj_add(dev, &v.obj, extack);
173 }
174
br_switchdev_port_vlan_del(struct net_device * dev,u16 vid)175 int br_switchdev_port_vlan_del(struct net_device *dev, u16 vid)
176 {
177 struct switchdev_obj_port_vlan v = {
178 .obj.orig_dev = dev,
179 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
180 .vid = vid,
181 };
182
183 return switchdev_port_obj_del(dev, &v.obj);
184 }
185
nbp_switchdev_hwdom_set(struct net_bridge_port * joining)186 static int nbp_switchdev_hwdom_set(struct net_bridge_port *joining)
187 {
188 struct net_bridge *br = joining->br;
189 struct net_bridge_port *p;
190 int hwdom;
191
192 /* joining is yet to be added to the port list. */
193 list_for_each_entry(p, &br->port_list, list) {
194 if (netdev_phys_item_id_same(&joining->ppid, &p->ppid)) {
195 joining->hwdom = p->hwdom;
196 return 0;
197 }
198 }
199
200 hwdom = find_next_zero_bit(&br->busy_hwdoms, BR_HWDOM_MAX, 1);
201 if (hwdom >= BR_HWDOM_MAX)
202 return -EBUSY;
203
204 set_bit(hwdom, &br->busy_hwdoms);
205 joining->hwdom = hwdom;
206 return 0;
207 }
208
nbp_switchdev_hwdom_put(struct net_bridge_port * leaving)209 static void nbp_switchdev_hwdom_put(struct net_bridge_port *leaving)
210 {
211 struct net_bridge *br = leaving->br;
212 struct net_bridge_port *p;
213
214 /* leaving is no longer in the port list. */
215 list_for_each_entry(p, &br->port_list, list) {
216 if (p->hwdom == leaving->hwdom)
217 return;
218 }
219
220 clear_bit(leaving->hwdom, &br->busy_hwdoms);
221 }
222
nbp_switchdev_add(struct net_bridge_port * p,struct netdev_phys_item_id ppid,bool tx_fwd_offload,struct netlink_ext_ack * extack)223 static int nbp_switchdev_add(struct net_bridge_port *p,
224 struct netdev_phys_item_id ppid,
225 bool tx_fwd_offload,
226 struct netlink_ext_ack *extack)
227 {
228 int err;
229
230 if (p->offload_count) {
231 /* Prevent unsupported configurations such as a bridge port
232 * which is a bonding interface, and the member ports are from
233 * different hardware switches.
234 */
235 if (!netdev_phys_item_id_same(&p->ppid, &ppid)) {
236 NL_SET_ERR_MSG_MOD(extack,
237 "Same bridge port cannot be offloaded by two physical switches");
238 return -EBUSY;
239 }
240
241 /* Tolerate drivers that call switchdev_bridge_port_offload()
242 * more than once for the same bridge port, such as when the
243 * bridge port is an offloaded bonding/team interface.
244 */
245 p->offload_count++;
246
247 return 0;
248 }
249
250 p->ppid = ppid;
251 p->offload_count = 1;
252
253 err = nbp_switchdev_hwdom_set(p);
254 if (err)
255 return err;
256
257 if (tx_fwd_offload) {
258 p->flags |= BR_TX_FWD_OFFLOAD;
259 static_branch_inc(&br_switchdev_tx_fwd_offload);
260 }
261
262 return 0;
263 }
264
nbp_switchdev_del(struct net_bridge_port * p)265 static void nbp_switchdev_del(struct net_bridge_port *p)
266 {
267 if (WARN_ON(!p->offload_count))
268 return;
269
270 p->offload_count--;
271
272 if (p->offload_count)
273 return;
274
275 if (p->hwdom)
276 nbp_switchdev_hwdom_put(p);
277
278 if (p->flags & BR_TX_FWD_OFFLOAD) {
279 p->flags &= ~BR_TX_FWD_OFFLOAD;
280 static_branch_dec(&br_switchdev_tx_fwd_offload);
281 }
282 }
283
284 static int
br_switchdev_fdb_replay_one(struct net_bridge * br,struct notifier_block * nb,const struct net_bridge_fdb_entry * fdb,unsigned long action,const void * ctx)285 br_switchdev_fdb_replay_one(struct net_bridge *br, struct notifier_block *nb,
286 const struct net_bridge_fdb_entry *fdb,
287 unsigned long action, const void *ctx)
288 {
289 struct switchdev_notifier_fdb_info item;
290 int err;
291
292 br_switchdev_fdb_populate(br, &item, fdb, ctx);
293
294 err = nb->notifier_call(nb, action, &item);
295 return notifier_to_errno(err);
296 }
297
298 static int
br_switchdev_fdb_replay(const struct net_device * br_dev,const void * ctx,bool adding,struct notifier_block * nb)299 br_switchdev_fdb_replay(const struct net_device *br_dev, const void *ctx,
300 bool adding, struct notifier_block *nb)
301 {
302 struct net_bridge_fdb_entry *fdb;
303 struct net_bridge *br;
304 unsigned long action;
305 int err = 0;
306
307 if (!nb)
308 return 0;
309
310 if (!netif_is_bridge_master(br_dev))
311 return -EINVAL;
312
313 br = netdev_priv(br_dev);
314
315 if (adding)
316 action = SWITCHDEV_FDB_ADD_TO_DEVICE;
317 else
318 action = SWITCHDEV_FDB_DEL_TO_DEVICE;
319
320 rcu_read_lock();
321
322 hlist_for_each_entry_rcu(fdb, &br->fdb_list, fdb_node) {
323 err = br_switchdev_fdb_replay_one(br, nb, fdb, action, ctx);
324 if (err)
325 break;
326 }
327
328 rcu_read_unlock();
329
330 return err;
331 }
332
333 static int
br_switchdev_vlan_replay_one(struct notifier_block * nb,struct net_device * dev,struct switchdev_obj_port_vlan * vlan,const void * ctx,unsigned long action,struct netlink_ext_ack * extack)334 br_switchdev_vlan_replay_one(struct notifier_block *nb,
335 struct net_device *dev,
336 struct switchdev_obj_port_vlan *vlan,
337 const void *ctx, unsigned long action,
338 struct netlink_ext_ack *extack)
339 {
340 struct switchdev_notifier_port_obj_info obj_info = {
341 .info = {
342 .dev = dev,
343 .extack = extack,
344 .ctx = ctx,
345 },
346 .obj = &vlan->obj,
347 };
348 int err;
349
350 err = nb->notifier_call(nb, action, &obj_info);
351 return notifier_to_errno(err);
352 }
353
br_switchdev_vlan_replay(struct net_device * br_dev,struct net_device * dev,const void * ctx,bool adding,struct notifier_block * nb,struct netlink_ext_ack * extack)354 static int br_switchdev_vlan_replay(struct net_device *br_dev,
355 struct net_device *dev,
356 const void *ctx, bool adding,
357 struct notifier_block *nb,
358 struct netlink_ext_ack *extack)
359 {
360 struct net_bridge_vlan_group *vg;
361 struct net_bridge_vlan *v;
362 struct net_bridge_port *p;
363 struct net_bridge *br;
364 unsigned long action;
365 int err = 0;
366 u16 pvid;
367
368 ASSERT_RTNL();
369
370 if (!nb)
371 return 0;
372
373 if (!netif_is_bridge_master(br_dev))
374 return -EINVAL;
375
376 if (!netif_is_bridge_master(dev) && !netif_is_bridge_port(dev))
377 return -EINVAL;
378
379 if (netif_is_bridge_master(dev)) {
380 br = netdev_priv(dev);
381 vg = br_vlan_group(br);
382 p = NULL;
383 } else {
384 p = br_port_get_rtnl(dev);
385 if (WARN_ON(!p))
386 return -EINVAL;
387 vg = nbp_vlan_group(p);
388 br = p->br;
389 }
390
391 if (!vg)
392 return 0;
393
394 if (adding)
395 action = SWITCHDEV_PORT_OBJ_ADD;
396 else
397 action = SWITCHDEV_PORT_OBJ_DEL;
398
399 pvid = br_get_pvid(vg);
400
401 list_for_each_entry(v, &vg->vlan_list, vlist) {
402 struct switchdev_obj_port_vlan vlan = {
403 .obj.orig_dev = dev,
404 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
405 .flags = br_vlan_flags(v, pvid),
406 .vid = v->vid,
407 };
408
409 if (!br_vlan_should_use(v))
410 continue;
411
412 err = br_switchdev_vlan_replay_one(nb, dev, &vlan, ctx,
413 action, extack);
414 if (err)
415 return err;
416 }
417
418 return err;
419 }
420
421 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
422 struct br_switchdev_mdb_complete_info {
423 struct net_bridge_port *port;
424 struct br_ip ip;
425 };
426
br_switchdev_mdb_complete(struct net_device * dev,int err,void * priv)427 static void br_switchdev_mdb_complete(struct net_device *dev, int err, void *priv)
428 {
429 struct br_switchdev_mdb_complete_info *data = priv;
430 struct net_bridge_port_group __rcu **pp;
431 struct net_bridge_port_group *p;
432 struct net_bridge_mdb_entry *mp;
433 struct net_bridge_port *port = data->port;
434 struct net_bridge *br = port->br;
435
436 if (err)
437 goto err;
438
439 spin_lock_bh(&br->multicast_lock);
440 mp = br_mdb_ip_get(br, &data->ip);
441 if (!mp)
442 goto out;
443 for (pp = &mp->ports; (p = mlock_dereference(*pp, br)) != NULL;
444 pp = &p->next) {
445 if (p->key.port != port)
446 continue;
447 p->flags |= MDB_PG_FLAGS_OFFLOAD;
448 }
449 out:
450 spin_unlock_bh(&br->multicast_lock);
451 err:
452 kfree(priv);
453 }
454
br_switchdev_mdb_populate(struct switchdev_obj_port_mdb * mdb,const struct net_bridge_mdb_entry * mp)455 static void br_switchdev_mdb_populate(struct switchdev_obj_port_mdb *mdb,
456 const struct net_bridge_mdb_entry *mp)
457 {
458 if (mp->addr.proto == htons(ETH_P_IP))
459 ip_eth_mc_map(mp->addr.dst.ip4, mdb->addr);
460 #if IS_ENABLED(CONFIG_IPV6)
461 else if (mp->addr.proto == htons(ETH_P_IPV6))
462 ipv6_eth_mc_map(&mp->addr.dst.ip6, mdb->addr);
463 #endif
464 else
465 ether_addr_copy(mdb->addr, mp->addr.dst.mac_addr);
466
467 mdb->vid = mp->addr.vid;
468 }
469
br_switchdev_host_mdb_one(struct net_device * dev,struct net_device * lower_dev,struct net_bridge_mdb_entry * mp,int type)470 static void br_switchdev_host_mdb_one(struct net_device *dev,
471 struct net_device *lower_dev,
472 struct net_bridge_mdb_entry *mp,
473 int type)
474 {
475 struct switchdev_obj_port_mdb mdb = {
476 .obj = {
477 .id = SWITCHDEV_OBJ_ID_HOST_MDB,
478 .flags = SWITCHDEV_F_DEFER,
479 .orig_dev = dev,
480 },
481 };
482
483 br_switchdev_mdb_populate(&mdb, mp);
484
485 switch (type) {
486 case RTM_NEWMDB:
487 switchdev_port_obj_add(lower_dev, &mdb.obj, NULL);
488 break;
489 case RTM_DELMDB:
490 switchdev_port_obj_del(lower_dev, &mdb.obj);
491 break;
492 }
493 }
494
br_switchdev_host_mdb(struct net_device * dev,struct net_bridge_mdb_entry * mp,int type)495 static void br_switchdev_host_mdb(struct net_device *dev,
496 struct net_bridge_mdb_entry *mp, int type)
497 {
498 struct net_device *lower_dev;
499 struct list_head *iter;
500
501 netdev_for_each_lower_dev(dev, lower_dev, iter)
502 br_switchdev_host_mdb_one(dev, lower_dev, mp, type);
503 }
504
505 static int
br_switchdev_mdb_replay_one(struct notifier_block * nb,struct net_device * dev,const struct switchdev_obj_port_mdb * mdb,unsigned long action,const void * ctx,struct netlink_ext_ack * extack)506 br_switchdev_mdb_replay_one(struct notifier_block *nb, struct net_device *dev,
507 const struct switchdev_obj_port_mdb *mdb,
508 unsigned long action, const void *ctx,
509 struct netlink_ext_ack *extack)
510 {
511 struct switchdev_notifier_port_obj_info obj_info = {
512 .info = {
513 .dev = dev,
514 .extack = extack,
515 .ctx = ctx,
516 },
517 .obj = &mdb->obj,
518 };
519 int err;
520
521 err = nb->notifier_call(nb, action, &obj_info);
522 return notifier_to_errno(err);
523 }
524
br_switchdev_mdb_queue_one(struct list_head * mdb_list,enum switchdev_obj_id id,const struct net_bridge_mdb_entry * mp,struct net_device * orig_dev)525 static int br_switchdev_mdb_queue_one(struct list_head *mdb_list,
526 enum switchdev_obj_id id,
527 const struct net_bridge_mdb_entry *mp,
528 struct net_device *orig_dev)
529 {
530 struct switchdev_obj_port_mdb *mdb;
531
532 mdb = kzalloc(sizeof(*mdb), GFP_ATOMIC);
533 if (!mdb)
534 return -ENOMEM;
535
536 mdb->obj.id = id;
537 mdb->obj.orig_dev = orig_dev;
538 br_switchdev_mdb_populate(mdb, mp);
539 list_add_tail(&mdb->obj.list, mdb_list);
540
541 return 0;
542 }
543
br_switchdev_mdb_notify(struct net_device * dev,struct net_bridge_mdb_entry * mp,struct net_bridge_port_group * pg,int type)544 void br_switchdev_mdb_notify(struct net_device *dev,
545 struct net_bridge_mdb_entry *mp,
546 struct net_bridge_port_group *pg,
547 int type)
548 {
549 struct br_switchdev_mdb_complete_info *complete_info;
550 struct switchdev_obj_port_mdb mdb = {
551 .obj = {
552 .id = SWITCHDEV_OBJ_ID_PORT_MDB,
553 .flags = SWITCHDEV_F_DEFER,
554 },
555 };
556
557 if (!pg)
558 return br_switchdev_host_mdb(dev, mp, type);
559
560 br_switchdev_mdb_populate(&mdb, mp);
561
562 mdb.obj.orig_dev = pg->key.port->dev;
563 switch (type) {
564 case RTM_NEWMDB:
565 complete_info = kmalloc(sizeof(*complete_info), GFP_ATOMIC);
566 if (!complete_info)
567 break;
568 complete_info->port = pg->key.port;
569 complete_info->ip = mp->addr;
570 mdb.obj.complete_priv = complete_info;
571 mdb.obj.complete = br_switchdev_mdb_complete;
572 if (switchdev_port_obj_add(pg->key.port->dev, &mdb.obj, NULL))
573 kfree(complete_info);
574 break;
575 case RTM_DELMDB:
576 switchdev_port_obj_del(pg->key.port->dev, &mdb.obj);
577 break;
578 }
579 }
580 #endif
581
582 static int
br_switchdev_mdb_replay(struct net_device * br_dev,struct net_device * dev,const void * ctx,bool adding,struct notifier_block * nb,struct netlink_ext_ack * extack)583 br_switchdev_mdb_replay(struct net_device *br_dev, struct net_device *dev,
584 const void *ctx, bool adding, struct notifier_block *nb,
585 struct netlink_ext_ack *extack)
586 {
587 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
588 const struct net_bridge_mdb_entry *mp;
589 struct switchdev_obj *obj, *tmp;
590 struct net_bridge *br;
591 unsigned long action;
592 LIST_HEAD(mdb_list);
593 int err = 0;
594
595 ASSERT_RTNL();
596
597 if (!nb)
598 return 0;
599
600 if (!netif_is_bridge_master(br_dev) || !netif_is_bridge_port(dev))
601 return -EINVAL;
602
603 br = netdev_priv(br_dev);
604
605 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
606 return 0;
607
608 /* We cannot walk over br->mdb_list protected just by the rtnl_mutex,
609 * because the write-side protection is br->multicast_lock. But we
610 * need to emulate the [ blocking ] calling context of a regular
611 * switchdev event, so since both br->multicast_lock and RCU read side
612 * critical sections are atomic, we have no choice but to pick the RCU
613 * read side lock, queue up all our events, leave the critical section
614 * and notify switchdev from blocking context.
615 */
616 rcu_read_lock();
617
618 hlist_for_each_entry_rcu(mp, &br->mdb_list, mdb_node) {
619 struct net_bridge_port_group __rcu * const *pp;
620 const struct net_bridge_port_group *p;
621
622 if (mp->host_joined) {
623 err = br_switchdev_mdb_queue_one(&mdb_list,
624 SWITCHDEV_OBJ_ID_HOST_MDB,
625 mp, br_dev);
626 if (err) {
627 rcu_read_unlock();
628 goto out_free_mdb;
629 }
630 }
631
632 for (pp = &mp->ports; (p = rcu_dereference(*pp)) != NULL;
633 pp = &p->next) {
634 if (p->key.port->dev != dev)
635 continue;
636
637 err = br_switchdev_mdb_queue_one(&mdb_list,
638 SWITCHDEV_OBJ_ID_PORT_MDB,
639 mp, dev);
640 if (err) {
641 rcu_read_unlock();
642 goto out_free_mdb;
643 }
644 }
645 }
646
647 rcu_read_unlock();
648
649 if (adding)
650 action = SWITCHDEV_PORT_OBJ_ADD;
651 else
652 action = SWITCHDEV_PORT_OBJ_DEL;
653
654 list_for_each_entry(obj, &mdb_list, list) {
655 err = br_switchdev_mdb_replay_one(nb, dev,
656 SWITCHDEV_OBJ_PORT_MDB(obj),
657 action, ctx, extack);
658 if (err)
659 goto out_free_mdb;
660 }
661
662 out_free_mdb:
663 list_for_each_entry_safe(obj, tmp, &mdb_list, list) {
664 list_del(&obj->list);
665 kfree(SWITCHDEV_OBJ_PORT_MDB(obj));
666 }
667
668 if (err)
669 return err;
670 #endif
671
672 return 0;
673 }
674
nbp_switchdev_sync_objs(struct net_bridge_port * p,const void * ctx,struct notifier_block * atomic_nb,struct notifier_block * blocking_nb,struct netlink_ext_ack * extack)675 static int nbp_switchdev_sync_objs(struct net_bridge_port *p, const void *ctx,
676 struct notifier_block *atomic_nb,
677 struct notifier_block *blocking_nb,
678 struct netlink_ext_ack *extack)
679 {
680 struct net_device *br_dev = p->br->dev;
681 struct net_device *dev = p->dev;
682 int err;
683
684 err = br_switchdev_vlan_replay(br_dev, dev, ctx, true, blocking_nb,
685 extack);
686 if (err && err != -EOPNOTSUPP)
687 return err;
688
689 err = br_switchdev_mdb_replay(br_dev, dev, ctx, true, blocking_nb,
690 extack);
691 if (err && err != -EOPNOTSUPP)
692 return err;
693
694 err = br_switchdev_fdb_replay(br_dev, ctx, true, atomic_nb);
695 if (err && err != -EOPNOTSUPP)
696 return err;
697
698 return 0;
699 }
700
nbp_switchdev_unsync_objs(struct net_bridge_port * p,const void * ctx,struct notifier_block * atomic_nb,struct notifier_block * blocking_nb)701 static void nbp_switchdev_unsync_objs(struct net_bridge_port *p,
702 const void *ctx,
703 struct notifier_block *atomic_nb,
704 struct notifier_block *blocking_nb)
705 {
706 struct net_device *br_dev = p->br->dev;
707 struct net_device *dev = p->dev;
708
709 br_switchdev_vlan_replay(br_dev, dev, ctx, false, blocking_nb, NULL);
710
711 br_switchdev_mdb_replay(br_dev, dev, ctx, false, blocking_nb, NULL);
712
713 br_switchdev_fdb_replay(br_dev, ctx, false, atomic_nb);
714 }
715
716 /* Let the bridge know that this port is offloaded, so that it can assign a
717 * switchdev hardware domain to it.
718 */
br_switchdev_port_offload(struct net_bridge_port * p,struct net_device * dev,const void * ctx,struct notifier_block * atomic_nb,struct notifier_block * blocking_nb,bool tx_fwd_offload,struct netlink_ext_ack * extack)719 int br_switchdev_port_offload(struct net_bridge_port *p,
720 struct net_device *dev, const void *ctx,
721 struct notifier_block *atomic_nb,
722 struct notifier_block *blocking_nb,
723 bool tx_fwd_offload,
724 struct netlink_ext_ack *extack)
725 {
726 struct netdev_phys_item_id ppid;
727 int err;
728
729 err = dev_get_port_parent_id(dev, &ppid, false);
730 if (err)
731 return err;
732
733 err = nbp_switchdev_add(p, ppid, tx_fwd_offload, extack);
734 if (err)
735 return err;
736
737 err = nbp_switchdev_sync_objs(p, ctx, atomic_nb, blocking_nb, extack);
738 if (err)
739 goto out_switchdev_del;
740
741 return 0;
742
743 out_switchdev_del:
744 nbp_switchdev_del(p);
745
746 return err;
747 }
748
br_switchdev_port_unoffload(struct net_bridge_port * p,const void * ctx,struct notifier_block * atomic_nb,struct notifier_block * blocking_nb)749 void br_switchdev_port_unoffload(struct net_bridge_port *p, const void *ctx,
750 struct notifier_block *atomic_nb,
751 struct notifier_block *blocking_nb)
752 {
753 nbp_switchdev_unsync_objs(p, ctx, atomic_nb, blocking_nb);
754
755 nbp_switchdev_del(p);
756 }
757