projects/linux·blob master · refs

1640 lines · 40.9 KiB

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
27static 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
34static struct kmem_cache *br_fdb_cache __read_mostly;
35
36int __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
45void br_fdb_fini(void)
46{
47 kmem_cache_destroy(br_fdb_cache);
48}
49
50int br_fdb_hash_init(struct net_bridge *br)
51{
52 return rhashtable_init(&br->fdb_hash_tbl, &br_fdb_rht_params);
53}
54
55void 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 */
63static inline unsigned long hold_time(const struct net_bridge *br)
64{
65 return br->topology_change ? br->forward_delay : br->ageing_time;
66}
67
68static 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
76static 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
89static 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
160nla_put_failure:
161 nlmsg_cancel(skb, nlh);
162 return -EMSGSIZE;
163}
164
165static 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
177static 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;
201errout:
202 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
203}
204
205static 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 */
220static 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
235struct 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}
261EXPORT_SYMBOL_GPL(br_fdb_find_port);
262
263struct 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 */
275static 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;
291undo:
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 */
303static 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
315static 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 */
338static 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
372void 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
386static 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
430static 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
460void 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 (READ_ONCE(f->dst) == p &&
474 test_bit(BR_FDB_LOCAL, &f->flags) &&
475 !test_bit(BR_FDB_ADDED_BY_USER, &f->flags)) {
476 /* delete old one */
477 fdb_delete_local(br, p, f);
478
479 /* if this port has no vlan information configured, or
480 * local entries are only kept on VLAN 0, we can safely
481 * be done at this point.
482 */
483 if (!vg || !vg->num_vlans || local_vlan_0)
484 goto insert;
485 }
486 }
487
488insert:
489 /* insert new address, may fail if invalid address or dup. */
490 fdb_add_local(br, p, newaddr, 0);
491
492 if (!vg || !vg->num_vlans || local_vlan_0)
493 goto done;
494
495 /* Now add entries for every VLAN configured on the port.
496 * This function runs under RTNL so the bitmap will not change
497 * from under us.
498 */
499 list_for_each_entry(v, &vg->vlan_list, vlist)
500 fdb_add_local(br, p, newaddr, v->vid);
501
502done:
503 spin_unlock_bh(&br->hash_lock);
504}
505
506void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
507{
508 struct net_bridge_vlan_group *vg;
509 struct net_bridge_fdb_entry *f;
510 struct net_bridge_vlan *v;
511 bool local_vlan_0;
512
513 local_vlan_0 = br_opt_get(br, BROPT_FDB_LOCAL_VLAN_0);
514
515 spin_lock_bh(&br->hash_lock);
516
517 /* If old entry was unassociated with any port, then delete it. */
518 f = br_fdb_find(br, br->dev->dev_addr, 0);
519 if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
520 !f->dst && !test_bit(BR_FDB_ADDED_BY_USER, &f->flags))
521 fdb_delete_local(br, NULL, f);
522
523 fdb_add_local(br, NULL, newaddr, 0);
524 vg = br_vlan_group(br);
525 if (!vg || !vg->num_vlans || local_vlan_0)
526 goto out;
527 /* Now remove and add entries for every VLAN configured on the
528 * bridge. This function runs under RTNL so the bitmap will not
529 * change from under us.
530 */
531 list_for_each_entry(v, &vg->vlan_list, vlist) {
532 if (!br_vlan_should_use(v))
533 continue;
534 f = br_fdb_find(br, br->dev->dev_addr, v->vid);
535 if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
536 !f->dst && !test_bit(BR_FDB_ADDED_BY_USER, &f->flags))
537 fdb_delete_local(br, NULL, f);
538 fdb_add_local(br, NULL, newaddr, v->vid);
539 }
540out:
541 spin_unlock_bh(&br->hash_lock);
542}
543
544void br_fdb_cleanup(struct work_struct *work)
545{
546 struct net_bridge *br = container_of(work, struct net_bridge,
547 gc_work.work);
548 struct net_bridge_fdb_entry *f = NULL;
549 unsigned long delay = hold_time(br);
550 unsigned long work_delay = delay;
551 unsigned long now = jiffies;
552
553 /* this part is tricky, in order to avoid blocking learning and
554 * consequently forwarding, we rely on rcu to delete objects with
555 * delayed freeing allowing us to continue traversing
556 */
557 rcu_read_lock();
558 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
559 unsigned long this_timer = READ_ONCE(f->updated) + delay;
560
561 if (test_bit(BR_FDB_STATIC, &f->flags) ||
562 test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &f->flags)) {
563 if (test_bit(BR_FDB_NOTIFY, &f->flags)) {
564 if (time_after(this_timer, now))
565 work_delay = min(work_delay,
566 this_timer - now);
567 else if (!test_and_set_bit(BR_FDB_NOTIFY_INACTIVE,
568 &f->flags))
569 fdb_notify(br, f, RTM_NEWNEIGH, false);
570 }
571 continue;
572 }
573
574 if (time_after(this_timer, now)) {
575 work_delay = min(work_delay, this_timer - now);
576 } else {
577 spin_lock_bh(&br->hash_lock);
578 if (!hlist_unhashed(&f->fdb_node))
579 fdb_delete(br, f, true);
580 spin_unlock_bh(&br->hash_lock);
581 }
582 }
583 rcu_read_unlock();
584
585 /* Cleanup minimum 10 milliseconds apart */
586 work_delay = max_t(unsigned long, work_delay, msecs_to_jiffies(10));
587 mod_delayed_work(system_long_wq, &br->gc_work, work_delay);
588}
589
590static void br_fdb_delete_locals_per_vlan_port(struct net_bridge *br,
591 struct net_bridge_port *p)
592{
593 struct net_bridge_vlan_group *vg;
594 struct net_bridge_vlan *v;
595 struct net_device *dev;
596
597 if (p) {
598 vg = nbp_vlan_group(p);
599 dev = p->dev;
600 } else {
601 vg = br_vlan_group(br);
602 dev = br->dev;
603 }
604
605 if (!vg)
606 return;
607
608 list_for_each_entry(v, &vg->vlan_list, vlist)
609 br_fdb_find_delete_local(br, p, dev->dev_addr, v->vid);
610}
611
612static void br_fdb_delete_locals_per_vlan(struct net_bridge *br)
613{
614 struct net_bridge_port *p;
615
616 ASSERT_RTNL();
617
618 list_for_each_entry(p, &br->port_list, list)
619 br_fdb_delete_locals_per_vlan_port(br, p);
620
621 br_fdb_delete_locals_per_vlan_port(br, NULL);
622}
623
624static int br_fdb_insert_locals_per_vlan_port(struct net_bridge *br,
625 struct net_bridge_port *p,
626 struct netlink_ext_ack *extack)
627{
628 struct net_bridge_vlan_group *vg;
629 struct net_bridge_vlan *v;
630 struct net_device *dev;
631 int err;
632
633 if (p) {
634 vg = nbp_vlan_group(p);
635 dev = p->dev;
636 } else {
637 vg = br_vlan_group(br);
638 dev = br->dev;
639 }
640
641 if (!vg)
642 return 0;
643
644 list_for_each_entry(v, &vg->vlan_list, vlist) {
645 if (!br_vlan_should_use(v))
646 continue;
647
648 err = br_fdb_add_local(br, p, dev->dev_addr, v->vid);
649 if (err)
650 return err;
651 }
652
653 return 0;
654}
655
656static int br_fdb_insert_locals_per_vlan(struct net_bridge *br,
657 struct netlink_ext_ack *extack)
658{
659 struct net_bridge_port *p;
660 int err;
661
662 ASSERT_RTNL();
663
664 list_for_each_entry(p, &br->port_list, list) {
665 err = br_fdb_insert_locals_per_vlan_port(br, p, extack);
666 if (err)
667 goto rollback;
668 }
669
670 err = br_fdb_insert_locals_per_vlan_port(br, NULL, extack);
671 if (err)
672 goto rollback;
673
674 return 0;
675
676rollback:
677 NL_SET_ERR_MSG_MOD(extack, "fdb_local_vlan_0 toggle: FDB entry insertion failed");
678 br_fdb_delete_locals_per_vlan(br);
679 return err;
680}
681
682int br_fdb_toggle_local_vlan_0(struct net_bridge *br, bool on,
683 struct netlink_ext_ack *extack)
684{
685 if (!on)
686 return br_fdb_insert_locals_per_vlan(br, extack);
687
688 br_fdb_delete_locals_per_vlan(br);
689 return 0;
690}
691
692static bool __fdb_flush_matches(const struct net_bridge *br,
693 const struct net_bridge_fdb_entry *f,
694 const struct net_bridge_fdb_flush_desc *desc)
695{
696 const struct net_bridge_port *dst = READ_ONCE(f->dst);
697 int port_ifidx = dst ? dst->dev->ifindex : br->dev->ifindex;
698
699 if (desc->vlan_id && desc->vlan_id != f->key.vlan_id)
700 return false;
701 if (desc->port_ifindex && desc->port_ifindex != port_ifidx)
702 return false;
703 if (desc->flags_mask && (f->flags & desc->flags_mask) != desc->flags)
704 return false;
705
706 return true;
707}
708
709/* Flush forwarding database entries matching the description */
710void br_fdb_flush(struct net_bridge *br,
711 const struct net_bridge_fdb_flush_desc *desc)
712{
713 struct net_bridge_fdb_entry *f;
714
715 rcu_read_lock();
716 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
717 if (!__fdb_flush_matches(br, f, desc))
718 continue;
719
720 spin_lock_bh(&br->hash_lock);
721 if (!hlist_unhashed(&f->fdb_node))
722 fdb_delete(br, f, true);
723 spin_unlock_bh(&br->hash_lock);
724 }
725 rcu_read_unlock();
726}
727
728static unsigned long __ndm_state_to_fdb_flags(u16 ndm_state)
729{
730 unsigned long flags = 0;
731
732 if (ndm_state & NUD_PERMANENT)
733 __set_bit(BR_FDB_LOCAL, &flags);
734 if (ndm_state & NUD_NOARP)
735 __set_bit(BR_FDB_STATIC, &flags);
736
737 return flags;
738}
739
740static unsigned long __ndm_flags_to_fdb_flags(u8 ndm_flags)
741{
742 unsigned long flags = 0;
743
744 if (ndm_flags & NTF_USE)
745 __set_bit(BR_FDB_ADDED_BY_USER, &flags);
746 if (ndm_flags & NTF_EXT_LEARNED)
747 __set_bit(BR_FDB_ADDED_BY_EXT_LEARN, &flags);
748 if (ndm_flags & NTF_OFFLOADED)
749 __set_bit(BR_FDB_OFFLOADED, &flags);
750 if (ndm_flags & NTF_STICKY)
751 __set_bit(BR_FDB_STICKY, &flags);
752
753 return flags;
754}
755
756static int __fdb_flush_validate_ifindex(const struct net_bridge *br,
757 int ifindex,
758 struct netlink_ext_ack *extack)
759{
760 const struct net_device *dev;
761
762 dev = __dev_get_by_index(dev_net(br->dev), ifindex);
763 if (!dev) {
764 NL_SET_ERR_MSG_MOD(extack, "Unknown flush device ifindex");
765 return -ENODEV;
766 }
767 if (!netif_is_bridge_master(dev) && !netif_is_bridge_port(dev)) {
768 NL_SET_ERR_MSG_MOD(extack, "Flush device is not a bridge or bridge port");
769 return -EINVAL;
770 }
771 if (netif_is_bridge_master(dev) && dev != br->dev) {
772 NL_SET_ERR_MSG_MOD(extack,
773 "Flush bridge device does not match target bridge device");
774 return -EINVAL;
775 }
776 if (netif_is_bridge_port(dev)) {
777 struct net_bridge_port *p = br_port_get_rtnl(dev);
778
779 if (p->br != br) {
780 NL_SET_ERR_MSG_MOD(extack, "Port belongs to a different bridge device");
781 return -EINVAL;
782 }
783 }
784
785 return 0;
786}
787
788static const struct nla_policy br_fdb_del_bulk_policy[NDA_MAX + 1] = {
789 [NDA_VLAN] = NLA_POLICY_RANGE(NLA_U16, 1, VLAN_N_VID - 2),
790 [NDA_IFINDEX] = NLA_POLICY_MIN(NLA_S32, 1),
791 [NDA_NDM_STATE_MASK] = { .type = NLA_U16 },
792 [NDA_NDM_FLAGS_MASK] = { .type = NLA_U8 },
793};
794
795int br_fdb_delete_bulk(struct nlmsghdr *nlh, struct net_device *dev,
796 struct netlink_ext_ack *extack)
797{
798 struct net_bridge_fdb_flush_desc desc = {};
799 struct ndmsg *ndm = nlmsg_data(nlh);
800 struct net_bridge_port *p = NULL;
801 struct nlattr *tb[NDA_MAX + 1];
802 struct net_bridge *br;
803 u8 ndm_flags;
804 int err;
805
806 ndm_flags = ndm->ndm_flags & ~FDB_FLUSH_IGNORED_NDM_FLAGS;
807
808 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX,
809 br_fdb_del_bulk_policy, extack);
810 if (err)
811 return err;
812
813 if (netif_is_bridge_master(dev)) {
814 br = netdev_priv(dev);
815 } else {
816 p = br_port_get_rtnl(dev);
817 if (!p) {
818 NL_SET_ERR_MSG_MOD(extack, "Device is not a bridge port");
819 return -EINVAL;
820 }
821 br = p->br;
822 }
823
824 if (tb[NDA_VLAN])
825 desc.vlan_id = nla_get_u16(tb[NDA_VLAN]);
826
827 if (ndm_flags & ~FDB_FLUSH_ALLOWED_NDM_FLAGS) {
828 NL_SET_ERR_MSG(extack, "Unsupported fdb flush ndm flag bits set");
829 return -EINVAL;
830 }
831 if (ndm->ndm_state & ~FDB_FLUSH_ALLOWED_NDM_STATES) {
832 NL_SET_ERR_MSG(extack, "Unsupported fdb flush ndm state bits set");
833 return -EINVAL;
834 }
835
836 desc.flags |= __ndm_state_to_fdb_flags(ndm->ndm_state);
837 desc.flags |= __ndm_flags_to_fdb_flags(ndm_flags);
838 if (tb[NDA_NDM_STATE_MASK]) {
839 u16 ndm_state_mask = nla_get_u16(tb[NDA_NDM_STATE_MASK]);
840
841 desc.flags_mask |= __ndm_state_to_fdb_flags(ndm_state_mask);
842 }
843 if (tb[NDA_NDM_FLAGS_MASK]) {
844 u8 ndm_flags_mask = nla_get_u8(tb[NDA_NDM_FLAGS_MASK]);
845
846 desc.flags_mask |= __ndm_flags_to_fdb_flags(ndm_flags_mask);
847 }
848 if (tb[NDA_IFINDEX]) {
849 int ifidx = nla_get_s32(tb[NDA_IFINDEX]);
850
851 err = __fdb_flush_validate_ifindex(br, ifidx, extack);
852 if (err)
853 return err;
854 desc.port_ifindex = ifidx;
855 } else if (p) {
856 /* flush was invoked with port device and NTF_MASTER */
857 desc.port_ifindex = p->dev->ifindex;
858 }
859
860 br_debug(br, "flushing port ifindex: %d vlan id: %u flags: 0x%lx flags mask: 0x%lx\n",
861 desc.port_ifindex, desc.vlan_id, desc.flags, desc.flags_mask);
862
863 br_fdb_flush(br, &desc);
864
865 return 0;
866}
867
868/* Flush all entries referring to a specific port.
869 * if do_all is set also flush static entries
870 * if vid is set delete all entries that match the vlan_id
871 */
872void br_fdb_delete_by_port(struct net_bridge *br,
873 const struct net_bridge_port *p,
874 u16 vid,
875 int do_all)
876{
877 struct net_bridge_fdb_entry *f;
878 struct hlist_node *tmp;
879
880 spin_lock_bh(&br->hash_lock);
881 hlist_for_each_entry_safe(f, tmp, &br->fdb_list, fdb_node) {
882 if (READ_ONCE(f->dst) != p)
883 continue;
884
885 if (!do_all)
886 if (test_bit(BR_FDB_STATIC, &f->flags) ||
887 (test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &f->flags) &&
888 !test_bit(BR_FDB_OFFLOADED, &f->flags)) ||
889 (vid && f->key.vlan_id != vid))
890 continue;
891
892 if (test_bit(BR_FDB_LOCAL, &f->flags))
893 fdb_delete_local(br, p, f);
894 else
895 fdb_delete(br, f, true);
896 }
897 spin_unlock_bh(&br->hash_lock);
898}
899
900/*
901 * Fill buffer with forwarding table records in
902 * the API format.
903 */
904int br_fdb_fillbuf(struct net_bridge *br, void *buf,
905 unsigned long maxnum, unsigned long skip)
906{
907 const struct net_bridge_port *dst;
908 struct net_bridge_fdb_entry *f;
909 struct __fdb_entry *fe = buf;
910 unsigned long delta;
911 int num = 0;
912
913 memset(buf, 0, maxnum*sizeof(struct __fdb_entry));
914
915 rcu_read_lock();
916 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
917 if (num >= maxnum)
918 break;
919
920 if (has_expired(br, f))
921 continue;
922
923 /* ignore pseudo entry for local MAC address */
924 dst = READ_ONCE(f->dst);
925 if (!dst)
926 continue;
927
928 if (skip) {
929 --skip;
930 continue;
931 }
932
933 /* convert from internal format to API */
934 memcpy(fe->mac_addr, f->key.addr.addr, ETH_ALEN);
935
936 /* due to ABI compat need to split into hi/lo */
937 fe->port_no = dst->port_no;
938 fe->port_hi = dst->port_no >> 8;
939
940 fe->is_local = test_bit(BR_FDB_LOCAL, &f->flags);
941 if (!test_bit(BR_FDB_STATIC, &f->flags)) {
942 delta = jiffies - READ_ONCE(f->updated);
943 fe->ageing_timer_value =
944 jiffies_delta_to_clock_t(delta);
945 }
946 ++fe;
947 ++num;
948 }
949 rcu_read_unlock();
950
951 return num;
952}
953
954/* Add entry for local address of interface */
955int br_fdb_add_local(struct net_bridge *br, struct net_bridge_port *source,
956 const unsigned char *addr, u16 vid)
957{
958 int ret;
959
960 spin_lock_bh(&br->hash_lock);
961 ret = fdb_add_local(br, source, addr, vid);
962 spin_unlock_bh(&br->hash_lock);
963 return ret;
964}
965
966/* returns true if the fdb was modified */
967static bool __fdb_mark_active(struct net_bridge_fdb_entry *fdb)
968{
969 return !!(test_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags) &&
970 test_and_clear_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags));
971}
972
973void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
974 const unsigned char *addr, u16 vid, unsigned long flags)
975{
976 struct net_bridge_fdb_entry *fdb;
977
978 /* some users want to always flood. */
979 if (hold_time(br) == 0)
980 return;
981
982 fdb = fdb_find_rcu(&br->fdb_hash_tbl, addr, vid);
983 if (likely(fdb)) {
984 /* attempt to update an entry for a local interface */
985 if (unlikely(test_bit(BR_FDB_LOCAL, &fdb->flags))) {
986 if (net_ratelimit())
987 br_warn(br, "received packet on %s with own address as source address (addr:%pM, vlan:%u)\n",
988 source->dev->name, addr, vid);
989 } else {
990 unsigned long now = jiffies;
991 bool fdb_modified = false;
992
993 if (now != READ_ONCE(fdb->updated)) {
994 WRITE_ONCE(fdb->updated, now);
995 fdb_modified = __fdb_mark_active(fdb);
996 }
997
998 /* fastpath: update of existing entry */
999 if (unlikely(source != READ_ONCE(fdb->dst) &&
1000 !test_bit(BR_FDB_STICKY, &fdb->flags))) {
1001 br_switchdev_fdb_notify(br, fdb, RTM_DELNEIGH);
1002 WRITE_ONCE(fdb->dst, source);
1003 fdb_modified = true;
1004 /* Take over HW learned entry */
1005 if (unlikely(test_bit(BR_FDB_ADDED_BY_EXT_LEARN,
1006 &fdb->flags)))
1007 clear_bit(BR_FDB_ADDED_BY_EXT_LEARN,
1008 &fdb->flags);
1009 /* Clear locked flag when roaming to an
1010 * unlocked port.
1011 */
1012 if (unlikely(test_bit(BR_FDB_LOCKED, &fdb->flags)))
1013 clear_bit(BR_FDB_LOCKED, &fdb->flags);
1014 }
1015
1016 if (unlikely(test_bit(BR_FDB_ADDED_BY_USER, &flags))) {
1017 set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1018 if (test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED,
1019 &fdb->flags))
1020 atomic_dec(&br->fdb_n_learned);
1021 }
1022 if (unlikely(fdb_modified)) {
1023 trace_br_fdb_update(br, source, addr, vid, flags);
1024 fdb_notify(br, fdb, RTM_NEWNEIGH, true);
1025 }
1026 }
1027 } else {
1028 spin_lock(&br->hash_lock);
1029 fdb = fdb_create(br, source, addr, vid, flags);
1030 if (fdb) {
1031 trace_br_fdb_update(br, source, addr, vid, flags);
1032 fdb_notify(br, fdb, RTM_NEWNEIGH, true);
1033 }
1034 /* else we lose race and someone else inserts
1035 * it first, don't bother updating
1036 */
1037 spin_unlock(&br->hash_lock);
1038 }
1039}
1040
1041/* Dump information about entries, in response to GETNEIGH */
1042int br_fdb_dump(struct sk_buff *skb,
1043 struct netlink_callback *cb,
1044 struct net_device *dev,
1045 struct net_device *filter_dev,
1046 int *idx)
1047{
1048 struct ndo_fdb_dump_context *ctx = (void *)cb->ctx;
1049 struct net_bridge *br = netdev_priv(dev);
1050 struct net_bridge_fdb_entry *f;
1051 int err = 0;
1052
1053 if (!netif_is_bridge_master(dev))
1054 return err;
1055
1056 if (!filter_dev) {
1057 err = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx);
1058 if (err < 0)
1059 return err;
1060 }
1061
1062 rcu_read_lock();
1063 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1064 const struct net_bridge_port *dst = READ_ONCE(f->dst);
1065
1066 if (*idx < ctx->fdb_idx)
1067 goto skip;
1068 if (filter_dev && (!dst || dst->dev != filter_dev)) {
1069 if (filter_dev != dev)
1070 goto skip;
1071 /* !f->dst is a special case for bridge
1072 * It means the MAC belongs to the bridge
1073 * Therefore need a little more filtering
1074 * we only want to dump the !f->dst case
1075 */
1076 if (dst)
1077 goto skip;
1078 }
1079 if (!filter_dev && dst)
1080 goto skip;
1081
1082 err = fdb_fill_info(skb, br, f,
1083 NETLINK_CB(cb->skb).portid,
1084 cb->nlh->nlmsg_seq,
1085 RTM_NEWNEIGH,
1086 NLM_F_MULTI);
1087 if (err < 0)
1088 break;
1089skip:
1090 *idx += 1;
1091 }
1092 rcu_read_unlock();
1093
1094 return err;
1095}
1096
1097int br_fdb_get(struct sk_buff *skb,
1098 struct nlattr *tb[],
1099 struct net_device *dev,
1100 const unsigned char *addr,
1101 u16 vid, u32 portid, u32 seq,
1102 struct netlink_ext_ack *extack)
1103{
1104 struct net_bridge *br = netdev_priv(dev);
1105 struct net_bridge_fdb_entry *f;
1106 int err = 0;
1107
1108 rcu_read_lock();
1109 f = br_fdb_find_rcu(br, addr, vid);
1110 if (!f) {
1111 NL_SET_ERR_MSG(extack, "Fdb entry not found");
1112 err = -ENOENT;
1113 goto errout;
1114 }
1115
1116 err = fdb_fill_info(skb, br, f, portid, seq,
1117 RTM_NEWNEIGH, 0);
1118errout:
1119 rcu_read_unlock();
1120 return err;
1121}
1122
1123/* returns true if the fdb is modified */
1124static bool fdb_handle_notify(struct net_bridge_fdb_entry *fdb, u8 notify)
1125{
1126 bool modified = false;
1127
1128 /* allow to mark an entry as inactive, usually done on creation */
1129 if ((notify & FDB_NOTIFY_INACTIVE_BIT) &&
1130 !test_and_set_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags))
1131 modified = true;
1132
1133 if ((notify & FDB_NOTIFY_BIT) &&
1134 !test_and_set_bit(BR_FDB_NOTIFY, &fdb->flags)) {
1135 /* enabled activity tracking */
1136 modified = true;
1137 } else if (!(notify & FDB_NOTIFY_BIT) &&
1138 test_and_clear_bit(BR_FDB_NOTIFY, &fdb->flags)) {
1139 /* disabled activity tracking, clear notify state */
1140 clear_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags);
1141 modified = true;
1142 }
1143
1144 return modified;
1145}
1146
1147/* Update (create or replace) forwarding database entry */
1148static int fdb_add_entry(struct net_bridge *br, struct net_bridge_port *source,
1149 const u8 *addr, struct ndmsg *ndm, u16 flags, u16 vid,
1150 struct nlattr *nfea_tb[])
1151{
1152 bool is_sticky = !!(ndm->ndm_flags & NTF_STICKY);
1153 bool refresh = !nfea_tb[NFEA_DONT_REFRESH];
1154 struct net_bridge_fdb_entry *fdb;
1155 u16 state = ndm->ndm_state;
1156 bool modified = false;
1157 u8 notify = 0;
1158
1159 /* If the port cannot learn allow only local and static entries */
1160 if (source && !(state & NUD_PERMANENT) && !(state & NUD_NOARP) &&
1161 !(source->state == BR_STATE_LEARNING ||
1162 source->state == BR_STATE_FORWARDING))
1163 return -EPERM;
1164
1165 if (!source && !(state & NUD_PERMANENT)) {
1166 pr_info("bridge: RTM_NEWNEIGH %s without NUD_PERMANENT\n",
1167 br->dev->name);
1168 return -EINVAL;
1169 }
1170
1171 if (is_sticky && (state & NUD_PERMANENT))
1172 return -EINVAL;
1173
1174 if (nfea_tb[NFEA_ACTIVITY_NOTIFY]) {
1175 notify = nla_get_u8(nfea_tb[NFEA_ACTIVITY_NOTIFY]);
1176 if ((notify & ~BR_FDB_NOTIFY_SETTABLE_BITS) ||
1177 (notify & BR_FDB_NOTIFY_SETTABLE_BITS) == FDB_NOTIFY_INACTIVE_BIT)
1178 return -EINVAL;
1179 }
1180
1181 fdb = br_fdb_find(br, addr, vid);
1182 if (fdb == NULL) {
1183 if (!(flags & NLM_F_CREATE))
1184 return -ENOENT;
1185
1186 fdb = fdb_create(br, source, addr, vid,
1187 BIT(BR_FDB_ADDED_BY_USER));
1188 if (!fdb)
1189 return -ENOMEM;
1190
1191 modified = true;
1192 } else {
1193 if (flags & NLM_F_EXCL)
1194 return -EEXIST;
1195
1196 if (READ_ONCE(fdb->dst) != source) {
1197 WRITE_ONCE(fdb->dst, source);
1198 modified = true;
1199 }
1200
1201 set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1202 if (test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED, &fdb->flags))
1203 atomic_dec(&br->fdb_n_learned);
1204 }
1205
1206 if (fdb_to_nud(br, fdb) != state) {
1207 if (state & NUD_PERMANENT) {
1208 set_bit(BR_FDB_LOCAL, &fdb->flags);
1209 if (!test_and_set_bit(BR_FDB_STATIC, &fdb->flags))
1210 fdb_add_hw_addr(br, addr);
1211 } else if (state & NUD_NOARP) {
1212 clear_bit(BR_FDB_LOCAL, &fdb->flags);
1213 if (!test_and_set_bit(BR_FDB_STATIC, &fdb->flags))
1214 fdb_add_hw_addr(br, addr);
1215 } else {
1216 clear_bit(BR_FDB_LOCAL, &fdb->flags);
1217 if (test_and_clear_bit(BR_FDB_STATIC, &fdb->flags))
1218 fdb_del_hw_addr(br, addr);
1219 }
1220
1221 modified = true;
1222 }
1223
1224 if (is_sticky != test_bit(BR_FDB_STICKY, &fdb->flags)) {
1225 change_bit(BR_FDB_STICKY, &fdb->flags);
1226 modified = true;
1227 }
1228
1229 if (test_and_clear_bit(BR_FDB_LOCKED, &fdb->flags))
1230 modified = true;
1231
1232 if (fdb_handle_notify(fdb, notify))
1233 modified = true;
1234
1235 WRITE_ONCE(fdb->used, jiffies);
1236 if (modified) {
1237 if (refresh)
1238 WRITE_ONCE(fdb->updated, jiffies);
1239 fdb_notify(br, fdb, RTM_NEWNEIGH, true);
1240 }
1241
1242 return 0;
1243}
1244
1245static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge *br,
1246 struct net_bridge_port *p, const unsigned char *addr,
1247 u16 nlh_flags, u16 vid, struct nlattr *nfea_tb[],
1248 bool *notified, struct netlink_ext_ack *extack)
1249{
1250 int err = 0;
1251
1252 if (ndm->ndm_flags & NTF_USE) {
1253 if (!p) {
1254 pr_info("bridge: RTM_NEWNEIGH %s with NTF_USE is not supported\n",
1255 br->dev->name);
1256 return -EINVAL;
1257 }
1258 if (!nbp_state_should_learn(p))
1259 return 0;
1260
1261 local_bh_disable();
1262 rcu_read_lock();
1263 br_fdb_update(br, p, addr, vid, BIT(BR_FDB_ADDED_BY_USER));
1264 rcu_read_unlock();
1265 local_bh_enable();
1266 } else if (ndm->ndm_flags & NTF_EXT_LEARNED) {
1267 if (!p && !(ndm->ndm_state & NUD_PERMANENT)) {
1268 NL_SET_ERR_MSG_MOD(extack,
1269 "FDB entry towards bridge must be permanent");
1270 return -EINVAL;
1271 }
1272 err = br_fdb_external_learn_add(br, p, addr, vid, false, true);
1273 } else {
1274 spin_lock_bh(&br->hash_lock);
1275 err = fdb_add_entry(br, p, addr, ndm, nlh_flags, vid, nfea_tb);
1276 spin_unlock_bh(&br->hash_lock);
1277 }
1278
1279 if (!err)
1280 *notified = true;
1281 return err;
1282}
1283
1284static const struct nla_policy br_nda_fdb_pol[NFEA_MAX + 1] = {
1285 [NFEA_ACTIVITY_NOTIFY] = { .type = NLA_U8 },
1286 [NFEA_DONT_REFRESH] = { .type = NLA_FLAG },
1287};
1288
1289/* Add new permanent fdb entry with RTM_NEWNEIGH */
1290int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
1291 struct net_device *dev,
1292 const unsigned char *addr, u16 vid, u16 nlh_flags,
1293 bool *notified, struct netlink_ext_ack *extack)
1294{
1295 struct nlattr *nfea_tb[NFEA_MAX + 1], *attr;
1296 struct net_bridge_vlan_group *vg;
1297 struct net_bridge_port *p = NULL;
1298 struct net_bridge_vlan *v;
1299 struct net_bridge *br = NULL;
1300 u32 ext_flags = 0;
1301 int err = 0;
1302
1303 trace_br_fdb_add(ndm, dev, addr, vid, nlh_flags);
1304
1305 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
1306 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
1307 return -EINVAL;
1308 }
1309
1310 if (is_zero_ether_addr(addr)) {
1311 pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
1312 return -EINVAL;
1313 }
1314
1315 if (netif_is_bridge_master(dev)) {
1316 br = netdev_priv(dev);
1317 vg = br_vlan_group(br);
1318 } else {
1319 p = br_port_get_rtnl(dev);
1320 if (!p) {
1321 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
1322 dev->name);
1323 return -EINVAL;
1324 }
1325 br = p->br;
1326 vg = nbp_vlan_group(p);
1327 }
1328
1329 if (tb[NDA_FLAGS_EXT])
1330 ext_flags = nla_get_u32(tb[NDA_FLAGS_EXT]);
1331
1332 if (ext_flags & NTF_EXT_LOCKED) {
1333 NL_SET_ERR_MSG_MOD(extack, "Cannot add FDB entry with \"locked\" flag set");
1334 return -EINVAL;
1335 }
1336
1337 if (tb[NDA_FDB_EXT_ATTRS]) {
1338 attr = tb[NDA_FDB_EXT_ATTRS];
1339 err = nla_parse_nested(nfea_tb, NFEA_MAX, attr,
1340 br_nda_fdb_pol, extack);
1341 if (err)
1342 return err;
1343 } else {
1344 memset(nfea_tb, 0, sizeof(struct nlattr *) * (NFEA_MAX + 1));
1345 }
1346
1347 if (vid) {
1348 v = br_vlan_find(vg, vid);
1349 if (!v || !br_vlan_should_use(v)) {
1350 pr_info("bridge: RTM_NEWNEIGH with unconfigured vlan %d on %s\n", vid, dev->name);
1351 return -EINVAL;
1352 }
1353
1354 /* VID was specified, so use it. */
1355 err = __br_fdb_add(ndm, br, p, addr, nlh_flags, vid, nfea_tb,
1356 notified, extack);
1357 } else {
1358 err = __br_fdb_add(ndm, br, p, addr, nlh_flags, 0, nfea_tb,
1359 notified, extack);
1360 if (err || !vg || !vg->num_vlans)
1361 goto out;
1362
1363 /* We have vlans configured on this port and user didn't
1364 * specify a VLAN. To be nice, add/update entry for every
1365 * vlan on this port.
1366 */
1367 list_for_each_entry(v, &vg->vlan_list, vlist) {
1368 if (!br_vlan_should_use(v))
1369 continue;
1370 err = __br_fdb_add(ndm, br, p, addr, nlh_flags, v->vid,
1371 nfea_tb, notified, extack);
1372 if (err)
1373 goto out;
1374 }
1375 }
1376
1377out:
1378 return err;
1379}
1380
1381static int fdb_delete_by_addr_and_port(struct net_bridge *br,
1382 const struct net_bridge_port *p,
1383 const u8 *addr, u16 vlan, bool *notified)
1384{
1385 struct net_bridge_fdb_entry *fdb;
1386
1387 fdb = br_fdb_find(br, addr, vlan);
1388 if (!fdb || READ_ONCE(fdb->dst) != p)
1389 return -ENOENT;
1390
1391 fdb_delete(br, fdb, true);
1392 *notified = true;
1393
1394 return 0;
1395}
1396
1397static int __br_fdb_delete(struct net_bridge *br,
1398 const struct net_bridge_port *p,
1399 const unsigned char *addr, u16 vid, bool *notified)
1400{
1401 int err;
1402
1403 spin_lock_bh(&br->hash_lock);
1404 err = fdb_delete_by_addr_and_port(br, p, addr, vid, notified);
1405 spin_unlock_bh(&br->hash_lock);
1406
1407 return err;
1408}
1409
1410/* Remove neighbor entry with RTM_DELNEIGH */
1411int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
1412 struct net_device *dev,
1413 const unsigned char *addr, u16 vid, bool *notified,
1414 struct netlink_ext_ack *extack)
1415{
1416 struct net_bridge_vlan_group *vg;
1417 struct net_bridge_port *p = NULL;
1418 struct net_bridge *br;
1419 int err;
1420
1421 if (netif_is_bridge_master(dev)) {
1422 br = netdev_priv(dev);
1423 vg = br_vlan_group(br);
1424 } else {
1425 p = br_port_get_rtnl(dev);
1426 if (!p) {
1427 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
1428 dev->name);
1429 return -EINVAL;
1430 }
1431 vg = nbp_vlan_group(p);
1432 br = p->br;
1433 }
1434
1435 if (vid) {
1436 err = __br_fdb_delete(br, p, addr, vid, notified);
1437 } else {
1438 struct net_bridge_vlan *v;
1439
1440 err = -ENOENT;
1441 err &= __br_fdb_delete(br, p, addr, 0, notified);
1442 if (!vg || !vg->num_vlans)
1443 return err;
1444
1445 list_for_each_entry(v, &vg->vlan_list, vlist) {
1446 if (!br_vlan_should_use(v))
1447 continue;
1448 err &= __br_fdb_delete(br, p, addr, v->vid, notified);
1449 }
1450 }
1451
1452 return err;
1453}
1454
1455int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p)
1456{
1457 struct net_bridge_fdb_entry *f, *tmp;
1458 int err = 0;
1459
1460 ASSERT_RTNL();
1461
1462 /* the key here is that static entries change only under rtnl */
1463 rcu_read_lock();
1464 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1465 /* We only care for static entries */
1466 if (!test_bit(BR_FDB_STATIC, &f->flags))
1467 continue;
1468 err = dev_uc_add(p->dev, f->key.addr.addr);
1469 if (err)
1470 goto rollback;
1471 }
1472done:
1473 rcu_read_unlock();
1474
1475 return err;
1476
1477rollback:
1478 hlist_for_each_entry_rcu(tmp, &br->fdb_list, fdb_node) {
1479 /* We only care for static entries */
1480 if (!test_bit(BR_FDB_STATIC, &tmp->flags))
1481 continue;
1482 if (tmp == f)
1483 break;
1484 dev_uc_del(p->dev, tmp->key.addr.addr);
1485 }
1486
1487 goto done;
1488}
1489
1490void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p)
1491{
1492 struct net_bridge_fdb_entry *f;
1493
1494 ASSERT_RTNL();
1495
1496 rcu_read_lock();
1497 hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1498 /* We only care for static entries */
1499 if (!test_bit(BR_FDB_STATIC, &f->flags))
1500 continue;
1501
1502 dev_uc_del(p->dev, f->key.addr.addr);
1503 }
1504 rcu_read_unlock();
1505}
1506
1507int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p,
1508 const unsigned char *addr, u16 vid, bool locked,
1509 bool swdev_notify)
1510{
1511 struct net_bridge_fdb_entry *fdb;
1512 bool modified = false;
1513 int err = 0;
1514
1515 trace_br_fdb_external_learn_add(br, p, addr, vid);
1516
1517 if (locked && (!p || !test_bit(BR_PORT_MAB_BIT, &p->flags)))
1518 return -EINVAL;
1519
1520 spin_lock_bh(&br->hash_lock);
1521
1522 fdb = br_fdb_find(br, addr, vid);
1523 if (!fdb) {
1524 unsigned long flags = BIT(BR_FDB_ADDED_BY_EXT_LEARN);
1525
1526 if (swdev_notify)
1527 flags |= BIT(BR_FDB_ADDED_BY_USER);
1528
1529 if (!p)
1530 flags |= BIT(BR_FDB_LOCAL);
1531
1532 if (locked)
1533 flags |= BIT(BR_FDB_LOCKED);
1534
1535 fdb = fdb_create(br, p, addr, vid, flags);
1536 if (!fdb) {
1537 err = -ENOMEM;
1538 goto err_unlock;
1539 }
1540 fdb_notify(br, fdb, RTM_NEWNEIGH, swdev_notify);
1541 } else {
1542 if (locked &&
1543 (!test_bit(BR_FDB_LOCKED, &fdb->flags) ||
1544 READ_ONCE(fdb->dst) != p)) {
1545 err = -EINVAL;
1546 goto err_unlock;
1547 }
1548
1549 WRITE_ONCE(fdb->updated, jiffies);
1550
1551 if (READ_ONCE(fdb->dst) != p) {
1552 WRITE_ONCE(fdb->dst, p);
1553 modified = true;
1554 }
1555
1556 if (test_and_set_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags)) {
1557 /* Refresh entry */
1558 WRITE_ONCE(fdb->used, jiffies);
1559 } else {
1560 modified = true;
1561 }
1562
1563 if (locked != test_bit(BR_FDB_LOCKED, &fdb->flags)) {
1564 change_bit(BR_FDB_LOCKED, &fdb->flags);
1565 modified = true;
1566 }
1567
1568 if (swdev_notify)
1569 set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1570
1571 if (!p)
1572 set_bit(BR_FDB_LOCAL, &fdb->flags);
1573
1574 if ((swdev_notify || !p) &&
1575 test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED, &fdb->flags))
1576 atomic_dec(&br->fdb_n_learned);
1577
1578 if (modified)
1579 fdb_notify(br, fdb, RTM_NEWNEIGH, swdev_notify);
1580 }
1581
1582err_unlock:
1583 spin_unlock_bh(&br->hash_lock);
1584
1585 return err;
1586}
1587
1588int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
1589 const unsigned char *addr, u16 vid,
1590 bool swdev_notify)
1591{
1592 struct net_bridge_fdb_entry *fdb;
1593 int err = 0;
1594
1595 spin_lock_bh(&br->hash_lock);
1596
1597 fdb = br_fdb_find(br, addr, vid);
1598 if (fdb && test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags))
1599 fdb_delete(br, fdb, swdev_notify);
1600 else
1601 err = -ENOENT;
1602
1603 spin_unlock_bh(&br->hash_lock);
1604
1605 return err;
1606}
1607
1608void br_fdb_offloaded_set(struct net_bridge *br, struct net_bridge_port *p,
1609 const unsigned char *addr, u16 vid, bool offloaded)
1610{
1611 struct net_bridge_fdb_entry *fdb;
1612
1613 spin_lock_bh(&br->hash_lock);
1614
1615 fdb = br_fdb_find(br, addr, vid);
1616 if (fdb && offloaded != test_bit(BR_FDB_OFFLOADED, &fdb->flags))
1617 change_bit(BR_FDB_OFFLOADED, &fdb->flags);
1618
1619 spin_unlock_bh(&br->hash_lock);
1620}
1621
1622void br_fdb_clear_offload(const struct net_device *dev, u16 vid)
1623{
1624 struct net_bridge_fdb_entry *f;
1625 struct net_bridge_port *p;
1626
1627 ASSERT_RTNL();
1628
1629 p = br_port_get_rtnl(dev);
1630 if (!p)
1631 return;
1632
1633 spin_lock_bh(&p->br->hash_lock);
1634 hlist_for_each_entry(f, &p->br->fdb_list, fdb_node) {
1635 if (READ_ONCE(f->dst) == p && f->key.vlan_id == vid)
1636 clear_bit(BR_FDB_OFFLOADED, &f->flags);
1637 }
1638 spin_unlock_bh(&p->br->hash_lock);
1639}
1640EXPORT_SYMBOL_GPL(br_fdb_clear_offload);