blob: cc36e59db7d75203d89017e8d458b72370df33da [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Forwarding database
3 * Linux ethernet bridge
4 *
5 * Authors:
6 * Lennert Buytenhek <buytenh@gnu.org>
7 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * 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.
12 */
13
14#include <linux/kernel.h>
15#include <linux/init.h>
Franck Bui-Huu82524742008-05-12 21:21:05 +020016#include <linux/rculist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/spinlock.h>
18#include <linux/times.h>
19#include <linux/netdevice.h>
20#include <linux/etherdevice.h>
21#include <linux/jhash.h>
Stephen Hemminger3f890922007-03-21 13:42:33 -070022#include <linux/random.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/slab.h>
Arun Sharma600634972011-07-26 16:09:06 -070024#include <linux/atomic.h>
Stephen Hemminger3f890922007-03-21 13:42:33 -070025#include <asm/unaligned.h>
Vlad Yasevich2ba071e2013-02-13 12:00:16 +000026#include <linux/if_vlan.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "br_private.h"
28
Christoph Lametere18b8902006-12-06 20:33:20 -080029static struct kmem_cache *br_fdb_cache __read_mostly;
Toshiaki Makita424bb9c2014-02-07 16:48:25 +090030static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
31 const unsigned char *addr,
32 __u16 vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -070033static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +000034 const unsigned char *addr, u16 vid);
stephen hemminger31e8a49c2011-12-08 07:17:41 +000035static void fdb_notify(struct net_bridge *br,
36 const struct net_bridge_fdb_entry *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Stephen Hemminger3f890922007-03-21 13:42:33 -070038static u32 fdb_salt __read_mostly;
39
Akinobu Mita87a596e2007-04-07 18:57:07 +090040int __init br_fdb_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041{
42 br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
43 sizeof(struct net_bridge_fdb_entry),
44 0,
Paul Mundt20c2df82007-07-20 10:11:58 +090045 SLAB_HWCACHE_ALIGN, NULL);
Akinobu Mita87a596e2007-04-07 18:57:07 +090046 if (!br_fdb_cache)
47 return -ENOMEM;
48
Stephen Hemminger3f890922007-03-21 13:42:33 -070049 get_random_bytes(&fdb_salt, sizeof(fdb_salt));
Akinobu Mita87a596e2007-04-07 18:57:07 +090050 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051}
52
Andrew Morton73afc902007-12-05 21:35:23 -080053void br_fdb_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070054{
55 kmem_cache_destroy(br_fdb_cache);
56}
57
58
59/* if topology_changing then use forward_delay (default 15 sec)
60 * otherwise keep longer (default 5 minutes)
61 */
Stephen Hemminger3f890922007-03-21 13:42:33 -070062static inline unsigned long hold_time(const struct net_bridge *br)
Linus Torvalds1da177e2005-04-16 15:20:36 -070063{
64 return br->topology_change ? br->forward_delay : br->ageing_time;
65}
66
Stephen Hemminger3f890922007-03-21 13:42:33 -070067static inline int has_expired(const struct net_bridge *br,
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 const struct net_bridge_fdb_entry *fdb)
69{
Joe Perchesf64f9e72009-11-29 16:55:45 -080070 return !fdb->is_static &&
stephen hemminger7cd88612011-04-04 14:03:28 +000071 time_before_eq(fdb->updated + hold_time(br), jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072}
73
Vlad Yasevich2ba071e2013-02-13 12:00:16 +000074static inline int br_mac_hash(const unsigned char *mac, __u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -070075{
Vlad Yasevich2ba071e2013-02-13 12:00:16 +000076 /* use 1 byte of OUI and 3 bytes of NIC */
Stephen Hemminger3f890922007-03-21 13:42:33 -070077 u32 key = get_unaligned((u32 *)(mac + 2));
Vlad Yasevich2ba071e2013-02-13 12:00:16 +000078 return jhash_2words(key, vid, fdb_salt) & (BR_HASH_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079}
80
Michał Mirosławda678292009-06-05 05:35:28 +000081static 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
Vlad Yasevich145beee2014-05-16 09:59:19 -040088/* When a static FDB entry is added, the mac address from the entry is
89 * added to the bridge private HW address list and all required ports
90 * are then updated with the new information.
91 * Called under RTNL.
92 */
Jiri Pirko020ec6b2014-11-28 14:34:12 +010093static void fdb_add_hw_addr(struct net_bridge *br, const unsigned char *addr)
Vlad Yasevich145beee2014-05-16 09:59:19 -040094{
95 int err;
Li RongQinga3f5ee72014-06-18 16:07:16 +080096 struct net_bridge_port *p;
Vlad Yasevich145beee2014-05-16 09:59:19 -040097
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:
Li RongQinga3f5ee72014-06-18 16:07:16 +0800110 list_for_each_entry_continue_reverse(p, &br->port_list, list) {
111 if (!br_promisc_port(p))
112 dev_uc_del(p->dev, addr);
Vlad Yasevich145beee2014-05-16 09:59:19 -0400113 }
114}
115
116/* When a static FDB entry is deleted, the HW address from that entry is
117 * also removed from the bridge private HW address list and updates all
118 * the ports with needed information.
119 * Called under RTNL.
120 */
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100121static void fdb_del_hw_addr(struct net_bridge *br, const unsigned char *addr)
Vlad Yasevich145beee2014-05-16 09:59:19 -0400122{
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
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000133static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134{
Vlad Yasevich145beee2014-05-16 09:59:19 -0400135 if (f->is_static)
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100136 fdb_del_hw_addr(br, f->addr.addr);
Vlad Yasevich145beee2014-05-16 09:59:19 -0400137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 hlist_del_rcu(&f->hlist);
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000139 fdb_notify(br, f, RTM_DELNEIGH);
Michał Mirosławda678292009-06-05 05:35:28 +0000140 call_rcu(&f->rcu, fdb_rcu_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141}
142
Toshiaki Makita960b5892014-02-07 16:48:23 +0900143/* Delete a local entry if no other port had the same address. */
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 /* Maybe another port has same hw addr? */
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;
Toshiaki Makitaa778e6d2014-02-07 16:48:24 +0900157 f->added_by_user = 0;
Toshiaki Makita960b5892014-02-07 16:48:23 +0900158 return;
159 }
160 }
161
162 /* Maybe bridge device has same hw addr? */
163 if (p && ether_addr_equal(br->dev->dev_addr, addr) &&
164 (!vid || br_vlan_find(br, vid))) {
165 f->dst = NULL;
Toshiaki Makitaa778e6d2014-02-07 16:48:24 +0900166 f->added_by_user = 0;
Toshiaki Makita960b5892014-02-07 16:48:23 +0900167 return;
168 }
169
170 fdb_delete(br, f);
171}
172
Toshiaki Makita424bb9c2014-02-07 16:48:25 +0900173void 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
188{
189 struct net_bridge *br = p->br;
Toshiaki Makita28368822014-02-07 16:48:19 +0900190 struct net_port_vlans *pv = nbp_get_vlan_info(p);
191 bool no_vlan = !pv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 int i;
Toshiaki Makita28368822014-02-07 16:48:19 +0900193 u16 vid;
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900194
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 spin_lock_bh(&br->hash_lock);
196
197 /* Search all chains since old address/hash is unknown */
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);
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900204 if (f->dst == p && f->is_local && !f->added_by_user) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 /* delete old one */
Toshiaki Makita960b5892014-02-07 16:48:23 +0900206 fdb_delete_local(br, p, f);
207
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000208 /* if this port has no vlan information
209 * configured, we can safely be done at
210 * this point.
211 */
212 if (no_vlan)
Toshiaki Makita28368822014-02-07 16:48:19 +0900213 goto insert;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 }
215 }
216 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Toshiaki Makita28368822014-02-07 16:48:19 +0900218insert:
219 /* insert new address, may fail if invalid address or dup. */
220 fdb_insert(br, p, newaddr, 0);
221
222 if (no_vlan)
223 goto done;
224
225 /* Now add entries for every VLAN configured on the port.
226 * This function runs under RTNL so the bitmap will not change
227 * from under us.
228 */
229 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID)
230 fdb_insert(br, p, newaddr, vid);
231
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000232done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 spin_unlock_bh(&br->hash_lock);
234}
235
stephen hemminger43598812011-12-08 07:17:49 +0000236void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
237{
238 struct net_bridge_fdb_entry *f;
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000239 struct net_port_vlans *pv;
240 u16 vid = 0;
stephen hemminger43598812011-12-08 07:17:49 +0000241
Toshiaki Makitaac4c8862014-02-07 16:48:26 +0900242 spin_lock_bh(&br->hash_lock);
243
stephen hemminger43598812011-12-08 07:17:49 +0000244 /* If old entry was unassociated with any port, then delete it. */
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000245 f = __br_fdb_get(br, br->dev->dev_addr, 0);
stephen hemminger43598812011-12-08 07:17:49 +0000246 if (f && f->is_local && !f->dst)
Toshiaki Makita960b5892014-02-07 16:48:23 +0900247 fdb_delete_local(br, NULL, f);
stephen hemminger43598812011-12-08 07:17:49 +0000248
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000249 fdb_insert(br, NULL, newaddr, 0);
250
251 /* Now remove and add entries for every VLAN configured on the
252 * bridge. This function runs under RTNL so the bitmap will not
253 * change from under us.
254 */
255 pv = br_get_vlan_info(br);
256 if (!pv)
Toshiaki Makitaac4c8862014-02-07 16:48:26 +0900257 goto out;
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000258
Toshiaki Makitaef40b7e2013-08-20 17:10:18 +0900259 for_each_set_bit_from(vid, pv->vlan_bitmap, VLAN_N_VID) {
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000260 f = __br_fdb_get(br, br->dev->dev_addr, vid);
261 if (f && f->is_local && !f->dst)
Toshiaki Makita960b5892014-02-07 16:48:23 +0900262 fdb_delete_local(br, NULL, f);
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000263 fdb_insert(br, NULL, newaddr, vid);
264 }
Toshiaki Makitaac4c8862014-02-07 16:48:26 +0900265out:
266 spin_unlock_bh(&br->hash_lock);
stephen hemminger43598812011-12-08 07:17:49 +0000267}
268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269void br_fdb_cleanup(unsigned long _data)
270{
271 struct net_bridge *br = (struct net_bridge *)_data;
272 unsigned long delay = hold_time(br);
stephen hemminger25442e02010-06-15 06:14:12 +0000273 unsigned long next_timer = jiffies + br->ageing_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 int i;
275
Eric Dumazet27a42932012-01-16 04:35:50 +0000276 spin_lock(&br->hash_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 for (i = 0; i < BR_HASH_SIZE; i++) {
278 struct net_bridge_fdb_entry *f;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800279 struct hlist_node *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Sasha Levinb67bfe02013-02-27 17:06:00 -0800281 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
Baruch Even071f7722007-05-31 01:20:45 -0700282 unsigned long this_timer;
283 if (f->is_static)
284 continue;
stephen hemminger7cd88612011-04-04 14:03:28 +0000285 this_timer = f->updated + delay;
Baruch Even071f7722007-05-31 01:20:45 -0700286 if (time_before_eq(this_timer, jiffies))
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000287 fdb_delete(br, f);
Fabio Checconi2bec0082008-03-20 15:54:58 -0700288 else if (time_before(this_timer, next_timer))
Baruch Even071f7722007-05-31 01:20:45 -0700289 next_timer = this_timer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 }
291 }
Eric Dumazet27a42932012-01-16 04:35:50 +0000292 spin_unlock(&br->hash_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
stephen hemminger25442e02010-06-15 06:14:12 +0000294 mod_timer(&br->gc_timer, round_jiffies_up(next_timer));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295}
296
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700297/* Completely flush all dynamic entries in forwarding database.*/
298void br_fdb_flush(struct net_bridge *br)
299{
300 int i;
Stephen Hemminger1a620692006-10-12 14:45:38 -0700301
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700302 spin_lock_bh(&br->hash_lock);
303 for (i = 0; i < BR_HASH_SIZE; i++) {
304 struct net_bridge_fdb_entry *f;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800305 struct hlist_node *n;
306 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700307 if (!f->is_static)
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000308 fdb_delete(br, f);
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700309 }
310 }
311 spin_unlock_bh(&br->hash_lock);
312}
313
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300314/* Flush all entries referring to a specific port.
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700315 * if do_all is set also flush static entries
316 */
Stephen Hemminger1a620692006-10-12 14:45:38 -0700317void br_fdb_delete_by_port(struct net_bridge *br,
318 const struct net_bridge_port *p,
319 int do_all)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320{
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;
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 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);
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900330 if (f->dst != p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 continue;
332
Stephen Hemminger1a620692006-10-12 14:45:38 -0700333 if (f->is_static && !do_all)
334 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
Toshiaki Makitaa778e6d2014-02-07 16:48:24 +0900336 if (f->is_local)
337 fdb_delete_local(br, p, f);
338 else
339 fdb_delete(br, f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
341 }
342 spin_unlock_bh(&br->hash_lock);
343}
344
stephen hemmingereeaf61d2010-07-27 08:26:30 +0000345/* No locking or refcounting, assumes caller has rcu_read_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000347 const unsigned char *addr,
348 __u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 struct net_bridge_fdb_entry *fdb;
351
Sasha Levinb67bfe02013-02-27 17:06:00 -0800352 hlist_for_each_entry_rcu(fdb,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000353 &br->hash[br_mac_hash(addr, vid)], hlist) {
354 if (ether_addr_equal(fdb->addr.addr, addr) &&
355 fdb->vlan_id == vid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 if (unlikely(has_expired(br, fdb)))
357 break;
358 return fdb;
359 }
360 }
361
362 return NULL;
363}
364
Igor Maraviće6373c42011-12-12 02:58:25 +0000365#if IS_ENABLED(CONFIG_ATM_LANE)
Michał Mirosławda678292009-06-05 05:35:28 +0000366/* Interface used by ATM LANE hook to test
367 * if an addr is on some other bridge port */
368int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
370 struct net_bridge_fdb_entry *fdb;
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000371 struct net_bridge_port *port;
Michał Mirosławda678292009-06-05 05:35:28 +0000372 int ret;
373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 rcu_read_lock();
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000375 port = br_port_get_rcu(dev);
376 if (!port)
377 ret = 0;
378 else {
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000379 fdb = __br_fdb_get(port->br, addr, 0);
stephen hemminger43598812011-12-08 07:17:49 +0000380 ret = fdb && fdb->dst && fdb->dst->dev != dev &&
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000381 fdb->dst->state == BR_STATE_FORWARDING;
382 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Michał Mirosławda678292009-06-05 05:35:28 +0000385 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386}
Michał Mirosławda678292009-06-05 05:35:28 +0000387#endif /* CONFIG_ATM_LANE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
389/*
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900390 * Fill buffer with forwarding table records in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 * the API format.
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 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++) {
Sasha Levinb67bfe02013-02-27 17:06:00 -0800404 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 if (num >= maxnum)
406 goto out;
407
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900408 if (has_expired(br, f))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 continue;
410
stephen hemminger43598812011-12-08 07:17:49 +0000411 /* ignore pseudo entry for local MAC address */
412 if (!f->dst)
413 continue;
414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 if (skip) {
416 --skip;
417 continue;
418 }
419
420 /* convert from internal format to API */
421 memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN);
Stephen Hemmingerae4f8fc2008-05-02 16:53:33 -0700422
423 /* due to ABI compat need to split into hi/lo */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 fe->port_no = f->dst->port_no;
Stephen Hemmingerae4f8fc2008-05-02 16:53:33 -0700425 fe->port_hi = f->dst->port_no >> 8;
426
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 fe->is_local = f->is_local;
428 if (!f->is_static)
Eric Dumazeta399a802012-08-08 21:13:53 +0000429 fe->ageing_timer_value = jiffies_delta_to_clock_t(jiffies - f->updated);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 ++fe;
431 ++num;
432 }
433 }
434
435 out:
436 rcu_read_unlock();
437
438 return num;
439}
440
stephen hemminger664de482011-04-04 14:03:29 +0000441static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000442 const unsigned char *addr,
443 __u16 vid)
stephen hemminger664de482011-04-04 14:03:29 +0000444{
stephen hemminger664de482011-04-04 14:03:29 +0000445 struct net_bridge_fdb_entry *fdb;
446
Sasha Levinb67bfe02013-02-27 17:06:00 -0800447 hlist_for_each_entry(fdb, head, hlist) {
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000448 if (ether_addr_equal(fdb->addr.addr, addr) &&
449 fdb->vlan_id == vid)
stephen hemminger664de482011-04-04 14:03:29 +0000450 return fdb;
451 }
452 return NULL;
453}
454
455static struct net_bridge_fdb_entry *fdb_find_rcu(struct hlist_head *head,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000456 const unsigned char *addr,
457 __u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 struct net_bridge_fdb_entry *fdb;
460
Sasha Levinb67bfe02013-02-27 17:06:00 -0800461 hlist_for_each_entry_rcu(fdb, head, hlist) {
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000462 if (ether_addr_equal(fdb->addr.addr, addr) &&
463 fdb->vlan_id == vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 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,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000471 const unsigned char *addr,
472 __u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473{
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 fdb->dst = source;
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000480 fdb->vlan_id = vid;
stephen hemminger03e9b642011-04-04 14:03:27 +0000481 fdb->is_local = 0;
482 fdb->is_static = 0;
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900483 fdb->added_by_user = 0;
Scott Feldmancf6b8e12014-11-28 14:34:21 +0100484 fdb->added_by_external_learn = 0;
stephen hemminger7cd88612011-04-04 14:03:28 +0000485 fdb->updated = fdb->used = jiffies;
Pavel Emelyanov1158f762011-02-04 13:02:36 -0800486 hlist_add_head_rcu(&fdb->hlist, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 }
488 return fdb;
489}
490
491static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000492 const unsigned char *addr, u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493{
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000494 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 struct net_bridge_fdb_entry *fdb;
496
497 if (!is_valid_ether_addr(addr))
498 return -EINVAL;
499
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000500 fdb = fdb_find(head, addr, vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 if (fdb) {
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900502 /* it is okay to have multiple ports with same
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 * address, just use the first one.
504 */
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900505 if (fdb->is_local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 return 0;
stephen hemminger28a16c92010-05-10 09:31:09 +0000507 br_warn(br, "adding interface %s with same address "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 "as a received packet\n",
Hong zhi guo9b469222013-03-23 02:27:50 +0000509 source ? source->dev->name : br->dev->name);
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000510 fdb_delete(br, fdb);
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000513 fdb = fdb_create(head, source, addr, vid);
stephen hemminger03e9b642011-04-04 14:03:27 +0000514 if (!fdb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 return -ENOMEM;
516
stephen hemminger03e9b642011-04-04 14:03:27 +0000517 fdb->is_local = fdb->is_static = 1;
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100518 fdb_add_hw_addr(br, addr);
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000519 fdb_notify(br, fdb, RTM_NEWNEIGH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 return 0;
521}
522
stephen hemminger03e9b642011-04-04 14:03:27 +0000523/* Add entry for local address of interface */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000525 const unsigned char *addr, u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526{
527 int ret;
528
529 spin_lock_bh(&br->hash_lock);
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000530 ret = fdb_insert(br, source, addr, vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 spin_unlock_bh(&br->hash_lock);
532 return ret;
533}
534
535void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900536 const unsigned char *addr, u16 vid, bool added_by_user)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537{
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000538 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 struct net_bridge_fdb_entry *fdb;
Jon Maxwellc65c7a32014-05-29 17:27:16 +1000540 bool fdb_modified = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
542 /* some users want to always flood. */
543 if (hold_time(br) == 0)
544 return;
545
Stephen Hemmingerdf1c0b82007-08-30 22:15:35 -0700546 /* ignore packets unless we are using this port */
547 if (!(source->state == BR_STATE_LEARNING ||
548 source->state == BR_STATE_FORWARDING))
549 return;
550
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000551 fdb = fdb_find_rcu(head, addr, vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 if (likely(fdb)) {
553 /* attempt to update an entry for a local interface */
554 if (unlikely(fdb->is_local)) {
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900555 if (net_ratelimit())
stephen hemminger28a16c92010-05-10 09:31:09 +0000556 br_warn(br, "received packet on %s with "
557 "own address as source address\n",
558 source->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 } else {
560 /* fastpath: update of existing entry */
Jon Maxwellc65c7a32014-05-29 17:27:16 +1000561 if (unlikely(source != fdb->dst)) {
562 fdb->dst = source;
563 fdb_modified = true;
564 }
stephen hemminger7cd88612011-04-04 14:03:28 +0000565 fdb->updated = jiffies;
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900566 if (unlikely(added_by_user))
567 fdb->added_by_user = 1;
Jon Maxwellc65c7a32014-05-29 17:27:16 +1000568 if (unlikely(fdb_modified))
569 fdb_notify(br, fdb, RTM_NEWNEIGH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 }
571 } else {
Stephen Hemmingerf8ae7372006-03-20 22:58:36 -0800572 spin_lock(&br->hash_lock);
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000573 if (likely(!fdb_find(head, addr, vid))) {
574 fdb = fdb_create(head, source, addr, vid);
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900575 if (fdb) {
576 if (unlikely(added_by_user))
577 fdb->added_by_user = 1;
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000578 fdb_notify(br, fdb, RTM_NEWNEIGH);
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900579 }
stephen hemmingerf58ee4e2011-12-06 13:02:24 +0000580 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 /* else we lose race and someone else inserts
582 * it first, don't bother updating
583 */
Stephen Hemmingerf8ae7372006-03-20 22:58:36 -0800584 spin_unlock(&br->hash_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586}
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000587
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
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000600static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000601 const struct net_bridge_fdb_entry *fdb,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000602 u32 portid, u32 seq, int type, unsigned int flags)
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000603{
604 unsigned long now = jiffies;
605 struct nda_cacheinfo ci;
606 struct nlmsghdr *nlh;
607 struct ndmsg *ndm;
608
Eric W. Biederman15e47302012-09-07 20:12:54 +0000609 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000610 if (nlh == NULL)
611 return -EMSGSIZE;
612
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000613 ndm = nlmsg_data(nlh);
614 ndm->ndm_family = AF_BRIDGE;
615 ndm->ndm_pad1 = 0;
616 ndm->ndm_pad2 = 0;
Scott Feldmancf6b8e12014-11-28 14:34:21 +0100617 ndm->ndm_flags = fdb->added_by_external_learn ? NTF_EXT_LEARNED : 0;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000618 ndm->ndm_type = 0;
stephen hemminger43598812011-12-08 07:17:49 +0000619 ndm->ndm_ifindex = fdb->dst ? fdb->dst->dev->ifindex : br->dev->ifindex;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000620 ndm->ndm_state = fdb_to_nud(fdb);
621
David S. Miller2eb812e2012-04-01 20:49:54 -0400622 if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->addr))
623 goto nla_put_failure;
Roopa Prabhu41c389d2014-05-27 22:39:37 -0700624 if (nla_put_u32(skb, NDA_MASTER, br->dev->ifindex))
625 goto nla_put_failure;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000626 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;
David S. Miller2eb812e2012-04-01 20:49:54 -0400630 if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
631 goto nla_put_failure;
Vlad Yasevich1690be62013-02-13 12:00:18 +0000632
Toshiaki Makita47fab412014-07-30 13:31:51 +0900633 if (fdb->vlan_id && nla_put(skb, NDA_VLAN, sizeof(u16), &fdb->vlan_id))
Vlad Yasevich1690be62013-02-13 12:00:18 +0000634 goto nla_put_failure;
635
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000636 return nlmsg_end(skb, nlh);
637
638nla_put_failure:
639 nlmsg_cancel(skb, nlh);
640 return -EMSGSIZE;
641}
642
643static inline size_t fdb_nlmsg_size(void)
644{
645 return NLMSG_ALIGN(sizeof(struct ndmsg))
646 + nla_total_size(ETH_ALEN) /* NDA_LLADDR */
Roopa Prabhu41c389d2014-05-27 22:39:37 -0700647 + nla_total_size(sizeof(u32)) /* NDA_MASTER */
Vlad Yasevich1690be62013-02-13 12:00:18 +0000648 + nla_total_size(sizeof(u16)) /* NDA_VLAN */
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000649 + nla_total_size(sizeof(struct nda_cacheinfo));
650}
651
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000652static void fdb_notify(struct net_bridge *br,
653 const struct net_bridge_fdb_entry *fdb, int type)
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000654{
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000655 struct net *net = dev_net(br->dev);
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000656 struct sk_buff *skb;
657 int err = -ENOBUFS;
658
659 skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
660 if (skb == NULL)
661 goto errout;
662
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000663 err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000664 if (err < 0) {
665 /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */
666 WARN_ON(err == -EMSGSIZE);
667 kfree_skb(skb);
668 goto errout;
669 }
670 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
671 return;
672errout:
tanxiaojun87e823b2013-12-19 13:28:10 +0800673 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000674}
675
676/* Dump information about entries, in response to GETNEIGH */
John Fastabend77162022012-04-15 06:43:56 +0000677int br_fdb_dump(struct sk_buff *skb,
678 struct netlink_callback *cb,
679 struct net_device *dev,
Jamal Hadi Salim5d5eacb2014-07-10 07:01:58 -0400680 struct net_device *filter_dev,
John Fastabend77162022012-04-15 06:43:56 +0000681 int idx)
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000682{
John Fastabend77162022012-04-15 06:43:56 +0000683 struct net_bridge *br = netdev_priv(dev);
684 int i;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000685
John Fastabend77162022012-04-15 06:43:56 +0000686 if (!(dev->priv_flags & IFF_EBRIDGE))
687 goto out;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000688
John Fastabend77162022012-04-15 06:43:56 +0000689 for (i = 0; i < BR_HASH_SIZE; i++) {
John Fastabend77162022012-04-15 06:43:56 +0000690 struct net_bridge_fdb_entry *f;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000691
Sasha Levinb67bfe02013-02-27 17:06:00 -0800692 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
John Fastabend77162022012-04-15 06:43:56 +0000693 if (idx < cb->args[0])
694 goto skip;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000695
Jamal Hadi Salim5e6d2432014-07-10 07:01:59 -0400696 if (filter_dev &&
697 (!f->dst || f->dst->dev != filter_dev)) {
698 if (filter_dev != dev)
699 goto skip;
700 /* !f->dst is a speacial case for bridge
701 * It means the MAC belongs to the bridge
702 * Therefore need a little more filtering
703 * we only want to dump the !f->dst case
704 */
705 if (f->dst)
706 goto skip;
707 }
Jamal Hadi Salim5d5eacb2014-07-10 07:01:58 -0400708
John Fastabend77162022012-04-15 06:43:56 +0000709 if (fdb_fill_info(skb, br, f,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000710 NETLINK_CB(cb->skb).portid,
John Fastabend77162022012-04-15 06:43:56 +0000711 cb->nlh->nlmsg_seq,
712 RTM_NEWNEIGH,
713 NLM_F_MULTI) < 0)
714 break;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000715skip:
John Fastabend77162022012-04-15 06:43:56 +0000716 ++idx;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000717 }
718 }
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000719
John Fastabend77162022012-04-15 06:43:56 +0000720out:
721 return idx;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000722}
stephen hemminger36fd2b62011-04-04 14:03:31 +0000723
stephen hemminger292d1392011-11-09 18:30:08 +0000724/* Update (create or replace) forwarding database entry */
stephen hemminger36fd2b62011-04-04 14:03:31 +0000725static int fdb_add_entry(struct net_bridge_port *source, const __u8 *addr,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000726 __u16 state, __u16 flags, __u16 vid)
stephen hemminger36fd2b62011-04-04 14:03:31 +0000727{
728 struct net_bridge *br = source->br;
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000729 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
stephen hemminger36fd2b62011-04-04 14:03:31 +0000730 struct net_bridge_fdb_entry *fdb;
roopab0a397f2013-04-22 12:56:49 +0000731 bool modified = false;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000732
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000733 fdb = fdb_find(head, addr, vid);
stephen hemminger64af1ba2011-09-30 14:37:27 +0000734 if (fdb == NULL) {
735 if (!(flags & NLM_F_CREATE))
736 return -ENOENT;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000737
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000738 fdb = fdb_create(head, source, addr, vid);
stephen hemminger64af1ba2011-09-30 14:37:27 +0000739 if (!fdb)
740 return -ENOMEM;
roopab0a397f2013-04-22 12:56:49 +0000741
742 modified = true;
stephen hemminger64af1ba2011-09-30 14:37:27 +0000743 } else {
744 if (flags & NLM_F_EXCL)
745 return -EEXIST;
roopab0a397f2013-04-22 12:56:49 +0000746
747 if (fdb->dst != source) {
748 fdb->dst = source;
749 modified = true;
750 }
stephen hemminger64af1ba2011-09-30 14:37:27 +0000751 }
stephen hemminger36fd2b62011-04-04 14:03:31 +0000752
stephen hemminger292d1392011-11-09 18:30:08 +0000753 if (fdb_to_nud(fdb) != state) {
Vlad Yasevich145beee2014-05-16 09:59:19 -0400754 if (state & NUD_PERMANENT) {
755 fdb->is_local = 1;
756 if (!fdb->is_static) {
757 fdb->is_static = 1;
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100758 fdb_add_hw_addr(br, addr);
Vlad Yasevich145beee2014-05-16 09:59:19 -0400759 }
760 } else if (state & NUD_NOARP) {
stephen hemminger292d1392011-11-09 18:30:08 +0000761 fdb->is_local = 0;
Vlad Yasevich145beee2014-05-16 09:59:19 -0400762 if (!fdb->is_static) {
763 fdb->is_static = 1;
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100764 fdb_add_hw_addr(br, addr);
Vlad Yasevich145beee2014-05-16 09:59:19 -0400765 }
766 } else {
767 fdb->is_local = 0;
768 if (fdb->is_static) {
769 fdb->is_static = 0;
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100770 fdb_del_hw_addr(br, addr);
Vlad Yasevich145beee2014-05-16 09:59:19 -0400771 }
772 }
stephen hemminger292d1392011-11-09 18:30:08 +0000773
roopab0a397f2013-04-22 12:56:49 +0000774 modified = true;
775 }
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900776 fdb->added_by_user = 1;
roopab0a397f2013-04-22 12:56:49 +0000777
778 fdb->used = jiffies;
779 if (modified) {
780 fdb->updated = jiffies;
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000781 fdb_notify(br, fdb, RTM_NEWNEIGH);
stephen hemminger292d1392011-11-09 18:30:08 +0000782 }
783
stephen hemminger36fd2b62011-04-04 14:03:31 +0000784 return 0;
785}
786
Vlad Yasevich1690be62013-02-13 12:00:18 +0000787static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge_port *p,
788 const unsigned char *addr, u16 nlh_flags, u16 vid)
789{
790 int err = 0;
791
792 if (ndm->ndm_flags & NTF_USE) {
793 rcu_read_lock();
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900794 br_fdb_update(p->br, p, addr, vid, true);
Vlad Yasevich1690be62013-02-13 12:00:18 +0000795 rcu_read_unlock();
796 } else {
797 spin_lock_bh(&p->br->hash_lock);
798 err = fdb_add_entry(p, addr, ndm->ndm_state,
799 nlh_flags, vid);
800 spin_unlock_bh(&p->br->hash_lock);
801 }
802
803 return err;
804}
805
stephen hemminger36fd2b62011-04-04 14:03:31 +0000806/* Add new permanent fdb entry with RTM_NEWNEIGH */
stephen hemmingeredc7d572012-10-01 12:32:33 +0000807int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
808 struct net_device *dev,
Jiri Pirkof6f64242014-11-28 14:34:15 +0100809 const unsigned char *addr, u16 vid, u16 nlh_flags)
stephen hemminger36fd2b62011-04-04 14:03:31 +0000810{
stephen hemminger36fd2b62011-04-04 14:03:31 +0000811 struct net_bridge_port *p;
John Fastabend77162022012-04-15 06:43:56 +0000812 int err = 0;
Vlad Yasevich1690be62013-02-13 12:00:18 +0000813 struct net_port_vlans *pv;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000814
stephen hemminger292d1392011-11-09 18:30:08 +0000815 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
816 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
817 return -EINVAL;
818 }
819
Stephen Hemminger537f7f82013-06-25 09:34:36 -0700820 if (is_zero_ether_addr(addr)) {
821 pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
822 return -EINVAL;
823 }
824
stephen hemminger36fd2b62011-04-04 14:03:31 +0000825 p = br_port_get_rtnl(dev);
826 if (p == NULL) {
827 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
828 dev->name);
829 return -EINVAL;
830 }
831
Vlad Yasevich1690be62013-02-13 12:00:18 +0000832 pv = nbp_get_vlan_info(p);
Jiri Pirkof6f64242014-11-28 14:34:15 +0100833 if (vid) {
Vlad Yasevich1690be62013-02-13 12:00:18 +0000834 if (!pv || !test_bit(vid, pv->vlan_bitmap)) {
835 pr_info("bridge: RTM_NEWNEIGH with unconfigured "
836 "vlan %d on port %s\n", vid, dev->name);
837 return -EINVAL;
838 }
839
840 /* VID was specified, so use it. */
841 err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
stephen hemminger292d1392011-11-09 18:30:08 +0000842 } else {
Toshiaki Makitaef40b7e2013-08-20 17:10:18 +0900843 if (!pv || bitmap_empty(pv->vlan_bitmap, VLAN_N_VID)) {
Vlad Yasevich1690be62013-02-13 12:00:18 +0000844 err = __br_fdb_add(ndm, p, addr, nlh_flags, 0);
845 goto out;
846 }
847
848 /* We have vlans configured on this port and user didn't
849 * specify a VLAN. To be nice, add/update entry for every
850 * vlan on this port.
851 */
Toshiaki Makitaef40b7e2013-08-20 17:10:18 +0900852 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
Vlad Yasevich1690be62013-02-13 12:00:18 +0000853 err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
854 if (err)
855 goto out;
Vlad Yasevich1690be62013-02-13 12:00:18 +0000856 }
stephen hemminger292d1392011-11-09 18:30:08 +0000857 }
stephen hemminger36fd2b62011-04-04 14:03:31 +0000858
Vlad Yasevich1690be62013-02-13 12:00:18 +0000859out:
860 return err;
861}
862
Toshiaki Makita424bb9c2014-02-07 16:48:25 +0900863static int fdb_delete_by_addr(struct net_bridge *br, const u8 *addr, u16 vlan)
Vlad Yasevich1690be62013-02-13 12:00:18 +0000864{
865 struct hlist_head *head = &br->hash[br_mac_hash(addr, vlan)];
866 struct net_bridge_fdb_entry *fdb;
867
868 fdb = fdb_find(head, addr, vlan);
869 if (!fdb)
870 return -ENOENT;
871
872 fdb_delete(br, fdb);
873 return 0;
874}
875
876static int __br_fdb_delete(struct net_bridge_port *p,
877 const unsigned char *addr, u16 vid)
878{
879 int err;
880
881 spin_lock_bh(&p->br->hash_lock);
882 err = fdb_delete_by_addr(p->br, addr, vid);
883 spin_unlock_bh(&p->br->hash_lock);
884
stephen hemminger36fd2b62011-04-04 14:03:31 +0000885 return err;
886}
887
stephen hemminger36fd2b62011-04-04 14:03:31 +0000888/* Remove neighbor entry with RTM_DELNEIGH */
Vlad Yasevich1690be62013-02-13 12:00:18 +0000889int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
890 struct net_device *dev,
Jiri Pirkof6f64242014-11-28 14:34:15 +0100891 const unsigned char *addr, u16 vid)
stephen hemminger36fd2b62011-04-04 14:03:31 +0000892{
stephen hemminger36fd2b62011-04-04 14:03:31 +0000893 struct net_bridge_port *p;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000894 int err;
Vlad Yasevich1690be62013-02-13 12:00:18 +0000895 struct net_port_vlans *pv;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000896
stephen hemminger36fd2b62011-04-04 14:03:31 +0000897 p = br_port_get_rtnl(dev);
898 if (p == NULL) {
899 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
900 dev->name);
901 return -EINVAL;
902 }
903
Vlad Yasevich1690be62013-02-13 12:00:18 +0000904 pv = nbp_get_vlan_info(p);
Jiri Pirkof6f64242014-11-28 14:34:15 +0100905 if (vid) {
Vlad Yasevich1690be62013-02-13 12:00:18 +0000906 if (!pv || !test_bit(vid, pv->vlan_bitmap)) {
907 pr_info("bridge: RTM_DELNEIGH with unconfigured "
908 "vlan %d on port %s\n", vid, dev->name);
909 return -EINVAL;
910 }
stephen hemminger36fd2b62011-04-04 14:03:31 +0000911
Vlad Yasevich1690be62013-02-13 12:00:18 +0000912 err = __br_fdb_delete(p, addr, vid);
913 } else {
Toshiaki Makitaef40b7e2013-08-20 17:10:18 +0900914 if (!pv || bitmap_empty(pv->vlan_bitmap, VLAN_N_VID)) {
Vlad Yasevich1690be62013-02-13 12:00:18 +0000915 err = __br_fdb_delete(p, addr, 0);
916 goto out;
917 }
918
919 /* We have vlans configured on this port and user didn't
920 * specify a VLAN. To be nice, add/update entry for every
921 * vlan on this port.
922 */
923 err = -ENOENT;
Toshiaki Makitaef40b7e2013-08-20 17:10:18 +0900924 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
Vlad Yasevich1690be62013-02-13 12:00:18 +0000925 err &= __br_fdb_delete(p, addr, vid);
Vlad Yasevich1690be62013-02-13 12:00:18 +0000926 }
927 }
928out:
stephen hemminger36fd2b62011-04-04 14:03:31 +0000929 return err;
930}
Vlad Yasevich8db24af2014-05-16 09:59:17 -0400931
932int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p)
933{
934 struct net_bridge_fdb_entry *fdb, *tmp;
935 int i;
936 int err;
937
938 ASSERT_RTNL();
939
940 for (i = 0; i < BR_HASH_SIZE; i++) {
941 hlist_for_each_entry(fdb, &br->hash[i], hlist) {
942 /* We only care for static entries */
943 if (!fdb->is_static)
944 continue;
945
946 err = dev_uc_add(p->dev, fdb->addr.addr);
947 if (err)
948 goto rollback;
949 }
950 }
951 return 0;
952
953rollback:
954 for (i = 0; i < BR_HASH_SIZE; i++) {
955 hlist_for_each_entry(tmp, &br->hash[i], hlist) {
956 /* If we reached the fdb that failed, we can stop */
957 if (tmp == fdb)
958 break;
959
960 /* We only care for static entries */
961 if (!tmp->is_static)
962 continue;
963
964 dev_uc_del(p->dev, tmp->addr.addr);
965 }
966 }
967 return err;
968}
969
970void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p)
971{
972 struct net_bridge_fdb_entry *fdb;
973 int i;
974
975 ASSERT_RTNL();
976
977 for (i = 0; i < BR_HASH_SIZE; i++) {
978 hlist_for_each_entry_rcu(fdb, &br->hash[i], hlist) {
979 /* We only care for static entries */
980 if (!fdb->is_static)
981 continue;
982
983 dev_uc_del(p->dev, fdb->addr.addr);
984 }
985 }
986}
Scott Feldmancf6b8e12014-11-28 14:34:21 +0100987
988int br_fdb_external_learn_add(struct net_device *dev,
989 const unsigned char *addr, u16 vid)
990{
991 struct net_bridge_port *p;
992 struct net_bridge *br;
993 struct hlist_head *head;
994 struct net_bridge_fdb_entry *fdb;
995 int err = 0;
996
997 rtnl_lock();
998
999 p = br_port_get_rtnl(dev);
1000 if (!p) {
1001 pr_info("bridge: %s not a bridge port\n", dev->name);
1002 err = -EINVAL;
1003 goto err_rtnl_unlock;
1004 }
1005
1006 br = p->br;
1007
1008 spin_lock_bh(&br->hash_lock);
1009
1010 head = &br->hash[br_mac_hash(addr, vid)];
1011 fdb = fdb_find(head, addr, vid);
1012 if (!fdb) {
1013 fdb = fdb_create(head, p, addr, vid);
1014 if (!fdb) {
1015 err = -ENOMEM;
1016 goto err_unlock;
1017 }
1018 fdb->added_by_external_learn = 1;
1019 fdb_notify(br, fdb, RTM_NEWNEIGH);
1020 } else if (fdb->added_by_external_learn) {
1021 /* Refresh entry */
1022 fdb->updated = fdb->used = jiffies;
1023 } else if (!fdb->added_by_user) {
1024 /* Take over SW learned entry */
1025 fdb->added_by_external_learn = 1;
1026 fdb->updated = jiffies;
1027 fdb_notify(br, fdb, RTM_NEWNEIGH);
1028 }
1029
1030err_unlock:
1031 spin_unlock_bh(&br->hash_lock);
1032err_rtnl_unlock:
1033 rtnl_unlock();
1034
1035 return err;
1036}
1037EXPORT_SYMBOL(br_fdb_external_learn_add);
1038
1039int br_fdb_external_learn_del(struct net_device *dev,
1040 const unsigned char *addr, u16 vid)
1041{
1042 struct net_bridge_port *p;
1043 struct net_bridge *br;
1044 struct hlist_head *head;
1045 struct net_bridge_fdb_entry *fdb;
1046 int err = 0;
1047
1048 rtnl_lock();
1049
1050 p = br_port_get_rtnl(dev);
1051 if (!p) {
1052 pr_info("bridge: %s not a bridge port\n", dev->name);
1053 err = -EINVAL;
1054 goto err_rtnl_unlock;
1055 }
1056
1057 br = p->br;
1058
1059 spin_lock_bh(&br->hash_lock);
1060
1061 head = &br->hash[br_mac_hash(addr, vid)];
1062 fdb = fdb_find(head, addr, vid);
1063 if (fdb && fdb->added_by_external_learn)
1064 fdb_delete(br, fdb);
1065 else
1066 err = -ENOENT;
1067
1068 spin_unlock_bh(&br->hash_lock);
1069err_rtnl_unlock:
1070 rtnl_unlock();
1071
1072 return err;
1073}
1074EXPORT_SYMBOL(br_fdb_external_learn_del);