3 * Linux ethernet bridge
6 * Lennert Buytenhek <buytenh@gnu.org>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
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 <net/switchdev.h>
28 #include "br_private.h"
30 static struct kmem_cache
*br_fdb_cache __read_mostly
;
31 static struct net_bridge_fdb_entry
*fdb_find(struct hlist_head
*head
,
32 const unsigned char *addr
,
34 static int fdb_insert(struct net_bridge
*br
, struct net_bridge_port
*source
,
35 const unsigned char *addr
, u16 vid
);
36 static void fdb_notify(struct net_bridge
*br
,
37 const struct net_bridge_fdb_entry
*, int);
39 static u32 fdb_salt __read_mostly
;
41 int __init
br_fdb_init(void)
43 br_fdb_cache
= kmem_cache_create("bridge_fdb_cache",
44 sizeof(struct net_bridge_fdb_entry
),
46 SLAB_HWCACHE_ALIGN
, NULL
);
50 get_random_bytes(&fdb_salt
, sizeof(fdb_salt
));
54 void br_fdb_fini(void)
56 kmem_cache_destroy(br_fdb_cache
);
60 /* if topology_changing then use forward_delay (default 15 sec)
61 * otherwise keep longer (default 5 minutes)
63 static inline unsigned long hold_time(const struct net_bridge
*br
)
65 return br
->topology_change
? br
->forward_delay
: br
->ageing_time
;
68 static inline int has_expired(const struct net_bridge
*br
,
69 const struct net_bridge_fdb_entry
*fdb
)
71 return !fdb
->is_static
&&
72 time_before_eq(fdb
->updated
+ hold_time(br
), jiffies
);
75 static inline int br_mac_hash(const unsigned char *mac
, __u16 vid
)
77 /* use 1 byte of OUI and 3 bytes of NIC */
78 u32 key
= get_unaligned((u32
*)(mac
+ 2));
79 return jhash_2words(key
, vid
, fdb_salt
) & (BR_HASH_SIZE
- 1);
82 static void fdb_rcu_free(struct rcu_head
*head
)
84 struct net_bridge_fdb_entry
*ent
85 = container_of(head
, struct net_bridge_fdb_entry
, rcu
);
86 kmem_cache_free(br_fdb_cache
, ent
);
89 /* When a static FDB entry is added, the mac address from the entry is
90 * added to the bridge private HW address list and all required ports
91 * are then updated with the new information.
94 static void fdb_add_hw_addr(struct net_bridge
*br
, const unsigned char *addr
)
97 struct net_bridge_port
*p
;
101 list_for_each_entry(p
, &br
->port_list
, list
) {
102 if (!br_promisc_port(p
)) {
103 err
= dev_uc_add(p
->dev
, addr
);
111 list_for_each_entry_continue_reverse(p
, &br
->port_list
, list
) {
112 if (!br_promisc_port(p
))
113 dev_uc_del(p
->dev
, addr
);
117 /* When a static FDB entry is deleted, the HW address from that entry is
118 * also removed from the bridge private HW address list and updates all
119 * the ports with needed information.
122 static void fdb_del_hw_addr(struct net_bridge
*br
, const unsigned char *addr
)
124 struct net_bridge_port
*p
;
128 list_for_each_entry(p
, &br
->port_list
, list
) {
129 if (!br_promisc_port(p
))
130 dev_uc_del(p
->dev
, addr
);
134 static void fdb_del_external_learn(struct net_bridge_fdb_entry
*f
)
136 struct switchdev_obj_port_fdb fdb
= {
138 .orig_dev
= f
->dst
->dev
,
139 .id
= SWITCHDEV_OBJ_ID_PORT_FDB
,
140 .flags
= SWITCHDEV_F_DEFER
,
145 ether_addr_copy(fdb
.addr
, f
->addr
.addr
);
146 switchdev_port_obj_del(f
->dst
->dev
, &fdb
.obj
);
149 static void fdb_delete(struct net_bridge
*br
, struct net_bridge_fdb_entry
*f
)
152 fdb_del_hw_addr(br
, f
->addr
.addr
);
154 if (f
->added_by_external_learn
)
155 fdb_del_external_learn(f
);
157 hlist_del_rcu(&f
->hlist
);
158 fdb_notify(br
, f
, RTM_DELNEIGH
);
159 call_rcu(&f
->rcu
, fdb_rcu_free
);
162 /* Delete a local entry if no other port had the same address. */
163 static void fdb_delete_local(struct net_bridge
*br
,
164 const struct net_bridge_port
*p
,
165 struct net_bridge_fdb_entry
*f
)
167 const unsigned char *addr
= f
->addr
.addr
;
168 struct net_bridge_vlan_group
*vg
;
169 const struct net_bridge_vlan
*v
;
170 struct net_bridge_port
*op
;
171 u16 vid
= f
->vlan_id
;
173 /* Maybe another port has same hw addr? */
174 list_for_each_entry(op
, &br
->port_list
, list
) {
175 vg
= nbp_vlan_group(op
);
176 if (op
!= p
&& ether_addr_equal(op
->dev
->dev_addr
, addr
) &&
177 (!vid
|| br_vlan_find(vg
, vid
))) {
179 f
->added_by_user
= 0;
184 vg
= br_vlan_group(br
);
185 v
= br_vlan_find(vg
, vid
);
186 /* Maybe bridge device has same hw addr? */
187 if (p
&& ether_addr_equal(br
->dev
->dev_addr
, addr
) &&
188 (!vid
|| (v
&& br_vlan_should_use(v
)))) {
190 f
->added_by_user
= 0;
197 void br_fdb_find_delete_local(struct net_bridge
*br
,
198 const struct net_bridge_port
*p
,
199 const unsigned char *addr
, u16 vid
)
201 struct hlist_head
*head
= &br
->hash
[br_mac_hash(addr
, vid
)];
202 struct net_bridge_fdb_entry
*f
;
204 spin_lock_bh(&br
->hash_lock
);
205 f
= fdb_find(head
, addr
, vid
);
206 if (f
&& f
->is_local
&& !f
->added_by_user
&& f
->dst
== p
)
207 fdb_delete_local(br
, p
, f
);
208 spin_unlock_bh(&br
->hash_lock
);
211 void br_fdb_changeaddr(struct net_bridge_port
*p
, const unsigned char *newaddr
)
213 struct net_bridge_vlan_group
*vg
;
214 struct net_bridge
*br
= p
->br
;
215 struct net_bridge_vlan
*v
;
218 spin_lock_bh(&br
->hash_lock
);
220 vg
= nbp_vlan_group(p
);
221 /* Search all chains since old address/hash is unknown */
222 for (i
= 0; i
< BR_HASH_SIZE
; i
++) {
223 struct hlist_node
*h
;
224 hlist_for_each(h
, &br
->hash
[i
]) {
225 struct net_bridge_fdb_entry
*f
;
227 f
= hlist_entry(h
, struct net_bridge_fdb_entry
, hlist
);
228 if (f
->dst
== p
&& f
->is_local
&& !f
->added_by_user
) {
230 fdb_delete_local(br
, p
, f
);
232 /* if this port has no vlan information
233 * configured, we can safely be done at
236 if (!vg
|| !vg
->num_vlans
)
243 /* insert new address, may fail if invalid address or dup. */
244 fdb_insert(br
, p
, newaddr
, 0);
246 if (!vg
|| !vg
->num_vlans
)
249 /* Now add entries for every VLAN configured on the port.
250 * This function runs under RTNL so the bitmap will not change
253 list_for_each_entry(v
, &vg
->vlan_list
, vlist
)
254 fdb_insert(br
, p
, newaddr
, v
->vid
);
257 spin_unlock_bh(&br
->hash_lock
);
260 void br_fdb_change_mac_address(struct net_bridge
*br
, const u8
*newaddr
)
262 struct net_bridge_vlan_group
*vg
;
263 struct net_bridge_fdb_entry
*f
;
264 struct net_bridge_vlan
*v
;
266 spin_lock_bh(&br
->hash_lock
);
268 /* If old entry was unassociated with any port, then delete it. */
269 f
= __br_fdb_get(br
, br
->dev
->dev_addr
, 0);
270 if (f
&& f
->is_local
&& !f
->dst
)
271 fdb_delete_local(br
, NULL
, f
);
273 fdb_insert(br
, NULL
, newaddr
, 0);
274 vg
= br_vlan_group(br
);
275 if (!vg
|| !vg
->num_vlans
)
277 /* Now remove and add entries for every VLAN configured on the
278 * bridge. This function runs under RTNL so the bitmap will not
279 * change from under us.
281 list_for_each_entry(v
, &vg
->vlan_list
, vlist
) {
282 f
= __br_fdb_get(br
, br
->dev
->dev_addr
, v
->vid
);
283 if (f
&& f
->is_local
&& !f
->dst
)
284 fdb_delete_local(br
, NULL
, f
);
285 fdb_insert(br
, NULL
, newaddr
, v
->vid
);
288 spin_unlock_bh(&br
->hash_lock
);
291 void br_fdb_cleanup(unsigned long _data
)
293 struct net_bridge
*br
= (struct net_bridge
*)_data
;
294 unsigned long delay
= hold_time(br
);
295 unsigned long next_timer
= jiffies
+ br
->ageing_time
;
298 spin_lock(&br
->hash_lock
);
299 for (i
= 0; i
< BR_HASH_SIZE
; i
++) {
300 struct net_bridge_fdb_entry
*f
;
301 struct hlist_node
*n
;
303 hlist_for_each_entry_safe(f
, n
, &br
->hash
[i
], hlist
) {
304 unsigned long this_timer
;
307 if (f
->added_by_external_learn
)
309 this_timer
= f
->updated
+ delay
;
310 if (time_before_eq(this_timer
, jiffies
))
312 else if (time_before(this_timer
, next_timer
))
313 next_timer
= this_timer
;
316 spin_unlock(&br
->hash_lock
);
318 mod_timer(&br
->gc_timer
, round_jiffies_up(next_timer
));
321 /* Completely flush all dynamic entries in forwarding database.*/
322 void br_fdb_flush(struct net_bridge
*br
)
326 spin_lock_bh(&br
->hash_lock
);
327 for (i
= 0; i
< BR_HASH_SIZE
; i
++) {
328 struct net_bridge_fdb_entry
*f
;
329 struct hlist_node
*n
;
330 hlist_for_each_entry_safe(f
, n
, &br
->hash
[i
], hlist
) {
335 spin_unlock_bh(&br
->hash_lock
);
338 /* Flush all entries referring to a specific port.
339 * if do_all is set also flush static entries
340 * if vid is set delete all entries that match the vlan_id
342 void br_fdb_delete_by_port(struct net_bridge
*br
,
343 const struct net_bridge_port
*p
,
349 spin_lock_bh(&br
->hash_lock
);
350 for (i
= 0; i
< BR_HASH_SIZE
; i
++) {
351 struct hlist_node
*h
, *g
;
353 hlist_for_each_safe(h
, g
, &br
->hash
[i
]) {
354 struct net_bridge_fdb_entry
*f
355 = hlist_entry(h
, struct net_bridge_fdb_entry
, hlist
);
360 if (f
->is_static
|| (vid
&& f
->vlan_id
!= vid
))
364 fdb_delete_local(br
, p
, f
);
369 spin_unlock_bh(&br
->hash_lock
);
372 /* No locking or refcounting, assumes caller has rcu_read_lock */
373 struct net_bridge_fdb_entry
*__br_fdb_get(struct net_bridge
*br
,
374 const unsigned char *addr
,
377 struct net_bridge_fdb_entry
*fdb
;
379 hlist_for_each_entry_rcu(fdb
,
380 &br
->hash
[br_mac_hash(addr
, vid
)], hlist
) {
381 if (ether_addr_equal(fdb
->addr
.addr
, addr
) &&
382 fdb
->vlan_id
== vid
) {
383 if (unlikely(has_expired(br
, fdb
)))
392 #if IS_ENABLED(CONFIG_ATM_LANE)
393 /* Interface used by ATM LANE hook to test
394 * if an addr is on some other bridge port */
395 int br_fdb_test_addr(struct net_device
*dev
, unsigned char *addr
)
397 struct net_bridge_fdb_entry
*fdb
;
398 struct net_bridge_port
*port
;
402 port
= br_port_get_rcu(dev
);
406 fdb
= __br_fdb_get(port
->br
, addr
, 0);
407 ret
= fdb
&& fdb
->dst
&& fdb
->dst
->dev
!= dev
&&
408 fdb
->dst
->state
== BR_STATE_FORWARDING
;
414 #endif /* CONFIG_ATM_LANE */
417 * Fill buffer with forwarding table records in
420 int br_fdb_fillbuf(struct net_bridge
*br
, void *buf
,
421 unsigned long maxnum
, unsigned long skip
)
423 struct __fdb_entry
*fe
= buf
;
425 struct net_bridge_fdb_entry
*f
;
427 memset(buf
, 0, maxnum
*sizeof(struct __fdb_entry
));
430 for (i
= 0; i
< BR_HASH_SIZE
; i
++) {
431 hlist_for_each_entry_rcu(f
, &br
->hash
[i
], hlist
) {
435 if (has_expired(br
, f
))
438 /* ignore pseudo entry for local MAC address */
447 /* convert from internal format to API */
448 memcpy(fe
->mac_addr
, f
->addr
.addr
, ETH_ALEN
);
450 /* due to ABI compat need to split into hi/lo */
451 fe
->port_no
= f
->dst
->port_no
;
452 fe
->port_hi
= f
->dst
->port_no
>> 8;
454 fe
->is_local
= f
->is_local
;
456 fe
->ageing_timer_value
= jiffies_delta_to_clock_t(jiffies
- f
->updated
);
468 static struct net_bridge_fdb_entry
*fdb_find(struct hlist_head
*head
,
469 const unsigned char *addr
,
472 struct net_bridge_fdb_entry
*fdb
;
474 hlist_for_each_entry(fdb
, head
, hlist
) {
475 if (ether_addr_equal(fdb
->addr
.addr
, addr
) &&
482 static struct net_bridge_fdb_entry
*fdb_find_rcu(struct hlist_head
*head
,
483 const unsigned char *addr
,
486 struct net_bridge_fdb_entry
*fdb
;
488 hlist_for_each_entry_rcu(fdb
, head
, hlist
) {
489 if (ether_addr_equal(fdb
->addr
.addr
, addr
) &&
496 static struct net_bridge_fdb_entry
*fdb_create(struct hlist_head
*head
,
497 struct net_bridge_port
*source
,
498 const unsigned char *addr
,
500 unsigned char is_local
,
501 unsigned char is_static
)
503 struct net_bridge_fdb_entry
*fdb
;
505 fdb
= kmem_cache_alloc(br_fdb_cache
, GFP_ATOMIC
);
507 memcpy(fdb
->addr
.addr
, addr
, ETH_ALEN
);
510 fdb
->is_local
= is_local
;
511 fdb
->is_static
= is_static
;
512 fdb
->added_by_user
= 0;
513 fdb
->added_by_external_learn
= 0;
514 fdb
->updated
= fdb
->used
= jiffies
;
515 hlist_add_head_rcu(&fdb
->hlist
, head
);
520 static int fdb_insert(struct net_bridge
*br
, struct net_bridge_port
*source
,
521 const unsigned char *addr
, u16 vid
)
523 struct hlist_head
*head
= &br
->hash
[br_mac_hash(addr
, vid
)];
524 struct net_bridge_fdb_entry
*fdb
;
526 if (!is_valid_ether_addr(addr
))
529 fdb
= fdb_find(head
, addr
, vid
);
531 /* it is okay to have multiple ports with same
532 * address, just use the first one.
536 br_warn(br
, "adding interface %s with same address "
537 "as a received packet\n",
538 source
? source
->dev
->name
: br
->dev
->name
);
542 fdb
= fdb_create(head
, source
, addr
, vid
, 1, 1);
546 fdb_add_hw_addr(br
, addr
);
547 fdb_notify(br
, fdb
, RTM_NEWNEIGH
);
551 /* Add entry for local address of interface */
552 int br_fdb_insert(struct net_bridge
*br
, struct net_bridge_port
*source
,
553 const unsigned char *addr
, u16 vid
)
557 spin_lock_bh(&br
->hash_lock
);
558 ret
= fdb_insert(br
, source
, addr
, vid
);
559 spin_unlock_bh(&br
->hash_lock
);
563 void br_fdb_update(struct net_bridge
*br
, struct net_bridge_port
*source
,
564 const unsigned char *addr
, u16 vid
, bool added_by_user
)
566 struct hlist_head
*head
= &br
->hash
[br_mac_hash(addr
, vid
)];
567 struct net_bridge_fdb_entry
*fdb
;
568 bool fdb_modified
= false;
570 /* some users want to always flood. */
571 if (hold_time(br
) == 0)
574 /* ignore packets unless we are using this port */
575 if (!(source
->state
== BR_STATE_LEARNING
||
576 source
->state
== BR_STATE_FORWARDING
))
579 fdb
= fdb_find_rcu(head
, addr
, vid
);
581 /* attempt to update an entry for a local interface */
582 if (unlikely(fdb
->is_local
)) {
584 br_warn(br
, "received packet on %s with "
585 "own address as source address\n",
588 /* fastpath: update of existing entry */
589 if (unlikely(source
!= fdb
->dst
)) {
593 fdb
->updated
= jiffies
;
594 if (unlikely(added_by_user
))
595 fdb
->added_by_user
= 1;
596 if (unlikely(fdb_modified
))
597 fdb_notify(br
, fdb
, RTM_NEWNEIGH
);
600 spin_lock(&br
->hash_lock
);
601 if (likely(!fdb_find(head
, addr
, vid
))) {
602 fdb
= fdb_create(head
, source
, addr
, vid
, 0, 0);
604 if (unlikely(added_by_user
))
605 fdb
->added_by_user
= 1;
606 fdb_notify(br
, fdb
, RTM_NEWNEIGH
);
609 /* else we lose race and someone else inserts
610 * it first, don't bother updating
612 spin_unlock(&br
->hash_lock
);
616 static int fdb_to_nud(const struct net_bridge
*br
,
617 const struct net_bridge_fdb_entry
*fdb
)
620 return NUD_PERMANENT
;
621 else if (fdb
->is_static
)
623 else if (has_expired(br
, fdb
))
626 return NUD_REACHABLE
;
629 static int fdb_fill_info(struct sk_buff
*skb
, const struct net_bridge
*br
,
630 const struct net_bridge_fdb_entry
*fdb
,
631 u32 portid
, u32 seq
, int type
, unsigned int flags
)
633 unsigned long now
= jiffies
;
634 struct nda_cacheinfo ci
;
635 struct nlmsghdr
*nlh
;
638 nlh
= nlmsg_put(skb
, portid
, seq
, type
, sizeof(*ndm
), flags
);
642 ndm
= nlmsg_data(nlh
);
643 ndm
->ndm_family
= AF_BRIDGE
;
646 ndm
->ndm_flags
= fdb
->added_by_external_learn
? NTF_EXT_LEARNED
: 0;
648 ndm
->ndm_ifindex
= fdb
->dst
? fdb
->dst
->dev
->ifindex
: br
->dev
->ifindex
;
649 ndm
->ndm_state
= fdb_to_nud(br
, fdb
);
651 if (nla_put(skb
, NDA_LLADDR
, ETH_ALEN
, &fdb
->addr
))
652 goto nla_put_failure
;
653 if (nla_put_u32(skb
, NDA_MASTER
, br
->dev
->ifindex
))
654 goto nla_put_failure
;
655 ci
.ndm_used
= jiffies_to_clock_t(now
- fdb
->used
);
656 ci
.ndm_confirmed
= 0;
657 ci
.ndm_updated
= jiffies_to_clock_t(now
- fdb
->updated
);
659 if (nla_put(skb
, NDA_CACHEINFO
, sizeof(ci
), &ci
))
660 goto nla_put_failure
;
662 if (fdb
->vlan_id
&& nla_put(skb
, NDA_VLAN
, sizeof(u16
), &fdb
->vlan_id
))
663 goto nla_put_failure
;
669 nlmsg_cancel(skb
, nlh
);
673 static inline size_t fdb_nlmsg_size(void)
675 return NLMSG_ALIGN(sizeof(struct ndmsg
))
676 + nla_total_size(ETH_ALEN
) /* NDA_LLADDR */
677 + nla_total_size(sizeof(u32
)) /* NDA_MASTER */
678 + nla_total_size(sizeof(u16
)) /* NDA_VLAN */
679 + nla_total_size(sizeof(struct nda_cacheinfo
));
682 static void fdb_notify(struct net_bridge
*br
,
683 const struct net_bridge_fdb_entry
*fdb
, int type
)
685 struct net
*net
= dev_net(br
->dev
);
689 skb
= nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC
);
693 err
= fdb_fill_info(skb
, br
, fdb
, 0, 0, type
, 0);
695 /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */
696 WARN_ON(err
== -EMSGSIZE
);
700 rtnl_notify(skb
, net
, 0, RTNLGRP_NEIGH
, NULL
, GFP_ATOMIC
);
703 rtnl_set_sk_err(net
, RTNLGRP_NEIGH
, err
);
706 /* Dump information about entries, in response to GETNEIGH */
707 int br_fdb_dump(struct sk_buff
*skb
,
708 struct netlink_callback
*cb
,
709 struct net_device
*dev
,
710 struct net_device
*filter_dev
,
713 struct net_bridge
*br
= netdev_priv(dev
);
716 if (!(dev
->priv_flags
& IFF_EBRIDGE
))
720 idx
= ndo_dflt_fdb_dump(skb
, cb
, dev
, NULL
, idx
);
722 for (i
= 0; i
< BR_HASH_SIZE
; i
++) {
723 struct net_bridge_fdb_entry
*f
;
725 hlist_for_each_entry_rcu(f
, &br
->hash
[i
], hlist
) {
726 if (idx
< cb
->args
[0])
730 (!f
->dst
|| f
->dst
->dev
!= filter_dev
)) {
731 if (filter_dev
!= dev
)
733 /* !f->dst is a special case for bridge
734 * It means the MAC belongs to the bridge
735 * Therefore need a little more filtering
736 * we only want to dump the !f->dst case
741 if (!filter_dev
&& f
->dst
)
744 if (fdb_fill_info(skb
, br
, f
,
745 NETLINK_CB(cb
->skb
).portid
,
759 /* Update (create or replace) forwarding database entry */
760 static int fdb_add_entry(struct net_bridge_port
*source
, const __u8
*addr
,
761 __u16 state
, __u16 flags
, __u16 vid
)
763 struct net_bridge
*br
= source
->br
;
764 struct hlist_head
*head
= &br
->hash
[br_mac_hash(addr
, vid
)];
765 struct net_bridge_fdb_entry
*fdb
;
766 bool modified
= false;
768 /* If the port cannot learn allow only local and static entries */
769 if (!(state
& NUD_PERMANENT
) && !(state
& NUD_NOARP
) &&
770 !(source
->state
== BR_STATE_LEARNING
||
771 source
->state
== BR_STATE_FORWARDING
))
774 fdb
= fdb_find(head
, addr
, vid
);
776 if (!(flags
& NLM_F_CREATE
))
779 fdb
= fdb_create(head
, source
, addr
, vid
, 0, 0);
785 if (flags
& NLM_F_EXCL
)
788 if (fdb
->dst
!= source
) {
794 if (fdb_to_nud(br
, fdb
) != state
) {
795 if (state
& NUD_PERMANENT
) {
797 if (!fdb
->is_static
) {
799 fdb_add_hw_addr(br
, addr
);
801 } else if (state
& NUD_NOARP
) {
803 if (!fdb
->is_static
) {
805 fdb_add_hw_addr(br
, addr
);
809 if (fdb
->is_static
) {
811 fdb_del_hw_addr(br
, addr
);
817 fdb
->added_by_user
= 1;
821 fdb
->updated
= jiffies
;
822 fdb_notify(br
, fdb
, RTM_NEWNEIGH
);
828 static int __br_fdb_add(struct ndmsg
*ndm
, struct net_bridge_port
*p
,
829 const unsigned char *addr
, u16 nlh_flags
, u16 vid
)
833 if (ndm
->ndm_flags
& NTF_USE
) {
836 br_fdb_update(p
->br
, p
, addr
, vid
, true);
840 spin_lock_bh(&p
->br
->hash_lock
);
841 err
= fdb_add_entry(p
, addr
, ndm
->ndm_state
,
843 spin_unlock_bh(&p
->br
->hash_lock
);
849 /* Add new permanent fdb entry with RTM_NEWNEIGH */
850 int br_fdb_add(struct ndmsg
*ndm
, struct nlattr
*tb
[],
851 struct net_device
*dev
,
852 const unsigned char *addr
, u16 vid
, u16 nlh_flags
)
854 struct net_bridge_vlan_group
*vg
;
855 struct net_bridge_port
*p
= NULL
;
856 struct net_bridge_vlan
*v
;
857 struct net_bridge
*br
= NULL
;
860 if (!(ndm
->ndm_state
& (NUD_PERMANENT
|NUD_NOARP
|NUD_REACHABLE
))) {
861 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm
->ndm_state
);
865 if (is_zero_ether_addr(addr
)) {
866 pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
870 if (dev
->priv_flags
& IFF_EBRIDGE
) {
871 br
= netdev_priv(dev
);
872 vg
= br_vlan_group(br
);
874 p
= br_port_get_rtnl(dev
);
876 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
880 vg
= nbp_vlan_group(p
);
884 v
= br_vlan_find(vg
, vid
);
885 if (!v
|| !br_vlan_should_use(v
)) {
886 pr_info("bridge: RTM_NEWNEIGH with unconfigured vlan %d on %s\n", vid
, dev
->name
);
890 /* VID was specified, so use it. */
891 if (dev
->priv_flags
& IFF_EBRIDGE
)
892 err
= br_fdb_insert(br
, NULL
, addr
, vid
);
894 err
= __br_fdb_add(ndm
, p
, addr
, nlh_flags
, vid
);
896 if (dev
->priv_flags
& IFF_EBRIDGE
)
897 err
= br_fdb_insert(br
, NULL
, addr
, 0);
899 err
= __br_fdb_add(ndm
, p
, addr
, nlh_flags
, 0);
900 if (err
|| !vg
|| !vg
->num_vlans
)
903 /* We have vlans configured on this port and user didn't
904 * specify a VLAN. To be nice, add/update entry for every
907 list_for_each_entry(v
, &vg
->vlan_list
, vlist
) {
908 if (!br_vlan_should_use(v
))
910 if (dev
->priv_flags
& IFF_EBRIDGE
)
911 err
= br_fdb_insert(br
, NULL
, addr
, v
->vid
);
913 err
= __br_fdb_add(ndm
, p
, addr
, nlh_flags
,
924 static int fdb_delete_by_addr(struct net_bridge
*br
, const u8
*addr
,
927 struct hlist_head
*head
= &br
->hash
[br_mac_hash(addr
, vid
)];
928 struct net_bridge_fdb_entry
*fdb
;
930 fdb
= fdb_find(head
, addr
, vid
);
938 static int __br_fdb_delete_by_addr(struct net_bridge
*br
,
939 const unsigned char *addr
, u16 vid
)
943 spin_lock_bh(&br
->hash_lock
);
944 err
= fdb_delete_by_addr(br
, addr
, vid
);
945 spin_unlock_bh(&br
->hash_lock
);
950 static int fdb_delete_by_addr_and_port(struct net_bridge_port
*p
,
951 const u8
*addr
, u16 vlan
)
953 struct net_bridge
*br
= p
->br
;
954 struct hlist_head
*head
= &br
->hash
[br_mac_hash(addr
, vlan
)];
955 struct net_bridge_fdb_entry
*fdb
;
957 fdb
= fdb_find(head
, addr
, vlan
);
958 if (!fdb
|| fdb
->dst
!= p
)
965 static int __br_fdb_delete(struct net_bridge_port
*p
,
966 const unsigned char *addr
, u16 vid
)
970 spin_lock_bh(&p
->br
->hash_lock
);
971 err
= fdb_delete_by_addr_and_port(p
, addr
, vid
);
972 spin_unlock_bh(&p
->br
->hash_lock
);
977 /* Remove neighbor entry with RTM_DELNEIGH */
978 int br_fdb_delete(struct ndmsg
*ndm
, struct nlattr
*tb
[],
979 struct net_device
*dev
,
980 const unsigned char *addr
, u16 vid
)
982 struct net_bridge_vlan_group
*vg
;
983 struct net_bridge_port
*p
= NULL
;
984 struct net_bridge_vlan
*v
;
985 struct net_bridge
*br
= NULL
;
988 if (dev
->priv_flags
& IFF_EBRIDGE
) {
989 br
= netdev_priv(dev
);
990 vg
= br_vlan_group(br
);
992 p
= br_port_get_rtnl(dev
);
994 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
998 vg
= nbp_vlan_group(p
);
1002 v
= br_vlan_find(vg
, vid
);
1004 pr_info("bridge: RTM_DELNEIGH with unconfigured vlan %d on %s\n", vid
, dev
->name
);
1008 if (dev
->priv_flags
& IFF_EBRIDGE
)
1009 err
= __br_fdb_delete_by_addr(br
, addr
, vid
);
1011 err
= __br_fdb_delete(p
, addr
, vid
);
1014 if (dev
->priv_flags
& IFF_EBRIDGE
)
1015 err
= __br_fdb_delete_by_addr(br
, addr
, 0);
1017 err
&= __br_fdb_delete(p
, addr
, 0);
1019 if (!vg
|| !vg
->num_vlans
)
1022 list_for_each_entry(v
, &vg
->vlan_list
, vlist
) {
1023 if (!br_vlan_should_use(v
))
1025 if (dev
->priv_flags
& IFF_EBRIDGE
)
1026 err
= __br_fdb_delete_by_addr(br
, addr
, v
->vid
);
1028 err
&= __br_fdb_delete(p
, addr
, v
->vid
);
1035 int br_fdb_sync_static(struct net_bridge
*br
, struct net_bridge_port
*p
)
1037 struct net_bridge_fdb_entry
*fdb
, *tmp
;
1043 for (i
= 0; i
< BR_HASH_SIZE
; i
++) {
1044 hlist_for_each_entry(fdb
, &br
->hash
[i
], hlist
) {
1045 /* We only care for static entries */
1046 if (!fdb
->is_static
)
1049 err
= dev_uc_add(p
->dev
, fdb
->addr
.addr
);
1057 for (i
= 0; i
< BR_HASH_SIZE
; i
++) {
1058 hlist_for_each_entry(tmp
, &br
->hash
[i
], hlist
) {
1059 /* If we reached the fdb that failed, we can stop */
1063 /* We only care for static entries */
1064 if (!tmp
->is_static
)
1067 dev_uc_del(p
->dev
, tmp
->addr
.addr
);
1073 void br_fdb_unsync_static(struct net_bridge
*br
, struct net_bridge_port
*p
)
1075 struct net_bridge_fdb_entry
*fdb
;
1080 for (i
= 0; i
< BR_HASH_SIZE
; i
++) {
1081 hlist_for_each_entry_rcu(fdb
, &br
->hash
[i
], hlist
) {
1082 /* We only care for static entries */
1083 if (!fdb
->is_static
)
1086 dev_uc_del(p
->dev
, fdb
->addr
.addr
);
1091 int br_fdb_external_learn_add(struct net_bridge
*br
, struct net_bridge_port
*p
,
1092 const unsigned char *addr
, u16 vid
)
1094 struct hlist_head
*head
;
1095 struct net_bridge_fdb_entry
*fdb
;
1099 spin_lock_bh(&br
->hash_lock
);
1101 head
= &br
->hash
[br_mac_hash(addr
, vid
)];
1102 fdb
= fdb_find(head
, addr
, vid
);
1104 fdb
= fdb_create(head
, p
, addr
, vid
, 0, 0);
1109 fdb
->added_by_external_learn
= 1;
1110 fdb_notify(br
, fdb
, RTM_NEWNEIGH
);
1111 } else if (fdb
->added_by_external_learn
) {
1113 fdb
->updated
= fdb
->used
= jiffies
;
1114 } else if (!fdb
->added_by_user
) {
1115 /* Take over SW learned entry */
1116 fdb
->added_by_external_learn
= 1;
1117 fdb
->updated
= jiffies
;
1118 fdb_notify(br
, fdb
, RTM_NEWNEIGH
);
1122 spin_unlock_bh(&br
->hash_lock
);
1127 int br_fdb_external_learn_del(struct net_bridge
*br
, struct net_bridge_port
*p
,
1128 const unsigned char *addr
, u16 vid
)
1130 struct hlist_head
*head
;
1131 struct net_bridge_fdb_entry
*fdb
;
1135 spin_lock_bh(&br
->hash_lock
);
1137 head
= &br
->hash
[br_mac_hash(addr
, vid
)];
1138 fdb
= fdb_find(head
, addr
, vid
);
1139 if (fdb
&& fdb
->added_by_external_learn
)
1140 fdb_delete(br
, fdb
);
1144 spin_unlock_bh(&br
->hash_lock
);