Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
br_fdb.c
Go to the documentation of this file.
1 /*
2  * Forwarding database
3  * Linux ethernet bridge
4  *
5  * Authors:
6  * Lennert Buytenhek <[email protected]>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version
11  * 2 of the License, or (at your option) any later version.
12  */
13 
14 #include <linux/kernel.h>
15 #include <linux/init.h>
16 #include <linux/rculist.h>
17 #include <linux/spinlock.h>
18 #include <linux/times.h>
19 #include <linux/netdevice.h>
20 #include <linux/etherdevice.h>
21 #include <linux/jhash.h>
22 #include <linux/random.h>
23 #include <linux/slab.h>
24 #include <linux/atomic.h>
25 #include <asm/unaligned.h>
26 #include "br_private.h"
27 
28 static struct kmem_cache *br_fdb_cache __read_mostly;
29 static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
30  const unsigned char *addr);
31 static void fdb_notify(struct net_bridge *br,
32  const struct net_bridge_fdb_entry *, int);
33 
34 static u32 fdb_salt __read_mostly;
35 
37 {
38  br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
39  sizeof(struct net_bridge_fdb_entry),
40  0,
42  if (!br_fdb_cache)
43  return -ENOMEM;
44 
45  get_random_bytes(&fdb_salt, sizeof(fdb_salt));
46  return 0;
47 }
48 
49 void br_fdb_fini(void)
50 {
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  */
58 static inline unsigned long hold_time(const struct net_bridge *br)
59 {
60  return br->topology_change ? br->forward_delay : br->ageing_time;
61 }
62 
63 static inline int has_expired(const struct net_bridge *br,
64  const struct net_bridge_fdb_entry *fdb)
65 {
66  return !fdb->is_static &&
67  time_before_eq(fdb->updated + hold_time(br), jiffies);
68 }
69 
70 static inline int br_mac_hash(const unsigned char *mac)
71 {
72  /* 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);
75 }
76 
77 static void fdb_rcu_free(struct rcu_head *head)
78 {
80  = container_of(head, struct net_bridge_fdb_entry, rcu);
81  kmem_cache_free(br_fdb_cache, ent);
82 }
83 
84 static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f)
85 {
86  hlist_del_rcu(&f->hlist);
87  fdb_notify(br, f, RTM_DELNEIGH);
88  call_rcu(&f->rcu, fdb_rcu_free);
89 }
90 
91 void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
92 {
93  struct net_bridge *br = p->br;
94  int i;
95 
96  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) {
109  if (op != p &&
110  ether_addr_equal(op->dev->dev_addr,
111  f->addr.addr)) {
112  f->dst = op;
113  goto insert;
114  }
115  }
116 
117  /* delete old one */
118  fdb_delete(br, f);
119  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 
130 void 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 
142 void br_fdb_cleanup(unsigned long _data)
143 {
144  struct net_bridge *br = (struct net_bridge *)_data;
145  unsigned long delay = hold_time(br);
146  unsigned long next_timer = jiffies + br->ageing_time;
147  int i;
148 
149  spin_lock(&br->hash_lock);
150  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) {
155  unsigned long this_timer;
156  if (f->is_static)
157  continue;
158  this_timer = f->updated + delay;
159  if (time_before_eq(this_timer, jiffies))
160  fdb_delete(br, f);
161  else if (time_before(this_timer, next_timer))
162  next_timer = this_timer;
163  }
164  }
165  spin_unlock(&br->hash_lock);
166 
167  mod_timer(&br->gc_timer, round_jiffies_up(next_timer));
168 }
169 
170 /* Completely flush all dynamic entries in forwarding database.*/
171 void br_fdb_flush(struct net_bridge *br)
172 {
173  int i;
174 
175  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)
181  fdb_delete(br, f);
182  }
183  }
184  spin_unlock_bh(&br->hash_lock);
185 }
186 
187 /* Flush all entries referring to a specific port.
188  * if do_all is set also flush static entries
189  */
191  const struct net_bridge_port *p,
192  int do_all)
193 {
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;
199 
200  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);
203  if (f->dst != p)
204  continue;
205 
206  if (f->is_static && !do_all)
207  continue;
208  /*
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) {
216  if (op != p &&
217  ether_addr_equal(op->dev->dev_addr,
218  f->addr.addr)) {
219  f->dst = op;
220  goto skip_delete;
221  }
222  }
223  }
224 
225  fdb_delete(br, f);
226  skip_delete: ;
227  }
228  }
229  spin_unlock_bh(&br->hash_lock);
230 }
231 
232 /* No locking or refcounting, assumes caller has rcu_read_lock */
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) {
240  if (ether_addr_equal(fdb->addr.addr, addr)) {
241  if (unlikely(has_expired(br, fdb)))
242  break;
243  return fdb;
244  }
245  }
246 
247  return NULL;
248 }
249 
250 #if IS_ENABLED(CONFIG_ATM_LANE)
251 /* Interface used by ATM LANE hook to test
252  * if an addr is on some other bridge port */
253 int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
254 {
255  struct net_bridge_fdb_entry *fdb;
256  struct net_bridge_port *port;
257  int ret;
258 
259  rcu_read_lock();
260  port = br_port_get_rcu(dev);
261  if (!port)
262  ret = 0;
263  else {
264  fdb = __br_fdb_get(port->br, addr);
265  ret = fdb && fdb->dst && fdb->dst->dev != dev &&
266  fdb->dst->state == BR_STATE_FORWARDING;
267  }
268  rcu_read_unlock();
269 
270  return ret;
271 }
272 #endif /* CONFIG_ATM_LANE */
273 
274 /*
275  * Fill buffer with forwarding table records in
276  * the API format.
277  */
278 int 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 
294  if (has_expired(br, f))
295  continue;
296 
297  /* ignore pseudo entry for local MAC address */
298  if (!f->dst)
299  continue;
300 
301  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);
308 
309  /* due to ABI compat need to split into hi/lo */
310  fe->port_no = f->dst->port_no;
311  fe->port_hi = f->dst->port_no >> 8;
312 
313  fe->is_local = f->is_local;
314  if (!f->is_static)
315  fe->ageing_timer_value = jiffies_delta_to_clock_t(jiffies - f->updated);
316  ++fe;
317  ++num;
318  }
319  }
320 
321  out:
322  rcu_read_unlock();
323 
324  return num;
325 }
326 
327 static 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 (ether_addr_equal(fdb->addr.addr, addr))
335  return fdb;
336  }
337  return NULL;
338 }
339 
340 static struct net_bridge_fdb_entry *fdb_find_rcu(struct hlist_head *head,
341  const unsigned char *addr)
342 {
343  struct hlist_node *h;
344  struct net_bridge_fdb_entry *fdb;
345 
346  hlist_for_each_entry_rcu(fdb, h, head, hlist) {
347  if (ether_addr_equal(fdb->addr.addr, addr))
348  return fdb;
349  }
350  return NULL;
351 }
352 
353 static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head,
354  struct net_bridge_port *source,
355  const unsigned char *addr)
356 {
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);
362  fdb->dst = source;
363  fdb->is_local = 0;
364  fdb->is_static = 0;
365  fdb->updated = fdb->used = jiffies;
366  hlist_add_head_rcu(&fdb->hlist, head);
367  }
368  return fdb;
369 }
370 
371 static 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) {
382  /* it is okay to have multiple ports with same
383  * address, just use the first one.
384  */
385  if (fdb->is_local)
386  return 0;
387  br_warn(br, "adding interface %s with same address "
388  "as a received packet\n",
389  source->dev->name);
390  fdb_delete(br, fdb);
391  }
392 
393  fdb = fdb_create(head, source, addr);
394  if (!fdb)
395  return -ENOMEM;
396 
397  fdb->is_local = fdb->is_static = 1;
398  fdb_notify(br, fdb, RTM_NEWNEIGH);
399  return 0;
400 }
401 
402 /* Add entry for local address of interface */
403 int 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 
414 void 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 
424  /* ignore packets unless we are using this port */
425  if (!(source->state == BR_STATE_LEARNING ||
426  source->state == BR_STATE_FORWARDING))
427  return;
428 
429  fdb = fdb_find_rcu(head, addr);
430  if (likely(fdb)) {
431  /* attempt to update an entry for a local interface */
432  if (unlikely(fdb->is_local)) {
433  if (net_ratelimit())
434  br_warn(br, "received packet on %s with "
435  "own address as source address\n",
436  source->dev->name);
437  } else {
438  /* fastpath: update of existing entry */
439  fdb->dst = source;
440  fdb->updated = jiffies;
441  }
442  } else {
443  spin_lock(&br->hash_lock);
444  if (likely(!fdb_find(head, addr))) {
445  fdb = fdb_create(head, source, addr);
446  if (fdb)
447  fdb_notify(br, fdb, RTM_NEWNEIGH);
448  }
449  /* else we lose race and someone else inserts
450  * it first, don't bother updating
451  */
452  spin_unlock(&br->hash_lock);
453  }
454 }
455 
456 static 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 
468 static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
469  const struct net_bridge_fdb_entry *fdb,
470  u32 portid, 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, portid, seq, type, sizeof(*ndm), flags);
478  if (nlh == NULL)
479  return -EMSGSIZE;
480 
481  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;
487  ndm->ndm_ifindex = fdb->dst ? fdb->dst->dev->ifindex : br->dev->ifindex;
488  ndm->ndm_state = fdb_to_nud(fdb);
489 
490  if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->addr))
491  goto nla_put_failure;
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  if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
497  goto nla_put_failure;
498  return nlmsg_end(skb, nlh);
499 
500 nla_put_failure:
501  nlmsg_cancel(skb, nlh);
502  return -EMSGSIZE;
503 }
504 
505 static 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 
512 static void fdb_notify(struct net_bridge *br,
513  const struct net_bridge_fdb_entry *fdb, int type)
514 {
515  struct net *net = dev_net(br->dev);
516  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 
523  err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
524  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;
532 errout:
533  if (err < 0)
534  rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
535 }
536 
537 /* Dump information about entries, in response to GETNEIGH */
538 int br_fdb_dump(struct sk_buff *skb,
539  struct netlink_callback *cb,
540  struct net_device *dev,
541  int idx)
542 {
543  struct net_bridge *br = netdev_priv(dev);
544  int i;
545 
546  if (!(dev->priv_flags & IFF_EBRIDGE))
547  goto out;
548 
549  for (i = 0; i < BR_HASH_SIZE; i++) {
550  struct hlist_node *h;
551  struct net_bridge_fdb_entry *f;
552 
553  hlist_for_each_entry_rcu(f, h, &br->hash[i], hlist) {
554  if (idx < cb->args[0])
555  goto skip;
556 
557  if (fdb_fill_info(skb, br, f,
558  NETLINK_CB(cb->skb).portid,
559  cb->nlh->nlmsg_seq,
560  RTM_NEWNEIGH,
561  NLM_F_MULTI) < 0)
562  break;
563 skip:
564  ++idx;
565  }
566  }
567 
568 out:
569  return idx;
570 }
571 
572 /* Update (create or replace) forwarding database entry */
573 static int fdb_add_entry(struct net_bridge_port *source, const __u8 *addr,
574  __u16 state, __u16 flags)
575 {
576  struct net_bridge *br = source->br;
577  struct hlist_head *head = &br->hash[br_mac_hash(addr)];
578  struct net_bridge_fdb_entry *fdb;
579 
580  fdb = fdb_find(head, addr);
581  if (fdb == NULL) {
582  if (!(flags & NLM_F_CREATE))
583  return -ENOENT;
584 
585  fdb = fdb_create(head, source, addr);
586  if (!fdb)
587  return -ENOMEM;
588  fdb_notify(br, fdb, RTM_NEWNEIGH);
589  } else {
590  if (flags & NLM_F_EXCL)
591  return -EEXIST;
592  }
593 
594  if (fdb_to_nud(fdb) != state) {
595  if (state & NUD_PERMANENT)
596  fdb->is_local = fdb->is_static = 1;
597  else if (state & NUD_NOARP) {
598  fdb->is_local = 0;
599  fdb->is_static = 1;
600  } else
601  fdb->is_local = fdb->is_static = 0;
602 
603  fdb->updated = fdb->used = jiffies;
604  fdb_notify(br, fdb, RTM_NEWNEIGH);
605  }
606 
607  return 0;
608 }
609 
610 /* Add new permanent fdb entry with RTM_NEWNEIGH */
611 int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
612  struct net_device *dev,
613  const unsigned char *addr, u16 nlh_flags)
614 {
615  struct net_bridge_port *p;
616  int err = 0;
617 
619  pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
620  return -EINVAL;
621  }
622 
623  p = br_port_get_rtnl(dev);
624  if (p == NULL) {
625  pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
626  dev->name);
627  return -EINVAL;
628  }
629 
630  if (ndm->ndm_flags & NTF_USE) {
631  rcu_read_lock();
632  br_fdb_update(p->br, p, addr);
633  rcu_read_unlock();
634  } else {
635  spin_lock_bh(&p->br->hash_lock);
636  err = fdb_add_entry(p, addr, ndm->ndm_state, nlh_flags);
637  spin_unlock_bh(&p->br->hash_lock);
638  }
639 
640  return err;
641 }
642 
643 static int fdb_delete_by_addr(struct net_bridge_port *p, const u8 *addr)
644 {
645  struct net_bridge *br = p->br;
646  struct hlist_head *head = &br->hash[br_mac_hash(addr)];
647  struct net_bridge_fdb_entry *fdb;
648 
649  fdb = fdb_find(head, addr);
650  if (!fdb)
651  return -ENOENT;
652 
653  fdb_delete(p->br, fdb);
654  return 0;
655 }
656 
657 /* Remove neighbor entry with RTM_DELNEIGH */
658 int br_fdb_delete(struct ndmsg *ndm, struct net_device *dev,
659  const unsigned char *addr)
660 {
661  struct net_bridge_port *p;
662  int err;
663 
664  p = br_port_get_rtnl(dev);
665  if (p == NULL) {
666  pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
667  dev->name);
668  return -EINVAL;
669  }
670 
671  spin_lock_bh(&p->br->hash_lock);
672  err = fdb_delete_by_addr(p, addr);
673  spin_unlock_bh(&p->br->hash_lock);
674 
675  return err;
676 }