blob: 5ba0c844d508cbe549788e2219b4dd9ab1383149 [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 Sharma60063492011-07-26 16:09:06 -070024#include <linux/atomic.h>
Stephen Hemminger3f890922007-03-21 13:42:33 -070025#include <asm/unaligned.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "br_private.h"
27
Christoph Lametere18b8902006-12-06 20:33:20 -080028static struct kmem_cache *br_fdb_cache __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070029static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
30 const unsigned char *addr);
stephen hemminger31e8a492011-12-08 07:17:41 +000031static void fdb_notify(struct net_bridge *br,
32 const struct net_bridge_fdb_entry *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Stephen Hemminger3f890922007-03-21 13:42:33 -070034static u32 fdb_salt __read_mostly;
35
Akinobu Mita87a596e2007-04-07 18:57:07 +090036int __init br_fdb_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070037{
38 br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
39 sizeof(struct net_bridge_fdb_entry),
40 0,
Paul Mundt20c2df82007-07-20 10:11:58 +090041 SLAB_HWCACHE_ALIGN, NULL);
Akinobu Mita87a596e2007-04-07 18:57:07 +090042 if (!br_fdb_cache)
43 return -ENOMEM;
44
Stephen Hemminger3f890922007-03-21 13:42:33 -070045 get_random_bytes(&fdb_salt, sizeof(fdb_salt));
Akinobu Mita87a596e2007-04-07 18:57:07 +090046 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070047}
48
Andrew Morton73afc902007-12-05 21:35:23 -080049void br_fdb_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050{
51 kmem_cache_destroy(br_fdb_cache);
52}
53
54
55/* if topology_changing then use forward_delay (default 15 sec)
56 * otherwise keep longer (default 5 minutes)
57 */
Stephen Hemminger3f890922007-03-21 13:42:33 -070058static inline unsigned long hold_time(const struct net_bridge *br)
Linus Torvalds1da177e2005-04-16 15:20:36 -070059{
60 return br->topology_change ? br->forward_delay : br->ageing_time;
61}
62
Stephen Hemminger3f890922007-03-21 13:42:33 -070063static inline int has_expired(const struct net_bridge *br,
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 const struct net_bridge_fdb_entry *fdb)
65{
Joe Perchesf64f9e72009-11-29 16:55:45 -080066 return !fdb->is_static &&
stephen hemminger7cd88612011-04-04 14:03:28 +000067 time_before_eq(fdb->updated + hold_time(br), jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068}
69
Stephen Hemminger3f890922007-03-21 13:42:33 -070070static inline int br_mac_hash(const unsigned char *mac)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071{
Stephen Hemminger3f890922007-03-21 13:42:33 -070072 /* use 1 byte of OUI cnd 3 bytes of NIC */
73 u32 key = get_unaligned((u32 *)(mac + 2));
74 return jhash_1word(key, fdb_salt) & (BR_HASH_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075}
76
Michał Mirosławda678292009-06-05 05:35:28 +000077static void fdb_rcu_free(struct rcu_head *head)
78{
79 struct net_bridge_fdb_entry *ent
80 = container_of(head, struct net_bridge_fdb_entry, rcu);
81 kmem_cache_free(br_fdb_cache, ent);
82}
83
stephen hemminger31e8a492011-12-08 07:17:41 +000084static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f)
Linus Torvalds1da177e2005-04-16 15:20:36 -070085{
86 hlist_del_rcu(&f->hlist);
stephen hemminger31e8a492011-12-08 07:17:41 +000087 fdb_notify(br, f, RTM_DELNEIGH);
Michał Mirosławda678292009-06-05 05:35:28 +000088 call_rcu(&f->rcu, fdb_rcu_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089}
90
91void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
92{
93 struct net_bridge *br = p->br;
94 int i;
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +090095
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 spin_lock_bh(&br->hash_lock);
97
98 /* Search all chains since old address/hash is unknown */
99 for (i = 0; i < BR_HASH_SIZE; i++) {
100 struct hlist_node *h;
101 hlist_for_each(h, &br->hash[i]) {
102 struct net_bridge_fdb_entry *f;
103
104 f = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
105 if (f->dst == p && f->is_local) {
106 /* maybe another port has same hw addr? */
107 struct net_bridge_port *op;
108 list_for_each_entry(op, &br->port_list, list) {
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900109 if (op != p &&
Stephen Hemminger6ede2462005-10-25 15:04:59 -0700110 !compare_ether_addr(op->dev->dev_addr,
111 f->addr.addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 f->dst = op;
113 goto insert;
114 }
115 }
116
117 /* delete old one */
stephen hemminger31e8a492011-12-08 07:17:41 +0000118 fdb_delete(br, f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 goto insert;
120 }
121 }
122 }
123 insert:
124 /* insert new address, may fail if invalid address or dup. */
125 fdb_insert(br, p, newaddr);
126
127 spin_unlock_bh(&br->hash_lock);
128}
129
stephen hemminger43598812011-12-08 07:17:49 +0000130void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
131{
132 struct net_bridge_fdb_entry *f;
133
134 /* If old entry was unassociated with any port, then delete it. */
135 f = __br_fdb_get(br, br->dev->dev_addr);
136 if (f && f->is_local && !f->dst)
137 fdb_delete(br, f);
138
139 fdb_insert(br, NULL, newaddr);
140}
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142void br_fdb_cleanup(unsigned long _data)
143{
144 struct net_bridge *br = (struct net_bridge *)_data;
145 unsigned long delay = hold_time(br);
stephen hemminger25442e02010-06-15 06:14:12 +0000146 unsigned long next_timer = jiffies + br->ageing_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 int i;
148
Eric Dumazet27a42932012-01-16 04:35:50 +0000149 spin_lock(&br->hash_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 for (i = 0; i < BR_HASH_SIZE; i++) {
151 struct net_bridge_fdb_entry *f;
152 struct hlist_node *h, *n;
153
154 hlist_for_each_entry_safe(f, h, n, &br->hash[i], hlist) {
Baruch Even071f7722007-05-31 01:20:45 -0700155 unsigned long this_timer;
156 if (f->is_static)
157 continue;
stephen hemminger7cd88612011-04-04 14:03:28 +0000158 this_timer = f->updated + delay;
Baruch Even071f7722007-05-31 01:20:45 -0700159 if (time_before_eq(this_timer, jiffies))
stephen hemminger31e8a492011-12-08 07:17:41 +0000160 fdb_delete(br, f);
Fabio Checconi2bec0082008-03-20 15:54:58 -0700161 else if (time_before(this_timer, next_timer))
Baruch Even071f7722007-05-31 01:20:45 -0700162 next_timer = this_timer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 }
164 }
Eric Dumazet27a42932012-01-16 04:35:50 +0000165 spin_unlock(&br->hash_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
stephen hemminger25442e02010-06-15 06:14:12 +0000167 mod_timer(&br->gc_timer, round_jiffies_up(next_timer));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168}
169
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700170/* Completely flush all dynamic entries in forwarding database.*/
171void br_fdb_flush(struct net_bridge *br)
172{
173 int i;
Stephen Hemminger1a620692006-10-12 14:45:38 -0700174
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700175 spin_lock_bh(&br->hash_lock);
176 for (i = 0; i < BR_HASH_SIZE; i++) {
177 struct net_bridge_fdb_entry *f;
178 struct hlist_node *h, *n;
179 hlist_for_each_entry_safe(f, h, n, &br->hash[i], hlist) {
180 if (!f->is_static)
stephen hemminger31e8a492011-12-08 07:17:41 +0000181 fdb_delete(br, f);
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700182 }
183 }
184 spin_unlock_bh(&br->hash_lock);
185}
186
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300187/* Flush all entries referring to a specific port.
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700188 * if do_all is set also flush static entries
189 */
Stephen Hemminger1a620692006-10-12 14:45:38 -0700190void br_fdb_delete_by_port(struct net_bridge *br,
191 const struct net_bridge_port *p,
192 int do_all)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193{
194 int i;
195
196 spin_lock_bh(&br->hash_lock);
197 for (i = 0; i < BR_HASH_SIZE; i++) {
198 struct hlist_node *h, *g;
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 hlist_for_each_safe(h, g, &br->hash[i]) {
201 struct net_bridge_fdb_entry *f
202 = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900203 if (f->dst != p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 continue;
205
Stephen Hemminger1a620692006-10-12 14:45:38 -0700206 if (f->is_static && !do_all)
207 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 /*
209 * if multiple ports all have the same device address
210 * then when one port is deleted, assign
211 * the local entry to other port
212 */
213 if (f->is_local) {
214 struct net_bridge_port *op;
215 list_for_each_entry(op, &br->port_list, list) {
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900216 if (op != p &&
Stephen Hemminger6ede2462005-10-25 15:04:59 -0700217 !compare_ether_addr(op->dev->dev_addr,
218 f->addr.addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 f->dst = op;
220 goto skip_delete;
221 }
222 }
223 }
224
stephen hemminger31e8a492011-12-08 07:17:41 +0000225 fdb_delete(br, f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 skip_delete: ;
227 }
228 }
229 spin_unlock_bh(&br->hash_lock);
230}
231
stephen hemmingereeaf61d2010-07-27 08:26:30 +0000232/* No locking or refcounting, assumes caller has rcu_read_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br,
234 const unsigned char *addr)
235{
236 struct hlist_node *h;
237 struct net_bridge_fdb_entry *fdb;
238
239 hlist_for_each_entry_rcu(fdb, h, &br->hash[br_mac_hash(addr)], hlist) {
Stephen Hemminger6ede2462005-10-25 15:04:59 -0700240 if (!compare_ether_addr(fdb->addr.addr, addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 if (unlikely(has_expired(br, fdb)))
242 break;
243 return fdb;
244 }
245 }
246
247 return NULL;
248}
249
Igor Maraviće6373c42011-12-12 02:58:25 +0000250#if IS_ENABLED(CONFIG_ATM_LANE)
Michał Mirosławda678292009-06-05 05:35:28 +0000251/* Interface used by ATM LANE hook to test
252 * if an addr is on some other bridge port */
253int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
255 struct net_bridge_fdb_entry *fdb;
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000256 struct net_bridge_port *port;
Michał Mirosławda678292009-06-05 05:35:28 +0000257 int ret;
258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 rcu_read_lock();
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000260 port = br_port_get_rcu(dev);
261 if (!port)
262 ret = 0;
263 else {
264 fdb = __br_fdb_get(port->br, addr);
stephen hemminger43598812011-12-08 07:17:49 +0000265 ret = fdb && fdb->dst && fdb->dst->dev != dev &&
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000266 fdb->dst->state == BR_STATE_FORWARDING;
267 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Michał Mirosławda678292009-06-05 05:35:28 +0000270 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271}
Michał Mirosławda678292009-06-05 05:35:28 +0000272#endif /* CONFIG_ATM_LANE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274/*
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900275 * Fill buffer with forwarding table records in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 * the API format.
277 */
278int br_fdb_fillbuf(struct net_bridge *br, void *buf,
279 unsigned long maxnum, unsigned long skip)
280{
281 struct __fdb_entry *fe = buf;
282 int i, num = 0;
283 struct hlist_node *h;
284 struct net_bridge_fdb_entry *f;
285
286 memset(buf, 0, maxnum*sizeof(struct __fdb_entry));
287
288 rcu_read_lock();
289 for (i = 0; i < BR_HASH_SIZE; i++) {
290 hlist_for_each_entry_rcu(f, h, &br->hash[i], hlist) {
291 if (num >= maxnum)
292 goto out;
293
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900294 if (has_expired(br, f))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 continue;
296
stephen hemminger43598812011-12-08 07:17:49 +0000297 /* ignore pseudo entry for local MAC address */
298 if (!f->dst)
299 continue;
300
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 if (skip) {
302 --skip;
303 continue;
304 }
305
306 /* convert from internal format to API */
307 memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN);
Stephen Hemmingerae4f8fc2008-05-02 16:53:33 -0700308
309 /* due to ABI compat need to split into hi/lo */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 fe->port_no = f->dst->port_no;
Stephen Hemmingerae4f8fc2008-05-02 16:53:33 -0700311 fe->port_hi = f->dst->port_no >> 8;
312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 fe->is_local = f->is_local;
314 if (!f->is_static)
stephen hemminger7cd88612011-04-04 14:03:28 +0000315 fe->ageing_timer_value = jiffies_to_clock_t(jiffies - f->updated);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 ++fe;
317 ++num;
318 }
319 }
320
321 out:
322 rcu_read_unlock();
323
324 return num;
325}
326
stephen hemminger664de482011-04-04 14:03:29 +0000327static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
328 const unsigned char *addr)
329{
330 struct hlist_node *h;
331 struct net_bridge_fdb_entry *fdb;
332
333 hlist_for_each_entry(fdb, h, head, hlist) {
334 if (!compare_ether_addr(fdb->addr.addr, addr))
335 return fdb;
336 }
337 return NULL;
338}
339
340static struct net_bridge_fdb_entry *fdb_find_rcu(struct hlist_head *head,
341 const unsigned char *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
343 struct hlist_node *h;
344 struct net_bridge_fdb_entry *fdb;
345
346 hlist_for_each_entry_rcu(fdb, h, head, hlist) {
Stephen Hemminger6ede2462005-10-25 15:04:59 -0700347 if (!compare_ether_addr(fdb->addr.addr, addr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 return fdb;
349 }
350 return NULL;
351}
352
353static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head,
354 struct net_bridge_port *source,
stephen hemminger03e9b642011-04-04 14:03:27 +0000355 const unsigned char *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356{
357 struct net_bridge_fdb_entry *fdb;
358
359 fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
360 if (fdb) {
361 memcpy(fdb->addr.addr, addr, ETH_ALEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 fdb->dst = source;
stephen hemminger03e9b642011-04-04 14:03:27 +0000363 fdb->is_local = 0;
364 fdb->is_static = 0;
stephen hemminger7cd88612011-04-04 14:03:28 +0000365 fdb->updated = fdb->used = jiffies;
Pavel Emelyanov1158f762011-02-04 13:02:36 -0800366 hlist_add_head_rcu(&fdb->hlist, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 }
368 return fdb;
369}
370
371static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
372 const unsigned char *addr)
373{
374 struct hlist_head *head = &br->hash[br_mac_hash(addr)];
375 struct net_bridge_fdb_entry *fdb;
376
377 if (!is_valid_ether_addr(addr))
378 return -EINVAL;
379
380 fdb = fdb_find(head, addr);
381 if (fdb) {
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900382 /* it is okay to have multiple ports with same
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 * address, just use the first one.
384 */
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900385 if (fdb->is_local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 return 0;
stephen hemminger28a16c92010-05-10 09:31:09 +0000387 br_warn(br, "adding interface %s with same address "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 "as a received packet\n",
389 source->dev->name);
stephen hemminger31e8a492011-12-08 07:17:41 +0000390 fdb_delete(br, fdb);
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900391 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
stephen hemminger03e9b642011-04-04 14:03:27 +0000393 fdb = fdb_create(head, source, addr);
394 if (!fdb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 return -ENOMEM;
396
stephen hemminger03e9b642011-04-04 14:03:27 +0000397 fdb->is_local = fdb->is_static = 1;
stephen hemminger31e8a492011-12-08 07:17:41 +0000398 fdb_notify(br, fdb, RTM_NEWNEIGH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 return 0;
400}
401
stephen hemminger03e9b642011-04-04 14:03:27 +0000402/* Add entry for local address of interface */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
404 const unsigned char *addr)
405{
406 int ret;
407
408 spin_lock_bh(&br->hash_lock);
409 ret = fdb_insert(br, source, addr);
410 spin_unlock_bh(&br->hash_lock);
411 return ret;
412}
413
414void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
415 const unsigned char *addr)
416{
417 struct hlist_head *head = &br->hash[br_mac_hash(addr)];
418 struct net_bridge_fdb_entry *fdb;
419
420 /* some users want to always flood. */
421 if (hold_time(br) == 0)
422 return;
423
Stephen Hemmingerdf1c0b82007-08-30 22:15:35 -0700424 /* ignore packets unless we are using this port */
425 if (!(source->state == BR_STATE_LEARNING ||
426 source->state == BR_STATE_FORWARDING))
427 return;
428
stephen hemminger664de482011-04-04 14:03:29 +0000429 fdb = fdb_find_rcu(head, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 if (likely(fdb)) {
431 /* attempt to update an entry for a local interface */
432 if (unlikely(fdb->is_local)) {
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900433 if (net_ratelimit())
stephen hemminger28a16c92010-05-10 09:31:09 +0000434 br_warn(br, "received packet on %s with "
435 "own address as source address\n",
436 source->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 } else {
438 /* fastpath: update of existing entry */
439 fdb->dst = source;
stephen hemminger7cd88612011-04-04 14:03:28 +0000440 fdb->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 }
442 } else {
Stephen Hemmingerf8ae7372006-03-20 22:58:36 -0800443 spin_lock(&br->hash_lock);
stephen hemmingerf58ee4e2011-12-06 13:02:24 +0000444 if (likely(!fdb_find(head, addr))) {
445 fdb = fdb_create(head, source, addr);
446 if (fdb)
stephen hemminger31e8a492011-12-08 07:17:41 +0000447 fdb_notify(br, fdb, RTM_NEWNEIGH);
stephen hemmingerf58ee4e2011-12-06 13:02:24 +0000448 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 /* else we lose race and someone else inserts
450 * it first, don't bother updating
451 */
Stephen Hemmingerf8ae7372006-03-20 22:58:36 -0800452 spin_unlock(&br->hash_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454}
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000455
456static int fdb_to_nud(const struct net_bridge_fdb_entry *fdb)
457{
458 if (fdb->is_local)
459 return NUD_PERMANENT;
460 else if (fdb->is_static)
461 return NUD_NOARP;
462 else if (has_expired(fdb->dst->br, fdb))
463 return NUD_STALE;
464 else
465 return NUD_REACHABLE;
466}
467
stephen hemminger31e8a492011-12-08 07:17:41 +0000468static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000469 const struct net_bridge_fdb_entry *fdb,
470 u32 pid, u32 seq, int type, unsigned int flags)
471{
472 unsigned long now = jiffies;
473 struct nda_cacheinfo ci;
474 struct nlmsghdr *nlh;
475 struct ndmsg *ndm;
476
477 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
478 if (nlh == NULL)
479 return -EMSGSIZE;
480
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000481 ndm = nlmsg_data(nlh);
482 ndm->ndm_family = AF_BRIDGE;
483 ndm->ndm_pad1 = 0;
484 ndm->ndm_pad2 = 0;
485 ndm->ndm_flags = 0;
486 ndm->ndm_type = 0;
stephen hemminger43598812011-12-08 07:17:49 +0000487 ndm->ndm_ifindex = fdb->dst ? fdb->dst->dev->ifindex : br->dev->ifindex;
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000488 ndm->ndm_state = fdb_to_nud(fdb);
489
490 NLA_PUT(skb, NDA_LLADDR, ETH_ALEN, &fdb->addr);
491
492 ci.ndm_used = jiffies_to_clock_t(now - fdb->used);
493 ci.ndm_confirmed = 0;
494 ci.ndm_updated = jiffies_to_clock_t(now - fdb->updated);
495 ci.ndm_refcnt = 0;
496 NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
497
498 return nlmsg_end(skb, nlh);
499
500nla_put_failure:
501 nlmsg_cancel(skb, nlh);
502 return -EMSGSIZE;
503}
504
505static inline size_t fdb_nlmsg_size(void)
506{
507 return NLMSG_ALIGN(sizeof(struct ndmsg))
508 + nla_total_size(ETH_ALEN) /* NDA_LLADDR */
509 + nla_total_size(sizeof(struct nda_cacheinfo));
510}
511
stephen hemminger31e8a492011-12-08 07:17:41 +0000512static void fdb_notify(struct net_bridge *br,
513 const struct net_bridge_fdb_entry *fdb, int type)
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000514{
stephen hemminger31e8a492011-12-08 07:17:41 +0000515 struct net *net = dev_net(br->dev);
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000516 struct sk_buff *skb;
517 int err = -ENOBUFS;
518
519 skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
520 if (skb == NULL)
521 goto errout;
522
stephen hemminger31e8a492011-12-08 07:17:41 +0000523 err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000524 if (err < 0) {
525 /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */
526 WARN_ON(err == -EMSGSIZE);
527 kfree_skb(skb);
528 goto errout;
529 }
530 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
531 return;
532errout:
533 if (err < 0)
534 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
535}
536
537/* Dump information about entries, in response to GETNEIGH */
538int br_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
539{
540 struct net *net = sock_net(skb->sk);
541 struct net_device *dev;
542 int idx = 0;
543
544 rcu_read_lock();
545 for_each_netdev_rcu(net, dev) {
546 struct net_bridge *br = netdev_priv(dev);
547 int i;
548
549 if (!(dev->priv_flags & IFF_EBRIDGE))
550 continue;
551
552 for (i = 0; i < BR_HASH_SIZE; i++) {
553 struct hlist_node *h;
554 struct net_bridge_fdb_entry *f;
555
556 hlist_for_each_entry_rcu(f, h, &br->hash[i], hlist) {
557 if (idx < cb->args[0])
558 goto skip;
559
stephen hemminger31e8a492011-12-08 07:17:41 +0000560 if (fdb_fill_info(skb, br, f,
stephen hemmingerb078f0d2011-04-04 14:03:30 +0000561 NETLINK_CB(cb->skb).pid,
562 cb->nlh->nlmsg_seq,
563 RTM_NEWNEIGH,
564 NLM_F_MULTI) < 0)
565 break;
566skip:
567 ++idx;
568 }
569 }
570 }
571 rcu_read_unlock();
572
573 cb->args[0] = idx;
574
575 return skb->len;
576}
stephen hemminger36fd2b62011-04-04 14:03:31 +0000577
stephen hemminger292d1392011-11-09 18:30:08 +0000578/* Update (create or replace) forwarding database entry */
stephen hemminger36fd2b62011-04-04 14:03:31 +0000579static int fdb_add_entry(struct net_bridge_port *source, const __u8 *addr,
stephen hemminger64af1ba2011-09-30 14:37:27 +0000580 __u16 state, __u16 flags)
stephen hemminger36fd2b62011-04-04 14:03:31 +0000581{
582 struct net_bridge *br = source->br;
583 struct hlist_head *head = &br->hash[br_mac_hash(addr)];
584 struct net_bridge_fdb_entry *fdb;
585
586 fdb = fdb_find(head, addr);
stephen hemminger64af1ba2011-09-30 14:37:27 +0000587 if (fdb == NULL) {
588 if (!(flags & NLM_F_CREATE))
589 return -ENOENT;
stephen hemminger36fd2b62011-04-04 14:03:31 +0000590
stephen hemminger64af1ba2011-09-30 14:37:27 +0000591 fdb = fdb_create(head, source, addr);
592 if (!fdb)
593 return -ENOMEM;
stephen hemminger31e8a492011-12-08 07:17:41 +0000594 fdb_notify(br, fdb, RTM_NEWNEIGH);
stephen hemminger64af1ba2011-09-30 14:37:27 +0000595 } else {
596 if (flags & NLM_F_EXCL)
597 return -EEXIST;
stephen hemminger64af1ba2011-09-30 14:37:27 +0000598 }
stephen hemminger36fd2b62011-04-04 14:03:31 +0000599
stephen hemminger292d1392011-11-09 18:30:08 +0000600 if (fdb_to_nud(fdb) != state) {
601 if (state & NUD_PERMANENT)
602 fdb->is_local = fdb->is_static = 1;
603 else if (state & NUD_NOARP) {
604 fdb->is_local = 0;
605 fdb->is_static = 1;
606 } else
607 fdb->is_local = fdb->is_static = 0;
608
609 fdb->updated = fdb->used = jiffies;
stephen hemminger31e8a492011-12-08 07:17:41 +0000610 fdb_notify(br, fdb, RTM_NEWNEIGH);
stephen hemminger292d1392011-11-09 18:30:08 +0000611 }
612
stephen hemminger36fd2b62011-04-04 14:03:31 +0000613 return 0;
614}
615
616/* Add new permanent fdb entry with RTM_NEWNEIGH */
617int br_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
618{
619 struct net *net = sock_net(skb->sk);
620 struct ndmsg *ndm;
621 struct nlattr *tb[NDA_MAX+1];
622 struct net_device *dev;
623 struct net_bridge_port *p;
624 const __u8 *addr;
625 int err;
626
627 ASSERT_RTNL();
628 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
629 if (err < 0)
630 return err;
631
632 ndm = nlmsg_data(nlh);
633 if (ndm->ndm_ifindex == 0) {
634 pr_info("bridge: RTM_NEWNEIGH with invalid ifindex\n");
635 return -EINVAL;
636 }
637
638 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
639 if (dev == NULL) {
640 pr_info("bridge: RTM_NEWNEIGH with unknown ifindex\n");
641 return -ENODEV;
642 }
643
644 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
645 pr_info("bridge: RTM_NEWNEIGH with invalid address\n");
646 return -EINVAL;
647 }
648
649 addr = nla_data(tb[NDA_LLADDR]);
650 if (!is_valid_ether_addr(addr)) {
651 pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
652 return -EINVAL;
653 }
654
stephen hemminger292d1392011-11-09 18:30:08 +0000655 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
656 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
657 return -EINVAL;
658 }
659
stephen hemminger36fd2b62011-04-04 14:03:31 +0000660 p = br_port_get_rtnl(dev);
661 if (p == NULL) {
662 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
663 dev->name);
664 return -EINVAL;
665 }
666
stephen hemminger292d1392011-11-09 18:30:08 +0000667 if (ndm->ndm_flags & NTF_USE) {
668 rcu_read_lock();
669 br_fdb_update(p->br, p, addr);
670 rcu_read_unlock();
671 } else {
672 spin_lock_bh(&p->br->hash_lock);
673 err = fdb_add_entry(p, addr, ndm->ndm_state, nlh->nlmsg_flags);
674 spin_unlock_bh(&p->br->hash_lock);
675 }
stephen hemminger36fd2b62011-04-04 14:03:31 +0000676
677 return err;
678}
679
680static int fdb_delete_by_addr(struct net_bridge_port *p, const u8 *addr)
681{
682 struct net_bridge *br = p->br;
683 struct hlist_head *head = &br->hash[br_mac_hash(addr)];
684 struct net_bridge_fdb_entry *fdb;
685
686 fdb = fdb_find(head, addr);
687 if (!fdb)
688 return -ENOENT;
689
stephen hemminger31e8a492011-12-08 07:17:41 +0000690 fdb_delete(p->br, fdb);
stephen hemminger36fd2b62011-04-04 14:03:31 +0000691 return 0;
692}
693
694/* Remove neighbor entry with RTM_DELNEIGH */
695int br_fdb_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
696{
697 struct net *net = sock_net(skb->sk);
698 struct ndmsg *ndm;
699 struct net_bridge_port *p;
700 struct nlattr *llattr;
701 const __u8 *addr;
702 struct net_device *dev;
703 int err;
704
705 ASSERT_RTNL();
706 if (nlmsg_len(nlh) < sizeof(*ndm))
707 return -EINVAL;
708
709 ndm = nlmsg_data(nlh);
710 if (ndm->ndm_ifindex == 0) {
711 pr_info("bridge: RTM_DELNEIGH with invalid ifindex\n");
712 return -EINVAL;
713 }
714
715 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
716 if (dev == NULL) {
717 pr_info("bridge: RTM_DELNEIGH with unknown ifindex\n");
718 return -ENODEV;
719 }
720
721 llattr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_LLADDR);
722 if (llattr == NULL || nla_len(llattr) != ETH_ALEN) {
723 pr_info("bridge: RTM_DELNEIGH with invalid address\n");
724 return -EINVAL;
725 }
726
727 addr = nla_data(llattr);
728
729 p = br_port_get_rtnl(dev);
730 if (p == NULL) {
731 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
732 dev->name);
733 return -EINVAL;
734 }
735
736 spin_lock_bh(&p->br->hash_lock);
737 err = fdb_delete_by_addr(p, addr);
738 spin_unlock_bh(&p->br->hash_lock);
739
740 return err;
741}