blob: 7f7d55132dd50f8666f389ec19f3359995953426 [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>
Scott Feldmanb4ad7ba2015-06-14 11:33:11 -070027#include <net/switchdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "br_private.h"
29
Christoph Lametere18b8902006-12-06 20:33:20 -080030static struct kmem_cache *br_fdb_cache __read_mostly;
Toshiaki Makita424bb9c2014-02-07 16:48:25 +090031static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
32 const unsigned char *addr,
33 __u16 vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -070034static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +000035 const unsigned char *addr, u16 vid);
stephen hemminger31e8a49c2011-12-08 07:17:41 +000036static void fdb_notify(struct net_bridge *br,
37 const struct net_bridge_fdb_entry *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Stephen Hemminger3f890922007-03-21 13:42:33 -070039static u32 fdb_salt __read_mostly;
40
Akinobu Mita87a596e2007-04-07 18:57:07 +090041int __init br_fdb_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070042{
43 br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
44 sizeof(struct net_bridge_fdb_entry),
45 0,
Paul Mundt20c2df82007-07-20 10:11:58 +090046 SLAB_HWCACHE_ALIGN, NULL);
Akinobu Mita87a596e2007-04-07 18:57:07 +090047 if (!br_fdb_cache)
48 return -ENOMEM;
49
Stephen Hemminger3f890922007-03-21 13:42:33 -070050 get_random_bytes(&fdb_salt, sizeof(fdb_salt));
Akinobu Mita87a596e2007-04-07 18:57:07 +090051 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052}
53
Andrew Morton73afc902007-12-05 21:35:23 -080054void br_fdb_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070055{
56 kmem_cache_destroy(br_fdb_cache);
57}
58
59
60/* if topology_changing then use forward_delay (default 15 sec)
61 * otherwise keep longer (default 5 minutes)
62 */
Stephen Hemminger3f890922007-03-21 13:42:33 -070063static inline unsigned long hold_time(const struct net_bridge *br)
Linus Torvalds1da177e2005-04-16 15:20:36 -070064{
65 return br->topology_change ? br->forward_delay : br->ageing_time;
66}
67
Stephen Hemminger3f890922007-03-21 13:42:33 -070068static inline int has_expired(const struct net_bridge *br,
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 const struct net_bridge_fdb_entry *fdb)
70{
Joe Perchesf64f9e72009-11-29 16:55:45 -080071 return !fdb->is_static &&
stephen hemminger7cd88612011-04-04 14:03:28 +000072 time_before_eq(fdb->updated + hold_time(br), jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073}
74
Vlad Yasevich2ba071e2013-02-13 12:00:16 +000075static inline int br_mac_hash(const unsigned char *mac, __u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -070076{
Vlad Yasevich2ba071e2013-02-13 12:00:16 +000077 /* use 1 byte of OUI and 3 bytes of NIC */
Stephen Hemminger3f890922007-03-21 13:42:33 -070078 u32 key = get_unaligned((u32 *)(mac + 2));
Vlad Yasevich2ba071e2013-02-13 12:00:16 +000079 return jhash_2words(key, vid, fdb_salt) & (BR_HASH_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070080}
81
Michał Mirosławda678292009-06-05 05:35:28 +000082static void fdb_rcu_free(struct rcu_head *head)
83{
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);
87}
88
Vlad Yasevich145beee2014-05-16 09:59:19 -040089/* 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.
92 * Called under RTNL.
93 */
Jiri Pirko020ec6b2014-11-28 14:34:12 +010094static void fdb_add_hw_addr(struct net_bridge *br, const unsigned char *addr)
Vlad Yasevich145beee2014-05-16 09:59:19 -040095{
96 int err;
Li RongQinga3f5ee72014-06-18 16:07:16 +080097 struct net_bridge_port *p;
Vlad Yasevich145beee2014-05-16 09:59:19 -040098
99 ASSERT_RTNL();
100
101 list_for_each_entry(p, &br->port_list, list) {
102 if (!br_promisc_port(p)) {
103 err = dev_uc_add(p->dev, addr);
104 if (err)
105 goto undo;
106 }
107 }
108
109 return;
110undo:
Li RongQinga3f5ee72014-06-18 16:07:16 +0800111 list_for_each_entry_continue_reverse(p, &br->port_list, list) {
112 if (!br_promisc_port(p))
113 dev_uc_del(p->dev, addr);
Vlad Yasevich145beee2014-05-16 09:59:19 -0400114 }
115}
116
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.
120 * Called under RTNL.
121 */
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100122static void fdb_del_hw_addr(struct net_bridge *br, const unsigned char *addr)
Vlad Yasevich145beee2014-05-16 09:59:19 -0400123{
124 struct net_bridge_port *p;
125
126 ASSERT_RTNL();
127
128 list_for_each_entry(p, &br->port_list, list) {
129 if (!br_promisc_port(p))
130 dev_uc_del(p->dev, addr);
131 }
132}
133
Scott Feldmanb4ad7ba2015-06-14 11:33:11 -0700134static void fdb_del_external_learn(struct net_bridge_fdb_entry *f)
135{
Jiri Pirko52ba57c2015-10-01 11:03:44 +0200136 struct switchdev_obj_port_fdb fdb = {
Jiri Pirko9e8f4a52015-10-01 11:03:46 +0200137 .obj.id = SWITCHDEV_OBJ_ID_PORT_FDB,
Vivien Didelotab069002015-09-29 12:07:17 -0400138 .addr = f->addr.addr,
139 .vid = f->vlan_id,
Scott Feldmanb4ad7ba2015-06-14 11:33:11 -0700140 };
141
Jiri Pirko9e8f4a52015-10-01 11:03:46 +0200142 switchdev_port_obj_del(f->dst->dev, &fdb.obj);
Scott Feldmanb4ad7ba2015-06-14 11:33:11 -0700143}
144
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000145static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
Vlad Yasevich145beee2014-05-16 09:59:19 -0400147 if (f->is_static)
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100148 fdb_del_hw_addr(br, f->addr.addr);
Vlad Yasevich145beee2014-05-16 09:59:19 -0400149
Scott Feldmanb4ad7ba2015-06-14 11:33:11 -0700150 if (f->added_by_external_learn)
151 fdb_del_external_learn(f);
152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 hlist_del_rcu(&f->hlist);
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000154 fdb_notify(br, f, RTM_DELNEIGH);
Michał Mirosławda678292009-06-05 05:35:28 +0000155 call_rcu(&f->rcu, fdb_rcu_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156}
157
Toshiaki Makita960b5892014-02-07 16:48:23 +0900158/* Delete a local entry if no other port had the same address. */
159static void fdb_delete_local(struct net_bridge *br,
160 const struct net_bridge_port *p,
161 struct net_bridge_fdb_entry *f)
162{
163 const unsigned char *addr = f->addr.addr;
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200164 struct net_bridge_vlan_group *vg;
165 const struct net_bridge_vlan *v;
Toshiaki Makita960b5892014-02-07 16:48:23 +0900166 struct net_bridge_port *op;
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200167 u16 vid = f->vlan_id;
Toshiaki Makita960b5892014-02-07 16:48:23 +0900168
169 /* Maybe another port has same hw addr? */
170 list_for_each_entry(op, &br->port_list, list) {
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200171 vg = nbp_vlan_group(op);
Toshiaki Makita960b5892014-02-07 16:48:23 +0900172 if (op != p && ether_addr_equal(op->dev->dev_addr, addr) &&
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200173 (!vid || br_vlan_find(vg, vid))) {
Toshiaki Makita960b5892014-02-07 16:48:23 +0900174 f->dst = op;
Toshiaki Makitaa778e6d2014-02-07 16:48:24 +0900175 f->added_by_user = 0;
Toshiaki Makita960b5892014-02-07 16:48:23 +0900176 return;
177 }
178 }
179
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200180 vg = br_vlan_group(br);
181 v = br_vlan_find(vg, vid);
Toshiaki Makita960b5892014-02-07 16:48:23 +0900182 /* Maybe bridge device has same hw addr? */
183 if (p && ether_addr_equal(br->dev->dev_addr, addr) &&
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200184 (!vid || (v && br_vlan_should_use(v)))) {
Toshiaki Makita960b5892014-02-07 16:48:23 +0900185 f->dst = NULL;
Toshiaki Makitaa778e6d2014-02-07 16:48:24 +0900186 f->added_by_user = 0;
Toshiaki Makita960b5892014-02-07 16:48:23 +0900187 return;
188 }
189
190 fdb_delete(br, f);
191}
192
Toshiaki Makita424bb9c2014-02-07 16:48:25 +0900193void br_fdb_find_delete_local(struct net_bridge *br,
194 const struct net_bridge_port *p,
195 const unsigned char *addr, u16 vid)
196{
197 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
198 struct net_bridge_fdb_entry *f;
199
200 spin_lock_bh(&br->hash_lock);
201 f = fdb_find(head, addr, vid);
202 if (f && f->is_local && !f->added_by_user && f->dst == p)
203 fdb_delete_local(br, p, f);
204 spin_unlock_bh(&br->hash_lock);
205}
206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
208{
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200209 struct net_bridge_vlan_group *vg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 struct net_bridge *br = p->br;
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200211 struct net_bridge_vlan *v;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 int i;
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 spin_lock_bh(&br->hash_lock);
215
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200216 vg = nbp_vlan_group(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 /* Search all chains since old address/hash is unknown */
218 for (i = 0; i < BR_HASH_SIZE; i++) {
219 struct hlist_node *h;
220 hlist_for_each(h, &br->hash[i]) {
221 struct net_bridge_fdb_entry *f;
222
223 f = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900224 if (f->dst == p && f->is_local && !f->added_by_user) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 /* delete old one */
Toshiaki Makita960b5892014-02-07 16:48:23 +0900226 fdb_delete_local(br, p, f);
227
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000228 /* if this port has no vlan information
229 * configured, we can safely be done at
230 * this point.
231 */
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200232 if (!vg || !vg->num_vlans)
Toshiaki Makita28368822014-02-07 16:48:19 +0900233 goto insert;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 }
235 }
236 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
Toshiaki Makita28368822014-02-07 16:48:19 +0900238insert:
239 /* insert new address, may fail if invalid address or dup. */
240 fdb_insert(br, p, newaddr, 0);
241
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200242 if (!vg || !vg->num_vlans)
Toshiaki Makita28368822014-02-07 16:48:19 +0900243 goto done;
244
245 /* Now add entries for every VLAN configured on the port.
246 * This function runs under RTNL so the bitmap will not change
247 * from under us.
248 */
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200249 list_for_each_entry(v, &vg->vlan_list, vlist)
250 fdb_insert(br, p, newaddr, v->vid);
Toshiaki Makita28368822014-02-07 16:48:19 +0900251
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000252done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 spin_unlock_bh(&br->hash_lock);
254}
255
stephen hemminger43598812011-12-08 07:17:49 +0000256void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
257{
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200258 struct net_bridge_vlan_group *vg;
stephen hemminger43598812011-12-08 07:17:49 +0000259 struct net_bridge_fdb_entry *f;
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200260 struct net_bridge_vlan *v;
stephen hemminger43598812011-12-08 07:17:49 +0000261
Toshiaki Makitaac4c8862014-02-07 16:48:26 +0900262 spin_lock_bh(&br->hash_lock);
263
stephen hemminger43598812011-12-08 07:17:49 +0000264 /* If old entry was unassociated with any port, then delete it. */
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000265 f = __br_fdb_get(br, br->dev->dev_addr, 0);
stephen hemminger43598812011-12-08 07:17:49 +0000266 if (f && f->is_local && !f->dst)
Toshiaki Makita960b5892014-02-07 16:48:23 +0900267 fdb_delete_local(br, NULL, f);
stephen hemminger43598812011-12-08 07:17:49 +0000268
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000269 fdb_insert(br, NULL, newaddr, 0);
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200270 vg = br_vlan_group(br);
271 if (!vg || !vg->num_vlans)
272 goto out;
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000273 /* Now remove and add entries for every VLAN configured on the
274 * bridge. This function runs under RTNL so the bitmap will not
275 * change from under us.
276 */
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200277 list_for_each_entry(v, &vg->vlan_list, vlist) {
278 f = __br_fdb_get(br, br->dev->dev_addr, v->vid);
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000279 if (f && f->is_local && !f->dst)
Toshiaki Makita960b5892014-02-07 16:48:23 +0900280 fdb_delete_local(br, NULL, f);
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200281 fdb_insert(br, NULL, newaddr, v->vid);
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000282 }
Toshiaki Makitaac4c8862014-02-07 16:48:26 +0900283out:
284 spin_unlock_bh(&br->hash_lock);
stephen hemminger43598812011-12-08 07:17:49 +0000285}
286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287void br_fdb_cleanup(unsigned long _data)
288{
289 struct net_bridge *br = (struct net_bridge *)_data;
290 unsigned long delay = hold_time(br);
stephen hemminger25442e02010-06-15 06:14:12 +0000291 unsigned long next_timer = jiffies + br->ageing_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 int i;
293
Eric Dumazet27a42932012-01-16 04:35:50 +0000294 spin_lock(&br->hash_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 for (i = 0; i < BR_HASH_SIZE; i++) {
296 struct net_bridge_fdb_entry *f;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800297 struct hlist_node *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Sasha Levinb67bfe02013-02-27 17:06:00 -0800299 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
Baruch Even071f7722007-05-31 01:20:45 -0700300 unsigned long this_timer;
David S. Miller3fcf9012015-02-04 23:52:44 -0800301 if (f->is_static)
Baruch Even071f7722007-05-31 01:20:45 -0700302 continue;
Siva Mannemdcd45e02015-09-23 08:39:19 -0700303 if (f->added_by_external_learn)
304 continue;
stephen hemminger7cd88612011-04-04 14:03:28 +0000305 this_timer = f->updated + delay;
Baruch Even071f7722007-05-31 01:20:45 -0700306 if (time_before_eq(this_timer, jiffies))
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000307 fdb_delete(br, f);
Fabio Checconi2bec0082008-03-20 15:54:58 -0700308 else if (time_before(this_timer, next_timer))
Baruch Even071f7722007-05-31 01:20:45 -0700309 next_timer = this_timer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 }
311 }
Eric Dumazet27a42932012-01-16 04:35:50 +0000312 spin_unlock(&br->hash_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
stephen hemminger25442e02010-06-15 06:14:12 +0000314 mod_timer(&br->gc_timer, round_jiffies_up(next_timer));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315}
316
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700317/* Completely flush all dynamic entries in forwarding database.*/
318void br_fdb_flush(struct net_bridge *br)
319{
320 int i;
Stephen Hemminger1a620692006-10-12 14:45:38 -0700321
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700322 spin_lock_bh(&br->hash_lock);
323 for (i = 0; i < BR_HASH_SIZE; i++) {
324 struct net_bridge_fdb_entry *f;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800325 struct hlist_node *n;
326 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700327 if (!f->is_static)
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000328 fdb_delete(br, f);
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700329 }
330 }
331 spin_unlock_bh(&br->hash_lock);
332}
333
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300334/* Flush all entries referring to a specific port.
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700335 * if do_all is set also flush static entries
Nikolay Aleksandrov1ea2d022015-06-23 05:28:16 -0700336 * if vid is set delete all entries that match the vlan_id
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700337 */
Stephen Hemminger1a620692006-10-12 14:45:38 -0700338void br_fdb_delete_by_port(struct net_bridge *br,
339 const struct net_bridge_port *p,
Nikolay Aleksandrov1ea2d022015-06-23 05:28:16 -0700340 u16 vid,
Stephen Hemminger1a620692006-10-12 14:45:38 -0700341 int do_all)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
343 int i;
344
345 spin_lock_bh(&br->hash_lock);
346 for (i = 0; i < BR_HASH_SIZE; i++) {
347 struct hlist_node *h, *g;
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 hlist_for_each_safe(h, g, &br->hash[i]) {
350 struct net_bridge_fdb_entry *f
351 = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900352 if (f->dst != p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 continue;
354
Nikolay Aleksandrov1ea2d022015-06-23 05:28:16 -0700355 if (!do_all)
356 if (f->is_static || (vid && f->vlan_id != vid))
357 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
Toshiaki Makitaa778e6d2014-02-07 16:48:24 +0900359 if (f->is_local)
360 fdb_delete_local(br, p, f);
361 else
362 fdb_delete(br, f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 }
364 }
365 spin_unlock_bh(&br->hash_lock);
366}
367
stephen hemmingereeaf61d2010-07-27 08:26:30 +0000368/* No locking or refcounting, assumes caller has rcu_read_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000370 const unsigned char *addr,
371 __u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 struct net_bridge_fdb_entry *fdb;
374
Sasha Levinb67bfe02013-02-27 17:06:00 -0800375 hlist_for_each_entry_rcu(fdb,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000376 &br->hash[br_mac_hash(addr, vid)], hlist) {
377 if (ether_addr_equal(fdb->addr.addr, addr) &&
378 fdb->vlan_id == vid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 if (unlikely(has_expired(br, fdb)))
380 break;
381 return fdb;
382 }
383 }
384
385 return NULL;
386}
387
Igor Maraviće6373c42011-12-12 02:58:25 +0000388#if IS_ENABLED(CONFIG_ATM_LANE)
Michał Mirosławda678292009-06-05 05:35:28 +0000389/* Interface used by ATM LANE hook to test
390 * if an addr is on some other bridge port */
391int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
393 struct net_bridge_fdb_entry *fdb;
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000394 struct net_bridge_port *port;
Michał Mirosławda678292009-06-05 05:35:28 +0000395 int ret;
396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 rcu_read_lock();
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000398 port = br_port_get_rcu(dev);
399 if (!port)
400 ret = 0;
401 else {
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000402 fdb = __br_fdb_get(port->br, addr, 0);
stephen hemminger43598812011-12-08 07:17:49 +0000403 ret = fdb && fdb->dst && fdb->dst->dev != dev &&
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000404 fdb->dst->state == BR_STATE_FORWARDING;
405 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407
Michał Mirosławda678292009-06-05 05:35:28 +0000408 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409}
Michał Mirosławda678292009-06-05 05:35:28 +0000410#endif /* CONFIG_ATM_LANE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
412/*
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900413 * Fill buffer with forwarding table records in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 * the API format.
415 */
416int br_fdb_fillbuf(struct net_bridge *br, void *buf,
417 unsigned long maxnum, unsigned long skip)
418{
419 struct __fdb_entry *fe = buf;
420 int i, num = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 struct net_bridge_fdb_entry *f;
422
423 memset(buf, 0, maxnum*sizeof(struct __fdb_entry));
424
425 rcu_read_lock();
426 for (i = 0; i < BR_HASH_SIZE; i++) {
Sasha Levinb67bfe02013-02-27 17:06:00 -0800427 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 if (num >= maxnum)
429 goto out;
430
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900431 if (has_expired(br, f))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 continue;
433
stephen hemminger43598812011-12-08 07:17:49 +0000434 /* ignore pseudo entry for local MAC address */
435 if (!f->dst)
436 continue;
437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 if (skip) {
439 --skip;
440 continue;
441 }
442
443 /* convert from internal format to API */
444 memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN);
Stephen Hemmingerae4f8fc2008-05-02 16:53:33 -0700445
446 /* due to ABI compat need to split into hi/lo */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 fe->port_no = f->dst->port_no;
Stephen Hemmingerae4f8fc2008-05-02 16:53:33 -0700448 fe->port_hi = f->dst->port_no >> 8;
449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 fe->is_local = f->is_local;
451 if (!f->is_static)
Eric Dumazeta399a802012-08-08 21:13:53 +0000452 fe->ageing_timer_value = jiffies_delta_to_clock_t(jiffies - f->updated);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 ++fe;
454 ++num;
455 }
456 }
457
458 out:
459 rcu_read_unlock();
460
461 return num;
462}
463
stephen hemminger664de482011-04-04 14:03:29 +0000464static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000465 const unsigned char *addr,
466 __u16 vid)
stephen hemminger664de482011-04-04 14:03:29 +0000467{
stephen hemminger664de482011-04-04 14:03:29 +0000468 struct net_bridge_fdb_entry *fdb;
469
Sasha Levinb67bfe02013-02-27 17:06:00 -0800470 hlist_for_each_entry(fdb, head, hlist) {
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000471 if (ether_addr_equal(fdb->addr.addr, addr) &&
472 fdb->vlan_id == vid)
stephen hemminger664de482011-04-04 14:03:29 +0000473 return fdb;
474 }
475 return NULL;
476}
477
478static struct net_bridge_fdb_entry *fdb_find_rcu(struct hlist_head *head,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000479 const unsigned char *addr,
480 __u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 struct net_bridge_fdb_entry *fdb;
483
Sasha Levinb67bfe02013-02-27 17:06:00 -0800484 hlist_for_each_entry_rcu(fdb, head, hlist) {
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000485 if (ether_addr_equal(fdb->addr.addr, addr) &&
486 fdb->vlan_id == vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 return fdb;
488 }
489 return NULL;
490}
491
492static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head,
493 struct net_bridge_port *source,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000494 const unsigned char *addr,
495 __u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
497 struct net_bridge_fdb_entry *fdb;
498
499 fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
500 if (fdb) {
501 memcpy(fdb->addr.addr, addr, ETH_ALEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 fdb->dst = source;
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000503 fdb->vlan_id = vid;
stephen hemminger03e9b642011-04-04 14:03:27 +0000504 fdb->is_local = 0;
505 fdb->is_static = 0;
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900506 fdb->added_by_user = 0;
Scott Feldmancf6b8e12014-11-28 14:34:21 +0100507 fdb->added_by_external_learn = 0;
stephen hemminger7cd88612011-04-04 14:03:28 +0000508 fdb->updated = fdb->used = jiffies;
Pavel Emelyanov1158f762011-02-04 13:02:36 -0800509 hlist_add_head_rcu(&fdb->hlist, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 }
511 return fdb;
512}
513
514static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000515 const unsigned char *addr, u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516{
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000517 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 struct net_bridge_fdb_entry *fdb;
519
520 if (!is_valid_ether_addr(addr))
521 return -EINVAL;
522
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000523 fdb = fdb_find(head, addr, vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 if (fdb) {
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900525 /* it is okay to have multiple ports with same
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 * address, just use the first one.
527 */
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900528 if (fdb->is_local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 return 0;
stephen hemminger28a16c92010-05-10 09:31:09 +0000530 br_warn(br, "adding interface %s with same address "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 "as a received packet\n",
Hong zhi guo9b469222013-03-23 02:27:50 +0000532 source ? source->dev->name : br->dev->name);
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000533 fdb_delete(br, fdb);
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900534 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000536 fdb = fdb_create(head, source, addr, vid);
stephen hemminger03e9b642011-04-04 14:03:27 +0000537 if (!fdb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 return -ENOMEM;
539
stephen hemminger03e9b642011-04-04 14:03:27 +0000540 fdb->is_local = fdb->is_static = 1;
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100541 fdb_add_hw_addr(br, addr);
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000542 fdb_notify(br, fdb, RTM_NEWNEIGH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 return 0;
544}
545
stephen hemminger03e9b642011-04-04 14:03:27 +0000546/* Add entry for local address of interface */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000548 const unsigned char *addr, u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549{
550 int ret;
551
552 spin_lock_bh(&br->hash_lock);
Vlad Yasevichbc9a25d2013-02-13 12:00:19 +0000553 ret = fdb_insert(br, source, addr, vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 spin_unlock_bh(&br->hash_lock);
555 return ret;
556}
557
558void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900559 const unsigned char *addr, u16 vid, bool added_by_user)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000561 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 struct net_bridge_fdb_entry *fdb;
Jon Maxwellc65c7a32014-05-29 17:27:16 +1000563 bool fdb_modified = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
565 /* some users want to always flood. */
566 if (hold_time(br) == 0)
567 return;
568
Stephen Hemmingerdf1c0b82007-08-30 22:15:35 -0700569 /* ignore packets unless we are using this port */
570 if (!(source->state == BR_STATE_LEARNING ||
571 source->state == BR_STATE_FORWARDING))
572 return;
573
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000574 fdb = fdb_find_rcu(head, addr, vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 if (likely(fdb)) {
576 /* attempt to update an entry for a local interface */
577 if (unlikely(fdb->is_local)) {
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900578 if (net_ratelimit())
stephen hemminger28a16c92010-05-10 09:31:09 +0000579 br_warn(br, "received packet on %s with "
580 "own address as source address\n",
581 source->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 } else {
583 /* fastpath: update of existing entry */
Jon Maxwellc65c7a32014-05-29 17:27:16 +1000584 if (unlikely(source != fdb->dst)) {
585 fdb->dst = source;
586 fdb_modified = true;
587 }
stephen hemminger7cd88612011-04-04 14:03:28 +0000588 fdb->updated = jiffies;
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900589 if (unlikely(added_by_user))
590 fdb->added_by_user = 1;
Jon Maxwellc65c7a32014-05-29 17:27:16 +1000591 if (unlikely(fdb_modified))
592 fdb_notify(br, fdb, RTM_NEWNEIGH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 }
594 } else {
Stephen Hemmingerf8ae7372006-03-20 22:58:36 -0800595 spin_lock(&br->hash_lock);
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000596 if (likely(!fdb_find(head, addr, vid))) {
597 fdb = fdb_create(head, source, addr, vid);
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900598 if (fdb) {
599 if (unlikely(added_by_user))
600 fdb->added_by_user = 1;
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000601 fdb_notify(br, fdb, RTM_NEWNEIGH);
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900602 }
stephen hemmingerf58ee4e2011-12-06 13:02:24 +0000603 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 /* else we lose race and someone else inserts
605 * it first, don't bother updating
606 */
Stephen Hemmingerf8ae7372006-03-20 22:58:36 -0800607 spin_unlock(&br->hash_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609}
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000610
611static int fdb_to_nud(const struct net_bridge_fdb_entry *fdb)
612{
613 if (fdb->is_local)
614 return NUD_PERMANENT;
615 else if (fdb->is_static)
616 return NUD_NOARP;
617 else if (has_expired(fdb->dst->br, fdb))
618 return NUD_STALE;
619 else
620 return NUD_REACHABLE;
621}
622
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000623static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000624 const struct net_bridge_fdb_entry *fdb,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000625 u32 portid, u32 seq, int type, unsigned int flags)
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000626{
627 unsigned long now = jiffies;
628 struct nda_cacheinfo ci;
629 struct nlmsghdr *nlh;
630 struct ndmsg *ndm;
631
Eric W. Biederman15e47302012-09-07 20:12:54 +0000632 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000633 if (nlh == NULL)
634 return -EMSGSIZE;
635
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000636 ndm = nlmsg_data(nlh);
637 ndm->ndm_family = AF_BRIDGE;
638 ndm->ndm_pad1 = 0;
639 ndm->ndm_pad2 = 0;
Scott Feldmancf6b8e12014-11-28 14:34:21 +0100640 ndm->ndm_flags = fdb->added_by_external_learn ? NTF_EXT_LEARNED : 0;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000641 ndm->ndm_type = 0;
stephen hemminger43598812011-12-08 07:17:49 +0000642 ndm->ndm_ifindex = fdb->dst ? fdb->dst->dev->ifindex : br->dev->ifindex;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000643 ndm->ndm_state = fdb_to_nud(fdb);
644
David S. Miller2eb812e2012-04-01 20:49:54 -0400645 if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->addr))
646 goto nla_put_failure;
Roopa Prabhu41c389d2014-05-27 22:39:37 -0700647 if (nla_put_u32(skb, NDA_MASTER, br->dev->ifindex))
648 goto nla_put_failure;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000649 ci.ndm_used = jiffies_to_clock_t(now - fdb->used);
650 ci.ndm_confirmed = 0;
651 ci.ndm_updated = jiffies_to_clock_t(now - fdb->updated);
652 ci.ndm_refcnt = 0;
David S. Miller2eb812e2012-04-01 20:49:54 -0400653 if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
654 goto nla_put_failure;
Vlad Yasevich1690be62013-02-13 12:00:18 +0000655
Toshiaki Makita47fab412014-07-30 13:31:51 +0900656 if (fdb->vlan_id && nla_put(skb, NDA_VLAN, sizeof(u16), &fdb->vlan_id))
Vlad Yasevich1690be62013-02-13 12:00:18 +0000657 goto nla_put_failure;
658
Johannes Berg053c0952015-01-16 22:09:00 +0100659 nlmsg_end(skb, nlh);
660 return 0;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000661
662nla_put_failure:
663 nlmsg_cancel(skb, nlh);
664 return -EMSGSIZE;
665}
666
667static inline size_t fdb_nlmsg_size(void)
668{
669 return NLMSG_ALIGN(sizeof(struct ndmsg))
670 + nla_total_size(ETH_ALEN) /* NDA_LLADDR */
Roopa Prabhu41c389d2014-05-27 22:39:37 -0700671 + nla_total_size(sizeof(u32)) /* NDA_MASTER */
Vlad Yasevich1690be62013-02-13 12:00:18 +0000672 + nla_total_size(sizeof(u16)) /* NDA_VLAN */
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000673 + nla_total_size(sizeof(struct nda_cacheinfo));
674}
675
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000676static void fdb_notify(struct net_bridge *br,
677 const struct net_bridge_fdb_entry *fdb, int type)
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000678{
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000679 struct net *net = dev_net(br->dev);
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000680 struct sk_buff *skb;
681 int err = -ENOBUFS;
682
683 skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
684 if (skb == NULL)
685 goto errout;
686
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000687 err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000688 if (err < 0) {
689 /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */
690 WARN_ON(err == -EMSGSIZE);
691 kfree_skb(skb);
692 goto errout;
693 }
694 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
695 return;
696errout:
tanxiaojun87e823b2013-12-19 13:28:10 +0800697 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000698}
699
700/* Dump information about entries, in response to GETNEIGH */
John Fastabend77162022012-04-15 06:43:56 +0000701int br_fdb_dump(struct sk_buff *skb,
702 struct netlink_callback *cb,
703 struct net_device *dev,
Jamal Hadi Salim5d5eacb2014-07-10 07:01:58 -0400704 struct net_device *filter_dev,
John Fastabend77162022012-04-15 06:43:56 +0000705 int idx)
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000706{
John Fastabend77162022012-04-15 06:43:56 +0000707 struct net_bridge *br = netdev_priv(dev);
708 int i;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000709
John Fastabend77162022012-04-15 06:43:56 +0000710 if (!(dev->priv_flags & IFF_EBRIDGE))
711 goto out;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000712
Hubert Sokolowski6cb69742015-01-05 17:29:21 +0000713 if (!filter_dev)
714 idx = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx);
715
John Fastabend77162022012-04-15 06:43:56 +0000716 for (i = 0; i < BR_HASH_SIZE; i++) {
John Fastabend77162022012-04-15 06:43:56 +0000717 struct net_bridge_fdb_entry *f;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000718
Sasha Levinb67bfe02013-02-27 17:06:00 -0800719 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
John Fastabend77162022012-04-15 06:43:56 +0000720 if (idx < cb->args[0])
721 goto skip;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000722
Jamal Hadi Salim5e6d2432014-07-10 07:01:59 -0400723 if (filter_dev &&
724 (!f->dst || f->dst->dev != filter_dev)) {
725 if (filter_dev != dev)
726 goto skip;
Hubert Sokolowski6cb69742015-01-05 17:29:21 +0000727 /* !f->dst is a special case for bridge
Jamal Hadi Salim5e6d2432014-07-10 07:01:59 -0400728 * It means the MAC belongs to the bridge
729 * Therefore need a little more filtering
730 * we only want to dump the !f->dst case
731 */
732 if (f->dst)
733 goto skip;
734 }
Hubert Sokolowski6cb69742015-01-05 17:29:21 +0000735 if (!filter_dev && f->dst)
736 goto skip;
Jamal Hadi Salim5d5eacb2014-07-10 07:01:58 -0400737
John Fastabend77162022012-04-15 06:43:56 +0000738 if (fdb_fill_info(skb, br, f,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000739 NETLINK_CB(cb->skb).portid,
John Fastabend77162022012-04-15 06:43:56 +0000740 cb->nlh->nlmsg_seq,
741 RTM_NEWNEIGH,
742 NLM_F_MULTI) < 0)
743 break;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000744skip:
John Fastabend77162022012-04-15 06:43:56 +0000745 ++idx;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000746 }
747 }
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000748
John Fastabend77162022012-04-15 06:43:56 +0000749out:
750 return idx;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000751}
stephen hemminger36fd2b62011-04-04 14:03:31 +0000752
stephen hemminger292d1392011-11-09 18:30:08 +0000753/* Update (create or replace) forwarding database entry */
stephen hemminger36fd2b62011-04-04 14:03:31 +0000754static int fdb_add_entry(struct net_bridge_port *source, const __u8 *addr,
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000755 __u16 state, __u16 flags, __u16 vid)
stephen hemminger36fd2b62011-04-04 14:03:31 +0000756{
757 struct net_bridge *br = source->br;
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000758 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
stephen hemminger36fd2b62011-04-04 14:03:31 +0000759 struct net_bridge_fdb_entry *fdb;
roopab0a397f2013-04-22 12:56:49 +0000760 bool modified = false;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000761
Wilson Kokeb8d7ba2015-05-25 06:39:31 -0700762 /* If the port cannot learn allow only local and static entries */
763 if (!(state & NUD_PERMANENT) && !(state & NUD_NOARP) &&
764 !(source->state == BR_STATE_LEARNING ||
765 source->state == BR_STATE_FORWARDING))
766 return -EPERM;
767
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000768 fdb = fdb_find(head, addr, vid);
stephen hemminger64af1ba2011-09-30 14:37:27 +0000769 if (fdb == NULL) {
770 if (!(flags & NLM_F_CREATE))
771 return -ENOENT;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000772
Vlad Yasevich2ba071e2013-02-13 12:00:16 +0000773 fdb = fdb_create(head, source, addr, vid);
stephen hemminger64af1ba2011-09-30 14:37:27 +0000774 if (!fdb)
775 return -ENOMEM;
roopab0a397f2013-04-22 12:56:49 +0000776
777 modified = true;
stephen hemminger64af1ba2011-09-30 14:37:27 +0000778 } else {
779 if (flags & NLM_F_EXCL)
780 return -EEXIST;
roopab0a397f2013-04-22 12:56:49 +0000781
782 if (fdb->dst != source) {
783 fdb->dst = source;
784 modified = true;
785 }
stephen hemminger64af1ba2011-09-30 14:37:27 +0000786 }
stephen hemminger36fd2b62011-04-04 14:03:31 +0000787
stephen hemminger292d1392011-11-09 18:30:08 +0000788 if (fdb_to_nud(fdb) != state) {
Vlad Yasevich145beee2014-05-16 09:59:19 -0400789 if (state & NUD_PERMANENT) {
790 fdb->is_local = 1;
791 if (!fdb->is_static) {
792 fdb->is_static = 1;
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100793 fdb_add_hw_addr(br, addr);
Vlad Yasevich145beee2014-05-16 09:59:19 -0400794 }
795 } else if (state & NUD_NOARP) {
stephen hemminger292d1392011-11-09 18:30:08 +0000796 fdb->is_local = 0;
Vlad Yasevich145beee2014-05-16 09:59:19 -0400797 if (!fdb->is_static) {
798 fdb->is_static = 1;
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100799 fdb_add_hw_addr(br, addr);
Vlad Yasevich145beee2014-05-16 09:59:19 -0400800 }
801 } else {
802 fdb->is_local = 0;
803 if (fdb->is_static) {
804 fdb->is_static = 0;
Jiri Pirko020ec6b2014-11-28 14:34:12 +0100805 fdb_del_hw_addr(br, addr);
Vlad Yasevich145beee2014-05-16 09:59:19 -0400806 }
807 }
stephen hemminger292d1392011-11-09 18:30:08 +0000808
roopab0a397f2013-04-22 12:56:49 +0000809 modified = true;
810 }
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900811 fdb->added_by_user = 1;
roopab0a397f2013-04-22 12:56:49 +0000812
813 fdb->used = jiffies;
814 if (modified) {
815 fdb->updated = jiffies;
stephen hemminger31e8a49c2011-12-08 07:17:41 +0000816 fdb_notify(br, fdb, RTM_NEWNEIGH);
stephen hemminger292d1392011-11-09 18:30:08 +0000817 }
818
stephen hemminger36fd2b62011-04-04 14:03:31 +0000819 return 0;
820}
821
Vlad Yasevich1690be62013-02-13 12:00:18 +0000822static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge_port *p,
823 const unsigned char *addr, u16 nlh_flags, u16 vid)
824{
825 int err = 0;
826
827 if (ndm->ndm_flags & NTF_USE) {
Nikolay Aleksandrovc4c832f2015-06-06 06:49:00 -0700828 local_bh_disable();
Vlad Yasevich1690be62013-02-13 12:00:18 +0000829 rcu_read_lock();
Toshiaki Makitaa5642ab2014-02-07 16:48:18 +0900830 br_fdb_update(p->br, p, addr, vid, true);
Vlad Yasevich1690be62013-02-13 12:00:18 +0000831 rcu_read_unlock();
Nikolay Aleksandrovc4c832f2015-06-06 06:49:00 -0700832 local_bh_enable();
Vlad Yasevich1690be62013-02-13 12:00:18 +0000833 } else {
834 spin_lock_bh(&p->br->hash_lock);
835 err = fdb_add_entry(p, addr, ndm->ndm_state,
836 nlh_flags, vid);
837 spin_unlock_bh(&p->br->hash_lock);
838 }
839
840 return err;
841}
842
stephen hemminger36fd2b62011-04-04 14:03:31 +0000843/* Add new permanent fdb entry with RTM_NEWNEIGH */
stephen hemmingeredc7d572012-10-01 12:32:33 +0000844int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
845 struct net_device *dev,
Jiri Pirkof6f64242014-11-28 14:34:15 +0100846 const unsigned char *addr, u16 vid, u16 nlh_flags)
stephen hemminger36fd2b62011-04-04 14:03:31 +0000847{
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200848 struct net_bridge_vlan_group *vg;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000849 struct net_bridge_port *p;
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200850 struct net_bridge_vlan *v;
John Fastabend77162022012-04-15 06:43:56 +0000851 int err = 0;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000852
stephen hemminger292d1392011-11-09 18:30:08 +0000853 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
854 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
855 return -EINVAL;
856 }
857
Stephen Hemminger537f7f82013-06-25 09:34:36 -0700858 if (is_zero_ether_addr(addr)) {
859 pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
860 return -EINVAL;
861 }
862
stephen hemminger36fd2b62011-04-04 14:03:31 +0000863 p = br_port_get_rtnl(dev);
864 if (p == NULL) {
865 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
866 dev->name);
867 return -EINVAL;
868 }
869
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200870 vg = nbp_vlan_group(p);
Jiri Pirkof6f64242014-11-28 14:34:15 +0100871 if (vid) {
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200872 v = br_vlan_find(vg, vid);
873 if (!v) {
Vlad Yasevich1690be62013-02-13 12:00:18 +0000874 pr_info("bridge: RTM_NEWNEIGH with unconfigured "
875 "vlan %d on port %s\n", vid, dev->name);
876 return -EINVAL;
877 }
878
879 /* VID was specified, so use it. */
880 err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
stephen hemminger292d1392011-11-09 18:30:08 +0000881 } else {
Toshiaki Makita25d3b492015-02-09 20:16:17 +0900882 err = __br_fdb_add(ndm, p, addr, nlh_flags, 0);
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200883 if (err || !vg || !vg->num_vlans)
Vlad Yasevich1690be62013-02-13 12:00:18 +0000884 goto out;
Vlad Yasevich1690be62013-02-13 12:00:18 +0000885
886 /* We have vlans configured on this port and user didn't
887 * specify a VLAN. To be nice, add/update entry for every
888 * vlan on this port.
889 */
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200890 list_for_each_entry(v, &vg->vlan_list, vlist) {
891 err = __br_fdb_add(ndm, p, addr, nlh_flags, v->vid);
Vlad Yasevich1690be62013-02-13 12:00:18 +0000892 if (err)
893 goto out;
Vlad Yasevich1690be62013-02-13 12:00:18 +0000894 }
stephen hemminger292d1392011-11-09 18:30:08 +0000895 }
stephen hemminger36fd2b62011-04-04 14:03:31 +0000896
Vlad Yasevich1690be62013-02-13 12:00:18 +0000897out:
898 return err;
899}
900
Nikolay Aleksandrov8c86f962015-06-09 03:34:13 -0700901static int fdb_delete_by_addr_and_port(struct net_bridge_port *p,
902 const u8 *addr, u16 vlan)
Vlad Yasevich1690be62013-02-13 12:00:18 +0000903{
Nikolay Aleksandrov8c86f962015-06-09 03:34:13 -0700904 struct net_bridge *br = p->br;
Vlad Yasevich1690be62013-02-13 12:00:18 +0000905 struct hlist_head *head = &br->hash[br_mac_hash(addr, vlan)];
906 struct net_bridge_fdb_entry *fdb;
907
908 fdb = fdb_find(head, addr, vlan);
Nikolay Aleksandrov8c86f962015-06-09 03:34:13 -0700909 if (!fdb || fdb->dst != p)
Vlad Yasevich1690be62013-02-13 12:00:18 +0000910 return -ENOENT;
911
912 fdb_delete(br, fdb);
913 return 0;
914}
915
916static int __br_fdb_delete(struct net_bridge_port *p,
917 const unsigned char *addr, u16 vid)
918{
919 int err;
920
921 spin_lock_bh(&p->br->hash_lock);
Nikolay Aleksandrov8c86f962015-06-09 03:34:13 -0700922 err = fdb_delete_by_addr_and_port(p, addr, vid);
Vlad Yasevich1690be62013-02-13 12:00:18 +0000923 spin_unlock_bh(&p->br->hash_lock);
924
stephen hemminger36fd2b62011-04-04 14:03:31 +0000925 return err;
926}
927
stephen hemminger36fd2b62011-04-04 14:03:31 +0000928/* Remove neighbor entry with RTM_DELNEIGH */
Vlad Yasevich1690be62013-02-13 12:00:18 +0000929int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
930 struct net_device *dev,
Jiri Pirkof6f64242014-11-28 14:34:15 +0100931 const unsigned char *addr, u16 vid)
stephen hemminger36fd2b62011-04-04 14:03:31 +0000932{
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200933 struct net_bridge_vlan_group *vg;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000934 struct net_bridge_port *p;
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200935 struct net_bridge_vlan *v;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000936 int err;
937
stephen hemminger36fd2b62011-04-04 14:03:31 +0000938 p = br_port_get_rtnl(dev);
939 if (p == NULL) {
940 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
941 dev->name);
942 return -EINVAL;
943 }
944
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200945 vg = nbp_vlan_group(p);
Jiri Pirkof6f64242014-11-28 14:34:15 +0100946 if (vid) {
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200947 v = br_vlan_find(vg, vid);
948 if (!v) {
Vlad Yasevich1690be62013-02-13 12:00:18 +0000949 pr_info("bridge: RTM_DELNEIGH with unconfigured "
950 "vlan %d on port %s\n", vid, dev->name);
951 return -EINVAL;
952 }
stephen hemminger36fd2b62011-04-04 14:03:31 +0000953
Vlad Yasevich1690be62013-02-13 12:00:18 +0000954 err = __br_fdb_delete(p, addr, vid);
955 } else {
Toshiaki Makita25d3b492015-02-09 20:16:17 +0900956 err = -ENOENT;
957 err &= __br_fdb_delete(p, addr, 0);
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200958 if (!vg || !vg->num_vlans)
Vlad Yasevich1690be62013-02-13 12:00:18 +0000959 goto out;
Vlad Yasevich1690be62013-02-13 12:00:18 +0000960
Nikolay Aleksandrov2594e902015-09-25 19:00:11 +0200961 list_for_each_entry(v, &vg->vlan_list, vlist)
962 err &= __br_fdb_delete(p, addr, v->vid);
Vlad Yasevich1690be62013-02-13 12:00:18 +0000963 }
964out:
stephen hemminger36fd2b62011-04-04 14:03:31 +0000965 return err;
966}
Vlad Yasevich8db24af2014-05-16 09:59:17 -0400967
968int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p)
969{
970 struct net_bridge_fdb_entry *fdb, *tmp;
971 int i;
972 int err;
973
974 ASSERT_RTNL();
975
976 for (i = 0; i < BR_HASH_SIZE; i++) {
977 hlist_for_each_entry(fdb, &br->hash[i], hlist) {
978 /* We only care for static entries */
979 if (!fdb->is_static)
980 continue;
981
982 err = dev_uc_add(p->dev, fdb->addr.addr);
983 if (err)
984 goto rollback;
985 }
986 }
987 return 0;
988
989rollback:
990 for (i = 0; i < BR_HASH_SIZE; i++) {
991 hlist_for_each_entry(tmp, &br->hash[i], hlist) {
992 /* If we reached the fdb that failed, we can stop */
993 if (tmp == fdb)
994 break;
995
996 /* We only care for static entries */
997 if (!tmp->is_static)
998 continue;
999
1000 dev_uc_del(p->dev, tmp->addr.addr);
1001 }
1002 }
1003 return err;
1004}
1005
1006void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p)
1007{
1008 struct net_bridge_fdb_entry *fdb;
1009 int i;
1010
1011 ASSERT_RTNL();
1012
1013 for (i = 0; i < BR_HASH_SIZE; i++) {
1014 hlist_for_each_entry_rcu(fdb, &br->hash[i], hlist) {
1015 /* We only care for static entries */
1016 if (!fdb->is_static)
1017 continue;
1018
1019 dev_uc_del(p->dev, fdb->addr.addr);
1020 }
1021 }
1022}
Scott Feldmancf6b8e12014-11-28 14:34:21 +01001023
Jiri Pirko3aeb6612015-01-15 23:49:37 +01001024int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p,
Scott Feldmancf6b8e12014-11-28 14:34:21 +01001025 const unsigned char *addr, u16 vid)
1026{
Scott Feldmancf6b8e12014-11-28 14:34:21 +01001027 struct hlist_head *head;
1028 struct net_bridge_fdb_entry *fdb;
1029 int err = 0;
1030
Jiri Pirko3aeb6612015-01-15 23:49:37 +01001031 ASSERT_RTNL();
Scott Feldmancf6b8e12014-11-28 14:34:21 +01001032 spin_lock_bh(&br->hash_lock);
1033
1034 head = &br->hash[br_mac_hash(addr, vid)];
1035 fdb = fdb_find(head, addr, vid);
1036 if (!fdb) {
1037 fdb = fdb_create(head, p, addr, vid);
1038 if (!fdb) {
1039 err = -ENOMEM;
1040 goto err_unlock;
1041 }
1042 fdb->added_by_external_learn = 1;
1043 fdb_notify(br, fdb, RTM_NEWNEIGH);
1044 } else if (fdb->added_by_external_learn) {
1045 /* Refresh entry */
1046 fdb->updated = fdb->used = jiffies;
1047 } else if (!fdb->added_by_user) {
1048 /* Take over SW learned entry */
1049 fdb->added_by_external_learn = 1;
1050 fdb->updated = jiffies;
1051 fdb_notify(br, fdb, RTM_NEWNEIGH);
1052 }
1053
1054err_unlock:
1055 spin_unlock_bh(&br->hash_lock);
Scott Feldmancf6b8e12014-11-28 14:34:21 +01001056
1057 return err;
1058}
Scott Feldmancf6b8e12014-11-28 14:34:21 +01001059
Jiri Pirko3aeb6612015-01-15 23:49:37 +01001060int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
Scott Feldmancf6b8e12014-11-28 14:34:21 +01001061 const unsigned char *addr, u16 vid)
1062{
Scott Feldmancf6b8e12014-11-28 14:34:21 +01001063 struct hlist_head *head;
1064 struct net_bridge_fdb_entry *fdb;
1065 int err = 0;
1066
Jiri Pirko3aeb6612015-01-15 23:49:37 +01001067 ASSERT_RTNL();
Scott Feldmancf6b8e12014-11-28 14:34:21 +01001068 spin_lock_bh(&br->hash_lock);
1069
1070 head = &br->hash[br_mac_hash(addr, vid)];
1071 fdb = fdb_find(head, addr, vid);
1072 if (fdb && fdb->added_by_external_learn)
1073 fdb_delete(br, fdb);
1074 else
1075 err = -ENOENT;
1076
1077 spin_unlock_bh(&br->hash_lock);
Scott Feldmancf6b8e12014-11-28 14:34:21 +01001078
1079 return err;
1080}