Debian Codegraph @

net/bridge/br_fdb.c

raw
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Forwarding database
4 * Linux ethernet bridge
5 *
6 * Authors:
7 * Lennert Buytenhek <[email protected]>
8 */
9
10 #include <linux/kernel.h>
11 #include <linux/init.h>
12 #include <linux/rculist.h>
13 #include <linux/spinlock.h>
14 #include <linux/times.h>
15 #include <linux/netdevice.h>
16 #include <linux/etherdevice.h>
17 #include <linux/jhash.h>
18 #include <linux/random.h>
19 #include <linux/slab.h>
20 #include <linux/atomic.h>
21 #include <linux/unaligned.h>
22 #include <linux/if_vlan.h>
23 #include <net/switchdev.h>
24 #include <trace/events/bridge.h>
25 #include "br_private.h"
26
27 static const struct rhashtable_params br_fdb_rht_params = {
28 .head_offset = offsetof(struct net_bridge_fdb_entry, rhnode),
29 .key_offset = offsetof(struct net_bridge_fdb_entry, key),
30 .key_len = sizeof(struct net_bridge_fdb_key),
31 .automatic_shrinking = true,
32 };
33
34 static struct kmem_cache *br_fdb_cache __read_mostly;
35
36 int __init br_fdb_init(void)
37 {
38 br_fdb_cache = KMEM_CACHE(net_bridge_fdb_entry, SLAB_HWCACHE_ALIGN);
39 if (!br_fdb_cache)
40 return -ENOMEM;
41
42 return 0;
43 }
44
45 void br_fdb_fini(void)
46 {
47 kmem_cache_destroy(br_fdb_cache);
48 }
49
50 int br_fdb_hash_init(struct net_bridge *br)
51 {
52 return rhashtable_init(&br->fdb_hash_tbl, &br_fdb_rht_params);
53 }
54
55 void br_fdb_hash_fini(struct net_bridge *br)
56 {
57 rhashtable_destroy(&br->fdb_hash_tbl);
58 }
59
60 /* if topology_changing then use forward_delay (default 15 sec)
61 * otherwise keep longer (default 5 minutes)
62 */
63 static inline unsigned long hold_time(const struct net_bridge *br)
64 {
65 return br->topology_change ? br->forward_delay : br->ageing_time;
66 }
67
68 static inline int has_expired(const struct net_bridge *br,
69 const struct net_bridge_fdb_entry *fdb)
70 {
71 return !test_bit(BR_FDB_STATIC, &fdb->flags) &&
72 !test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags) &&
73 time_before_eq(READ_ONCE(fdb->updated) + hold_time(br), jiffies);
74 }
75
76 static int fdb_to_nud(const struct net_bridge *br,
77 const struct net_bridge_fdb_entry *fdb)
78 {
79 if (test_bit(BR_FDB_LOCAL, &fdb->flags))
80 return NUD_PERMANENT;
81 else if (test_bit(BR_FDB_STATIC, &fdb->flags))
82 return NUD_NOARP;
83 else if (has_expired(br, fdb))
84 return NUD_STALE;
85 else
86 return NUD_REACHABLE;
87 }
88
89 static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
90 const struct net_bridge_fdb_entry *fdb,
91 u32 portid, u32 seq, int type, unsigned int flags)
92 {
93 const struct net_bridge_port *dst = READ_ONCE(fdb->dst);
94 unsigned long now = jiffies;
95 struct nda_cacheinfo ci;
96 struct nlmsghdr *nlh;
97 struct ndmsg *ndm;
98 u32 ext_flags = 0;
99
100 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
101 if (nlh == NULL)
102 return -EMSGSIZE;
103
104 ndm = nlmsg_data(nlh);
105 ndm->ndm_family = AF_BRIDGE;
106 ndm->ndm_pad1 = 0;
107 ndm->ndm_pad2 = 0;
108 ndm->ndm_flags = 0;
109 ndm->ndm_type = 0;
110 ndm->ndm_ifindex = dst ? dst->dev->ifindex : br->dev->ifindex;
111 ndm->ndm_state = fdb_to_nud(br, fdb);
112
113 if (test_bit(BR_FDB_OFFLOADED, &fdb->flags))
114 ndm->ndm_flags |= NTF_OFFLOADED;
115 if (test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags))
116 ndm->ndm_flags |= NTF_EXT_LEARNED;
117 if (test_bit(BR_FDB_STICKY, &fdb->flags))
118 ndm->ndm_flags |= NTF_STICKY;
119 if (test_bit(BR_FDB_LOCKED, &fdb->flags))
120 ext_flags |= NTF_EXT_LOCKED;
121
122 if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->key.addr))
123 goto nla_put_failure;
124 if (nla_put_u32(skb, NDA_MASTER, br->dev->ifindex))
125 goto nla_put_failure;
126 if (nla_put_u32(skb, NDA_FLAGS_EXT, ext_flags))
127 goto nla_put_failure;
128
129 ci.ndm_used = jiffies_to_clock_t(now - READ_ONCE(fdb->used));
130 ci.ndm_confirmed = 0;
131 ci.ndm_updated = jiffies_to_clock_t(now - READ_ONCE(fdb->updated));
132 ci.ndm_refcnt = 0;
133 if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
134 goto nla_put_failure;
135
136 if (fdb->key.vlan_id && nla_put(skb, NDA_VLAN, sizeof(u16),
137 &fdb->key.vlan_id))
138 goto nla_put_failure;
139
140 if (test_bit(BR_FDB_NOTIFY, &fdb->flags)) {
141 struct nlattr *nest = nla_nest_start(skb, NDA_FDB_EXT_ATTRS);
142 u8 notify_bits = FDB_NOTIFY_BIT;
143
144 if (!nest)
145 goto nla_put_failure;
146 if (test_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags))
147 notify_bits |= FDB_NOTIFY_INACTIVE_BIT;
148
149 if (nla_put_u8(skb, NFEA_ACTIVITY_NOTIFY, notify_bits)) {
150 nla_nest_cancel(skb, nest);
151 goto nla_put_failure;
152 }
153
154 nla_nest_end(skb, nest);
155 }
156
157 nlmsg_end(skb, nlh);
158 return 0;
159
160 nla_put_failure:
161 nlmsg_cancel(skb, nlh);
162 return -EMSGSIZE;
163 }
164
165 static inline size_t fdb_nlmsg_size(void)
166 {
167 return NLMSG_ALIGN(sizeof(struct ndmsg))
168 + nla_total_size(ETH_ALEN) /* NDA_LLADDR */
169 + nla_total_size(sizeof(u32)) /* NDA_MASTER */
170 + nla_total_size(sizeof(u32)) /* NDA_FLAGS_EXT */
171 + nla_total_size(sizeof(u16)) /* NDA_VLAN */
172 + nla_total_size(sizeof(struct nda_cacheinfo))
173 + nla_total_size(0) /* NDA_FDB_EXT_ATTRS */
174 + nla_total_size(sizeof(u8)); /* NFEA_ACTIVITY_NOTIFY */
175 }
176
177 static void fdb_notify(struct net_bridge *br,
178 const struct net_bridge_fdb_entry *fdb, int type,
179 bool swdev_notify)
180 {
181 struct net *net = dev_net(br->dev);
182 struct sk_buff *skb;
183 int err = -ENOBUFS;
184
185 if (swdev_notify)
186 br_switchdev_fdb_notify(br, fdb, type);
187
188 skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
189 if (skb == NULL)
190 goto errout;
191
192 err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
193 if (err < 0) {
194 /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */
195 WARN_ON(err == -EMSGSIZE);
196 kfree_skb(skb);
197 goto errout;
198 }
199 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
200 return;
201 errout:
202 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
203 }
204
205 static struct net_bridge_fdb_entry *fdb_find_rcu(struct rhashtable *tbl,
206 const unsigned char *addr,
207 __u16 vid)
208 {
209 struct net_bridge_fdb_key key;
210
211 WARN_ON_ONCE(!rcu_read_lock_held());
212
213 key.vlan_id = vid;
214 memcpy(key.addr.addr, addr, sizeof(key.addr.addr));
215
216 return rhashtable_lookup(tbl, &key, br_fdb_rht_params);
217 }
218
219 /* requires bridge hash_lock */
220 static struct net_bridge_fdb_entry *br_fdb_find(struct net_bridge *br,
221 const unsigned char *addr,
222 __u16 vid)
223 {
224 struct net_bridge_fdb_entry *fdb;
225
226 lockdep_assert_held_once(&br->hash_lock);
227
228 rcu_read_lock();
229 fdb = fdb_find_rcu(&br->fdb_hash_tbl, addr, vid);
230 rcu_read_unlock();
231
232 return fdb;
233 }
234
235 struct net_device *br_fdb_find_port(const struct net_device *br_dev,
236 const unsigned char *addr,
237 __u16 vid)
238 {
239 const struct net_bridge_port *dst;
240 struct net_bridge_fdb_entry *f;
241 struct net_device *dev = NULL;
242 struct net_bridge *br;
243
244 ASSERT_RTNL();
245
246 if (!netif_is_bridge_master(br_dev))
247 return NULL;
248
249 br = netdev_priv(br_dev);
250 rcu_read_lock();
251 f = br_fdb_find_rcu(br, addr, vid);
252 if (f) {
253 dst = READ_ONCE(f->dst);
254 if (dst)
255 dev = dst->dev;
256 }
257 rcu_read_unlock();
258
259 return dev;
260 }
261 EXPORT_SYMBOL_GPL(br_fdb_find_port);
262
263 struct net_bridge_fdb_entry *br_fdb_find_rcu(struct net_bridge *br,
264 const unsigned char *addr,
265 __u16 vid)
266 {
267 return fdb_find_rcu(&br->fdb_hash_tbl, addr, vid);
268 }
269
270 /* When a static FDB entry is added, the mac address from the entry is
271 * added to the bridge private HW address list and all required ports
272 * are then updated with the new information.
273 * Called under RTNL.
274 */
275 static void fdb_add_hw_addr(struct net_bridge *br, const unsigned char *addr)
276 {
277 int err;
278 struct net_bridge_port *p;
279
280 ASSERT_RTNL();
281
282 list_for_each_entry(p, &br->port_list, list) {
283 if (!br_promisc_port(p)) {
284 err = dev_uc_add(p->dev, addr);
285 if (err)
286 goto undo;
287 }
288 }
289
290 return;
291 undo:
292 list_for_each_entry_continue_reverse(p, &br->port_list, list) {
293 if (!br_promisc_port(p))
294 dev_uc_del(p->dev, addr);
295 }
296 }
297
298 /* When a static FDB entry is deleted, the HW address from that entry is
299 * also removed from the bridge private HW address list and updates all
300 * the ports with needed information.
301 * Called under RTNL.
302 */
303 static void fdb_del_hw_addr(struct net_bridge *br, const unsigned char *addr)
304 {
305 struct net_bridge_port *p;
306
307 ASSERT_RTNL();
308
309 list_for_each_entry(p, &br->port_list, list) {
310 if (!br_promisc_port(p))
311 dev_uc_del(p->dev, addr);
312 }
313 }
314
315 static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f,
316 bool swdev_notify)
317 {
318 trace_fdb_delete(br, f);
319
320 if (test_bit(BR_FDB_STATIC, &f->flags))
321 fdb_del_hw_addr(br, f->key.addr.addr);
322
323 hlist_del_init_rcu(&f->fdb_node);
324 rhashtable_remove_fast(&br->fdb_hash_tbl, &f->rhnode,
325 br_fdb_rht_params);
326 if (test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED, &f->flags))
327 atomic_dec(&br->fdb_n_learned);
328 fdb_notify(br, f, RTM_DELNEIGH, swdev_notify);
329 kfree_rcu(f, rcu);
330 }
331
332 /* Delete a local entry if no other port had the same address.
333 *
334 * This function should only be called on entries with BR_FDB_LOCAL set,
335 * so even with BR_FDB_ADDED_BY_USER cleared we never need to increase
336 * the accounting for dynamically learned entries again.
337 */
338 static void fdb_delete_local(struct net_bridge *br,
339 const struct net_bridge_port *p,
340 struct net_bridge_fdb_entry *f)
341 {
342 const unsigned char *addr = f->key.addr.addr;
343 struct net_bridge_vlan_group *vg;
344 const struct net_bridge_vlan *v;
345 struct net_bridge_port *op;
346 u16 vid = f->key.vlan_id;
347
348 /* Maybe another port has same hw addr? */
349 list_for_each_entry(op, &br->port_list, list) {
350 vg = nbp_vlan_group(op);
351 if (op != p && ether_addr_equal(op->dev->dev_addr, addr) &&
352 (!vid || br_vlan_find(vg, vid))) {
353 WRITE_ONCE(f->dst, op);
354 clear_bit(BR_FDB_ADDED_BY_USER, &f->flags);
355 return;
356 }
357 }
358
359 vg = br_vlan_group(br);
360 v = br_vlan_find(vg, vid);
361 /* Maybe bridge device has same hw addr? */
362 if (p && ether_addr_equal(br->dev->dev_addr, addr) &&
363 (!vid || (v && br_vlan_should_use(v)))) {
364 WRITE_ONCE(f->dst, NULL);
365 clear_bit(BR_FDB_ADDED_BY_USER, &f->flags);
366 return;
367 }
368
369 fdb_delete(br, f, true);
370 }
371
372 void br_fdb_find_delete_local(struct net_bridge *br,
373 const struct net_bridge_port *p,
374 const unsigned char *addr, u16 vid)
375 {
376 struct net_bridge_fdb_entry *f;
377
378 spin_lock_bh(&br->hash_lock);
379 f = br_fdb_find(br, addr, vid);
380 if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
381 !test_bit(BR_FDB_ADDED_BY_USER, &f->flags) && f->dst == p)
382 fdb_delete_local(br, p, f);
383 spin_unlock_bh(&br->hash_lock);
384 }
385
386 static struct net_bridge_fdb_entry *fdb_create(struct net_bridge *br,
387 struct net_bridge_port *source,
388 const unsigned char *addr,
389 __u16 vid,
390 unsigned long flags)
391 {
392 bool learned = !test_bit(BR_FDB_ADDED_BY_USER, &flags) &&
393 !test_bit(BR_FDB_LOCAL, &flags);
394 u32 max_learned = READ_ONCE(br->fdb_max_learned);
395 struct net_bridge_fdb_entry *fdb;
396 int err;
397
398 if (likely(learned)) {
399 int n_learned = atomic_read(&br->fdb_n_learned);
400
401 if (unlikely(max_learned && n_learned >= max_learned))
402 return NULL;
403 __set_bit(BR_FDB_DYNAMIC_LEARNED, &flags);
404 }
405
406 fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
407 if (!fdb)
408 return NULL;
409
410 memcpy(fdb->key.addr.addr, addr, ETH_ALEN);
411 WRITE_ONCE(fdb->dst, source);
412 fdb->key.vlan_id = vid;
413 fdb->flags = flags;
414 fdb->updated = fdb->used = jiffies;
415 err = rhashtable_lookup_insert_fast(&br->fdb_hash_tbl, &fdb->rhnode,
416 br_fdb_rht_params);
417 if (err) {
418 kmem_cache_free(br_fdb_cache, fdb);
419 return NULL;
420 }
421
422 if (likely(learned))
423 atomic_inc(&br->fdb_n_learned);
424
425 hlist_add_head_rcu(&fdb->fdb_node, &br->fdb_list);
426
427 return fdb;
428 }
429
430 static int fdb_add_local(struct net_bridge *br, struct net_bridge_port *source,
431 const unsigned char *addr, u16 vid)
432 {
433 struct net_bridge_fdb_entry *fdb;
434
435 if (!is_valid_ether_addr(addr))
436 return -EINVAL;
437
438 fdb = br_fdb_find(br, addr, vid);
439 if (fdb) {
440 /* it is okay to have multiple ports with same
441 * address, just use the first one.
442 */
443 if (test_bit(BR_FDB_LOCAL, &fdb->flags))
444 return 0;
445 br_warn(br, "adding interface %s with same address as a received packet (addr:%pM, vlan:%u)\n",
446 source ? source->dev->name : br->dev->name, addr, vid);
447 fdb_delete(br, fdb, true);
448 }
449
450 fdb = fdb_create(br, source, addr, vid,
451 BIT(BR_FDB_LOCAL) | BIT(BR_FDB_STATIC));
452 if (!fdb)
453 return -ENOMEM;
454
455 fdb_add_hw_addr(br, addr);
456 fdb_notify(br, fdb, RTM_NEWNEIGH, true);
457 return 0;
458 }
459
460 void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
461 {
462 struct net_bridge_vlan_group *vg;
463 struct net_bridge_fdb_entry *f;
464 struct net_bridge *br = p->br;
465 struct net_bridge_vlan *v;
466 bool local_vlan_0;
467
468 local_vlan_0 = br_opt_get(br, BROPT_FDB_LOCAL_VLAN_0);
469
470 spin_lock_bh(&br->hash_lock);
471 vg = nbp_vlan_group(p);
472 hlist_for_each_entry(f, &br->fdb_list, fdb_node) {
473 if (f->dst == p && test_bit(BR_FDB_LOCAL, &f->flags) &&
474 !test_bit(BR_FDB_ADDED_BY_USER, &f->flags)) {
475 /* delete old one */
476 fdb_delete_local(br, p, f);
477
478 /* if this port has no vlan information configured, or
479 * local entries are only kept on VLAN 0, we can safely
480 * be done at this point.
481 */
482 if (!vg || !vg->num_vlans || local_vlan_0)
483 goto insert;
484 }
485 }
486
487 insert:
488 /* insert new address, may fail if invalid address or dup. */
489 fdb_add_local(br, p, newaddr, 0);
490
491 if (!vg || !vg->num_vlans || local_vlan_0)
492 goto done;
493
494 /* Now add entries for every VLAN configured on the port.
495 * This function runs under RTNL so the bitmap will not change
496 * from under us.
497 */
498 list_for_each_entry(v, &vg->vlan_list, vlist)
499 fdb_add_local(br, p, newaddr, v->vid);
500
501 done:
502 spin_unlock_bh(&br->hash_lock);
503 }
504
505 void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
506 {
507 struct net_bridge_vlan_group *vg;
508 struct net_bridge_fdb_entry *f;
509 struct net_bridge_vlan *v;
510 bool local_vlan_0;
511
512 local_vlan_0 = br_opt_get(br, BROPT_FDB_LOCAL_VLAN_0);
513
514 spin_lock_bh(&br->hash_lock);
515
516 /* If old entry was unassociated with any port, then delete it. */
517 f = br_fdb_find(br, br->dev->dev_addr, 0);
518 if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
519 !f->dst && !test_bit(BR_FDB_ADDED_BY_USER, &f->flags))
520 fdb_delete_local(br, NULL, f);
521
522 fdb_add_local(br, NULL, newaddr, 0);
523 vg = br_vlan_group(br);
524 if (!vg || !vg->num_vlans || local_vlan_0)
525 goto out;
526 /* Now remove and add entries for every VLAN configured on the
527 * bridge. This function runs under RTNL so the bitmap will not
528 * change from under us.
529 */
530 list_for_each_entry(v, &vg->vlan_list, vlist) {
531 if (!br_vlan_should_use(v))
532 continue;
533 f = br_fdb_find(br, br->dev->dev_addr, v->vid);
534 if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
535 !f->dst && !test_bit(BR_FDB_ADDED_BY_USER, &f->flags))
536 fdb_delete_local(br, NULL, f);
537 fdb_add_local(br, NULL, newaddr, v->vid);
538 }
539 out:
540 spin_unlock_bh(&br->hash_lock);
541 }
542
543 void br_fdb_cleanup(struct work_struct *work)
544 {
545 struct net_bridge *br = container_of(work, struct net_bridge,
546 gc_work.work);
547 struct net_bridge_fdb_entry *f = NULL;
548 unsigned long delay = hold_time(br);
549 unsigned long work_delay = delay;
550 unsigned long now = jiffies;
551
552 /* this part is tricky, in order to avoid blocking learning and
553 * consequently forwarding, we rely on rcu to delete objects with
554 * delayed freeing allowing us to continue traversing
555 */
556 rcu_read_lock();
557 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
558 unsigned long this_timer = READ_ONCE(f->updated) + delay;
559
560 if (test_bit(BR_FDB_STATIC, &f->flags) ||
561 test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &f->flags)) {
562 if (test_bit(BR_FDB_NOTIFY, &f->flags)) {
563 if (time_after(this_timer, now))
564 work_delay = min(work_delay,
565 this_timer - now);
566 else if (!test_and_set_bit(BR_FDB_NOTIFY_INACTIVE,
567 &f->flags))
568 fdb_notify(br, f, RTM_NEWNEIGH, false);
569 }
570 continue;
571 }
572
573 if (time_after(this_timer, now)) {
574 work_delay = min(work_delay, this_timer - now);
575 } else {
576 spin_lock_bh(&br->hash_lock);
577 if (!hlist_unhashed(&f->fdb_node))
578 fdb_delete(br, f, true);
579 spin_unlock_bh(&br->hash_lock);
580 }
581 }
582 rcu_read_unlock();
583
584 /* Cleanup minimum 10 milliseconds apart */
585 work_delay = max_t(unsigned long, work_delay, msecs_to_jiffies(10));
586 mod_delayed_work(system_long_wq, &br->gc_work, work_delay);
587 }
588
589 static void br_fdb_delete_locals_per_vlan_port(struct net_bridge *br,
590 struct net_bridge_port *p)
591 {
592 struct net_bridge_vlan_group *vg;
593 struct net_bridge_vlan *v;
594 struct net_device *dev;
595
596 if (p) {
597 vg = nbp_vlan_group(p);
598 dev = p->dev;
599 } else {
600 vg = br_vlan_group(br);
601 dev = br->dev;
602 }
603
604 if (!vg)
605 return;
606
607 list_for_each_entry(v, &vg->vlan_list, vlist)
608 br_fdb_find_delete_local(br, p, dev->dev_addr, v->vid);
609 }
610
611 static void br_fdb_delete_locals_per_vlan(struct net_bridge *br)
612 {
613 struct net_bridge_port *p;
614
615 ASSERT_RTNL();
616
617 list_for_each_entry(p, &br->port_list, list)
618 br_fdb_delete_locals_per_vlan_port(br, p);
619
620 br_fdb_delete_locals_per_vlan_port(br, NULL);
621 }
622
623 static int br_fdb_insert_locals_per_vlan_port(struct net_bridge *br,
624 struct net_bridge_port *p,
625 struct netlink_ext_ack *extack)
626 {
627 struct net_bridge_vlan_group *vg;
628 struct net_bridge_vlan *v;
629 struct net_device *dev;
630 int err;
631
632 if (p) {
633 vg = nbp_vlan_group(p);
634 dev = p->dev;
635 } else {
636 vg = br_vlan_group(br);
637 dev = br->dev;
638 }
639
640 if (!vg)
641 return 0;
642
643 list_for_each_entry(v, &vg->vlan_list, vlist) {
644 if (!br_vlan_should_use(v))
645 continue;
646
647 err = br_fdb_add_local(br, p, dev->dev_addr, v->vid);
648 if (err)
649 return err;
650 }
651
652 return 0;
653 }
654
655 static int br_fdb_insert_locals_per_vlan(struct net_bridge *br,
656 struct netlink_ext_ack *extack)
657 {
658 struct net_bridge_port *p;
659 int err;
660
661 ASSERT_RTNL();
662
663 list_for_each_entry(p, &br->port_list, list) {
664 err = br_fdb_insert_locals_per_vlan_port(br, p, extack);
665 if (err)
666 goto rollback;
667 }
668
669 err = br_fdb_insert_locals_per_vlan_port(br, NULL, extack);
670 if (err)
671 goto rollback;
672
673 return 0;
674
675 rollback:
676 NL_SET_ERR_MSG_MOD(extack, "fdb_local_vlan_0 toggle: FDB entry insertion failed");
677 br_fdb_delete_locals_per_vlan(br);
678 return err;
679 }
680
681 int br_fdb_toggle_local_vlan_0(struct net_bridge *br, bool on,
682 struct netlink_ext_ack *extack)
683 {
684 if (!on)
685 return br_fdb_insert_locals_per_vlan(br, extack);
686
687 br_fdb_delete_locals_per_vlan(br);
688 return 0;
689 }
690
691 static bool __fdb_flush_matches(const struct net_bridge *br,
692 const struct net_bridge_fdb_entry *f,
693 const struct net_bridge_fdb_flush_desc *desc)
694 {
695 const struct net_bridge_port *dst = READ_ONCE(f->dst);
696 int port_ifidx = dst ? dst->dev->ifindex : br->dev->ifindex;
697
698 if (desc->vlan_id && desc->vlan_id != f->key.vlan_id)
699 return false;
700 if (desc->port_ifindex && desc->port_ifindex != port_ifidx)
701 return false;
702 if (desc->flags_mask && (f->flags & desc->flags_mask) != desc->flags)
703 return false;
704
705 return true;
706 }
707
708 /* Flush forwarding database entries matching the description */
709 void br_fdb_flush(struct net_bridge *br,
710 const struct net_bridge_fdb_flush_desc *desc)
711 {
712 struct net_bridge_fdb_entry *f;
713
714 rcu_read_lock();
715 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
716 if (!__fdb_flush_matches(br, f, desc))
717 continue;
718
719 spin_lock_bh(&br->hash_lock);
720 if (!hlist_unhashed(&f->fdb_node))
721 fdb_delete(br, f, true);
722 spin_unlock_bh(&br->hash_lock);
723 }
724 rcu_read_unlock();
725 }
726
727 static unsigned long __ndm_state_to_fdb_flags(u16 ndm_state)
728 {
729 unsigned long flags = 0;
730
731 if (ndm_state & NUD_PERMANENT)
732 __set_bit(BR_FDB_LOCAL, &flags);
733 if (ndm_state & NUD_NOARP)
734 __set_bit(BR_FDB_STATIC, &flags);
735
736 return flags;
737 }
738
739 static unsigned long __ndm_flags_to_fdb_flags(u8 ndm_flags)
740 {
741 unsigned long flags = 0;
742
743 if (ndm_flags & NTF_USE)
744 __set_bit(BR_FDB_ADDED_BY_USER, &flags);
745 if (ndm_flags & NTF_EXT_LEARNED)
746 __set_bit(BR_FDB_ADDED_BY_EXT_LEARN, &flags);
747 if (ndm_flags & NTF_OFFLOADED)
748 __set_bit(BR_FDB_OFFLOADED, &flags);
749 if (ndm_flags & NTF_STICKY)
750 __set_bit(BR_FDB_STICKY, &flags);
751
752 return flags;
753 }
754
755 static int __fdb_flush_validate_ifindex(const struct net_bridge *br,
756 int ifindex,
757 struct netlink_ext_ack *extack)
758 {
759 const struct net_device *dev;
760
761 dev = __dev_get_by_index(dev_net(br->dev), ifindex);
762 if (!dev) {
763 NL_SET_ERR_MSG_MOD(extack, "Unknown flush device ifindex");
764 return -ENODEV;
765 }
766 if (!netif_is_bridge_master(dev) && !netif_is_bridge_port(dev)) {
767 NL_SET_ERR_MSG_MOD(extack, "Flush device is not a bridge or bridge port");
768 return -EINVAL;
769 }
770 if (netif_is_bridge_master(dev) && dev != br->dev) {
771 NL_SET_ERR_MSG_MOD(extack,
772 "Flush bridge device does not match target bridge device");
773 return -EINVAL;
774 }
775 if (netif_is_bridge_port(dev)) {
776 struct net_bridge_port *p = br_port_get_rtnl(dev);
777
778 if (p->br != br) {
779 NL_SET_ERR_MSG_MOD(extack, "Port belongs to a different bridge device");
780 return -EINVAL;
781 }
782 }
783
784 return 0;
785 }
786
787 static const struct nla_policy br_fdb_del_bulk_policy[NDA_MAX + 1] = {
788 [NDA_VLAN] = NLA_POLICY_RANGE(NLA_U16, 1, VLAN_N_VID - 2),
789 [NDA_IFINDEX] = NLA_POLICY_MIN(NLA_S32, 1),
790 [NDA_NDM_STATE_MASK] = { .type = NLA_U16 },
791 [NDA_NDM_FLAGS_MASK] = { .type = NLA_U8 },
792 };
793
794 int br_fdb_delete_bulk(struct nlmsghdr *nlh, struct net_device *dev,
795 struct netlink_ext_ack *extack)
796 {
797 struct net_bridge_fdb_flush_desc desc = {};
798 struct ndmsg *ndm = nlmsg_data(nlh);
799 struct net_bridge_port *p = NULL;
800 struct nlattr *tb[NDA_MAX + 1];
801 struct net_bridge *br;
802 u8 ndm_flags;
803 int err;
804
805 ndm_flags = ndm->ndm_flags & ~FDB_FLUSH_IGNORED_NDM_FLAGS;
806
807 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX,
808 br_fdb_del_bulk_policy, extack);
809 if (err)
810 return err;
811
812 if (netif_is_bridge_master(dev)) {
813 br = netdev_priv(dev);
814 } else {
815 p = br_port_get_rtnl(dev);
816 if (!p) {
817 NL_SET_ERR_MSG_MOD(extack, "Device is not a bridge port");
818 return -EINVAL;
819 }
820 br = p->br;
821 }
822
823 if (tb[NDA_VLAN])
824 desc.vlan_id = nla_get_u16(tb[NDA_VLAN]);
825
826 if (ndm_flags & ~FDB_FLUSH_ALLOWED_NDM_FLAGS) {
827 NL_SET_ERR_MSG(extack, "Unsupported fdb flush ndm flag bits set");
828 return -EINVAL;
829 }
830 if (ndm->ndm_state & ~FDB_FLUSH_ALLOWED_NDM_STATES) {
831 NL_SET_ERR_MSG(extack, "Unsupported fdb flush ndm state bits set");
832 return -EINVAL;
833 }
834
835 desc.flags |= __ndm_state_to_fdb_flags(ndm->ndm_state);
836 desc.flags |= __ndm_flags_to_fdb_flags(ndm_flags);
837 if (tb[NDA_NDM_STATE_MASK]) {
838 u16 ndm_state_mask = nla_get_u16(tb[NDA_NDM_STATE_MASK]);
839
840 desc.flags_mask |= __ndm_state_to_fdb_flags(ndm_state_mask);
841 }
842 if (tb[NDA_NDM_FLAGS_MASK]) {
843 u8 ndm_flags_mask = nla_get_u8(tb[NDA_NDM_FLAGS_MASK]);
844
845 desc.flags_mask |= __ndm_flags_to_fdb_flags(ndm_flags_mask);
846 }
847 if (tb[NDA_IFINDEX]) {
848 int ifidx = nla_get_s32(tb[NDA_IFINDEX]);
849
850 err = __fdb_flush_validate_ifindex(br, ifidx, extack);
851 if (err)
852 return err;
853 desc.port_ifindex = ifidx;
854 } else if (p) {
855 /* flush was invoked with port device and NTF_MASTER */
856 desc.port_ifindex = p->dev->ifindex;
857 }
858
859 br_debug(br, "flushing port ifindex: %d vlan id: %u flags: 0x%lx flags mask: 0x%lx\n",
860 desc.port_ifindex, desc.vlan_id, desc.flags, desc.flags_mask);
861
862 br_fdb_flush(br, &desc);
863
864 return 0;
865 }
866
867 /* Flush all entries referring to a specific port.
868 * if do_all is set also flush static entries
869 * if vid is set delete all entries that match the vlan_id
870 */
871 void br_fdb_delete_by_port(struct net_bridge *br,
872 const struct net_bridge_port *p,
873 u16 vid,
874 int do_all)
875 {
876 struct net_bridge_fdb_entry *f;
877 struct hlist_node *tmp;
878
879 spin_lock_bh(&br->hash_lock);
880 hlist_for_each_entry_safe(f, tmp, &br->fdb_list, fdb_node) {
881 if (f->dst != p)
882 continue;
883
884 if (!do_all)
885 if (test_bit(BR_FDB_STATIC, &f->flags) ||
886 (test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &f->flags) &&
887 !test_bit(BR_FDB_OFFLOADED, &f->flags)) ||
888 (vid && f->key.vlan_id != vid))
889 continue;
890
891 if (test_bit(BR_FDB_LOCAL, &f->flags))
892 fdb_delete_local(br, p, f);
893 else
894 fdb_delete(br, f, true);
895 }
896 spin_unlock_bh(&br->hash_lock);
897 }
898
899 #if IS_ENABLED(CONFIG_ATM_LANE)
900 /* Interface used by ATM LANE hook to test
901 * if an addr is on some other bridge port */
902 int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
903 {
904 struct net_bridge_fdb_entry *fdb;
905 struct net_bridge_port *port;
906 int ret;
907
908 rcu_read_lock();
909 port = br_port_get_rcu(dev);
910 if (!port)
911 ret = 0;
912 else {
913 const struct net_bridge_port *dst = NULL;
914
915 fdb = br_fdb_find_rcu(port->br, addr, 0);
916 if (fdb)
917 dst = READ_ONCE(fdb->dst);
918
919 ret = dst && dst->dev != dev &&
920 dst->state == BR_STATE_FORWARDING;
921 }
922 rcu_read_unlock();
923
924 return ret;
925 }
926 #endif /* CONFIG_ATM_LANE */
927
928 /*
929 * Fill buffer with forwarding table records in
930 * the API format.
931 */
932 int br_fdb_fillbuf(struct net_bridge *br, void *buf,
933 unsigned long maxnum, unsigned long skip)
934 {
935 const struct net_bridge_port *dst;
936 struct net_bridge_fdb_entry *f;
937 struct __fdb_entry *fe = buf;
938 unsigned long delta;
939 int num = 0;
940
941 memset(buf, 0, maxnum*sizeof(struct __fdb_entry));
942
943 rcu_read_lock();
944 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
945 if (num >= maxnum)
946 break;
947
948 if (has_expired(br, f))
949 continue;
950
951 /* ignore pseudo entry for local MAC address */
952 dst = READ_ONCE(f->dst);
953 if (!dst)
954 continue;
955
956 if (skip) {
957 --skip;
958 continue;
959 }
960
961 /* convert from internal format to API */
962 memcpy(fe->mac_addr, f->key.addr.addr, ETH_ALEN);
963
964 /* due to ABI compat need to split into hi/lo */
965 fe->port_no = dst->port_no;
966 fe->port_hi = dst->port_no >> 8;
967
968 fe->is_local = test_bit(BR_FDB_LOCAL, &f->flags);
969 if (!test_bit(BR_FDB_STATIC, &f->flags)) {
970 delta = jiffies - READ_ONCE(f->updated);
971 fe->ageing_timer_value =
972 jiffies_delta_to_clock_t(delta);
973 }
974 ++fe;
975 ++num;
976 }
977 rcu_read_unlock();
978
979 return num;
980 }
981
982 /* Add entry for local address of interface */
983 int br_fdb_add_local(struct net_bridge *br, struct net_bridge_port *source,
984 const unsigned char *addr, u16 vid)
985 {
986 int ret;
987
988 spin_lock_bh(&br->hash_lock);
989 ret = fdb_add_local(br, source, addr, vid);
990 spin_unlock_bh(&br->hash_lock);
991 return ret;
992 }
993
994 /* returns true if the fdb was modified */
995 static bool __fdb_mark_active(struct net_bridge_fdb_entry *fdb)
996 {
997 return !!(test_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags) &&
998 test_and_clear_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags));
999 }
1000
1001 void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
1002 const unsigned char *addr, u16 vid, unsigned long flags)
1003 {
1004 struct net_bridge_fdb_entry *fdb;
1005
1006 /* some users want to always flood. */
1007 if (hold_time(br) == 0)
1008 return;
1009
1010 fdb = fdb_find_rcu(&br->fdb_hash_tbl, addr, vid);
1011 if (likely(fdb)) {
1012 /* attempt to update an entry for a local interface */
1013 if (unlikely(test_bit(BR_FDB_LOCAL, &fdb->flags))) {
1014 if (net_ratelimit())
1015 br_warn(br, "received packet on %s with own address as source address (addr:%pM, vlan:%u)\n",
1016 source->dev->name, addr, vid);
1017 } else {
1018 unsigned long now = jiffies;
1019 bool fdb_modified = false;
1020
1021 if (now != READ_ONCE(fdb->updated)) {
1022 WRITE_ONCE(fdb->updated, now);
1023 fdb_modified = __fdb_mark_active(fdb);
1024 }
1025
1026 /* fastpath: update of existing entry */
1027 if (unlikely(source != READ_ONCE(fdb->dst) &&
1028 !test_bit(BR_FDB_STICKY, &fdb->flags))) {
1029 br_switchdev_fdb_notify(br, fdb, RTM_DELNEIGH);
1030 WRITE_ONCE(fdb->dst, source);
1031 fdb_modified = true;
1032 /* Take over HW learned entry */
1033 if (unlikely(test_bit(BR_FDB_ADDED_BY_EXT_LEARN,
1034 &fdb->flags)))
1035 clear_bit(BR_FDB_ADDED_BY_EXT_LEARN,
1036 &fdb->flags);
1037 /* Clear locked flag when roaming to an
1038 * unlocked port.
1039 */
1040 if (unlikely(test_bit(BR_FDB_LOCKED, &fdb->flags)))
1041 clear_bit(BR_FDB_LOCKED, &fdb->flags);
1042 }
1043
1044 if (unlikely(test_bit(BR_FDB_ADDED_BY_USER, &flags))) {
1045 set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1046 if (test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED,
1047 &fdb->flags))
1048 atomic_dec(&br->fdb_n_learned);
1049 }
1050 if (unlikely(fdb_modified)) {
1051 trace_br_fdb_update(br, source, addr, vid, flags);
1052 fdb_notify(br, fdb, RTM_NEWNEIGH, true);
1053 }
1054 }
1055 } else {
1056 spin_lock(&br->hash_lock);
1057 fdb = fdb_create(br, source, addr, vid, flags);
1058 if (fdb) {
1059 trace_br_fdb_update(br, source, addr, vid, flags);
1060 fdb_notify(br, fdb, RTM_NEWNEIGH, true);
1061 }
1062 /* else we lose race and someone else inserts
1063 * it first, don't bother updating
1064 */
1065 spin_unlock(&br->hash_lock);
1066 }
1067 }
1068
1069 /* Dump information about entries, in response to GETNEIGH */
1070 int br_fdb_dump(struct sk_buff *skb,
1071 struct netlink_callback *cb,
1072 struct net_device *dev,
1073 struct net_device *filter_dev,
1074 int *idx)
1075 {
1076 struct ndo_fdb_dump_context *ctx = (void *)cb->ctx;
1077 struct net_bridge *br = netdev_priv(dev);
1078 struct net_bridge_fdb_entry *f;
1079 int err = 0;
1080
1081 if (!netif_is_bridge_master(dev))
1082 return err;
1083
1084 if (!filter_dev) {
1085 err = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx);
1086 if (err < 0)
1087 return err;
1088 }
1089
1090 rcu_read_lock();
1091 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1092 const struct net_bridge_port *dst = READ_ONCE(f->dst);
1093
1094 if (*idx < ctx->fdb_idx)
1095 goto skip;
1096 if (filter_dev && (!dst || dst->dev != filter_dev)) {
1097 if (filter_dev != dev)
1098 goto skip;
1099 /* !f->dst is a special case for bridge
1100 * It means the MAC belongs to the bridge
1101 * Therefore need a little more filtering
1102 * we only want to dump the !f->dst case
1103 */
1104 if (dst)
1105 goto skip;
1106 }
1107 if (!filter_dev && dst)
1108 goto skip;
1109
1110 err = fdb_fill_info(skb, br, f,
1111 NETLINK_CB(cb->skb).portid,
1112 cb->nlh->nlmsg_seq,
1113 RTM_NEWNEIGH,
1114 NLM_F_MULTI);
1115 if (err < 0)
1116 break;
1117 skip:
1118 *idx += 1;
1119 }
1120 rcu_read_unlock();
1121
1122 return err;
1123 }
1124
1125 int br_fdb_get(struct sk_buff *skb,
1126 struct nlattr *tb[],
1127 struct net_device *dev,
1128 const unsigned char *addr,
1129 u16 vid, u32 portid, u32 seq,
1130 struct netlink_ext_ack *extack)
1131 {
1132 struct net_bridge *br = netdev_priv(dev);
1133 struct net_bridge_fdb_entry *f;
1134 int err = 0;
1135
1136 rcu_read_lock();
1137 f = br_fdb_find_rcu(br, addr, vid);
1138 if (!f) {
1139 NL_SET_ERR_MSG(extack, "Fdb entry not found");
1140 err = -ENOENT;
1141 goto errout;
1142 }
1143
1144 err = fdb_fill_info(skb, br, f, portid, seq,
1145 RTM_NEWNEIGH, 0);
1146 errout:
1147 rcu_read_unlock();
1148 return err;
1149 }
1150
1151 /* returns true if the fdb is modified */
1152 static bool fdb_handle_notify(struct net_bridge_fdb_entry *fdb, u8 notify)
1153 {
1154 bool modified = false;
1155
1156 /* allow to mark an entry as inactive, usually done on creation */
1157 if ((notify & FDB_NOTIFY_INACTIVE_BIT) &&
1158 !test_and_set_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags))
1159 modified = true;
1160
1161 if ((notify & FDB_NOTIFY_BIT) &&
1162 !test_and_set_bit(BR_FDB_NOTIFY, &fdb->flags)) {
1163 /* enabled activity tracking */
1164 modified = true;
1165 } else if (!(notify & FDB_NOTIFY_BIT) &&
1166 test_and_clear_bit(BR_FDB_NOTIFY, &fdb->flags)) {
1167 /* disabled activity tracking, clear notify state */
1168 clear_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags);
1169 modified = true;
1170 }
1171
1172 return modified;
1173 }
1174
1175 /* Update (create or replace) forwarding database entry */
1176 static int fdb_add_entry(struct net_bridge *br, struct net_bridge_port *source,
1177 const u8 *addr, struct ndmsg *ndm, u16 flags, u16 vid,
1178 struct nlattr *nfea_tb[])
1179 {
1180 bool is_sticky = !!(ndm->ndm_flags & NTF_STICKY);
1181 bool refresh = !nfea_tb[NFEA_DONT_REFRESH];
1182 struct net_bridge_fdb_entry *fdb;
1183 u16 state = ndm->ndm_state;
1184 bool modified = false;
1185 u8 notify = 0;
1186
1187 /* If the port cannot learn allow only local and static entries */
1188 if (source && !(state & NUD_PERMANENT) && !(state & NUD_NOARP) &&
1189 !(source->state == BR_STATE_LEARNING ||
1190 source->state == BR_STATE_FORWARDING))
1191 return -EPERM;
1192
1193 if (!source && !(state & NUD_PERMANENT)) {
1194 pr_info("bridge: RTM_NEWNEIGH %s without NUD_PERMANENT\n",
1195 br->dev->name);
1196 return -EINVAL;
1197 }
1198
1199 if (is_sticky && (state & NUD_PERMANENT))
1200 return -EINVAL;
1201
1202 if (nfea_tb[NFEA_ACTIVITY_NOTIFY]) {
1203 notify = nla_get_u8(nfea_tb[NFEA_ACTIVITY_NOTIFY]);
1204 if ((notify & ~BR_FDB_NOTIFY_SETTABLE_BITS) ||
1205 (notify & BR_FDB_NOTIFY_SETTABLE_BITS) == FDB_NOTIFY_INACTIVE_BIT)
1206 return -EINVAL;
1207 }
1208
1209 fdb = br_fdb_find(br, addr, vid);
1210 if (fdb == NULL) {
1211 if (!(flags & NLM_F_CREATE))
1212 return -ENOENT;
1213
1214 fdb = fdb_create(br, source, addr, vid,
1215 BIT(BR_FDB_ADDED_BY_USER));
1216 if (!fdb)
1217 return -ENOMEM;
1218
1219 modified = true;
1220 } else {
1221 if (flags & NLM_F_EXCL)
1222 return -EEXIST;
1223
1224 if (READ_ONCE(fdb->dst) != source) {
1225 WRITE_ONCE(fdb->dst, source);
1226 modified = true;
1227 }
1228
1229 set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1230 if (test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED, &fdb->flags))
1231 atomic_dec(&br->fdb_n_learned);
1232 }
1233
1234 if (fdb_to_nud(br, fdb) != state) {
1235 if (state & NUD_PERMANENT) {
1236 set_bit(BR_FDB_LOCAL, &fdb->flags);
1237 if (!test_and_set_bit(BR_FDB_STATIC, &fdb->flags))
1238 fdb_add_hw_addr(br, addr);
1239 } else if (state & NUD_NOARP) {
1240 clear_bit(BR_FDB_LOCAL, &fdb->flags);
1241 if (!test_and_set_bit(BR_FDB_STATIC, &fdb->flags))
1242 fdb_add_hw_addr(br, addr);
1243 } else {
1244 clear_bit(BR_FDB_LOCAL, &fdb->flags);
1245 if (test_and_clear_bit(BR_FDB_STATIC, &fdb->flags))
1246 fdb_del_hw_addr(br, addr);
1247 }
1248
1249 modified = true;
1250 }
1251
1252 if (is_sticky != test_bit(BR_FDB_STICKY, &fdb->flags)) {
1253 change_bit(BR_FDB_STICKY, &fdb->flags);
1254 modified = true;
1255 }
1256
1257 if (test_and_clear_bit(BR_FDB_LOCKED, &fdb->flags))
1258 modified = true;
1259
1260 if (fdb_handle_notify(fdb, notify))
1261 modified = true;
1262
1263 WRITE_ONCE(fdb->used, jiffies);
1264 if (modified) {
1265 if (refresh)
1266 WRITE_ONCE(fdb->updated, jiffies);
1267 fdb_notify(br, fdb, RTM_NEWNEIGH, true);
1268 }
1269
1270 return 0;
1271 }
1272
1273 static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge *br,
1274 struct net_bridge_port *p, const unsigned char *addr,
1275 u16 nlh_flags, u16 vid, struct nlattr *nfea_tb[],
1276 bool *notified, struct netlink_ext_ack *extack)
1277 {
1278 int err = 0;
1279
1280 if (ndm->ndm_flags & NTF_USE) {
1281 if (!p) {
1282 pr_info("bridge: RTM_NEWNEIGH %s with NTF_USE is not supported\n",
1283 br->dev->name);
1284 return -EINVAL;
1285 }
1286 if (!nbp_state_should_learn(p))
1287 return 0;
1288
1289 local_bh_disable();
1290 rcu_read_lock();
1291 br_fdb_update(br, p, addr, vid, BIT(BR_FDB_ADDED_BY_USER));
1292 rcu_read_unlock();
1293 local_bh_enable();
1294 } else if (ndm->ndm_flags & NTF_EXT_LEARNED) {
1295 if (!p && !(ndm->ndm_state & NUD_PERMANENT)) {
1296 NL_SET_ERR_MSG_MOD(extack,
1297 "FDB entry towards bridge must be permanent");
1298 return -EINVAL;
1299 }
1300 err = br_fdb_external_learn_add(br, p, addr, vid, false, true);
1301 } else {
1302 spin_lock_bh(&br->hash_lock);
1303 err = fdb_add_entry(br, p, addr, ndm, nlh_flags, vid, nfea_tb);
1304 spin_unlock_bh(&br->hash_lock);
1305 }
1306
1307 if (!err)
1308 *notified = true;
1309 return err;
1310 }
1311
1312 static const struct nla_policy br_nda_fdb_pol[NFEA_MAX + 1] = {
1313 [NFEA_ACTIVITY_NOTIFY] = { .type = NLA_U8 },
1314 [NFEA_DONT_REFRESH] = { .type = NLA_FLAG },
1315 };
1316
1317 /* Add new permanent fdb entry with RTM_NEWNEIGH */
1318 int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
1319 struct net_device *dev,
1320 const unsigned char *addr, u16 vid, u16 nlh_flags,
1321 bool *notified, struct netlink_ext_ack *extack)
1322 {
1323 struct nlattr *nfea_tb[NFEA_MAX + 1], *attr;
1324 struct net_bridge_vlan_group *vg;
1325 struct net_bridge_port *p = NULL;
1326 struct net_bridge_vlan *v;
1327 struct net_bridge *br = NULL;
1328 u32 ext_flags = 0;
1329 int err = 0;
1330
1331 trace_br_fdb_add(ndm, dev, addr, vid, nlh_flags);
1332
1333 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
1334 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
1335 return -EINVAL;
1336 }
1337
1338 if (is_zero_ether_addr(addr)) {
1339 pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
1340 return -EINVAL;
1341 }
1342
1343 if (netif_is_bridge_master(dev)) {
1344 br = netdev_priv(dev);
1345 vg = br_vlan_group(br);
1346 } else {
1347 p = br_port_get_rtnl(dev);
1348 if (!p) {
1349 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
1350 dev->name);
1351 return -EINVAL;
1352 }
1353 br = p->br;
1354 vg = nbp_vlan_group(p);
1355 }
1356
1357 if (tb[NDA_FLAGS_EXT])
1358 ext_flags = nla_get_u32(tb[NDA_FLAGS_EXT]);
1359
1360 if (ext_flags & NTF_EXT_LOCKED) {
1361 NL_SET_ERR_MSG_MOD(extack, "Cannot add FDB entry with \"locked\" flag set");
1362 return -EINVAL;
1363 }
1364
1365 if (tb[NDA_FDB_EXT_ATTRS]) {
1366 attr = tb[NDA_FDB_EXT_ATTRS];
1367 err = nla_parse_nested(nfea_tb, NFEA_MAX, attr,
1368 br_nda_fdb_pol, extack);
1369 if (err)
1370 return err;
1371 } else {
1372 memset(nfea_tb, 0, sizeof(struct nlattr *) * (NFEA_MAX + 1));
1373 }
1374
1375 if (vid) {
1376 v = br_vlan_find(vg, vid);
1377 if (!v || !br_vlan_should_use(v)) {
1378 pr_info("bridge: RTM_NEWNEIGH with unconfigured vlan %d on %s\n", vid, dev->name);
1379 return -EINVAL;
1380 }
1381
1382 /* VID was specified, so use it. */
1383 err = __br_fdb_add(ndm, br, p, addr, nlh_flags, vid, nfea_tb,
1384 notified, extack);
1385 } else {
1386 err = __br_fdb_add(ndm, br, p, addr, nlh_flags, 0, nfea_tb,
1387 notified, extack);
1388 if (err || !vg || !vg->num_vlans)
1389 goto out;
1390
1391 /* We have vlans configured on this port and user didn't
1392 * specify a VLAN. To be nice, add/update entry for every
1393 * vlan on this port.
1394 */
1395 list_for_each_entry(v, &vg->vlan_list, vlist) {
1396 if (!br_vlan_should_use(v))
1397 continue;
1398 err = __br_fdb_add(ndm, br, p, addr, nlh_flags, v->vid,
1399 nfea_tb, notified, extack);
1400 if (err)
1401 goto out;
1402 }
1403 }
1404
1405 out:
1406 return err;
1407 }
1408
1409 static int fdb_delete_by_addr_and_port(struct net_bridge *br,
1410 const struct net_bridge_port *p,
1411 const u8 *addr, u16 vlan, bool *notified)
1412 {
1413 struct net_bridge_fdb_entry *fdb;
1414
1415 fdb = br_fdb_find(br, addr, vlan);
1416 if (!fdb || READ_ONCE(fdb->dst) != p)
1417 return -ENOENT;
1418
1419 fdb_delete(br, fdb, true);
1420 *notified = true;
1421
1422 return 0;
1423 }
1424
1425 static int __br_fdb_delete(struct net_bridge *br,
1426 const struct net_bridge_port *p,
1427 const unsigned char *addr, u16 vid, bool *notified)
1428 {
1429 int err;
1430
1431 spin_lock_bh(&br->hash_lock);
1432 err = fdb_delete_by_addr_and_port(br, p, addr, vid, notified);
1433 spin_unlock_bh(&br->hash_lock);
1434
1435 return err;
1436 }
1437
1438 /* Remove neighbor entry with RTM_DELNEIGH */
1439 int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
1440 struct net_device *dev,
1441 const unsigned char *addr, u16 vid, bool *notified,
1442 struct netlink_ext_ack *extack)
1443 {
1444 struct net_bridge_vlan_group *vg;
1445 struct net_bridge_port *p = NULL;
1446 struct net_bridge *br;
1447 int err;
1448
1449 if (netif_is_bridge_master(dev)) {
1450 br = netdev_priv(dev);
1451 vg = br_vlan_group(br);
1452 } else {
1453 p = br_port_get_rtnl(dev);
1454 if (!p) {
1455 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
1456 dev->name);
1457 return -EINVAL;
1458 }
1459 vg = nbp_vlan_group(p);
1460 br = p->br;
1461 }
1462
1463 if (vid) {
1464 err = __br_fdb_delete(br, p, addr, vid, notified);
1465 } else {
1466 struct net_bridge_vlan *v;
1467
1468 err = -ENOENT;
1469 err &= __br_fdb_delete(br, p, addr, 0, notified);
1470 if (!vg || !vg->num_vlans)
1471 return err;
1472
1473 list_for_each_entry(v, &vg->vlan_list, vlist) {
1474 if (!br_vlan_should_use(v))
1475 continue;
1476 err &= __br_fdb_delete(br, p, addr, v->vid, notified);
1477 }
1478 }
1479
1480 return err;
1481 }
1482
1483 int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p)
1484 {
1485 struct net_bridge_fdb_entry *f, *tmp;
1486 int err = 0;
1487
1488 ASSERT_RTNL();
1489
1490 /* the key here is that static entries change only under rtnl */
1491 rcu_read_lock();
1492 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1493 /* We only care for static entries */
1494 if (!test_bit(BR_FDB_STATIC, &f->flags))
1495 continue;
1496 err = dev_uc_add(p->dev, f->key.addr.addr);
1497 if (err)
1498 goto rollback;
1499 }
1500 done:
1501 rcu_read_unlock();
1502
1503 return err;
1504
1505 rollback:
1506 hlist_for_each_entry_rcu(tmp, &br->fdb_list, fdb_node) {
1507 /* We only care for static entries */
1508 if (!test_bit(BR_FDB_STATIC, &tmp->flags))
1509 continue;
1510 if (tmp == f)
1511 break;
1512 dev_uc_del(p->dev, tmp->key.addr.addr);
1513 }
1514
1515 goto done;
1516 }
1517
1518 void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p)
1519 {
1520 struct net_bridge_fdb_entry *f;
1521
1522 ASSERT_RTNL();
1523
1524 rcu_read_lock();
1525 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1526 /* We only care for static entries */
1527 if (!test_bit(BR_FDB_STATIC, &f->flags))
1528 continue;
1529
1530 dev_uc_del(p->dev, f->key.addr.addr);
1531 }
1532 rcu_read_unlock();
1533 }
1534
1535 int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p,
1536 const unsigned char *addr, u16 vid, bool locked,
1537 bool swdev_notify)
1538 {
1539 struct net_bridge_fdb_entry *fdb;
1540 bool modified = false;
1541 int err = 0;
1542
1543 trace_br_fdb_external_learn_add(br, p, addr, vid);
1544
1545 if (locked && (!p || !(p->flags & BR_PORT_MAB)))
1546 return -EINVAL;
1547
1548 spin_lock_bh(&br->hash_lock);
1549
1550 fdb = br_fdb_find(br, addr, vid);
1551 if (!fdb) {
1552 unsigned long flags = BIT(BR_FDB_ADDED_BY_EXT_LEARN);
1553
1554 if (swdev_notify)
1555 flags |= BIT(BR_FDB_ADDED_BY_USER);
1556
1557 if (!p)
1558 flags |= BIT(BR_FDB_LOCAL);
1559
1560 if (locked)
1561 flags |= BIT(BR_FDB_LOCKED);
1562
1563 fdb = fdb_create(br, p, addr, vid, flags);
1564 if (!fdb) {
1565 err = -ENOMEM;
1566 goto err_unlock;
1567 }
1568 fdb_notify(br, fdb, RTM_NEWNEIGH, swdev_notify);
1569 } else {
1570 if (locked &&
1571 (!test_bit(BR_FDB_LOCKED, &fdb->flags) ||
1572 READ_ONCE(fdb->dst) != p)) {
1573 err = -EINVAL;
1574 goto err_unlock;
1575 }
1576
1577 WRITE_ONCE(fdb->updated, jiffies);
1578
1579 if (READ_ONCE(fdb->dst) != p) {
1580 WRITE_ONCE(fdb->dst, p);
1581 modified = true;
1582 }
1583
1584 if (test_and_set_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags)) {
1585 /* Refresh entry */
1586 WRITE_ONCE(fdb->used, jiffies);
1587 } else {
1588 modified = true;
1589 }
1590
1591 if (locked != test_bit(BR_FDB_LOCKED, &fdb->flags)) {
1592 change_bit(BR_FDB_LOCKED, &fdb->flags);
1593 modified = true;
1594 }
1595
1596 if (swdev_notify)
1597 set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1598
1599 if (!p)
1600 set_bit(BR_FDB_LOCAL, &fdb->flags);
1601
1602 if ((swdev_notify || !p) &&
1603 test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED, &fdb->flags))
1604 atomic_dec(&br->fdb_n_learned);
1605
1606 if (modified)
1607 fdb_notify(br, fdb, RTM_NEWNEIGH, swdev_notify);
1608 }
1609
1610 err_unlock:
1611 spin_unlock_bh(&br->hash_lock);
1612
1613 return err;
1614 }
1615
1616 int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
1617 const unsigned char *addr, u16 vid,
1618 bool swdev_notify)
1619 {
1620 struct net_bridge_fdb_entry *fdb;
1621 int err = 0;
1622
1623 spin_lock_bh(&br->hash_lock);
1624
1625 fdb = br_fdb_find(br, addr, vid);
1626 if (fdb && test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags))
1627 fdb_delete(br, fdb, swdev_notify);
1628 else
1629 err = -ENOENT;
1630
1631 spin_unlock_bh(&br->hash_lock);
1632
1633 return err;
1634 }
1635
1636 void br_fdb_offloaded_set(struct net_bridge *br, struct net_bridge_port *p,
1637 const unsigned char *addr, u16 vid, bool offloaded)
1638 {
1639 struct net_bridge_fdb_entry *fdb;
1640
1641 spin_lock_bh(&br->hash_lock);
1642
1643 fdb = br_fdb_find(br, addr, vid);
1644 if (fdb && offloaded != test_bit(BR_FDB_OFFLOADED, &fdb->flags))
1645 change_bit(BR_FDB_OFFLOADED, &fdb->flags);
1646
1647 spin_unlock_bh(&br->hash_lock);
1648 }
1649
1650 void br_fdb_clear_offload(const struct net_device *dev, u16 vid)
1651 {
1652 struct net_bridge_fdb_entry *f;
1653 struct net_bridge_port *p;
1654
1655 ASSERT_RTNL();
1656
1657 p = br_port_get_rtnl(dev);
1658 if (!p)
1659 return;
1660
1661 spin_lock_bh(&p->br->hash_lock);
1662 hlist_for_each_entry(f, &p->br->fdb_list, fdb_node) {
1663 if (f->dst == p && f->key.vlan_id == vid)
1664 clear_bit(BR_FDB_OFFLOADED, &f->flags);
1665 }
1666 spin_unlock_bh(&p->br->hash_lock);
1667 }
1668 EXPORT_SYMBOL_GPL(br_fdb_clear_offload);