1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/kernel.h>
15#include <linux/init.h>
16#include <linux/rculist.h>
17#include <linux/spinlock.h>
18#include <linux/times.h>
19#include <linux/netdevice.h>
20#include <linux/etherdevice.h>
21#include <linux/jhash.h>
22#include <linux/random.h>
23#include <linux/slab.h>
24#include <linux/atomic.h>
25#include <asm/unaligned.h>
26#include <linux/if_vlan.h>
27#include "br_private.h"
28
29static struct kmem_cache *br_fdb_cache __read_mostly;
30static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
31 const unsigned char *addr,
32 __u16 vid);
33static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
34 const unsigned char *addr, u16 vid);
35static void fdb_notify(struct net_bridge *br,
36 const struct net_bridge_fdb_entry *, int);
37
38static u32 fdb_salt __read_mostly;
39
40int __init br_fdb_init(void)
41{
42 br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
43 sizeof(struct net_bridge_fdb_entry),
44 0,
45 SLAB_HWCACHE_ALIGN, NULL);
46 if (!br_fdb_cache)
47 return -ENOMEM;
48
49 get_random_bytes(&fdb_salt, sizeof(fdb_salt));
50 return 0;
51}
52
53void br_fdb_fini(void)
54{
55 kmem_cache_destroy(br_fdb_cache);
56}
57
58
59
60
61
62static inline unsigned long hold_time(const struct net_bridge *br)
63{
64 return br->topology_change ? br->forward_delay : br->ageing_time;
65}
66
67static inline int has_expired(const struct net_bridge *br,
68 const struct net_bridge_fdb_entry *fdb)
69{
70 return !fdb->is_static &&
71 time_before_eq(fdb->updated + hold_time(br), jiffies);
72}
73
74static inline int br_mac_hash(const unsigned char *mac, __u16 vid)
75{
76
77 u32 key = get_unaligned((u32 *)(mac + 2));
78 return jhash_2words(key, vid, fdb_salt) & (BR_HASH_SIZE - 1);
79}
80
81static void fdb_rcu_free(struct rcu_head *head)
82{
83 struct net_bridge_fdb_entry *ent
84 = container_of(head, struct net_bridge_fdb_entry, rcu);
85 kmem_cache_free(br_fdb_cache, ent);
86}
87
88
89
90
91
92
93static void fdb_add_hw_addr(struct net_bridge *br, const unsigned char *addr)
94{
95 int err;
96 struct net_bridge_port *p;
97
98 ASSERT_RTNL();
99
100 list_for_each_entry(p, &br->port_list, list) {
101 if (!br_promisc_port(p)) {
102 err = dev_uc_add(p->dev, addr);
103 if (err)
104 goto undo;
105 }
106 }
107
108 return;
109undo:
110 list_for_each_entry_continue_reverse(p, &br->port_list, list) {
111 if (!br_promisc_port(p))
112 dev_uc_del(p->dev, addr);
113 }
114}
115
116
117
118
119
120
121static void fdb_del_hw_addr(struct net_bridge *br, const unsigned char *addr)
122{
123 struct net_bridge_port *p;
124
125 ASSERT_RTNL();
126
127 list_for_each_entry(p, &br->port_list, list) {
128 if (!br_promisc_port(p))
129 dev_uc_del(p->dev, addr);
130 }
131}
132
133static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f)
134{
135 if (f->is_static)
136 fdb_del_hw_addr(br, f->addr.addr);
137
138 hlist_del_rcu(&f->hlist);
139 fdb_notify(br, f, RTM_DELNEIGH);
140 call_rcu(&f->rcu, fdb_rcu_free);
141}
142
143
144static void fdb_delete_local(struct net_bridge *br,
145 const struct net_bridge_port *p,
146 struct net_bridge_fdb_entry *f)
147{
148 const unsigned char *addr = f->addr.addr;
149 u16 vid = f->vlan_id;
150 struct net_bridge_port *op;
151
152
153 list_for_each_entry(op, &br->port_list, list) {
154 if (op != p && ether_addr_equal(op->dev->dev_addr, addr) &&
155 (!vid || nbp_vlan_find(op, vid))) {
156 f->dst = op;
157 f->added_by_user = 0;
158 return;
159 }
160 }
161
162
163 if (p && ether_addr_equal(br->dev->dev_addr, addr) &&
164 (!vid || br_vlan_find(br, vid))) {
165 f->dst = NULL;
166 f->added_by_user = 0;
167 return;
168 }
169
170 fdb_delete(br, f);
171}
172
173void br_fdb_find_delete_local(struct net_bridge *br,
174 const struct net_bridge_port *p,
175 const unsigned char *addr, u16 vid)
176{
177 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
178 struct net_bridge_fdb_entry *f;
179
180 spin_lock_bh(&br->hash_lock);
181 f = fdb_find(head, addr, vid);
182 if (f && f->is_local && !f->added_by_user && f->dst == p)
183 fdb_delete_local(br, p, f);
184 spin_unlock_bh(&br->hash_lock);
185}
186
187void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
188{
189 struct net_bridge *br = p->br;
190 struct net_port_vlans *pv = nbp_get_vlan_info(p);
191 bool no_vlan = !pv;
192 int i;
193 u16 vid;
194
195 spin_lock_bh(&br->hash_lock);
196
197
198 for (i = 0; i < BR_HASH_SIZE; i++) {
199 struct hlist_node *h;
200 hlist_for_each(h, &br->hash[i]) {
201 struct net_bridge_fdb_entry *f;
202
203 f = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
204 if (f->dst == p && f->is_local && !f->added_by_user) {
205
206 fdb_delete_local(br, p, f);
207
208
209
210
211
212 if (no_vlan)
213 goto insert;
214 }
215 }
216 }
217
218insert:
219
220 fdb_insert(br, p, newaddr, 0);
221
222 if (no_vlan)
223 goto done;
224
225
226
227
228
229 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID)
230 fdb_insert(br, p, newaddr, vid);
231
232done:
233 spin_unlock_bh(&br->hash_lock);
234}
235
236void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
237{
238 struct net_bridge_fdb_entry *f;
239 struct net_port_vlans *pv;
240 u16 vid = 0;
241
242 spin_lock_bh(&br->hash_lock);
243
244
245 f = __br_fdb_get(br, br->dev->dev_addr, 0);
246 if (f && f->is_local && !f->dst)
247 fdb_delete_local(br, NULL, f);
248
249 fdb_insert(br, NULL, newaddr, 0);
250
251
252
253
254
255 pv = br_get_vlan_info(br);
256 if (!pv)
257 goto out;
258
259 for_each_set_bit_from(vid, pv->vlan_bitmap, VLAN_N_VID) {
260 f = __br_fdb_get(br, br->dev->dev_addr, vid);
261 if (f && f->is_local && !f->dst)
262 fdb_delete_local(br, NULL, f);
263 fdb_insert(br, NULL, newaddr, vid);
264 }
265out:
266 spin_unlock_bh(&br->hash_lock);
267}
268
269void br_fdb_cleanup(unsigned long _data)
270{
271 struct net_bridge *br = (struct net_bridge *)_data;
272 unsigned long delay = hold_time(br);
273 unsigned long next_timer = jiffies + br->ageing_time;
274 int i;
275
276 spin_lock(&br->hash_lock);
277 for (i = 0; i < BR_HASH_SIZE; i++) {
278 struct net_bridge_fdb_entry *f;
279 struct hlist_node *n;
280
281 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
282 unsigned long this_timer;
283 if (f->is_static)
284 continue;
285 this_timer = f->updated + delay;
286 if (time_before_eq(this_timer, jiffies))
287 fdb_delete(br, f);
288 else if (time_before(this_timer, next_timer))
289 next_timer = this_timer;
290 }
291 }
292 spin_unlock(&br->hash_lock);
293
294 mod_timer(&br->gc_timer, round_jiffies_up(next_timer));
295}
296
297
298void br_fdb_flush(struct net_bridge *br)
299{
300 int i;
301
302 spin_lock_bh(&br->hash_lock);
303 for (i = 0; i < BR_HASH_SIZE; i++) {
304 struct net_bridge_fdb_entry *f;
305 struct hlist_node *n;
306 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
307 if (!f->is_static)
308 fdb_delete(br, f);
309 }
310 }
311 spin_unlock_bh(&br->hash_lock);
312}
313
314
315
316
317void br_fdb_delete_by_port(struct net_bridge *br,
318 const struct net_bridge_port *p,
319 int do_all)
320{
321 int i;
322
323 spin_lock_bh(&br->hash_lock);
324 for (i = 0; i < BR_HASH_SIZE; i++) {
325 struct hlist_node *h, *g;
326
327 hlist_for_each_safe(h, g, &br->hash[i]) {
328 struct net_bridge_fdb_entry *f
329 = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
330 if (f->dst != p)
331 continue;
332
333 if (f->is_static && !do_all)
334 continue;
335
336 if (f->is_local)
337 fdb_delete_local(br, p, f);
338 else
339 fdb_delete(br, f);
340 }
341 }
342 spin_unlock_bh(&br->hash_lock);
343}
344
345
346struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br,
347 const unsigned char *addr,
348 __u16 vid)
349{
350 struct net_bridge_fdb_entry *fdb;
351
352 hlist_for_each_entry_rcu(fdb,
353 &br->hash[br_mac_hash(addr, vid)], hlist) {
354 if (ether_addr_equal(fdb->addr.addr, addr) &&
355 fdb->vlan_id == vid) {
356 if (unlikely(has_expired(br, fdb)))
357 break;
358 return fdb;
359 }
360 }
361
362 return NULL;
363}
364
365#if IS_ENABLED(CONFIG_ATM_LANE)
366
367
368int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
369{
370 struct net_bridge_fdb_entry *fdb;
371 struct net_bridge_port *port;
372 int ret;
373
374 rcu_read_lock();
375 port = br_port_get_rcu(dev);
376 if (!port)
377 ret = 0;
378 else {
379 fdb = __br_fdb_get(port->br, addr, 0);
380 ret = fdb && fdb->dst && fdb->dst->dev != dev &&
381 fdb->dst->state == BR_STATE_FORWARDING;
382 }
383 rcu_read_unlock();
384
385 return ret;
386}
387#endif
388
389
390
391
392
393int br_fdb_fillbuf(struct net_bridge *br, void *buf,
394 unsigned long maxnum, unsigned long skip)
395{
396 struct __fdb_entry *fe = buf;
397 int i, num = 0;
398 struct net_bridge_fdb_entry *f;
399
400 memset(buf, 0, maxnum*sizeof(struct __fdb_entry));
401
402 rcu_read_lock();
403 for (i = 0; i < BR_HASH_SIZE; i++) {
404 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
405 if (num >= maxnum)
406 goto out;
407
408 if (has_expired(br, f))
409 continue;
410
411
412 if (!f->dst)
413 continue;
414
415 if (skip) {
416 --skip;
417 continue;
418 }
419
420
421 memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN);
422
423
424 fe->port_no = f->dst->port_no;
425 fe->port_hi = f->dst->port_no >> 8;
426
427 fe->is_local = f->is_local;
428 if (!f->is_static)
429 fe->ageing_timer_value = jiffies_delta_to_clock_t(jiffies - f->updated);
430 ++fe;
431 ++num;
432 }
433 }
434
435 out:
436 rcu_read_unlock();
437
438 return num;
439}
440
441static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
442 const unsigned char *addr,
443 __u16 vid)
444{
445 struct net_bridge_fdb_entry *fdb;
446
447 hlist_for_each_entry(fdb, head, hlist) {
448 if (ether_addr_equal(fdb->addr.addr, addr) &&
449 fdb->vlan_id == vid)
450 return fdb;
451 }
452 return NULL;
453}
454
455static struct net_bridge_fdb_entry *fdb_find_rcu(struct hlist_head *head,
456 const unsigned char *addr,
457 __u16 vid)
458{
459 struct net_bridge_fdb_entry *fdb;
460
461 hlist_for_each_entry_rcu(fdb, head, hlist) {
462 if (ether_addr_equal(fdb->addr.addr, addr) &&
463 fdb->vlan_id == vid)
464 return fdb;
465 }
466 return NULL;
467}
468
469static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head,
470 struct net_bridge_port *source,
471 const unsigned char *addr,
472 __u16 vid)
473{
474 struct net_bridge_fdb_entry *fdb;
475
476 fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
477 if (fdb) {
478 memcpy(fdb->addr.addr, addr, ETH_ALEN);
479 fdb->dst = source;
480 fdb->vlan_id = vid;
481 fdb->is_local = 0;
482 fdb->is_static = 0;
483 fdb->added_by_user = 0;
484 fdb->added_by_external_learn = 0;
485 fdb->updated = fdb->used = jiffies;
486 hlist_add_head_rcu(&fdb->hlist, head);
487 }
488 return fdb;
489}
490
491static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
492 const unsigned char *addr, u16 vid)
493{
494 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
495 struct net_bridge_fdb_entry *fdb;
496
497 if (!is_valid_ether_addr(addr))
498 return -EINVAL;
499
500 fdb = fdb_find(head, addr, vid);
501 if (fdb) {
502
503
504
505 if (fdb->is_local)
506 return 0;
507 br_warn(br, "adding interface %s with same address "
508 "as a received packet\n",
509 source ? source->dev->name : br->dev->name);
510 fdb_delete(br, fdb);
511 }
512
513 fdb = fdb_create(head, source, addr, vid);
514 if (!fdb)
515 return -ENOMEM;
516
517 fdb->is_local = fdb->is_static = 1;
518 fdb_add_hw_addr(br, addr);
519 fdb_notify(br, fdb, RTM_NEWNEIGH);
520 return 0;
521}
522
523
524int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
525 const unsigned char *addr, u16 vid)
526{
527 int ret;
528
529 spin_lock_bh(&br->hash_lock);
530 ret = fdb_insert(br, source, addr, vid);
531 spin_unlock_bh(&br->hash_lock);
532 return ret;
533}
534
535void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
536 const unsigned char *addr, u16 vid, bool added_by_user)
537{
538 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
539 struct net_bridge_fdb_entry *fdb;
540 bool fdb_modified = false;
541
542
543 if (hold_time(br) == 0)
544 return;
545
546
547 if (!(source->state == BR_STATE_LEARNING ||
548 source->state == BR_STATE_FORWARDING))
549 return;
550
551 fdb = fdb_find_rcu(head, addr, vid);
552 if (likely(fdb)) {
553
554 if (unlikely(fdb->is_local)) {
555 if (net_ratelimit())
556 br_warn(br, "received packet on %s with "
557 "own address as source address\n",
558 source->dev->name);
559 } else {
560
561 if (unlikely(source != fdb->dst)) {
562 fdb->dst = source;
563 fdb_modified = true;
564 }
565 fdb->updated = jiffies;
566 if (unlikely(added_by_user))
567 fdb->added_by_user = 1;
568 if (unlikely(fdb_modified))
569 fdb_notify(br, fdb, RTM_NEWNEIGH);
570 }
571 } else {
572 spin_lock(&br->hash_lock);
573 if (likely(!fdb_find(head, addr, vid))) {
574 fdb = fdb_create(head, source, addr, vid);
575 if (fdb) {
576 if (unlikely(added_by_user))
577 fdb->added_by_user = 1;
578 fdb_notify(br, fdb, RTM_NEWNEIGH);
579 }
580 }
581
582
583
584 spin_unlock(&br->hash_lock);
585 }
586}
587
588static int fdb_to_nud(const struct net_bridge_fdb_entry *fdb)
589{
590 if (fdb->is_local)
591 return NUD_PERMANENT;
592 else if (fdb->is_static)
593 return NUD_NOARP;
594 else if (has_expired(fdb->dst->br, fdb))
595 return NUD_STALE;
596 else
597 return NUD_REACHABLE;
598}
599
600static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
601 const struct net_bridge_fdb_entry *fdb,
602 u32 portid, u32 seq, int type, unsigned int flags)
603{
604 unsigned long now = jiffies;
605 struct nda_cacheinfo ci;
606 struct nlmsghdr *nlh;
607 struct ndmsg *ndm;
608
609 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
610 if (nlh == NULL)
611 return -EMSGSIZE;
612
613 ndm = nlmsg_data(nlh);
614 ndm->ndm_family = AF_BRIDGE;
615 ndm->ndm_pad1 = 0;
616 ndm->ndm_pad2 = 0;
617 ndm->ndm_flags = fdb->added_by_external_learn ? NTF_EXT_LEARNED : 0;
618 ndm->ndm_type = 0;
619 ndm->ndm_ifindex = fdb->dst ? fdb->dst->dev->ifindex : br->dev->ifindex;
620 ndm->ndm_state = fdb_to_nud(fdb);
621
622 if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->addr))
623 goto nla_put_failure;
624 if (nla_put_u32(skb, NDA_MASTER, br->dev->ifindex))
625 goto nla_put_failure;
626 ci.ndm_used = jiffies_to_clock_t(now - fdb->used);
627 ci.ndm_confirmed = 0;
628 ci.ndm_updated = jiffies_to_clock_t(now - fdb->updated);
629 ci.ndm_refcnt = 0;
630 if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
631 goto nla_put_failure;
632
633 if (fdb->vlan_id && nla_put(skb, NDA_VLAN, sizeof(u16), &fdb->vlan_id))
634 goto nla_put_failure;
635
636 nlmsg_end(skb, nlh);
637 return 0;
638
639nla_put_failure:
640 nlmsg_cancel(skb, nlh);
641 return -EMSGSIZE;
642}
643
644static inline size_t fdb_nlmsg_size(void)
645{
646 return NLMSG_ALIGN(sizeof(struct ndmsg))
647 + nla_total_size(ETH_ALEN)
648 + nla_total_size(sizeof(u32))
649 + nla_total_size(sizeof(u16))
650 + nla_total_size(sizeof(struct nda_cacheinfo));
651}
652
653static void fdb_notify(struct net_bridge *br,
654 const struct net_bridge_fdb_entry *fdb, int type)
655{
656 struct net *net = dev_net(br->dev);
657 struct sk_buff *skb;
658 int err = -ENOBUFS;
659
660 skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
661 if (skb == NULL)
662 goto errout;
663
664 err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
665 if (err < 0) {
666
667 WARN_ON(err == -EMSGSIZE);
668 kfree_skb(skb);
669 goto errout;
670 }
671 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
672 return;
673errout:
674 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
675}
676
677
678int br_fdb_dump(struct sk_buff *skb,
679 struct netlink_callback *cb,
680 struct net_device *dev,
681 struct net_device *filter_dev,
682 int idx)
683{
684 struct net_bridge *br = netdev_priv(dev);
685 int i;
686
687 if (!(dev->priv_flags & IFF_EBRIDGE))
688 goto out;
689
690 if (!filter_dev)
691 idx = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx);
692
693 for (i = 0; i < BR_HASH_SIZE; i++) {
694 struct net_bridge_fdb_entry *f;
695
696 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
697 if (idx < cb->args[0])
698 goto skip;
699
700 if (filter_dev &&
701 (!f->dst || f->dst->dev != filter_dev)) {
702 if (filter_dev != dev)
703 goto skip;
704
705
706
707
708
709 if (f->dst)
710 goto skip;
711 }
712 if (!filter_dev && f->dst)
713 goto skip;
714
715 if (fdb_fill_info(skb, br, f,
716 NETLINK_CB(cb->skb).portid,
717 cb->nlh->nlmsg_seq,
718 RTM_NEWNEIGH,
719 NLM_F_MULTI) < 0)
720 break;
721skip:
722 ++idx;
723 }
724 }
725
726out:
727 return idx;
728}
729
730
731static int fdb_add_entry(struct net_bridge_port *source, const __u8 *addr,
732 __u16 state, __u16 flags, __u16 vid)
733{
734 struct net_bridge *br = source->br;
735 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
736 struct net_bridge_fdb_entry *fdb;
737 bool modified = false;
738
739 fdb = fdb_find(head, addr, vid);
740 if (fdb == NULL) {
741 if (!(flags & NLM_F_CREATE))
742 return -ENOENT;
743
744 fdb = fdb_create(head, source, addr, vid);
745 if (!fdb)
746 return -ENOMEM;
747
748 modified = true;
749 } else {
750 if (flags & NLM_F_EXCL)
751 return -EEXIST;
752
753 if (fdb->dst != source) {
754 fdb->dst = source;
755 modified = true;
756 }
757 }
758
759 if (fdb_to_nud(fdb) != state) {
760 if (state & NUD_PERMANENT) {
761 fdb->is_local = 1;
762 if (!fdb->is_static) {
763 fdb->is_static = 1;
764 fdb_add_hw_addr(br, addr);
765 }
766 } else if (state & NUD_NOARP) {
767 fdb->is_local = 0;
768 if (!fdb->is_static) {
769 fdb->is_static = 1;
770 fdb_add_hw_addr(br, addr);
771 }
772 } else {
773 fdb->is_local = 0;
774 if (fdb->is_static) {
775 fdb->is_static = 0;
776 fdb_del_hw_addr(br, addr);
777 }
778 }
779
780 modified = true;
781 }
782 fdb->added_by_user = 1;
783
784 fdb->used = jiffies;
785 if (modified) {
786 fdb->updated = jiffies;
787 fdb_notify(br, fdb, RTM_NEWNEIGH);
788 }
789
790 return 0;
791}
792
793static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge_port *p,
794 const unsigned char *addr, u16 nlh_flags, u16 vid)
795{
796 int err = 0;
797
798 if (ndm->ndm_flags & NTF_USE) {
799 rcu_read_lock();
800 br_fdb_update(p->br, p, addr, vid, true);
801 rcu_read_unlock();
802 } else {
803 spin_lock_bh(&p->br->hash_lock);
804 err = fdb_add_entry(p, addr, ndm->ndm_state,
805 nlh_flags, vid);
806 spin_unlock_bh(&p->br->hash_lock);
807 }
808
809 return err;
810}
811
812
813int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
814 struct net_device *dev,
815 const unsigned char *addr, u16 vid, u16 nlh_flags)
816{
817 struct net_bridge_port *p;
818 int err = 0;
819 struct net_port_vlans *pv;
820
821 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
822 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
823 return -EINVAL;
824 }
825
826 if (is_zero_ether_addr(addr)) {
827 pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
828 return -EINVAL;
829 }
830
831 p = br_port_get_rtnl(dev);
832 if (p == NULL) {
833 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
834 dev->name);
835 return -EINVAL;
836 }
837
838 pv = nbp_get_vlan_info(p);
839 if (vid) {
840 if (!pv || !test_bit(vid, pv->vlan_bitmap)) {
841 pr_info("bridge: RTM_NEWNEIGH with unconfigured "
842 "vlan %d on port %s\n", vid, dev->name);
843 return -EINVAL;
844 }
845
846
847 err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
848 } else {
849 err = __br_fdb_add(ndm, p, addr, nlh_flags, 0);
850 if (err || !pv)
851 goto out;
852
853
854
855
856
857 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
858 err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
859 if (err)
860 goto out;
861 }
862 }
863
864out:
865 return err;
866}
867
868static int fdb_delete_by_addr(struct net_bridge *br, const u8 *addr, u16 vlan)
869{
870 struct hlist_head *head = &br->hash[br_mac_hash(addr, vlan)];
871 struct net_bridge_fdb_entry *fdb;
872
873 fdb = fdb_find(head, addr, vlan);
874 if (!fdb)
875 return -ENOENT;
876
877 fdb_delete(br, fdb);
878 return 0;
879}
880
881static int __br_fdb_delete(struct net_bridge_port *p,
882 const unsigned char *addr, u16 vid)
883{
884 int err;
885
886 spin_lock_bh(&p->br->hash_lock);
887 err = fdb_delete_by_addr(p->br, addr, vid);
888 spin_unlock_bh(&p->br->hash_lock);
889
890 return err;
891}
892
893
894int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
895 struct net_device *dev,
896 const unsigned char *addr, u16 vid)
897{
898 struct net_bridge_port *p;
899 int err;
900 struct net_port_vlans *pv;
901
902 p = br_port_get_rtnl(dev);
903 if (p == NULL) {
904 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
905 dev->name);
906 return -EINVAL;
907 }
908
909 pv = nbp_get_vlan_info(p);
910 if (vid) {
911 if (!pv || !test_bit(vid, pv->vlan_bitmap)) {
912 pr_info("bridge: RTM_DELNEIGH with unconfigured "
913 "vlan %d on port %s\n", vid, dev->name);
914 return -EINVAL;
915 }
916
917 err = __br_fdb_delete(p, addr, vid);
918 } else {
919 err = -ENOENT;
920 err &= __br_fdb_delete(p, addr, 0);
921 if (!pv)
922 goto out;
923
924
925
926
927
928 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
929 err &= __br_fdb_delete(p, addr, vid);
930 }
931 }
932out:
933 return err;
934}
935
936int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p)
937{
938 struct net_bridge_fdb_entry *fdb, *tmp;
939 int i;
940 int err;
941
942 ASSERT_RTNL();
943
944 for (i = 0; i < BR_HASH_SIZE; i++) {
945 hlist_for_each_entry(fdb, &br->hash[i], hlist) {
946
947 if (!fdb->is_static)
948 continue;
949
950 err = dev_uc_add(p->dev, fdb->addr.addr);
951 if (err)
952 goto rollback;
953 }
954 }
955 return 0;
956
957rollback:
958 for (i = 0; i < BR_HASH_SIZE; i++) {
959 hlist_for_each_entry(tmp, &br->hash[i], hlist) {
960
961 if (tmp == fdb)
962 break;
963
964
965 if (!tmp->is_static)
966 continue;
967
968 dev_uc_del(p->dev, tmp->addr.addr);
969 }
970 }
971 return err;
972}
973
974void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p)
975{
976 struct net_bridge_fdb_entry *fdb;
977 int i;
978
979 ASSERT_RTNL();
980
981 for (i = 0; i < BR_HASH_SIZE; i++) {
982 hlist_for_each_entry_rcu(fdb, &br->hash[i], hlist) {
983
984 if (!fdb->is_static)
985 continue;
986
987 dev_uc_del(p->dev, fdb->addr.addr);
988 }
989 }
990}
991
992int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p,
993 const unsigned char *addr, u16 vid)
994{
995 struct hlist_head *head;
996 struct net_bridge_fdb_entry *fdb;
997 int err = 0;
998
999 ASSERT_RTNL();
1000 spin_lock_bh(&br->hash_lock);
1001
1002 head = &br->hash[br_mac_hash(addr, vid)];
1003 fdb = fdb_find(head, addr, vid);
1004 if (!fdb) {
1005 fdb = fdb_create(head, p, addr, vid);
1006 if (!fdb) {
1007 err = -ENOMEM;
1008 goto err_unlock;
1009 }
1010 fdb->added_by_external_learn = 1;
1011 fdb_notify(br, fdb, RTM_NEWNEIGH);
1012 } else if (fdb->added_by_external_learn) {
1013
1014 fdb->updated = fdb->used = jiffies;
1015 } else if (!fdb->added_by_user) {
1016
1017 fdb->added_by_external_learn = 1;
1018 fdb->updated = jiffies;
1019 fdb_notify(br, fdb, RTM_NEWNEIGH);
1020 }
1021
1022err_unlock:
1023 spin_unlock_bh(&br->hash_lock);
1024
1025 return err;
1026}
1027
1028int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
1029 const unsigned char *addr, u16 vid)
1030{
1031 struct hlist_head *head;
1032 struct net_bridge_fdb_entry *fdb;
1033 int err = 0;
1034
1035 ASSERT_RTNL();
1036 spin_lock_bh(&br->hash_lock);
1037
1038 head = &br->hash[br_mac_hash(addr, vid)];
1039 fdb = fdb_find(head, addr, vid);
1040 if (fdb && fdb->added_by_external_learn)
1041 fdb_delete(br, fdb);
1042 else
1043 err = -ENOENT;
1044
1045 spin_unlock_bh(&br->hash_lock);
1046
1047 return err;
1048}
1049