projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mwifiex: remove_bss_prio_lock
[deliverable/linux.git] / net / bridge / br_fdb.c
1 /*
2 * Forwarding database
3 * Linux ethernet bridge
4 *
5 * Authors:
6 * Lennert Buytenhek <buytenh@gnu.org>
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 <linux/if_vlan.h>
27 #include "br_private.h"
28
29 static struct kmem_cache *br_fdb_cache __read_mostly;
30 static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
31 const unsigned char *addr,
32 __u16 vid);
33 static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
34 const unsigned char *addr, u16 vid);
35 static void fdb_notify(struct net_bridge *br,
36 const struct net_bridge_fdb_entry *, int);
37
38 static u32 fdb_salt __read_mostly;
39
40 int __init br_fdb_init(void)
41 {
42 br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
43 sizeof(struct net_bridge_fdb_entry),
44 0,
45 SLAB_HWCACHE_ALIGN, NULL);
46 if (!br_fdb_cache)
47 return -ENOMEM;
48
49 get_random_bytes(&fdb_salt, sizeof(fdb_salt));
50 return 0;
51 }
52
53 void br_fdb_fini(void)
54 {
55 kmem_cache_destroy(br_fdb_cache);
56 }
57
58
59 /* if topology_changing then use forward_delay (default 15 sec)
60 * otherwise keep longer (default 5 minutes)
61 */
62 static inline unsigned long hold_time(const struct net_bridge *br)
63 {
64 return br->topology_change ? br->forward_delay : br->ageing_time;
65 }
66
67 static inline int has_expired(const struct net_bridge *br,
68 const struct net_bridge_fdb_entry *fdb)
69 {
70 return !fdb->is_static &&
71 time_before_eq(fdb->updated + hold_time(br), jiffies);
72 }
73
74 static inline int br_mac_hash(const unsigned char *mac, __u16 vid)
75 {
76 /* use 1 byte of OUI and 3 bytes of NIC */
77 u32 key = get_unaligned((u32 *)(mac + 2));
78 return jhash_2words(key, vid, fdb_salt) & (BR_HASH_SIZE - 1);
79 }
80
81 static void fdb_rcu_free(struct rcu_head *head)
82 {
83 struct net_bridge_fdb_entry *ent
84 = container_of(head, struct net_bridge_fdb_entry, rcu);
85 kmem_cache_free(br_fdb_cache, ent);
86 }
87
88 /* When a static FDB entry is added, the mac address from the entry is
89 * added to the bridge private HW address list and all required ports
90 * are then updated with the new information.
91 * Called under RTNL.
92 */
93 static void fdb_add_hw_addr(struct net_bridge *br, const unsigned char *addr)
94 {
95 int err;
96 struct net_bridge_port *p;
97
98 ASSERT_RTNL();
99
100 list_for_each_entry(p, &br->port_list, list) {
101 if (!br_promisc_port(p)) {
102 err = dev_uc_add(p->dev, addr);
103 if (err)
104 goto undo;
105 }
106 }
107
108 return;
109 undo:
110 list_for_each_entry_continue_reverse(p, &br->port_list, list) {
111 if (!br_promisc_port(p))
112 dev_uc_del(p->dev, addr);
113 }
114 }
115
116 /* When a static FDB entry is deleted, the HW address from that entry is
117 * also removed from the bridge private HW address list and updates all
118 * the ports with needed information.
119 * Called under RTNL.
120 */
121 static void fdb_del_hw_addr(struct net_bridge *br, const unsigned char *addr)
122 {
123 struct net_bridge_port *p;
124
125 ASSERT_RTNL();
126
127 list_for_each_entry(p, &br->port_list, list) {
128 if (!br_promisc_port(p))
129 dev_uc_del(p->dev, addr);
130 }
131 }
132
133 static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f)
134 {
135 if (f->is_static)
136 fdb_del_hw_addr(br, f->addr.addr);
137
138 hlist_del_rcu(&f->hlist);
139 fdb_notify(br, f, RTM_DELNEIGH);
140 call_rcu(&f->rcu, fdb_rcu_free);
141 }
142
143 /* Delete a local entry if no other port had the same address. */
144 static void fdb_delete_local(struct net_bridge *br,
145 const struct net_bridge_port *p,
146 struct net_bridge_fdb_entry *f)
147 {
148 const unsigned char *addr = f->addr.addr;
149 u16 vid = f->vlan_id;
150 struct net_bridge_port *op;
151
152 /* Maybe another port has same hw addr? */
153 list_for_each_entry(op, &br->port_list, list) {
154 if (op != p && ether_addr_equal(op->dev->dev_addr, addr) &&
155 (!vid || nbp_vlan_find(op, vid))) {
156 f->dst = op;
157 f->added_by_user = 0;
158 return;
159 }
160 }
161
162 /* Maybe bridge device has same hw addr? */
163 if (p && ether_addr_equal(br->dev->dev_addr, addr) &&
164 (!vid || br_vlan_find(br, vid))) {
165 f->dst = NULL;
166 f->added_by_user = 0;
167 return;
168 }
169
170 fdb_delete(br, f);
171 }
172
173 void br_fdb_find_delete_local(struct net_bridge *br,
174 const struct net_bridge_port *p,
175 const unsigned char *addr, u16 vid)
176 {
177 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
178 struct net_bridge_fdb_entry *f;
179
180 spin_lock_bh(&br->hash_lock);
181 f = fdb_find(head, addr, vid);
182 if (f && f->is_local && !f->added_by_user && f->dst == p)
183 fdb_delete_local(br, p, f);
184 spin_unlock_bh(&br->hash_lock);
185 }
186
187 void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
188 {
189 struct net_bridge *br = p->br;
190 struct net_port_vlans *pv = nbp_get_vlan_info(p);
191 bool no_vlan = !pv;
192 int i;
193 u16 vid;
194
195 spin_lock_bh(&br->hash_lock);
196
197 /* Search all chains since old address/hash is unknown */
198 for (i = 0; i < BR_HASH_SIZE; i++) {
199 struct hlist_node *h;
200 hlist_for_each(h, &br->hash[i]) {
201 struct net_bridge_fdb_entry *f;
202
203 f = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
204 if (f->dst == p && f->is_local && !f->added_by_user) {
205 /* delete old one */
206 fdb_delete_local(br, p, f);
207
208 /* if this port has no vlan information
209 * configured, we can safely be done at
210 * this point.
211 */
212 if (no_vlan)
213 goto insert;
214 }
215 }
216 }
217
218 insert:
219 /* insert new address, may fail if invalid address or dup. */
220 fdb_insert(br, p, newaddr, 0);
221
222 if (no_vlan)
223 goto done;
224
225 /* Now add entries for every VLAN configured on the port.
226 * This function runs under RTNL so the bitmap will not change
227 * from under us.
228 */
229 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID)
230 fdb_insert(br, p, newaddr, vid);
231
232 done:
233 spin_unlock_bh(&br->hash_lock);
234 }
235
236 void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
237 {
238 struct net_bridge_fdb_entry *f;
239 struct net_port_vlans *pv;
240 u16 vid = 0;
241
242 spin_lock_bh(&br->hash_lock);
243
244 /* If old entry was unassociated with any port, then delete it. */
245 f = __br_fdb_get(br, br->dev->dev_addr, 0);
246 if (f && f->is_local && !f->dst)
247 fdb_delete_local(br, NULL, f);
248
249 fdb_insert(br, NULL, newaddr, 0);
250
251 /* Now remove and add entries for every VLAN configured on the
252 * bridge. This function runs under RTNL so the bitmap will not
253 * change from under us.
254 */
255 pv = br_get_vlan_info(br);
256 if (!pv)
257 goto out;
258
259 for_each_set_bit_from(vid, pv->vlan_bitmap, VLAN_N_VID) {
260 f = __br_fdb_get(br, br->dev->dev_addr, vid);
261 if (f && f->is_local && !f->dst)
262 fdb_delete_local(br, NULL, f);
263 fdb_insert(br, NULL, newaddr, vid);
264 }
265 out:
266 spin_unlock_bh(&br->hash_lock);
267 }
268
269 void br_fdb_cleanup(unsigned long _data)
270 {
271 struct net_bridge *br = (struct net_bridge *)_data;
272 unsigned long delay = hold_time(br);
273 unsigned long next_timer = jiffies + br->ageing_time;
274 int i;
275
276 spin_lock(&br->hash_lock);
277 for (i = 0; i < BR_HASH_SIZE; i++) {
278 struct net_bridge_fdb_entry *f;
279 struct hlist_node *n;
280
281 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
282 unsigned long this_timer;
283 if (f->is_static)
284 continue;
285 this_timer = f->updated + delay;
286 if (time_before_eq(this_timer, jiffies))
287 fdb_delete(br, f);
288 else if (time_before(this_timer, next_timer))
289 next_timer = this_timer;
290 }
291 }
292 spin_unlock(&br->hash_lock);
293
294 mod_timer(&br->gc_timer, round_jiffies_up(next_timer));
295 }
296
297 /* Completely flush all dynamic entries in forwarding database.*/
298 void br_fdb_flush(struct net_bridge *br)
299 {
300 int i;
301
302 spin_lock_bh(&br->hash_lock);
303 for (i = 0; i < BR_HASH_SIZE; i++) {
304 struct net_bridge_fdb_entry *f;
305 struct hlist_node *n;
306 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
307 if (!f->is_static)
308 fdb_delete(br, f);
309 }
310 }
311 spin_unlock_bh(&br->hash_lock);
312 }
313
314 /* Flush all entries referring to a specific port.
315 * if do_all is set also flush static entries
316 */
317 void br_fdb_delete_by_port(struct net_bridge *br,
318 const struct net_bridge_port *p,
319 int do_all)
320 {
321 int i;
322
323 spin_lock_bh(&br->hash_lock);
324 for (i = 0; i < BR_HASH_SIZE; i++) {
325 struct hlist_node *h, *g;
326
327 hlist_for_each_safe(h, g, &br->hash[i]) {
328 struct net_bridge_fdb_entry *f
329 = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
330 if (f->dst != p)
331 continue;
332
333 if (f->is_static && !do_all)
334 continue;
335
336 if (f->is_local)
337 fdb_delete_local(br, p, f);
338 else
339 fdb_delete(br, f);
340 }
341 }
342 spin_unlock_bh(&br->hash_lock);
343 }
344
345 /* No locking or refcounting, assumes caller has rcu_read_lock */
346 struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br,
347 const unsigned char *addr,
348 __u16 vid)
349 {
350 struct net_bridge_fdb_entry *fdb;
351
352 hlist_for_each_entry_rcu(fdb,
353 &br->hash[br_mac_hash(addr, vid)], hlist) {
354 if (ether_addr_equal(fdb->addr.addr, addr) &&
355 fdb->vlan_id == vid) {
356 if (unlikely(has_expired(br, fdb)))
357 break;
358 return fdb;
359 }
360 }
361
362 return NULL;
363 }
364
365 #if IS_ENABLED(CONFIG_ATM_LANE)
366 /* Interface used by ATM LANE hook to test
367 * if an addr is on some other bridge port */
368 int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
369 {
370 struct net_bridge_fdb_entry *fdb;
371 struct net_bridge_port *port;
372 int ret;
373
374 rcu_read_lock();
375 port = br_port_get_rcu(dev);
376 if (!port)
377 ret = 0;
378 else {
379 fdb = __br_fdb_get(port->br, addr, 0);
380 ret = fdb && fdb->dst && fdb->dst->dev != dev &&
381 fdb->dst->state == BR_STATE_FORWARDING;
382 }
383 rcu_read_unlock();
384
385 return ret;
386 }
387 #endif /* CONFIG_ATM_LANE */
388
389 /*
390 * Fill buffer with forwarding table records in
391 * the API format.
392 */
393 int br_fdb_fillbuf(struct net_bridge *br, void *buf,
394 unsigned long maxnum, unsigned long skip)
395 {
396 struct __fdb_entry *fe = buf;
397 int i, num = 0;
398 struct net_bridge_fdb_entry *f;
399
400 memset(buf, 0, maxnum*sizeof(struct __fdb_entry));
401
402 rcu_read_lock();
403 for (i = 0; i < BR_HASH_SIZE; i++) {
404 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
405 if (num >= maxnum)
406 goto out;
407
408 if (has_expired(br, f))
409 continue;
410
411 /* ignore pseudo entry for local MAC address */
412 if (!f->dst)
413 continue;
414
415 if (skip) {
416 --skip;
417 continue;
418 }
419
420 /* convert from internal format to API */
421 memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN);
422
423 /* due to ABI compat need to split into hi/lo */
424 fe->port_no = f->dst->port_no;
425 fe->port_hi = f->dst->port_no >> 8;
426
427 fe->is_local = f->is_local;
428 if (!f->is_static)
429 fe->ageing_timer_value = jiffies_delta_to_clock_t(jiffies - f->updated);
430 ++fe;
431 ++num;
432 }
433 }
434
435 out:
436 rcu_read_unlock();
437
438 return num;
439 }
440
441 static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
442 const unsigned char *addr,
443 __u16 vid)
444 {
445 struct net_bridge_fdb_entry *fdb;
446
447 hlist_for_each_entry(fdb, head, hlist) {
448 if (ether_addr_equal(fdb->addr.addr, addr) &&
449 fdb->vlan_id == vid)
450 return fdb;
451 }
452 return NULL;
453 }
454
455 static struct net_bridge_fdb_entry *fdb_find_rcu(struct hlist_head *head,
456 const unsigned char *addr,
457 __u16 vid)
458 {
459 struct net_bridge_fdb_entry *fdb;
460
461 hlist_for_each_entry_rcu(fdb, head, hlist) {
462 if (ether_addr_equal(fdb->addr.addr, addr) &&
463 fdb->vlan_id == vid)
464 return fdb;
465 }
466 return NULL;
467 }
468
469 static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head,
470 struct net_bridge_port *source,
471 const unsigned char *addr,
472 __u16 vid)
473 {
474 struct net_bridge_fdb_entry *fdb;
475
476 fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
477 if (fdb) {
478 memcpy(fdb->addr.addr, addr, ETH_ALEN);
479 fdb->dst = source;
480 fdb->vlan_id = vid;
481 fdb->is_local = 0;
482 fdb->is_static = 0;
483 fdb->added_by_user = 0;
484 fdb->added_by_external_learn = 0;
485 fdb->updated = fdb->used = jiffies;
486 hlist_add_head_rcu(&fdb->hlist, head);
487 }
488 return fdb;
489 }
490
491 static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
492 const unsigned char *addr, u16 vid)
493 {
494 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
495 struct net_bridge_fdb_entry *fdb;
496
497 if (!is_valid_ether_addr(addr))
498 return -EINVAL;
499
500 fdb = fdb_find(head, addr, vid);
501 if (fdb) {
502 /* it is okay to have multiple ports with same
503 * address, just use the first one.
504 */
505 if (fdb->is_local)
506 return 0;
507 br_warn(br, "adding interface %s with same address "
508 "as a received packet\n",
509 source ? source->dev->name : br->dev->name);
510 fdb_delete(br, fdb);
511 }
512
513 fdb = fdb_create(head, source, addr, vid);
514 if (!fdb)
515 return -ENOMEM;
516
517 fdb->is_local = fdb->is_static = 1;
518 fdb_add_hw_addr(br, addr);
519 fdb_notify(br, fdb, RTM_NEWNEIGH);
520 return 0;
521 }
522
523 /* Add entry for local address of interface */
524 int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
525 const unsigned char *addr, u16 vid)
526 {
527 int ret;
528
529 spin_lock_bh(&br->hash_lock);
530 ret = fdb_insert(br, source, addr, vid);
531 spin_unlock_bh(&br->hash_lock);
532 return ret;
533 }
534
535 void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
536 const unsigned char *addr, u16 vid, bool added_by_user)
537 {
538 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
539 struct net_bridge_fdb_entry *fdb;
540 bool fdb_modified = false;
541
542 /* some users want to always flood. */
543 if (hold_time(br) == 0)
544 return;
545
546 /* ignore packets unless we are using this port */
547 if (!(source->state == BR_STATE_LEARNING ||
548 source->state == BR_STATE_FORWARDING))
549 return;
550
551 fdb = fdb_find_rcu(head, addr, vid);
552 if (likely(fdb)) {
553 /* attempt to update an entry for a local interface */
554 if (unlikely(fdb->is_local)) {
555 if (net_ratelimit())
556 br_warn(br, "received packet on %s with "
557 "own address as source address\n",
558 source->dev->name);
559 } else {
560 /* fastpath: update of existing entry */
561 if (unlikely(source != fdb->dst)) {
562 fdb->dst = source;
563 fdb_modified = true;
564 }
565 fdb->updated = jiffies;
566 if (unlikely(added_by_user))
567 fdb->added_by_user = 1;
568 if (unlikely(fdb_modified))
569 fdb_notify(br, fdb, RTM_NEWNEIGH);
570 }
571 } else {
572 spin_lock(&br->hash_lock);
573 if (likely(!fdb_find(head, addr, vid))) {
574 fdb = fdb_create(head, source, addr, vid);
575 if (fdb) {
576 if (unlikely(added_by_user))
577 fdb->added_by_user = 1;
578 fdb_notify(br, fdb, RTM_NEWNEIGH);
579 }
580 }
581 /* else we lose race and someone else inserts
582 * it first, don't bother updating
583 */
584 spin_unlock(&br->hash_lock);
585 }
586 }
587
588 static int fdb_to_nud(const struct net_bridge_fdb_entry *fdb)
589 {
590 if (fdb->is_local)
591 return NUD_PERMANENT;
592 else if (fdb->is_static)
593 return NUD_NOARP;
594 else if (has_expired(fdb->dst->br, fdb))
595 return NUD_STALE;
596 else
597 return NUD_REACHABLE;
598 }
599
600 static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
601 const struct net_bridge_fdb_entry *fdb,
602 u32 portid, u32 seq, int type, unsigned int flags)
603 {
604 unsigned long now = jiffies;
605 struct nda_cacheinfo ci;
606 struct nlmsghdr *nlh;
607 struct ndmsg *ndm;
608
609 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
610 if (nlh == NULL)
611 return -EMSGSIZE;
612
613 ndm = nlmsg_data(nlh);
614 ndm->ndm_family = AF_BRIDGE;
615 ndm->ndm_pad1 = 0;
616 ndm->ndm_pad2 = 0;
617 ndm->ndm_flags = fdb->added_by_external_learn ? NTF_EXT_LEARNED : 0;
618 ndm->ndm_type = 0;
619 ndm->ndm_ifindex = fdb->dst ? fdb->dst->dev->ifindex : br->dev->ifindex;
620 ndm->ndm_state = fdb_to_nud(fdb);
621
622 if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->addr))
623 goto nla_put_failure;
624 if (nla_put_u32(skb, NDA_MASTER, br->dev->ifindex))
625 goto nla_put_failure;
626 ci.ndm_used = jiffies_to_clock_t(now - fdb->used);
627 ci.ndm_confirmed = 0;
628 ci.ndm_updated = jiffies_to_clock_t(now - fdb->updated);
629 ci.ndm_refcnt = 0;
630 if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
631 goto nla_put_failure;
632
633 if (fdb->vlan_id && nla_put(skb, NDA_VLAN, sizeof(u16), &fdb->vlan_id))
634 goto nla_put_failure;
635
636 nlmsg_end(skb, nlh);
637 return 0;
638
639 nla_put_failure:
640 nlmsg_cancel(skb, nlh);
641 return -EMSGSIZE;
642 }
643
644 static inline size_t fdb_nlmsg_size(void)
645 {
646 return NLMSG_ALIGN(sizeof(struct ndmsg))
647 + nla_total_size(ETH_ALEN) /* NDA_LLADDR */
648 + nla_total_size(sizeof(u32)) /* NDA_MASTER */
649 + nla_total_size(sizeof(u16)) /* NDA_VLAN */
650 + nla_total_size(sizeof(struct nda_cacheinfo));
651 }
652
653 static void fdb_notify(struct net_bridge *br,
654 const struct net_bridge_fdb_entry *fdb, int type)
655 {
656 struct net *net = dev_net(br->dev);
657 struct sk_buff *skb;
658 int err = -ENOBUFS;
659
660 skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
661 if (skb == NULL)
662 goto errout;
663
664 err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
665 if (err < 0) {
666 /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */
667 WARN_ON(err == -EMSGSIZE);
668 kfree_skb(skb);
669 goto errout;
670 }
671 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
672 return;
673 errout:
674 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
675 }
676
677 /* Dump information about entries, in response to GETNEIGH */
678 int br_fdb_dump(struct sk_buff *skb,
679 struct netlink_callback *cb,
680 struct net_device *dev,
681 struct net_device *filter_dev,
682 int idx)
683 {
684 struct net_bridge *br = netdev_priv(dev);
685 int i;
686
687 if (!(dev->priv_flags & IFF_EBRIDGE))
688 goto out;
689
690 if (!filter_dev)
691 idx = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx);
692
693 for (i = 0; i < BR_HASH_SIZE; i++) {
694 struct net_bridge_fdb_entry *f;
695
696 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
697 if (idx < cb->args[0])
698 goto skip;
699
700 if (filter_dev &&
701 (!f->dst || f->dst->dev != filter_dev)) {
702 if (filter_dev != dev)
703 goto skip;
704 /* !f->dst is a special case for bridge
705 * It means the MAC belongs to the bridge
706 * Therefore need a little more filtering
707 * we only want to dump the !f->dst case
708 */
709 if (f->dst)
710 goto skip;
711 }
712 if (!filter_dev && f->dst)
713 goto skip;
714
715 if (fdb_fill_info(skb, br, f,
716 NETLINK_CB(cb->skb).portid,
717 cb->nlh->nlmsg_seq,
718 RTM_NEWNEIGH,
719 NLM_F_MULTI) < 0)
720 break;
721 skip:
722 ++idx;
723 }
724 }
725
726 out:
727 return idx;
728 }
729
730 /* Update (create or replace) forwarding database entry */
731 static int fdb_add_entry(struct net_bridge_port *source, const __u8 *addr,
732 __u16 state, __u16 flags, __u16 vid)
733 {
734 struct net_bridge *br = source->br;
735 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
736 struct net_bridge_fdb_entry *fdb;
737 bool modified = false;
738
739 fdb = fdb_find(head, addr, vid);
740 if (fdb == NULL) {
741 if (!(flags & NLM_F_CREATE))
742 return -ENOENT;
743
744 fdb = fdb_create(head, source, addr, vid);
745 if (!fdb)
746 return -ENOMEM;
747
748 modified = true;
749 } else {
750 if (flags & NLM_F_EXCL)
751 return -EEXIST;
752
753 if (fdb->dst != source) {
754 fdb->dst = source;
755 modified = true;
756 }
757 }
758
759 if (fdb_to_nud(fdb) != state) {
760 if (state & NUD_PERMANENT) {
761 fdb->is_local = 1;
762 if (!fdb->is_static) {
763 fdb->is_static = 1;
764 fdb_add_hw_addr(br, addr);
765 }
766 } else if (state & NUD_NOARP) {
767 fdb->is_local = 0;
768 if (!fdb->is_static) {
769 fdb->is_static = 1;
770 fdb_add_hw_addr(br, addr);
771 }
772 } else {
773 fdb->is_local = 0;
774 if (fdb->is_static) {
775 fdb->is_static = 0;
776 fdb_del_hw_addr(br, addr);
777 }
778 }
779
780 modified = true;
781 }
782 fdb->added_by_user = 1;
783
784 fdb->used = jiffies;
785 if (modified) {
786 fdb->updated = jiffies;
787 fdb_notify(br, fdb, RTM_NEWNEIGH);
788 }
789
790 return 0;
791 }
792
793 static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge_port *p,
794 const unsigned char *addr, u16 nlh_flags, u16 vid)
795 {
796 int err = 0;
797
798 if (ndm->ndm_flags & NTF_USE) {
799 rcu_read_lock();
800 br_fdb_update(p->br, p, addr, vid, true);
801 rcu_read_unlock();
802 } else {
803 spin_lock_bh(&p->br->hash_lock);
804 err = fdb_add_entry(p, addr, ndm->ndm_state,
805 nlh_flags, vid);
806 spin_unlock_bh(&p->br->hash_lock);
807 }
808
809 return err;
810 }
811
812 /* Add new permanent fdb entry with RTM_NEWNEIGH */
813 int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
814 struct net_device *dev,
815 const unsigned char *addr, u16 vid, u16 nlh_flags)
816 {
817 struct net_bridge_port *p;
818 int err = 0;
819 struct net_port_vlans *pv;
820
821 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
822 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
823 return -EINVAL;
824 }
825
826 if (is_zero_ether_addr(addr)) {
827 pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
828 return -EINVAL;
829 }
830
831 p = br_port_get_rtnl(dev);
832 if (p == NULL) {
833 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
834 dev->name);
835 return -EINVAL;
836 }
837
838 pv = nbp_get_vlan_info(p);
839 if (vid) {
840 if (!pv || !test_bit(vid, pv->vlan_bitmap)) {
841 pr_info("bridge: RTM_NEWNEIGH with unconfigured "
842 "vlan %d on port %s\n", vid, dev->name);
843 return -EINVAL;
844 }
845
846 /* VID was specified, so use it. */
847 err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
848 } else {
849 err = __br_fdb_add(ndm, p, addr, nlh_flags, 0);
850 if (err || !pv)
851 goto out;
852
853 /* We have vlans configured on this port and user didn't
854 * specify a VLAN. To be nice, add/update entry for every
855 * vlan on this port.
856 */
857 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
858 err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
859 if (err)
860 goto out;
861 }
862 }
863
864 out:
865 return err;
866 }
867
868 static int fdb_delete_by_addr(struct net_bridge *br, const u8 *addr, u16 vlan)
869 {
870 struct hlist_head *head = &br->hash[br_mac_hash(addr, vlan)];
871 struct net_bridge_fdb_entry *fdb;
872
873 fdb = fdb_find(head, addr, vlan);
874 if (!fdb)
875 return -ENOENT;
876
877 fdb_delete(br, fdb);
878 return 0;
879 }
880
881 static int __br_fdb_delete(struct net_bridge_port *p,
882 const unsigned char *addr, u16 vid)
883 {
884 int err;
885
886 spin_lock_bh(&p->br->hash_lock);
887 err = fdb_delete_by_addr(p->br, addr, vid);
888 spin_unlock_bh(&p->br->hash_lock);
889
890 return err;
891 }
892
893 /* Remove neighbor entry with RTM_DELNEIGH */
894 int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
895 struct net_device *dev,
896 const unsigned char *addr, u16 vid)
897 {
898 struct net_bridge_port *p;
899 int err;
900 struct net_port_vlans *pv;
901
902 p = br_port_get_rtnl(dev);
903 if (p == NULL) {
904 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
905 dev->name);
906 return -EINVAL;
907 }
908
909 pv = nbp_get_vlan_info(p);
910 if (vid) {
911 if (!pv || !test_bit(vid, pv->vlan_bitmap)) {
912 pr_info("bridge: RTM_DELNEIGH with unconfigured "
913 "vlan %d on port %s\n", vid, dev->name);
914 return -EINVAL;
915 }
916
917 err = __br_fdb_delete(p, addr, vid);
918 } else {
919 err = -ENOENT;
920 err &= __br_fdb_delete(p, addr, 0);
921 if (!pv)
922 goto out;
923
924 /* We have vlans configured on this port and user didn't
925 * specify a VLAN. To be nice, add/update entry for every
926 * vlan on this port.
927 */
928 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
929 err &= __br_fdb_delete(p, addr, vid);
930 }
931 }
932 out:
933 return err;
934 }
935
936 int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p)
937 {
938 struct net_bridge_fdb_entry *fdb, *tmp;
939 int i;
940 int err;
941
942 ASSERT_RTNL();
943
944 for (i = 0; i < BR_HASH_SIZE; i++) {
945 hlist_for_each_entry(fdb, &br->hash[i], hlist) {
946 /* We only care for static entries */
947 if (!fdb->is_static)
948 continue;
949
950 err = dev_uc_add(p->dev, fdb->addr.addr);
951 if (err)
952 goto rollback;
953 }
954 }
955 return 0;
956
957 rollback:
958 for (i = 0; i < BR_HASH_SIZE; i++) {
959 hlist_for_each_entry(tmp, &br->hash[i], hlist) {
960 /* If we reached the fdb that failed, we can stop */
961 if (tmp == fdb)
962 break;
963
964 /* We only care for static entries */
965 if (!tmp->is_static)
966 continue;
967
968 dev_uc_del(p->dev, tmp->addr.addr);
969 }
970 }
971 return err;
972 }
973
974 void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p)
975 {
976 struct net_bridge_fdb_entry *fdb;
977 int i;
978
979 ASSERT_RTNL();
980
981 for (i = 0; i < BR_HASH_SIZE; i++) {
982 hlist_for_each_entry_rcu(fdb, &br->hash[i], hlist) {
983 /* We only care for static entries */
984 if (!fdb->is_static)
985 continue;
986
987 dev_uc_del(p->dev, fdb->addr.addr);
988 }
989 }
990 }
991
992 int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p,
993 const unsigned char *addr, u16 vid)
994 {
995 struct hlist_head *head;
996 struct net_bridge_fdb_entry *fdb;
997 int err = 0;
998
999 ASSERT_RTNL();
1000 spin_lock_bh(&br->hash_lock);
1001
1002 head = &br->hash[br_mac_hash(addr, vid)];
1003 fdb = fdb_find(head, addr, vid);
1004 if (!fdb) {
1005 fdb = fdb_create(head, p, addr, vid);
1006 if (!fdb) {
1007 err = -ENOMEM;
1008 goto err_unlock;
1009 }
1010 fdb->added_by_external_learn = 1;
1011 fdb_notify(br, fdb, RTM_NEWNEIGH);
1012 } else if (fdb->added_by_external_learn) {
1013 /* Refresh entry */
1014 fdb->updated = fdb->used = jiffies;
1015 } else if (!fdb->added_by_user) {
1016 /* Take over SW learned entry */
1017 fdb->added_by_external_learn = 1;
1018 fdb->updated = jiffies;
1019 fdb_notify(br, fdb, RTM_NEWNEIGH);
1020 }
1021
1022 err_unlock:
1023 spin_unlock_bh(&br->hash_lock);
1024
1025 return err;
1026 }
1027
1028 int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
1029 const unsigned char *addr, u16 vid)
1030 {
1031 struct hlist_head *head;
1032 struct net_bridge_fdb_entry *fdb;
1033 int err = 0;
1034
1035 ASSERT_RTNL();
1036 spin_lock_bh(&br->hash_lock);
1037
1038 head = &br->hash[br_mac_hash(addr, vid)];
1039 fdb = fdb_find(head, addr, vid);
1040 if (fdb && fdb->added_by_external_learn)
1041 fdb_delete(br, fdb);
1042 else
1043 err = -ENOENT;
1044
1045 spin_unlock_bh(&br->hash_lock);
1046
1047 return err;
1048 }
Linux kernel - Deliverables
This page took 0.054756 seconds and 5 git commands to generate.