Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[linux-3.10.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 int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
31                       const unsigned char *addr, u16 vid);
32 static void fdb_notify(struct net_bridge *br,
33                        const struct net_bridge_fdb_entry *, int);
34
35 static u32 fdb_salt __read_mostly;
36
37 int __init br_fdb_init(void)
38 {
39         br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
40                                          sizeof(struct net_bridge_fdb_entry),
41                                          0,
42                                          SLAB_HWCACHE_ALIGN, NULL);
43         if (!br_fdb_cache)
44                 return -ENOMEM;
45
46         get_random_bytes(&fdb_salt, sizeof(fdb_salt));
47         return 0;
48 }
49
50 void br_fdb_fini(void)
51 {
52         kmem_cache_destroy(br_fdb_cache);
53 }
54
55
56 /* if topology_changing then use forward_delay (default 15 sec)
57  * otherwise keep longer (default 5 minutes)
58  */
59 static inline unsigned long hold_time(const struct net_bridge *br)
60 {
61         return br->topology_change ? br->forward_delay : br->ageing_time;
62 }
63
64 static inline int has_expired(const struct net_bridge *br,
65                                   const struct net_bridge_fdb_entry *fdb)
66 {
67         return !fdb->is_static &&
68                 time_before_eq(fdb->updated + hold_time(br), jiffies);
69 }
70
71 static inline int br_mac_hash(const unsigned char *mac, __u16 vid)
72 {
73         /* use 1 byte of OUI and 3 bytes of NIC */
74         u32 key = get_unaligned((u32 *)(mac + 2));
75         return jhash_2words(key, vid, fdb_salt) & (BR_HASH_SIZE - 1);
76 }
77
78 static void fdb_rcu_free(struct rcu_head *head)
79 {
80         struct net_bridge_fdb_entry *ent
81                 = container_of(head, struct net_bridge_fdb_entry, rcu);
82         kmem_cache_free(br_fdb_cache, ent);
83 }
84
85 static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f)
86 {
87         hlist_del_rcu(&f->hlist);
88         fdb_notify(br, f, RTM_DELNEIGH);
89         call_rcu(&f->rcu, fdb_rcu_free);
90 }
91
92 void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
93 {
94         struct net_bridge *br = p->br;
95         bool no_vlan = (nbp_get_vlan_info(p) == NULL) ? true : false;
96         int i;
97
98         spin_lock_bh(&br->hash_lock);
99
100         /* Search all chains since old address/hash is unknown */
101         for (i = 0; i < BR_HASH_SIZE; i++) {
102                 struct hlist_node *h;
103                 hlist_for_each(h, &br->hash[i]) {
104                         struct net_bridge_fdb_entry *f;
105
106                         f = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
107                         if (f->dst == p && f->is_local) {
108                                 /* maybe another port has same hw addr? */
109                                 struct net_bridge_port *op;
110                                 u16 vid = f->vlan_id;
111                                 list_for_each_entry(op, &br->port_list, list) {
112                                         if (op != p &&
113                                             ether_addr_equal(op->dev->dev_addr,
114                                                              f->addr.addr) &&
115                                             nbp_vlan_find(op, vid)) {
116                                                 f->dst = op;
117                                                 goto insert;
118                                         }
119                                 }
120
121                                 /* delete old one */
122                                 fdb_delete(br, f);
123 insert:
124                                 /* insert new address,  may fail if invalid
125                                  * address or dup.
126                                  */
127                                 fdb_insert(br, p, newaddr, vid);
128
129                                 /* if this port has no vlan information
130                                  * configured, we can safely be done at
131                                  * this point.
132                                  */
133                                 if (no_vlan)
134                                         goto done;
135                         }
136                 }
137         }
138
139 done:
140         spin_unlock_bh(&br->hash_lock);
141 }
142
143 void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
144 {
145         struct net_bridge_fdb_entry *f;
146         struct net_port_vlans *pv;
147         u16 vid = 0;
148
149         /* If old entry was unassociated with any port, then delete it. */
150         f = __br_fdb_get(br, br->dev->dev_addr, 0);
151         if (f && f->is_local && !f->dst)
152                 fdb_delete(br, f);
153
154         fdb_insert(br, NULL, newaddr, 0);
155
156         /* Now remove and add entries for every VLAN configured on the
157          * bridge.  This function runs under RTNL so the bitmap will not
158          * change from under us.
159          */
160         pv = br_get_vlan_info(br);
161         if (!pv)
162                 return;
163
164         for_each_set_bit_from(vid, pv->vlan_bitmap, BR_VLAN_BITMAP_LEN) {
165                 f = __br_fdb_get(br, br->dev->dev_addr, vid);
166                 if (f && f->is_local && !f->dst)
167                         fdb_delete(br, f);
168                 fdb_insert(br, NULL, newaddr, vid);
169         }
170 }
171
172 void br_fdb_cleanup(unsigned long _data)
173 {
174         struct net_bridge *br = (struct net_bridge *)_data;
175         unsigned long delay = hold_time(br);
176         unsigned long next_timer = jiffies + br->ageing_time;
177         int i;
178
179         spin_lock(&br->hash_lock);
180         for (i = 0; i < BR_HASH_SIZE; i++) {
181                 struct net_bridge_fdb_entry *f;
182                 struct hlist_node *n;
183
184                 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
185                         unsigned long this_timer;
186                         if (f->is_static)
187                                 continue;
188                         this_timer = f->updated + delay;
189                         if (time_before_eq(this_timer, jiffies))
190                                 fdb_delete(br, f);
191                         else if (time_before(this_timer, next_timer))
192                                 next_timer = this_timer;
193                 }
194         }
195         spin_unlock(&br->hash_lock);
196
197         mod_timer(&br->gc_timer, round_jiffies_up(next_timer));
198 }
199
200 /* Completely flush all dynamic entries in forwarding database.*/
201 void br_fdb_flush(struct net_bridge *br)
202 {
203         int i;
204
205         spin_lock_bh(&br->hash_lock);
206         for (i = 0; i < BR_HASH_SIZE; i++) {
207                 struct net_bridge_fdb_entry *f;
208                 struct hlist_node *n;
209                 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
210                         if (!f->is_static)
211                                 fdb_delete(br, f);
212                 }
213         }
214         spin_unlock_bh(&br->hash_lock);
215 }
216
217 /* Flush all entries referring to a specific port.
218  * if do_all is set also flush static entries
219  */
220 void br_fdb_delete_by_port(struct net_bridge *br,
221                            const struct net_bridge_port *p,
222                            int do_all)
223 {
224         int i;
225
226         spin_lock_bh(&br->hash_lock);
227         for (i = 0; i < BR_HASH_SIZE; i++) {
228                 struct hlist_node *h, *g;
229
230                 hlist_for_each_safe(h, g, &br->hash[i]) {
231                         struct net_bridge_fdb_entry *f
232                                 = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
233                         if (f->dst != p)
234                                 continue;
235
236                         if (f->is_static && !do_all)
237                                 continue;
238                         /*
239                          * if multiple ports all have the same device address
240                          * then when one port is deleted, assign
241                          * the local entry to other port
242                          */
243                         if (f->is_local) {
244                                 struct net_bridge_port *op;
245                                 list_for_each_entry(op, &br->port_list, list) {
246                                         if (op != p &&
247                                             ether_addr_equal(op->dev->dev_addr,
248                                                              f->addr.addr)) {
249                                                 f->dst = op;
250                                                 goto skip_delete;
251                                         }
252                                 }
253                         }
254
255                         fdb_delete(br, f);
256                 skip_delete: ;
257                 }
258         }
259         spin_unlock_bh(&br->hash_lock);
260 }
261
262 /* No locking or refcounting, assumes caller has rcu_read_lock */
263 struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br,
264                                           const unsigned char *addr,
265                                           __u16 vid)
266 {
267         struct net_bridge_fdb_entry *fdb;
268
269         hlist_for_each_entry_rcu(fdb,
270                                 &br->hash[br_mac_hash(addr, vid)], hlist) {
271                 if (ether_addr_equal(fdb->addr.addr, addr) &&
272                     fdb->vlan_id == vid) {
273                         if (unlikely(has_expired(br, fdb)))
274                                 break;
275                         return fdb;
276                 }
277         }
278
279         return NULL;
280 }
281
282 #if IS_ENABLED(CONFIG_ATM_LANE)
283 /* Interface used by ATM LANE hook to test
284  * if an addr is on some other bridge port */
285 int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
286 {
287         struct net_bridge_fdb_entry *fdb;
288         struct net_bridge_port *port;
289         int ret;
290
291         rcu_read_lock();
292         port = br_port_get_rcu(dev);
293         if (!port)
294                 ret = 0;
295         else {
296                 fdb = __br_fdb_get(port->br, addr, 0);
297                 ret = fdb && fdb->dst && fdb->dst->dev != dev &&
298                         fdb->dst->state == BR_STATE_FORWARDING;
299         }
300         rcu_read_unlock();
301
302         return ret;
303 }
304 #endif /* CONFIG_ATM_LANE */
305
306 /*
307  * Fill buffer with forwarding table records in
308  * the API format.
309  */
310 int br_fdb_fillbuf(struct net_bridge *br, void *buf,
311                    unsigned long maxnum, unsigned long skip)
312 {
313         struct __fdb_entry *fe = buf;
314         int i, num = 0;
315         struct net_bridge_fdb_entry *f;
316
317         memset(buf, 0, maxnum*sizeof(struct __fdb_entry));
318
319         rcu_read_lock();
320         for (i = 0; i < BR_HASH_SIZE; i++) {
321                 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
322                         if (num >= maxnum)
323                                 goto out;
324
325                         if (has_expired(br, f))
326                                 continue;
327
328                         /* ignore pseudo entry for local MAC address */
329                         if (!f->dst)
330                                 continue;
331
332                         if (skip) {
333                                 --skip;
334                                 continue;
335                         }
336
337                         /* convert from internal format to API */
338                         memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN);
339
340                         /* due to ABI compat need to split into hi/lo */
341                         fe->port_no = f->dst->port_no;
342                         fe->port_hi = f->dst->port_no >> 8;
343
344                         fe->is_local = f->is_local;
345                         if (!f->is_static)
346                                 fe->ageing_timer_value = jiffies_delta_to_clock_t(jiffies - f->updated);
347                         ++fe;
348                         ++num;
349                 }
350         }
351
352  out:
353         rcu_read_unlock();
354
355         return num;
356 }
357
358 static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
359                                              const unsigned char *addr,
360                                              __u16 vid)
361 {
362         struct net_bridge_fdb_entry *fdb;
363
364         hlist_for_each_entry(fdb, head, hlist) {
365                 if (ether_addr_equal(fdb->addr.addr, addr) &&
366                     fdb->vlan_id == vid)
367                         return fdb;
368         }
369         return NULL;
370 }
371
372 static struct net_bridge_fdb_entry *fdb_find_rcu(struct hlist_head *head,
373                                                  const unsigned char *addr,
374                                                  __u16 vid)
375 {
376         struct net_bridge_fdb_entry *fdb;
377
378         hlist_for_each_entry_rcu(fdb, head, hlist) {
379                 if (ether_addr_equal(fdb->addr.addr, addr) &&
380                     fdb->vlan_id == vid)
381                         return fdb;
382         }
383         return NULL;
384 }
385
386 static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head,
387                                                struct net_bridge_port *source,
388                                                const unsigned char *addr,
389                                                __u16 vid)
390 {
391         struct net_bridge_fdb_entry *fdb;
392
393         fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
394         if (fdb) {
395                 memcpy(fdb->addr.addr, addr, ETH_ALEN);
396                 fdb->dst = source;
397                 fdb->vlan_id = vid;
398                 fdb->is_local = 0;
399                 fdb->is_static = 0;
400                 fdb->updated = fdb->used = jiffies;
401                 hlist_add_head_rcu(&fdb->hlist, head);
402         }
403         return fdb;
404 }
405
406 static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
407                   const unsigned char *addr, u16 vid)
408 {
409         struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
410         struct net_bridge_fdb_entry *fdb;
411
412         if (!is_valid_ether_addr(addr))
413                 return -EINVAL;
414
415         fdb = fdb_find(head, addr, vid);
416         if (fdb) {
417                 /* it is okay to have multiple ports with same
418                  * address, just use the first one.
419                  */
420                 if (fdb->is_local)
421                         return 0;
422                 br_warn(br, "adding interface %s with same address "
423                        "as a received packet\n",
424                        source ? source->dev->name : br->dev->name);
425                 fdb_delete(br, fdb);
426         }
427
428         fdb = fdb_create(head, source, addr, vid);
429         if (!fdb)
430                 return -ENOMEM;
431
432         fdb->is_local = fdb->is_static = 1;
433         fdb_notify(br, fdb, RTM_NEWNEIGH);
434         return 0;
435 }
436
437 /* Add entry for local address of interface */
438 int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
439                   const unsigned char *addr, u16 vid)
440 {
441         int ret;
442
443         spin_lock_bh(&br->hash_lock);
444         ret = fdb_insert(br, source, addr, vid);
445         spin_unlock_bh(&br->hash_lock);
446         return ret;
447 }
448
449 void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
450                    const unsigned char *addr, u16 vid)
451 {
452         struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
453         struct net_bridge_fdb_entry *fdb;
454
455         /* some users want to always flood. */
456         if (hold_time(br) == 0)
457                 return;
458
459         /* ignore packets unless we are using this port */
460         if (!(source->state == BR_STATE_LEARNING ||
461               source->state == BR_STATE_FORWARDING))
462                 return;
463
464         fdb = fdb_find_rcu(head, addr, vid);
465         if (likely(fdb)) {
466                 /* attempt to update an entry for a local interface */
467                 if (unlikely(fdb->is_local)) {
468                         if (net_ratelimit())
469                                 br_warn(br, "received packet on %s with "
470                                         "own address as source address\n",
471                                         source->dev->name);
472                 } else {
473                         /* fastpath: update of existing entry */
474                         fdb->dst = source;
475                         fdb->updated = jiffies;
476                 }
477         } else {
478                 spin_lock(&br->hash_lock);
479                 if (likely(!fdb_find(head, addr, vid))) {
480                         fdb = fdb_create(head, source, addr, vid);
481                         if (fdb)
482                                 fdb_notify(br, fdb, RTM_NEWNEIGH);
483                 }
484                 /* else  we lose race and someone else inserts
485                  * it first, don't bother updating
486                  */
487                 spin_unlock(&br->hash_lock);
488         }
489 }
490
491 static int fdb_to_nud(const struct net_bridge_fdb_entry *fdb)
492 {
493         if (fdb->is_local)
494                 return NUD_PERMANENT;
495         else if (fdb->is_static)
496                 return NUD_NOARP;
497         else if (has_expired(fdb->dst->br, fdb))
498                 return NUD_STALE;
499         else
500                 return NUD_REACHABLE;
501 }
502
503 static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
504                          const struct net_bridge_fdb_entry *fdb,
505                          u32 portid, u32 seq, int type, unsigned int flags)
506 {
507         unsigned long now = jiffies;
508         struct nda_cacheinfo ci;
509         struct nlmsghdr *nlh;
510         struct ndmsg *ndm;
511
512         nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
513         if (nlh == NULL)
514                 return -EMSGSIZE;
515
516         ndm = nlmsg_data(nlh);
517         ndm->ndm_family  = AF_BRIDGE;
518         ndm->ndm_pad1    = 0;
519         ndm->ndm_pad2    = 0;
520         ndm->ndm_flags   = 0;
521         ndm->ndm_type    = 0;
522         ndm->ndm_ifindex = fdb->dst ? fdb->dst->dev->ifindex : br->dev->ifindex;
523         ndm->ndm_state   = fdb_to_nud(fdb);
524
525         if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->addr))
526                 goto nla_put_failure;
527         ci.ndm_used      = jiffies_to_clock_t(now - fdb->used);
528         ci.ndm_confirmed = 0;
529         ci.ndm_updated   = jiffies_to_clock_t(now - fdb->updated);
530         ci.ndm_refcnt    = 0;
531         if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
532                 goto nla_put_failure;
533
534         if (nla_put(skb, NDA_VLAN, sizeof(u16), &fdb->vlan_id))
535                 goto nla_put_failure;
536
537         return nlmsg_end(skb, nlh);
538
539 nla_put_failure:
540         nlmsg_cancel(skb, nlh);
541         return -EMSGSIZE;
542 }
543
544 static inline size_t fdb_nlmsg_size(void)
545 {
546         return NLMSG_ALIGN(sizeof(struct ndmsg))
547                 + nla_total_size(ETH_ALEN) /* NDA_LLADDR */
548                 + nla_total_size(sizeof(u16)) /* NDA_VLAN */
549                 + nla_total_size(sizeof(struct nda_cacheinfo));
550 }
551
552 static void fdb_notify(struct net_bridge *br,
553                        const struct net_bridge_fdb_entry *fdb, int type)
554 {
555         struct net *net = dev_net(br->dev);
556         struct sk_buff *skb;
557         int err = -ENOBUFS;
558
559         skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
560         if (skb == NULL)
561                 goto errout;
562
563         err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
564         if (err < 0) {
565                 /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */
566                 WARN_ON(err == -EMSGSIZE);
567                 kfree_skb(skb);
568                 goto errout;
569         }
570         rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
571         return;
572 errout:
573         if (err < 0)
574                 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
575 }
576
577 /* Dump information about entries, in response to GETNEIGH */
578 int br_fdb_dump(struct sk_buff *skb,
579                 struct netlink_callback *cb,
580                 struct net_device *dev,
581                 int idx)
582 {
583         struct net_bridge *br = netdev_priv(dev);
584         int i;
585
586         if (!(dev->priv_flags & IFF_EBRIDGE))
587                 goto out;
588
589         for (i = 0; i < BR_HASH_SIZE; i++) {
590                 struct net_bridge_fdb_entry *f;
591
592                 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
593                         if (idx < cb->args[0])
594                                 goto skip;
595
596                         if (fdb_fill_info(skb, br, f,
597                                           NETLINK_CB(cb->skb).portid,
598                                           cb->nlh->nlmsg_seq,
599                                           RTM_NEWNEIGH,
600                                           NLM_F_MULTI) < 0)
601                                 break;
602 skip:
603                         ++idx;
604                 }
605         }
606
607 out:
608         return idx;
609 }
610
611 /* Update (create or replace) forwarding database entry */
612 static int fdb_add_entry(struct net_bridge_port *source, const __u8 *addr,
613                          __u16 state, __u16 flags, __u16 vid)
614 {
615         struct net_bridge *br = source->br;
616         struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
617         struct net_bridge_fdb_entry *fdb;
618
619         fdb = fdb_find(head, addr, vid);
620         if (fdb == NULL) {
621                 if (!(flags & NLM_F_CREATE))
622                         return -ENOENT;
623
624                 fdb = fdb_create(head, source, addr, vid);
625                 if (!fdb)
626                         return -ENOMEM;
627                 fdb_notify(br, fdb, RTM_NEWNEIGH);
628         } else {
629                 if (flags & NLM_F_EXCL)
630                         return -EEXIST;
631         }
632
633         if (fdb_to_nud(fdb) != state) {
634                 if (state & NUD_PERMANENT)
635                         fdb->is_local = fdb->is_static = 1;
636                 else if (state & NUD_NOARP) {
637                         fdb->is_local = 0;
638                         fdb->is_static = 1;
639                 } else
640                         fdb->is_local = fdb->is_static = 0;
641
642                 fdb->updated = fdb->used = jiffies;
643                 fdb_notify(br, fdb, RTM_NEWNEIGH);
644         }
645
646         return 0;
647 }
648
649 static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge_port *p,
650                const unsigned char *addr, u16 nlh_flags, u16 vid)
651 {
652         int err = 0;
653
654         if (ndm->ndm_flags & NTF_USE) {
655                 rcu_read_lock();
656                 br_fdb_update(p->br, p, addr, vid);
657                 rcu_read_unlock();
658         } else {
659                 spin_lock_bh(&p->br->hash_lock);
660                 err = fdb_add_entry(p, addr, ndm->ndm_state,
661                                     nlh_flags, vid);
662                 spin_unlock_bh(&p->br->hash_lock);
663         }
664
665         return err;
666 }
667
668 /* Add new permanent fdb entry with RTM_NEWNEIGH */
669 int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
670                struct net_device *dev,
671                const unsigned char *addr, u16 nlh_flags)
672 {
673         struct net_bridge_port *p;
674         int err = 0;
675         struct net_port_vlans *pv;
676         unsigned short vid = VLAN_N_VID;
677
678         if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
679                 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
680                 return -EINVAL;
681         }
682
683         if (tb[NDA_VLAN]) {
684                 if (nla_len(tb[NDA_VLAN]) != sizeof(unsigned short)) {
685                         pr_info("bridge: RTM_NEWNEIGH with invalid vlan\n");
686                         return -EINVAL;
687                 }
688
689                 vid = nla_get_u16(tb[NDA_VLAN]);
690
691                 if (vid >= VLAN_N_VID) {
692                         pr_info("bridge: RTM_NEWNEIGH with invalid vlan id %d\n",
693                                 vid);
694                         return -EINVAL;
695                 }
696         }
697
698         p = br_port_get_rtnl(dev);
699         if (p == NULL) {
700                 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
701                         dev->name);
702                 return -EINVAL;
703         }
704
705         pv = nbp_get_vlan_info(p);
706         if (vid != VLAN_N_VID) {
707                 if (!pv || !test_bit(vid, pv->vlan_bitmap)) {
708                         pr_info("bridge: RTM_NEWNEIGH with unconfigured "
709                                 "vlan %d on port %s\n", vid, dev->name);
710                         return -EINVAL;
711                 }
712
713                 /* VID was specified, so use it. */
714                 err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
715         } else {
716                 if (!pv || bitmap_empty(pv->vlan_bitmap, BR_VLAN_BITMAP_LEN)) {
717                         err = __br_fdb_add(ndm, p, addr, nlh_flags, 0);
718                         goto out;
719                 }
720
721                 /* We have vlans configured on this port and user didn't
722                  * specify a VLAN.  To be nice, add/update entry for every
723                  * vlan on this port.
724                  */
725                 for_each_set_bit(vid, pv->vlan_bitmap, BR_VLAN_BITMAP_LEN) {
726                         err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
727                         if (err)
728                                 goto out;
729                 }
730         }
731
732 out:
733         return err;
734 }
735
736 int fdb_delete_by_addr(struct net_bridge *br, const u8 *addr,
737                        u16 vlan)
738 {
739         struct hlist_head *head = &br->hash[br_mac_hash(addr, vlan)];
740         struct net_bridge_fdb_entry *fdb;
741
742         fdb = fdb_find(head, addr, vlan);
743         if (!fdb)
744                 return -ENOENT;
745
746         fdb_delete(br, fdb);
747         return 0;
748 }
749
750 static int __br_fdb_delete(struct net_bridge_port *p,
751                            const unsigned char *addr, u16 vid)
752 {
753         int err;
754
755         spin_lock_bh(&p->br->hash_lock);
756         err = fdb_delete_by_addr(p->br, addr, vid);
757         spin_unlock_bh(&p->br->hash_lock);
758
759         return err;
760 }
761
762 /* Remove neighbor entry with RTM_DELNEIGH */
763 int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
764                   struct net_device *dev,
765                   const unsigned char *addr)
766 {
767         struct net_bridge_port *p;
768         int err;
769         struct net_port_vlans *pv;
770         unsigned short vid = VLAN_N_VID;
771
772         if (tb[NDA_VLAN]) {
773                 if (nla_len(tb[NDA_VLAN]) != sizeof(unsigned short)) {
774                         pr_info("bridge: RTM_NEWNEIGH with invalid vlan\n");
775                         return -EINVAL;
776                 }
777
778                 vid = nla_get_u16(tb[NDA_VLAN]);
779
780                 if (vid >= VLAN_N_VID) {
781                         pr_info("bridge: RTM_NEWNEIGH with invalid vlan id %d\n",
782                                 vid);
783                         return -EINVAL;
784                 }
785         }
786         p = br_port_get_rtnl(dev);
787         if (p == NULL) {
788                 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
789                         dev->name);
790                 return -EINVAL;
791         }
792
793         pv = nbp_get_vlan_info(p);
794         if (vid != VLAN_N_VID) {
795                 if (!pv || !test_bit(vid, pv->vlan_bitmap)) {
796                         pr_info("bridge: RTM_DELNEIGH with unconfigured "
797                                 "vlan %d on port %s\n", vid, dev->name);
798                         return -EINVAL;
799                 }
800
801                 err = __br_fdb_delete(p, addr, vid);
802         } else {
803                 if (!pv || bitmap_empty(pv->vlan_bitmap, BR_VLAN_BITMAP_LEN)) {
804                         err = __br_fdb_delete(p, addr, 0);
805                         goto out;
806                 }
807
808                 /* We have vlans configured on this port and user didn't
809                  * specify a VLAN.  To be nice, add/update entry for every
810                  * vlan on this port.
811                  */
812                 err = -ENOENT;
813                 for_each_set_bit(vid, pv->vlan_bitmap, BR_VLAN_BITMAP_LEN) {
814                         err &= __br_fdb_delete(p, addr, vid);
815                 }
816         }
817 out:
818         return err;
819 }