1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Generic address resolution entity
6 * Pedro Roque <roque@di.fc.ul.pt>
7 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
10 * Vitaly E. Lavrov releasing NULL neighbor in neigh_add.
11 * Harald Welte Add neighbour cache statistics like rtstat
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 #include <linux/slab.h>
17 #include <linux/kmemleak.h>
18 #include <linux/types.h>
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/socket.h>
22 #include <linux/netdevice.h>
23 #include <linux/proc_fs.h>
25 #include <linux/sysctl.h>
27 #include <linux/times.h>
28 #include <net/net_namespace.h>
29 #include <net/neighbour.h>
33 #include <net/netevent.h>
34 #include <net/netlink.h>
35 #include <linux/rtnetlink.h>
36 #include <linux/random.h>
37 #include <linux/string.h>
38 #include <linux/log2.h>
39 #include <linux/inetdevice.h>
40 #include <net/addrconf.h>
42 #include <trace/events/neigh.h>
45 #define neigh_dbg(level, fmt, ...) \
47 if (level <= NEIGH_DEBUG) \
48 pr_debug(fmt, ##__VA_ARGS__); \
51 #define PNEIGH_HASHMASK 0xF
53 static void neigh_timer_handler(struct timer_list *t);
54 static void __neigh_notify(struct neighbour *n, int type, int flags,
56 static void neigh_update_notify(struct neighbour *neigh, u32 nlmsg_pid);
57 static int pneigh_ifdown_and_unlock(struct neigh_table *tbl,
58 struct net_device *dev);
61 static const struct seq_operations neigh_stat_seq_ops;
65 Neighbour hash table buckets are protected with rwlock tbl->lock.
67 - All the scans/updates to hash buckets MUST be made under this lock.
68 - NOTHING clever should be made under this lock: no callbacks
69 to protocol backends, no attempts to send something to network.
70 It will result in deadlocks, if backend/driver wants to use neighbour
72 - If the entry requires some non-trivial actions, increase
73 its reference count and release table lock.
75 Neighbour entries are protected:
76 - with reference count.
77 - with rwlock neigh->lock
79 Reference count prevents destruction.
81 neigh->lock mainly serializes ll address data and its validity state.
82 However, the same lock is used to protect another entry fields:
86 Again, nothing clever shall be made under neigh->lock,
87 the most complicated procedure, which we allow is dev->hard_header.
88 It is supposed, that dev->hard_header is simplistic and does
89 not make callbacks to neighbour tables.
92 static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb)
98 static void neigh_cleanup_and_release(struct neighbour *neigh)
100 trace_neigh_cleanup_and_release(neigh, 0);
101 __neigh_notify(neigh, RTM_DELNEIGH, 0, 0);
102 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
103 neigh_release(neigh);
107 * It is random distribution in the interval (1/2)*base...(3/2)*base.
108 * It corresponds to default IPv6 settings and is not overridable,
109 * because it is really reasonable choice.
112 unsigned long neigh_rand_reach_time(unsigned long base)
114 return base ? get_random_u32_below(base) + (base >> 1) : 0;
116 EXPORT_SYMBOL(neigh_rand_reach_time);
118 static void neigh_mark_dead(struct neighbour *n)
121 if (!list_empty(&n->gc_list)) {
122 list_del_init(&n->gc_list);
123 atomic_dec(&n->tbl->gc_entries);
125 if (!list_empty(&n->managed_list))
126 list_del_init(&n->managed_list);
129 static void neigh_update_gc_list(struct neighbour *n)
131 bool on_gc_list, exempt_from_gc;
133 write_lock_bh(&n->tbl->lock);
134 write_lock(&n->lock);
138 /* remove from the gc list if new state is permanent or if neighbor
139 * is externally learned; otherwise entry should be on the gc list
141 exempt_from_gc = n->nud_state & NUD_PERMANENT ||
142 n->flags & NTF_EXT_LEARNED;
143 on_gc_list = !list_empty(&n->gc_list);
145 if (exempt_from_gc && on_gc_list) {
146 list_del_init(&n->gc_list);
147 atomic_dec(&n->tbl->gc_entries);
148 } else if (!exempt_from_gc && !on_gc_list) {
149 /* add entries to the tail; cleaning removes from the front */
150 list_add_tail(&n->gc_list, &n->tbl->gc_list);
151 atomic_inc(&n->tbl->gc_entries);
154 write_unlock(&n->lock);
155 write_unlock_bh(&n->tbl->lock);
158 static void neigh_update_managed_list(struct neighbour *n)
160 bool on_managed_list, add_to_managed;
162 write_lock_bh(&n->tbl->lock);
163 write_lock(&n->lock);
167 add_to_managed = n->flags & NTF_MANAGED;
168 on_managed_list = !list_empty(&n->managed_list);
170 if (!add_to_managed && on_managed_list)
171 list_del_init(&n->managed_list);
172 else if (add_to_managed && !on_managed_list)
173 list_add_tail(&n->managed_list, &n->tbl->managed_list);
175 write_unlock(&n->lock);
176 write_unlock_bh(&n->tbl->lock);
179 static void neigh_update_flags(struct neighbour *neigh, u32 flags, int *notify,
180 bool *gc_update, bool *managed_update)
182 u32 ndm_flags, old_flags = neigh->flags;
184 if (!(flags & NEIGH_UPDATE_F_ADMIN))
187 ndm_flags = (flags & NEIGH_UPDATE_F_EXT_LEARNED) ? NTF_EXT_LEARNED : 0;
188 ndm_flags |= (flags & NEIGH_UPDATE_F_MANAGED) ? NTF_MANAGED : 0;
190 if ((old_flags ^ ndm_flags) & NTF_EXT_LEARNED) {
191 if (ndm_flags & NTF_EXT_LEARNED)
192 neigh->flags |= NTF_EXT_LEARNED;
194 neigh->flags &= ~NTF_EXT_LEARNED;
198 if ((old_flags ^ ndm_flags) & NTF_MANAGED) {
199 if (ndm_flags & NTF_MANAGED)
200 neigh->flags |= NTF_MANAGED;
202 neigh->flags &= ~NTF_MANAGED;
204 *managed_update = true;
208 static bool neigh_del(struct neighbour *n, struct neighbour __rcu **np,
209 struct neigh_table *tbl)
213 write_lock(&n->lock);
214 if (refcount_read(&n->refcnt) == 1) {
215 struct neighbour *neigh;
217 neigh = rcu_dereference_protected(n->next,
218 lockdep_is_held(&tbl->lock));
219 rcu_assign_pointer(*np, neigh);
223 write_unlock(&n->lock);
225 neigh_cleanup_and_release(n);
229 bool neigh_remove_one(struct neighbour *ndel, struct neigh_table *tbl)
231 struct neigh_hash_table *nht;
232 void *pkey = ndel->primary_key;
235 struct neighbour __rcu **np;
237 nht = rcu_dereference_protected(tbl->nht,
238 lockdep_is_held(&tbl->lock));
239 hash_val = tbl->hash(pkey, ndel->dev, nht->hash_rnd);
240 hash_val = hash_val >> (32 - nht->hash_shift);
242 np = &nht->hash_buckets[hash_val];
243 while ((n = rcu_dereference_protected(*np,
244 lockdep_is_held(&tbl->lock)))) {
246 return neigh_del(n, np, tbl);
252 static int neigh_forced_gc(struct neigh_table *tbl)
254 int max_clean = atomic_read(&tbl->gc_entries) - tbl->gc_thresh2;
255 unsigned long tref = jiffies - 5 * HZ;
256 struct neighbour *n, *tmp;
259 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
261 write_lock_bh(&tbl->lock);
263 list_for_each_entry_safe(n, tmp, &tbl->gc_list, gc_list) {
264 if (refcount_read(&n->refcnt) == 1) {
267 write_lock(&n->lock);
268 if ((n->nud_state == NUD_FAILED) ||
269 (n->nud_state == NUD_NOARP) ||
270 (tbl->is_multicast &&
271 tbl->is_multicast(n->primary_key)) ||
272 !time_in_range(n->updated, tref, jiffies))
274 write_unlock(&n->lock);
276 if (remove && neigh_remove_one(n, tbl))
278 if (shrunk >= max_clean)
283 tbl->last_flush = jiffies;
285 write_unlock_bh(&tbl->lock);
290 static void neigh_add_timer(struct neighbour *n, unsigned long when)
292 /* Use safe distance from the jiffies - LONG_MAX point while timer
293 * is running in DELAY/PROBE state but still show to user space
294 * large times in the past.
296 unsigned long mint = jiffies - (LONG_MAX - 86400 * HZ);
299 if (!time_in_range(n->confirmed, mint, jiffies))
301 if (time_before(n->used, n->confirmed))
302 n->used = n->confirmed;
303 if (unlikely(mod_timer(&n->timer, when))) {
304 printk("NEIGH: BUG, double timer add, state is %x\n",
310 static int neigh_del_timer(struct neighbour *n)
312 if ((n->nud_state & NUD_IN_TIMER) &&
313 del_timer(&n->timer)) {
320 static struct neigh_parms *neigh_get_dev_parms_rcu(struct net_device *dev,
325 return __in_dev_arp_parms_get_rcu(dev);
327 return __in6_dev_nd_parms_get_rcu(dev);
332 static void neigh_parms_qlen_dec(struct net_device *dev, int family)
334 struct neigh_parms *p;
337 p = neigh_get_dev_parms_rcu(dev, family);
343 static void pneigh_queue_purge(struct sk_buff_head *list, struct net *net,
346 struct sk_buff_head tmp;
350 skb_queue_head_init(&tmp);
351 spin_lock_irqsave(&list->lock, flags);
352 skb = skb_peek(list);
353 while (skb != NULL) {
354 struct sk_buff *skb_next = skb_peek_next(skb, list);
355 struct net_device *dev = skb->dev;
357 if (net == NULL || net_eq(dev_net(dev), net)) {
358 neigh_parms_qlen_dec(dev, family);
359 __skb_unlink(skb, list);
360 __skb_queue_tail(&tmp, skb);
364 spin_unlock_irqrestore(&list->lock, flags);
366 while ((skb = __skb_dequeue(&tmp))) {
372 static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev,
376 struct neigh_hash_table *nht;
378 nht = rcu_dereference_protected(tbl->nht,
379 lockdep_is_held(&tbl->lock));
381 for (i = 0; i < (1 << nht->hash_shift); i++) {
383 struct neighbour __rcu **np = &nht->hash_buckets[i];
385 while ((n = rcu_dereference_protected(*np,
386 lockdep_is_held(&tbl->lock))) != NULL) {
387 if (dev && n->dev != dev) {
391 if (skip_perm && n->nud_state & NUD_PERMANENT) {
395 rcu_assign_pointer(*np,
396 rcu_dereference_protected(n->next,
397 lockdep_is_held(&tbl->lock)));
398 write_lock(&n->lock);
401 if (refcount_read(&n->refcnt) != 1) {
402 /* The most unpleasant situation.
403 We must destroy neighbour entry,
404 but someone still uses it.
406 The destroy will be delayed until
407 the last user releases us, but
408 we must kill timers etc. and move
411 __skb_queue_purge(&n->arp_queue);
412 n->arp_queue_len_bytes = 0;
413 n->output = neigh_blackhole;
414 if (n->nud_state & NUD_VALID)
415 n->nud_state = NUD_NOARP;
417 n->nud_state = NUD_NONE;
418 neigh_dbg(2, "neigh %p is stray\n", n);
420 write_unlock(&n->lock);
421 neigh_cleanup_and_release(n);
426 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
428 write_lock_bh(&tbl->lock);
429 neigh_flush_dev(tbl, dev, false);
430 write_unlock_bh(&tbl->lock);
432 EXPORT_SYMBOL(neigh_changeaddr);
434 static int __neigh_ifdown(struct neigh_table *tbl, struct net_device *dev,
437 write_lock_bh(&tbl->lock);
438 neigh_flush_dev(tbl, dev, skip_perm);
439 pneigh_ifdown_and_unlock(tbl, dev);
440 pneigh_queue_purge(&tbl->proxy_queue, dev ? dev_net(dev) : NULL,
442 if (skb_queue_empty_lockless(&tbl->proxy_queue))
443 del_timer_sync(&tbl->proxy_timer);
447 int neigh_carrier_down(struct neigh_table *tbl, struct net_device *dev)
449 __neigh_ifdown(tbl, dev, true);
452 EXPORT_SYMBOL(neigh_carrier_down);
454 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
456 __neigh_ifdown(tbl, dev, false);
459 EXPORT_SYMBOL(neigh_ifdown);
461 static struct neighbour *neigh_alloc(struct neigh_table *tbl,
462 struct net_device *dev,
463 u32 flags, bool exempt_from_gc)
465 struct neighbour *n = NULL;
466 unsigned long now = jiffies;
472 entries = atomic_inc_return(&tbl->gc_entries) - 1;
473 if (entries >= tbl->gc_thresh3 ||
474 (entries >= tbl->gc_thresh2 &&
475 time_after(now, tbl->last_flush + 5 * HZ))) {
476 if (!neigh_forced_gc(tbl) &&
477 entries >= tbl->gc_thresh3) {
478 net_info_ratelimited("%s: neighbor table overflow!\n",
480 NEIGH_CACHE_STAT_INC(tbl, table_fulls);
486 n = kzalloc(tbl->entry_size + dev->neigh_priv_len, GFP_ATOMIC);
490 __skb_queue_head_init(&n->arp_queue);
491 rwlock_init(&n->lock);
492 seqlock_init(&n->ha_lock);
493 n->updated = n->used = now;
494 n->nud_state = NUD_NONE;
495 n->output = neigh_blackhole;
497 seqlock_init(&n->hh.hh_lock);
498 n->parms = neigh_parms_clone(&tbl->parms);
499 timer_setup(&n->timer, neigh_timer_handler, 0);
501 NEIGH_CACHE_STAT_INC(tbl, allocs);
503 refcount_set(&n->refcnt, 1);
505 INIT_LIST_HEAD(&n->gc_list);
506 INIT_LIST_HEAD(&n->managed_list);
508 atomic_inc(&tbl->entries);
514 atomic_dec(&tbl->gc_entries);
518 static void neigh_get_hash_rnd(u32 *x)
520 *x = get_random_u32() | 1;
523 static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift)
525 size_t size = (1 << shift) * sizeof(struct neighbour *);
526 struct neigh_hash_table *ret;
527 struct neighbour __rcu **buckets;
530 ret = kmalloc(sizeof(*ret), GFP_ATOMIC);
533 if (size <= PAGE_SIZE) {
534 buckets = kzalloc(size, GFP_ATOMIC);
536 buckets = (struct neighbour __rcu **)
537 __get_free_pages(GFP_ATOMIC | __GFP_ZERO,
539 kmemleak_alloc(buckets, size, 1, GFP_ATOMIC);
545 ret->hash_buckets = buckets;
546 ret->hash_shift = shift;
547 for (i = 0; i < NEIGH_NUM_HASH_RND; i++)
548 neigh_get_hash_rnd(&ret->hash_rnd[i]);
552 static void neigh_hash_free_rcu(struct rcu_head *head)
554 struct neigh_hash_table *nht = container_of(head,
555 struct neigh_hash_table,
557 size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *);
558 struct neighbour __rcu **buckets = nht->hash_buckets;
560 if (size <= PAGE_SIZE) {
563 kmemleak_free(buckets);
564 free_pages((unsigned long)buckets, get_order(size));
569 static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl,
570 unsigned long new_shift)
572 unsigned int i, hash;
573 struct neigh_hash_table *new_nht, *old_nht;
575 NEIGH_CACHE_STAT_INC(tbl, hash_grows);
577 old_nht = rcu_dereference_protected(tbl->nht,
578 lockdep_is_held(&tbl->lock));
579 new_nht = neigh_hash_alloc(new_shift);
583 for (i = 0; i < (1 << old_nht->hash_shift); i++) {
584 struct neighbour *n, *next;
586 for (n = rcu_dereference_protected(old_nht->hash_buckets[i],
587 lockdep_is_held(&tbl->lock));
590 hash = tbl->hash(n->primary_key, n->dev,
593 hash >>= (32 - new_nht->hash_shift);
594 next = rcu_dereference_protected(n->next,
595 lockdep_is_held(&tbl->lock));
597 rcu_assign_pointer(n->next,
598 rcu_dereference_protected(
599 new_nht->hash_buckets[hash],
600 lockdep_is_held(&tbl->lock)));
601 rcu_assign_pointer(new_nht->hash_buckets[hash], n);
605 rcu_assign_pointer(tbl->nht, new_nht);
606 call_rcu(&old_nht->rcu, neigh_hash_free_rcu);
610 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
611 struct net_device *dev)
615 NEIGH_CACHE_STAT_INC(tbl, lookups);
618 n = __neigh_lookup_noref(tbl, pkey, dev);
620 if (!refcount_inc_not_zero(&n->refcnt))
622 NEIGH_CACHE_STAT_INC(tbl, hits);
625 rcu_read_unlock_bh();
628 EXPORT_SYMBOL(neigh_lookup);
630 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
634 unsigned int key_len = tbl->key_len;
636 struct neigh_hash_table *nht;
638 NEIGH_CACHE_STAT_INC(tbl, lookups);
641 nht = rcu_dereference_bh(tbl->nht);
642 hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift);
644 for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
646 n = rcu_dereference_bh(n->next)) {
647 if (!memcmp(n->primary_key, pkey, key_len) &&
648 net_eq(dev_net(n->dev), net)) {
649 if (!refcount_inc_not_zero(&n->refcnt))
651 NEIGH_CACHE_STAT_INC(tbl, hits);
656 rcu_read_unlock_bh();
659 EXPORT_SYMBOL(neigh_lookup_nodev);
661 static struct neighbour *
662 ___neigh_create(struct neigh_table *tbl, const void *pkey,
663 struct net_device *dev, u32 flags,
664 bool exempt_from_gc, bool want_ref)
666 u32 hash_val, key_len = tbl->key_len;
667 struct neighbour *n1, *rc, *n;
668 struct neigh_hash_table *nht;
671 n = neigh_alloc(tbl, dev, flags, exempt_from_gc);
672 trace_neigh_create(tbl, dev, pkey, n, exempt_from_gc);
674 rc = ERR_PTR(-ENOBUFS);
678 memcpy(n->primary_key, pkey, key_len);
680 netdev_hold(dev, &n->dev_tracker, GFP_ATOMIC);
682 /* Protocol specific setup. */
683 if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
685 goto out_neigh_release;
688 if (dev->netdev_ops->ndo_neigh_construct) {
689 error = dev->netdev_ops->ndo_neigh_construct(dev, n);
692 goto out_neigh_release;
696 /* Device specific setup. */
697 if (n->parms->neigh_setup &&
698 (error = n->parms->neigh_setup(n)) < 0) {
700 goto out_neigh_release;
703 n->confirmed = jiffies - (NEIGH_VAR(n->parms, BASE_REACHABLE_TIME) << 1);
705 write_lock_bh(&tbl->lock);
706 nht = rcu_dereference_protected(tbl->nht,
707 lockdep_is_held(&tbl->lock));
709 if (atomic_read(&tbl->entries) > (1 << nht->hash_shift))
710 nht = neigh_hash_grow(tbl, nht->hash_shift + 1);
712 hash_val = tbl->hash(n->primary_key, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
714 if (n->parms->dead) {
715 rc = ERR_PTR(-EINVAL);
719 for (n1 = rcu_dereference_protected(nht->hash_buckets[hash_val],
720 lockdep_is_held(&tbl->lock));
722 n1 = rcu_dereference_protected(n1->next,
723 lockdep_is_held(&tbl->lock))) {
724 if (dev == n1->dev && !memcmp(n1->primary_key, n->primary_key, key_len)) {
734 list_add_tail(&n->gc_list, &n->tbl->gc_list);
735 if (n->flags & NTF_MANAGED)
736 list_add_tail(&n->managed_list, &n->tbl->managed_list);
739 rcu_assign_pointer(n->next,
740 rcu_dereference_protected(nht->hash_buckets[hash_val],
741 lockdep_is_held(&tbl->lock)));
742 rcu_assign_pointer(nht->hash_buckets[hash_val], n);
743 write_unlock_bh(&tbl->lock);
744 neigh_dbg(2, "neigh %p is created\n", n);
749 write_unlock_bh(&tbl->lock);
752 atomic_dec(&tbl->gc_entries);
757 struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey,
758 struct net_device *dev, bool want_ref)
760 return ___neigh_create(tbl, pkey, dev, 0, false, want_ref);
762 EXPORT_SYMBOL(__neigh_create);
764 static u32 pneigh_hash(const void *pkey, unsigned int key_len)
766 u32 hash_val = *(u32 *)(pkey + key_len - 4);
767 hash_val ^= (hash_val >> 16);
768 hash_val ^= hash_val >> 8;
769 hash_val ^= hash_val >> 4;
770 hash_val &= PNEIGH_HASHMASK;
774 static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n,
777 unsigned int key_len,
778 struct net_device *dev)
781 if (!memcmp(n->key, pkey, key_len) &&
782 net_eq(pneigh_net(n), net) &&
783 (n->dev == dev || !n->dev))
790 struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl,
791 struct net *net, const void *pkey, struct net_device *dev)
793 unsigned int key_len = tbl->key_len;
794 u32 hash_val = pneigh_hash(pkey, key_len);
796 return __pneigh_lookup_1(tbl->phash_buckets[hash_val],
797 net, pkey, key_len, dev);
799 EXPORT_SYMBOL_GPL(__pneigh_lookup);
801 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl,
802 struct net *net, const void *pkey,
803 struct net_device *dev, int creat)
805 struct pneigh_entry *n;
806 unsigned int key_len = tbl->key_len;
807 u32 hash_val = pneigh_hash(pkey, key_len);
809 read_lock_bh(&tbl->lock);
810 n = __pneigh_lookup_1(tbl->phash_buckets[hash_val],
811 net, pkey, key_len, dev);
812 read_unlock_bh(&tbl->lock);
819 n = kzalloc(sizeof(*n) + key_len, GFP_KERNEL);
823 write_pnet(&n->net, net);
824 memcpy(n->key, pkey, key_len);
826 netdev_hold(dev, &n->dev_tracker, GFP_KERNEL);
828 if (tbl->pconstructor && tbl->pconstructor(n)) {
829 netdev_put(dev, &n->dev_tracker);
835 write_lock_bh(&tbl->lock);
836 n->next = tbl->phash_buckets[hash_val];
837 tbl->phash_buckets[hash_val] = n;
838 write_unlock_bh(&tbl->lock);
842 EXPORT_SYMBOL(pneigh_lookup);
845 int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey,
846 struct net_device *dev)
848 struct pneigh_entry *n, **np;
849 unsigned int key_len = tbl->key_len;
850 u32 hash_val = pneigh_hash(pkey, key_len);
852 write_lock_bh(&tbl->lock);
853 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
855 if (!memcmp(n->key, pkey, key_len) && n->dev == dev &&
856 net_eq(pneigh_net(n), net)) {
858 write_unlock_bh(&tbl->lock);
859 if (tbl->pdestructor)
861 netdev_put(n->dev, &n->dev_tracker);
866 write_unlock_bh(&tbl->lock);
870 static int pneigh_ifdown_and_unlock(struct neigh_table *tbl,
871 struct net_device *dev)
873 struct pneigh_entry *n, **np, *freelist = NULL;
876 for (h = 0; h <= PNEIGH_HASHMASK; h++) {
877 np = &tbl->phash_buckets[h];
878 while ((n = *np) != NULL) {
879 if (!dev || n->dev == dev) {
888 write_unlock_bh(&tbl->lock);
889 while ((n = freelist)) {
892 if (tbl->pdestructor)
894 netdev_put(n->dev, &n->dev_tracker);
900 static void neigh_parms_destroy(struct neigh_parms *parms);
902 static inline void neigh_parms_put(struct neigh_parms *parms)
904 if (refcount_dec_and_test(&parms->refcnt))
905 neigh_parms_destroy(parms);
909 * neighbour must already be out of the table;
912 void neigh_destroy(struct neighbour *neigh)
914 struct net_device *dev = neigh->dev;
916 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
919 pr_warn("Destroying alive neighbour %p\n", neigh);
924 if (neigh_del_timer(neigh))
925 pr_warn("Impossible event\n");
927 write_lock_bh(&neigh->lock);
928 __skb_queue_purge(&neigh->arp_queue);
929 write_unlock_bh(&neigh->lock);
930 neigh->arp_queue_len_bytes = 0;
932 if (dev->netdev_ops->ndo_neigh_destroy)
933 dev->netdev_ops->ndo_neigh_destroy(dev, neigh);
935 netdev_put(dev, &neigh->dev_tracker);
936 neigh_parms_put(neigh->parms);
938 neigh_dbg(2, "neigh %p is destroyed\n", neigh);
940 atomic_dec(&neigh->tbl->entries);
941 kfree_rcu(neigh, rcu);
943 EXPORT_SYMBOL(neigh_destroy);
945 /* Neighbour state is suspicious;
948 Called with write_locked neigh.
950 static void neigh_suspect(struct neighbour *neigh)
952 neigh_dbg(2, "neigh %p is suspected\n", neigh);
954 neigh->output = neigh->ops->output;
957 /* Neighbour state is OK;
960 Called with write_locked neigh.
962 static void neigh_connect(struct neighbour *neigh)
964 neigh_dbg(2, "neigh %p is connected\n", neigh);
966 neigh->output = neigh->ops->connected_output;
969 static void neigh_periodic_work(struct work_struct *work)
971 struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work);
973 struct neighbour __rcu **np;
975 struct neigh_hash_table *nht;
977 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
979 write_lock_bh(&tbl->lock);
980 nht = rcu_dereference_protected(tbl->nht,
981 lockdep_is_held(&tbl->lock));
984 * periodically recompute ReachableTime from random function
987 if (time_after(jiffies, tbl->last_rand + 300 * HZ)) {
988 struct neigh_parms *p;
989 tbl->last_rand = jiffies;
990 list_for_each_entry(p, &tbl->parms_list, list)
992 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
995 if (atomic_read(&tbl->entries) < tbl->gc_thresh1)
998 for (i = 0 ; i < (1 << nht->hash_shift); i++) {
999 np = &nht->hash_buckets[i];
1001 while ((n = rcu_dereference_protected(*np,
1002 lockdep_is_held(&tbl->lock))) != NULL) {
1005 write_lock(&n->lock);
1007 state = n->nud_state;
1008 if ((state & (NUD_PERMANENT | NUD_IN_TIMER)) ||
1009 (n->flags & NTF_EXT_LEARNED)) {
1010 write_unlock(&n->lock);
1014 if (time_before(n->used, n->confirmed) &&
1015 time_is_before_eq_jiffies(n->confirmed))
1016 n->used = n->confirmed;
1018 if (refcount_read(&n->refcnt) == 1 &&
1019 (state == NUD_FAILED ||
1020 !time_in_range_open(jiffies, n->used,
1021 n->used + NEIGH_VAR(n->parms, GC_STALETIME)))) {
1024 write_unlock(&n->lock);
1025 neigh_cleanup_and_release(n);
1028 write_unlock(&n->lock);
1034 * It's fine to release lock here, even if hash table
1035 * grows while we are preempted.
1037 write_unlock_bh(&tbl->lock);
1039 write_lock_bh(&tbl->lock);
1040 nht = rcu_dereference_protected(tbl->nht,
1041 lockdep_is_held(&tbl->lock));
1044 /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks.
1045 * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2
1046 * BASE_REACHABLE_TIME.
1048 queue_delayed_work(system_power_efficient_wq, &tbl->gc_work,
1049 NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME) >> 1);
1050 write_unlock_bh(&tbl->lock);
1053 static __inline__ int neigh_max_probes(struct neighbour *n)
1055 struct neigh_parms *p = n->parms;
1056 return NEIGH_VAR(p, UCAST_PROBES) + NEIGH_VAR(p, APP_PROBES) +
1057 (n->nud_state & NUD_PROBE ? NEIGH_VAR(p, MCAST_REPROBES) :
1058 NEIGH_VAR(p, MCAST_PROBES));
1061 static void neigh_invalidate(struct neighbour *neigh)
1062 __releases(neigh->lock)
1063 __acquires(neigh->lock)
1065 struct sk_buff *skb;
1067 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
1068 neigh_dbg(2, "neigh %p is failed\n", neigh);
1069 neigh->updated = jiffies;
1071 /* It is very thin place. report_unreachable is very complicated
1072 routine. Particularly, it can hit the same neighbour entry!
1074 So that, we try to be accurate and avoid dead loop. --ANK
1076 while (neigh->nud_state == NUD_FAILED &&
1077 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1078 write_unlock(&neigh->lock);
1079 neigh->ops->error_report(neigh, skb);
1080 write_lock(&neigh->lock);
1082 __skb_queue_purge(&neigh->arp_queue);
1083 neigh->arp_queue_len_bytes = 0;
1086 static void neigh_probe(struct neighbour *neigh)
1087 __releases(neigh->lock)
1089 struct sk_buff *skb = skb_peek_tail(&neigh->arp_queue);
1090 /* keep skb alive even if arp_queue overflows */
1092 skb = skb_clone(skb, GFP_ATOMIC);
1093 write_unlock(&neigh->lock);
1094 if (neigh->ops->solicit)
1095 neigh->ops->solicit(neigh, skb);
1096 atomic_inc(&neigh->probes);
1100 /* Called when a timer expires for a neighbour entry. */
1102 static void neigh_timer_handler(struct timer_list *t)
1104 unsigned long now, next;
1105 struct neighbour *neigh = from_timer(neigh, t, timer);
1109 write_lock(&neigh->lock);
1111 state = neigh->nud_state;
1115 if (!(state & NUD_IN_TIMER))
1118 if (state & NUD_REACHABLE) {
1119 if (time_before_eq(now,
1120 neigh->confirmed + neigh->parms->reachable_time)) {
1121 neigh_dbg(2, "neigh %p is still alive\n", neigh);
1122 next = neigh->confirmed + neigh->parms->reachable_time;
1123 } else if (time_before_eq(now,
1125 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
1126 neigh_dbg(2, "neigh %p is delayed\n", neigh);
1127 neigh->nud_state = NUD_DELAY;
1128 neigh->updated = jiffies;
1129 neigh_suspect(neigh);
1130 next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME);
1132 neigh_dbg(2, "neigh %p is suspected\n", neigh);
1133 neigh->nud_state = NUD_STALE;
1134 neigh->updated = jiffies;
1135 neigh_suspect(neigh);
1138 } else if (state & NUD_DELAY) {
1139 if (time_before_eq(now,
1141 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
1142 neigh_dbg(2, "neigh %p is now reachable\n", neigh);
1143 neigh->nud_state = NUD_REACHABLE;
1144 neigh->updated = jiffies;
1145 neigh_connect(neigh);
1147 next = neigh->confirmed + neigh->parms->reachable_time;
1149 neigh_dbg(2, "neigh %p is probed\n", neigh);
1150 neigh->nud_state = NUD_PROBE;
1151 neigh->updated = jiffies;
1152 atomic_set(&neigh->probes, 0);
1154 next = now + max(NEIGH_VAR(neigh->parms, RETRANS_TIME),
1158 /* NUD_PROBE|NUD_INCOMPLETE */
1159 next = now + max(NEIGH_VAR(neigh->parms, RETRANS_TIME), HZ/100);
1162 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
1163 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
1164 neigh->nud_state = NUD_FAILED;
1166 neigh_invalidate(neigh);
1170 if (neigh->nud_state & NUD_IN_TIMER) {
1171 if (time_before(next, jiffies + HZ/100))
1172 next = jiffies + HZ/100;
1173 if (!mod_timer(&neigh->timer, next))
1176 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
1180 write_unlock(&neigh->lock);
1184 neigh_update_notify(neigh, 0);
1186 trace_neigh_timer_handler(neigh, 0);
1188 neigh_release(neigh);
1191 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb,
1192 const bool immediate_ok)
1195 bool immediate_probe = false;
1197 write_lock_bh(&neigh->lock);
1200 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
1205 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
1206 if (NEIGH_VAR(neigh->parms, MCAST_PROBES) +
1207 NEIGH_VAR(neigh->parms, APP_PROBES)) {
1208 unsigned long next, now = jiffies;
1210 atomic_set(&neigh->probes,
1211 NEIGH_VAR(neigh->parms, UCAST_PROBES));
1212 neigh_del_timer(neigh);
1213 neigh->nud_state = NUD_INCOMPLETE;
1214 neigh->updated = now;
1215 if (!immediate_ok) {
1218 immediate_probe = true;
1219 next = now + max(NEIGH_VAR(neigh->parms,
1223 neigh_add_timer(neigh, next);
1225 neigh->nud_state = NUD_FAILED;
1226 neigh->updated = jiffies;
1227 write_unlock_bh(&neigh->lock);
1229 kfree_skb_reason(skb, SKB_DROP_REASON_NEIGH_FAILED);
1232 } else if (neigh->nud_state & NUD_STALE) {
1233 neigh_dbg(2, "neigh %p is delayed\n", neigh);
1234 neigh_del_timer(neigh);
1235 neigh->nud_state = NUD_DELAY;
1236 neigh->updated = jiffies;
1237 neigh_add_timer(neigh, jiffies +
1238 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME));
1241 if (neigh->nud_state == NUD_INCOMPLETE) {
1243 while (neigh->arp_queue_len_bytes + skb->truesize >
1244 NEIGH_VAR(neigh->parms, QUEUE_LEN_BYTES)) {
1245 struct sk_buff *buff;
1247 buff = __skb_dequeue(&neigh->arp_queue);
1250 neigh->arp_queue_len_bytes -= buff->truesize;
1251 kfree_skb_reason(buff, SKB_DROP_REASON_NEIGH_QUEUEFULL);
1252 NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards);
1255 __skb_queue_tail(&neigh->arp_queue, skb);
1256 neigh->arp_queue_len_bytes += skb->truesize;
1261 if (immediate_probe)
1264 write_unlock(&neigh->lock);
1266 trace_neigh_event_send_done(neigh, rc);
1270 if (neigh->nud_state & NUD_STALE)
1272 write_unlock_bh(&neigh->lock);
1273 kfree_skb_reason(skb, SKB_DROP_REASON_NEIGH_DEAD);
1274 trace_neigh_event_send_dead(neigh, 1);
1277 EXPORT_SYMBOL(__neigh_event_send);
1279 static void neigh_update_hhs(struct neighbour *neigh)
1281 struct hh_cache *hh;
1282 void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
1285 if (neigh->dev->header_ops)
1286 update = neigh->dev->header_ops->cache_update;
1290 if (READ_ONCE(hh->hh_len)) {
1291 write_seqlock_bh(&hh->hh_lock);
1292 update(hh, neigh->dev, neigh->ha);
1293 write_sequnlock_bh(&hh->hh_lock);
1298 /* Generic update routine.
1299 -- lladdr is new lladdr or NULL, if it is not supplied.
1300 -- new is new state.
1302 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
1304 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
1305 lladdr instead of overriding it
1307 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
1308 NEIGH_UPDATE_F_USE means that the entry is user triggered.
1309 NEIGH_UPDATE_F_MANAGED means that the entry will be auto-refreshed.
1310 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
1312 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1315 Caller MUST hold reference count on the entry.
1317 static int __neigh_update(struct neighbour *neigh, const u8 *lladdr,
1318 u8 new, u32 flags, u32 nlmsg_pid,
1319 struct netlink_ext_ack *extack)
1321 bool gc_update = false, managed_update = false;
1322 int update_isrouter = 0;
1323 struct net_device *dev;
1324 int err, notify = 0;
1327 trace_neigh_update(neigh, lladdr, new, flags, nlmsg_pid);
1329 write_lock_bh(&neigh->lock);
1332 old = neigh->nud_state;
1336 NL_SET_ERR_MSG(extack, "Neighbor entry is now dead");
1340 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
1341 (old & (NUD_NOARP | NUD_PERMANENT)))
1344 neigh_update_flags(neigh, flags, ¬ify, &gc_update, &managed_update);
1345 if (flags & (NEIGH_UPDATE_F_USE | NEIGH_UPDATE_F_MANAGED)) {
1346 new = old & ~NUD_PERMANENT;
1347 neigh->nud_state = new;
1352 if (!(new & NUD_VALID)) {
1353 neigh_del_timer(neigh);
1354 if (old & NUD_CONNECTED)
1355 neigh_suspect(neigh);
1356 neigh->nud_state = new;
1358 notify = old & NUD_VALID;
1359 if ((old & (NUD_INCOMPLETE | NUD_PROBE)) &&
1360 (new & NUD_FAILED)) {
1361 neigh_invalidate(neigh);
1367 /* Compare new lladdr with cached one */
1368 if (!dev->addr_len) {
1369 /* First case: device needs no address. */
1371 } else if (lladdr) {
1372 /* The second case: if something is already cached
1373 and a new address is proposed:
1375 - if they are different, check override flag
1377 if ((old & NUD_VALID) &&
1378 !memcmp(lladdr, neigh->ha, dev->addr_len))
1381 /* No address is supplied; if we know something,
1382 use it, otherwise discard the request.
1385 if (!(old & NUD_VALID)) {
1386 NL_SET_ERR_MSG(extack, "No link layer address given");
1392 /* Update confirmed timestamp for neighbour entry after we
1393 * received ARP packet even if it doesn't change IP to MAC binding.
1395 if (new & NUD_CONNECTED)
1396 neigh->confirmed = jiffies;
1398 /* If entry was valid and address is not changed,
1399 do not change entry state, if new one is STALE.
1402 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1403 if (old & NUD_VALID) {
1404 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1405 update_isrouter = 0;
1406 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1407 (old & NUD_CONNECTED)) {
1413 if (lladdr == neigh->ha && new == NUD_STALE &&
1414 !(flags & NEIGH_UPDATE_F_ADMIN))
1419 /* Update timestamp only once we know we will make a change to the
1420 * neighbour entry. Otherwise we risk to move the locktime window with
1421 * noop updates and ignore relevant ARP updates.
1423 if (new != old || lladdr != neigh->ha)
1424 neigh->updated = jiffies;
1427 neigh_del_timer(neigh);
1428 if (new & NUD_PROBE)
1429 atomic_set(&neigh->probes, 0);
1430 if (new & NUD_IN_TIMER)
1431 neigh_add_timer(neigh, (jiffies +
1432 ((new & NUD_REACHABLE) ?
1433 neigh->parms->reachable_time :
1435 neigh->nud_state = new;
1439 if (lladdr != neigh->ha) {
1440 write_seqlock(&neigh->ha_lock);
1441 memcpy(&neigh->ha, lladdr, dev->addr_len);
1442 write_sequnlock(&neigh->ha_lock);
1443 neigh_update_hhs(neigh);
1444 if (!(new & NUD_CONNECTED))
1445 neigh->confirmed = jiffies -
1446 (NEIGH_VAR(neigh->parms, BASE_REACHABLE_TIME) << 1);
1451 if (new & NUD_CONNECTED)
1452 neigh_connect(neigh);
1454 neigh_suspect(neigh);
1455 if (!(old & NUD_VALID)) {
1456 struct sk_buff *skb;
1458 /* Again: avoid dead loop if something went wrong */
1460 while (neigh->nud_state & NUD_VALID &&
1461 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1462 struct dst_entry *dst = skb_dst(skb);
1463 struct neighbour *n2, *n1 = neigh;
1464 write_unlock_bh(&neigh->lock);
1468 /* Why not just use 'neigh' as-is? The problem is that
1469 * things such as shaper, eql, and sch_teql can end up
1470 * using alternative, different, neigh objects to output
1471 * the packet in the output path. So what we need to do
1472 * here is re-lookup the top-level neigh in the path so
1473 * we can reinject the packet there.
1476 if (dst && dst->obsolete != DST_OBSOLETE_DEAD) {
1477 n2 = dst_neigh_lookup_skb(dst, skb);
1481 n1->output(n1, skb);
1486 write_lock_bh(&neigh->lock);
1488 __skb_queue_purge(&neigh->arp_queue);
1489 neigh->arp_queue_len_bytes = 0;
1492 if (update_isrouter)
1493 neigh_update_is_router(neigh, flags, ¬ify);
1494 write_unlock_bh(&neigh->lock);
1495 if (((new ^ old) & NUD_PERMANENT) || gc_update)
1496 neigh_update_gc_list(neigh);
1498 neigh_update_managed_list(neigh);
1500 neigh_update_notify(neigh, nlmsg_pid);
1501 trace_neigh_update_done(neigh, err);
1505 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
1506 u32 flags, u32 nlmsg_pid)
1508 return __neigh_update(neigh, lladdr, new, flags, nlmsg_pid, NULL);
1510 EXPORT_SYMBOL(neigh_update);
1512 /* Update the neigh to listen temporarily for probe responses, even if it is
1513 * in a NUD_FAILED state. The caller has to hold neigh->lock for writing.
1515 void __neigh_set_probe_once(struct neighbour *neigh)
1519 neigh->updated = jiffies;
1520 if (!(neigh->nud_state & NUD_FAILED))
1522 neigh->nud_state = NUD_INCOMPLETE;
1523 atomic_set(&neigh->probes, neigh_max_probes(neigh));
1524 neigh_add_timer(neigh,
1525 jiffies + max(NEIGH_VAR(neigh->parms, RETRANS_TIME),
1528 EXPORT_SYMBOL(__neigh_set_probe_once);
1530 struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1531 u8 *lladdr, void *saddr,
1532 struct net_device *dev)
1534 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1535 lladdr || !dev->addr_len);
1537 neigh_update(neigh, lladdr, NUD_STALE,
1538 NEIGH_UPDATE_F_OVERRIDE, 0);
1541 EXPORT_SYMBOL(neigh_event_ns);
1543 /* called with read_lock_bh(&n->lock); */
1544 static void neigh_hh_init(struct neighbour *n)
1546 struct net_device *dev = n->dev;
1547 __be16 prot = n->tbl->protocol;
1548 struct hh_cache *hh = &n->hh;
1550 write_lock_bh(&n->lock);
1552 /* Only one thread can come in here and initialize the
1556 dev->header_ops->cache(n, hh, prot);
1558 write_unlock_bh(&n->lock);
1561 /* Slow and careful. */
1563 int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb)
1567 if (!neigh_event_send(neigh, skb)) {
1569 struct net_device *dev = neigh->dev;
1572 if (dev->header_ops->cache && !READ_ONCE(neigh->hh.hh_len))
1573 neigh_hh_init(neigh);
1576 __skb_pull(skb, skb_network_offset(skb));
1577 seq = read_seqbegin(&neigh->ha_lock);
1578 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1579 neigh->ha, NULL, skb->len);
1580 } while (read_seqretry(&neigh->ha_lock, seq));
1583 rc = dev_queue_xmit(skb);
1594 EXPORT_SYMBOL(neigh_resolve_output);
1596 /* As fast as possible without hh cache */
1598 int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb)
1600 struct net_device *dev = neigh->dev;
1605 __skb_pull(skb, skb_network_offset(skb));
1606 seq = read_seqbegin(&neigh->ha_lock);
1607 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1608 neigh->ha, NULL, skb->len);
1609 } while (read_seqretry(&neigh->ha_lock, seq));
1612 err = dev_queue_xmit(skb);
1619 EXPORT_SYMBOL(neigh_connected_output);
1621 int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb)
1623 return dev_queue_xmit(skb);
1625 EXPORT_SYMBOL(neigh_direct_output);
1627 static void neigh_managed_work(struct work_struct *work)
1629 struct neigh_table *tbl = container_of(work, struct neigh_table,
1631 struct neighbour *neigh;
1633 write_lock_bh(&tbl->lock);
1634 list_for_each_entry(neigh, &tbl->managed_list, managed_list)
1635 neigh_event_send_probe(neigh, NULL, false);
1636 queue_delayed_work(system_power_efficient_wq, &tbl->managed_work,
1637 NEIGH_VAR(&tbl->parms, INTERVAL_PROBE_TIME_MS));
1638 write_unlock_bh(&tbl->lock);
1641 static void neigh_proxy_process(struct timer_list *t)
1643 struct neigh_table *tbl = from_timer(tbl, t, proxy_timer);
1644 long sched_next = 0;
1645 unsigned long now = jiffies;
1646 struct sk_buff *skb, *n;
1648 spin_lock(&tbl->proxy_queue.lock);
1650 skb_queue_walk_safe(&tbl->proxy_queue, skb, n) {
1651 long tdif = NEIGH_CB(skb)->sched_next - now;
1654 struct net_device *dev = skb->dev;
1656 neigh_parms_qlen_dec(dev, tbl->family);
1657 __skb_unlink(skb, &tbl->proxy_queue);
1659 if (tbl->proxy_redo && netif_running(dev)) {
1661 tbl->proxy_redo(skb);
1668 } else if (!sched_next || tdif < sched_next)
1671 del_timer(&tbl->proxy_timer);
1673 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1674 spin_unlock(&tbl->proxy_queue.lock);
1677 static unsigned long neigh_proxy_delay(struct neigh_parms *p)
1679 /* If proxy_delay is zero, do not call get_random_u32_below()
1680 * as it is undefined behavior.
1682 unsigned long proxy_delay = NEIGH_VAR(p, PROXY_DELAY);
1684 return proxy_delay ?
1685 jiffies + get_random_u32_below(proxy_delay) : jiffies;
1688 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1689 struct sk_buff *skb)
1691 unsigned long sched_next = neigh_proxy_delay(p);
1693 if (p->qlen > NEIGH_VAR(p, PROXY_QLEN)) {
1698 NEIGH_CB(skb)->sched_next = sched_next;
1699 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
1701 spin_lock(&tbl->proxy_queue.lock);
1702 if (del_timer(&tbl->proxy_timer)) {
1703 if (time_before(tbl->proxy_timer.expires, sched_next))
1704 sched_next = tbl->proxy_timer.expires;
1708 __skb_queue_tail(&tbl->proxy_queue, skb);
1710 mod_timer(&tbl->proxy_timer, sched_next);
1711 spin_unlock(&tbl->proxy_queue.lock);
1713 EXPORT_SYMBOL(pneigh_enqueue);
1715 static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl,
1716 struct net *net, int ifindex)
1718 struct neigh_parms *p;
1720 list_for_each_entry(p, &tbl->parms_list, list) {
1721 if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) ||
1722 (!p->dev && !ifindex && net_eq(net, &init_net)))
1729 struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1730 struct neigh_table *tbl)
1732 struct neigh_parms *p;
1733 struct net *net = dev_net(dev);
1734 const struct net_device_ops *ops = dev->netdev_ops;
1736 p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL);
1739 refcount_set(&p->refcnt, 1);
1741 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
1743 netdev_hold(dev, &p->dev_tracker, GFP_KERNEL);
1745 write_pnet(&p->net, net);
1746 p->sysctl_table = NULL;
1748 if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) {
1749 netdev_put(dev, &p->dev_tracker);
1754 write_lock_bh(&tbl->lock);
1755 list_add(&p->list, &tbl->parms.list);
1756 write_unlock_bh(&tbl->lock);
1758 neigh_parms_data_state_cleanall(p);
1762 EXPORT_SYMBOL(neigh_parms_alloc);
1764 static void neigh_rcu_free_parms(struct rcu_head *head)
1766 struct neigh_parms *parms =
1767 container_of(head, struct neigh_parms, rcu_head);
1769 neigh_parms_put(parms);
1772 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1774 if (!parms || parms == &tbl->parms)
1776 write_lock_bh(&tbl->lock);
1777 list_del(&parms->list);
1779 write_unlock_bh(&tbl->lock);
1780 netdev_put(parms->dev, &parms->dev_tracker);
1781 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1783 EXPORT_SYMBOL(neigh_parms_release);
1785 static void neigh_parms_destroy(struct neigh_parms *parms)
1790 static struct lock_class_key neigh_table_proxy_queue_class;
1792 static struct neigh_table *neigh_tables[NEIGH_NR_TABLES] __read_mostly;
1794 void neigh_table_init(int index, struct neigh_table *tbl)
1796 unsigned long now = jiffies;
1797 unsigned long phsize;
1799 INIT_LIST_HEAD(&tbl->parms_list);
1800 INIT_LIST_HEAD(&tbl->gc_list);
1801 INIT_LIST_HEAD(&tbl->managed_list);
1803 list_add(&tbl->parms.list, &tbl->parms_list);
1804 write_pnet(&tbl->parms.net, &init_net);
1805 refcount_set(&tbl->parms.refcnt, 1);
1806 tbl->parms.reachable_time =
1807 neigh_rand_reach_time(NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME));
1808 tbl->parms.qlen = 0;
1810 tbl->stats = alloc_percpu(struct neigh_statistics);
1812 panic("cannot create neighbour cache statistics");
1814 #ifdef CONFIG_PROC_FS
1815 if (!proc_create_seq_data(tbl->id, 0, init_net.proc_net_stat,
1816 &neigh_stat_seq_ops, tbl))
1817 panic("cannot create neighbour proc dir entry");
1820 RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3));
1822 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
1823 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
1825 if (!tbl->nht || !tbl->phash_buckets)
1826 panic("cannot allocate neighbour cache hashes");
1828 if (!tbl->entry_size)
1829 tbl->entry_size = ALIGN(offsetof(struct neighbour, primary_key) +
1830 tbl->key_len, NEIGH_PRIV_ALIGN);
1832 WARN_ON(tbl->entry_size % NEIGH_PRIV_ALIGN);
1834 rwlock_init(&tbl->lock);
1836 INIT_DEFERRABLE_WORK(&tbl->gc_work, neigh_periodic_work);
1837 queue_delayed_work(system_power_efficient_wq, &tbl->gc_work,
1838 tbl->parms.reachable_time);
1839 INIT_DEFERRABLE_WORK(&tbl->managed_work, neigh_managed_work);
1840 queue_delayed_work(system_power_efficient_wq, &tbl->managed_work, 0);
1842 timer_setup(&tbl->proxy_timer, neigh_proxy_process, 0);
1843 skb_queue_head_init_class(&tbl->proxy_queue,
1844 &neigh_table_proxy_queue_class);
1846 tbl->last_flush = now;
1847 tbl->last_rand = now + tbl->parms.reachable_time * 20;
1849 neigh_tables[index] = tbl;
1851 EXPORT_SYMBOL(neigh_table_init);
1853 int neigh_table_clear(int index, struct neigh_table *tbl)
1855 neigh_tables[index] = NULL;
1856 /* It is not clean... Fix it to unload IPv6 module safely */
1857 cancel_delayed_work_sync(&tbl->managed_work);
1858 cancel_delayed_work_sync(&tbl->gc_work);
1859 del_timer_sync(&tbl->proxy_timer);
1860 pneigh_queue_purge(&tbl->proxy_queue, NULL, tbl->family);
1861 neigh_ifdown(tbl, NULL);
1862 if (atomic_read(&tbl->entries))
1863 pr_crit("neighbour leakage\n");
1865 call_rcu(&rcu_dereference_protected(tbl->nht, 1)->rcu,
1866 neigh_hash_free_rcu);
1869 kfree(tbl->phash_buckets);
1870 tbl->phash_buckets = NULL;
1872 remove_proc_entry(tbl->id, init_net.proc_net_stat);
1874 free_percpu(tbl->stats);
1879 EXPORT_SYMBOL(neigh_table_clear);
1881 static struct neigh_table *neigh_find_table(int family)
1883 struct neigh_table *tbl = NULL;
1887 tbl = neigh_tables[NEIGH_ARP_TABLE];
1890 tbl = neigh_tables[NEIGH_ND_TABLE];
1897 const struct nla_policy nda_policy[NDA_MAX+1] = {
1898 [NDA_UNSPEC] = { .strict_start_type = NDA_NH_ID },
1899 [NDA_DST] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1900 [NDA_LLADDR] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1901 [NDA_CACHEINFO] = { .len = sizeof(struct nda_cacheinfo) },
1902 [NDA_PROBES] = { .type = NLA_U32 },
1903 [NDA_VLAN] = { .type = NLA_U16 },
1904 [NDA_PORT] = { .type = NLA_U16 },
1905 [NDA_VNI] = { .type = NLA_U32 },
1906 [NDA_IFINDEX] = { .type = NLA_U32 },
1907 [NDA_MASTER] = { .type = NLA_U32 },
1908 [NDA_PROTOCOL] = { .type = NLA_U8 },
1909 [NDA_NH_ID] = { .type = NLA_U32 },
1910 [NDA_FLAGS_EXT] = NLA_POLICY_MASK(NLA_U32, NTF_EXT_MASK),
1911 [NDA_FDB_EXT_ATTRS] = { .type = NLA_NESTED },
1914 static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh,
1915 struct netlink_ext_ack *extack)
1917 struct net *net = sock_net(skb->sk);
1919 struct nlattr *dst_attr;
1920 struct neigh_table *tbl;
1921 struct neighbour *neigh;
1922 struct net_device *dev = NULL;
1926 if (nlmsg_len(nlh) < sizeof(*ndm))
1929 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1931 NL_SET_ERR_MSG(extack, "Network address not specified");
1935 ndm = nlmsg_data(nlh);
1936 if (ndm->ndm_ifindex) {
1937 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
1944 tbl = neigh_find_table(ndm->ndm_family);
1946 return -EAFNOSUPPORT;
1948 if (nla_len(dst_attr) < (int)tbl->key_len) {
1949 NL_SET_ERR_MSG(extack, "Invalid network address");
1953 if (ndm->ndm_flags & NTF_PROXY) {
1954 err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
1961 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1962 if (neigh == NULL) {
1967 err = __neigh_update(neigh, NULL, NUD_FAILED,
1968 NEIGH_UPDATE_F_OVERRIDE | NEIGH_UPDATE_F_ADMIN,
1969 NETLINK_CB(skb).portid, extack);
1970 write_lock_bh(&tbl->lock);
1971 neigh_release(neigh);
1972 neigh_remove_one(neigh, tbl);
1973 write_unlock_bh(&tbl->lock);
1979 static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh,
1980 struct netlink_ext_ack *extack)
1982 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE |
1983 NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1984 struct net *net = sock_net(skb->sk);
1986 struct nlattr *tb[NDA_MAX+1];
1987 struct neigh_table *tbl;
1988 struct net_device *dev = NULL;
1989 struct neighbour *neigh;
1996 err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX,
1997 nda_policy, extack);
2003 NL_SET_ERR_MSG(extack, "Network address not specified");
2007 ndm = nlmsg_data(nlh);
2008 ndm_flags = ndm->ndm_flags;
2009 if (tb[NDA_FLAGS_EXT]) {
2010 u32 ext = nla_get_u32(tb[NDA_FLAGS_EXT]);
2012 BUILD_BUG_ON(sizeof(neigh->flags) * BITS_PER_BYTE <
2013 (sizeof(ndm->ndm_flags) * BITS_PER_BYTE +
2014 hweight32(NTF_EXT_MASK)));
2015 ndm_flags |= (ext << NTF_EXT_SHIFT);
2017 if (ndm->ndm_ifindex) {
2018 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
2024 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len) {
2025 NL_SET_ERR_MSG(extack, "Invalid link address");
2030 tbl = neigh_find_table(ndm->ndm_family);
2032 return -EAFNOSUPPORT;
2034 if (nla_len(tb[NDA_DST]) < (int)tbl->key_len) {
2035 NL_SET_ERR_MSG(extack, "Invalid network address");
2039 dst = nla_data(tb[NDA_DST]);
2040 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
2042 if (tb[NDA_PROTOCOL])
2043 protocol = nla_get_u8(tb[NDA_PROTOCOL]);
2044 if (ndm_flags & NTF_PROXY) {
2045 struct pneigh_entry *pn;
2047 if (ndm_flags & NTF_MANAGED) {
2048 NL_SET_ERR_MSG(extack, "Invalid NTF_* flag combination");
2053 pn = pneigh_lookup(tbl, net, dst, dev, 1);
2055 pn->flags = ndm_flags;
2057 pn->protocol = protocol;
2064 NL_SET_ERR_MSG(extack, "Device not specified");
2068 if (tbl->allow_add && !tbl->allow_add(dev, extack)) {
2073 neigh = neigh_lookup(tbl, dst, dev);
2074 if (neigh == NULL) {
2075 bool ndm_permanent = ndm->ndm_state & NUD_PERMANENT;
2076 bool exempt_from_gc = ndm_permanent ||
2077 ndm_flags & NTF_EXT_LEARNED;
2079 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
2083 if (ndm_permanent && (ndm_flags & NTF_MANAGED)) {
2084 NL_SET_ERR_MSG(extack, "Invalid NTF_* flag for permanent entry");
2089 neigh = ___neigh_create(tbl, dst, dev,
2091 (NTF_EXT_LEARNED | NTF_MANAGED),
2092 exempt_from_gc, true);
2093 if (IS_ERR(neigh)) {
2094 err = PTR_ERR(neigh);
2098 if (nlh->nlmsg_flags & NLM_F_EXCL) {
2100 neigh_release(neigh);
2104 if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
2105 flags &= ~(NEIGH_UPDATE_F_OVERRIDE |
2106 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
2110 neigh->protocol = protocol;
2111 if (ndm_flags & NTF_EXT_LEARNED)
2112 flags |= NEIGH_UPDATE_F_EXT_LEARNED;
2113 if (ndm_flags & NTF_ROUTER)
2114 flags |= NEIGH_UPDATE_F_ISROUTER;
2115 if (ndm_flags & NTF_MANAGED)
2116 flags |= NEIGH_UPDATE_F_MANAGED;
2117 if (ndm_flags & NTF_USE)
2118 flags |= NEIGH_UPDATE_F_USE;
2120 err = __neigh_update(neigh, lladdr, ndm->ndm_state, flags,
2121 NETLINK_CB(skb).portid, extack);
2122 if (!err && ndm_flags & (NTF_USE | NTF_MANAGED)) {
2123 neigh_event_send(neigh, NULL);
2126 neigh_release(neigh);
2131 static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
2133 struct nlattr *nest;
2135 nest = nla_nest_start_noflag(skb, NDTA_PARMS);
2140 nla_put_u32(skb, NDTPA_IFINDEX, parms->dev->ifindex)) ||
2141 nla_put_u32(skb, NDTPA_REFCNT, refcount_read(&parms->refcnt)) ||
2142 nla_put_u32(skb, NDTPA_QUEUE_LENBYTES,
2143 NEIGH_VAR(parms, QUEUE_LEN_BYTES)) ||
2144 /* approximative value for deprecated QUEUE_LEN (in packets) */
2145 nla_put_u32(skb, NDTPA_QUEUE_LEN,
2146 NEIGH_VAR(parms, QUEUE_LEN_BYTES) / SKB_TRUESIZE(ETH_FRAME_LEN)) ||
2147 nla_put_u32(skb, NDTPA_PROXY_QLEN, NEIGH_VAR(parms, PROXY_QLEN)) ||
2148 nla_put_u32(skb, NDTPA_APP_PROBES, NEIGH_VAR(parms, APP_PROBES)) ||
2149 nla_put_u32(skb, NDTPA_UCAST_PROBES,
2150 NEIGH_VAR(parms, UCAST_PROBES)) ||
2151 nla_put_u32(skb, NDTPA_MCAST_PROBES,
2152 NEIGH_VAR(parms, MCAST_PROBES)) ||
2153 nla_put_u32(skb, NDTPA_MCAST_REPROBES,
2154 NEIGH_VAR(parms, MCAST_REPROBES)) ||
2155 nla_put_msecs(skb, NDTPA_REACHABLE_TIME, parms->reachable_time,
2157 nla_put_msecs(skb, NDTPA_BASE_REACHABLE_TIME,
2158 NEIGH_VAR(parms, BASE_REACHABLE_TIME), NDTPA_PAD) ||
2159 nla_put_msecs(skb, NDTPA_GC_STALETIME,
2160 NEIGH_VAR(parms, GC_STALETIME), NDTPA_PAD) ||
2161 nla_put_msecs(skb, NDTPA_DELAY_PROBE_TIME,
2162 NEIGH_VAR(parms, DELAY_PROBE_TIME), NDTPA_PAD) ||
2163 nla_put_msecs(skb, NDTPA_RETRANS_TIME,
2164 NEIGH_VAR(parms, RETRANS_TIME), NDTPA_PAD) ||
2165 nla_put_msecs(skb, NDTPA_ANYCAST_DELAY,
2166 NEIGH_VAR(parms, ANYCAST_DELAY), NDTPA_PAD) ||
2167 nla_put_msecs(skb, NDTPA_PROXY_DELAY,
2168 NEIGH_VAR(parms, PROXY_DELAY), NDTPA_PAD) ||
2169 nla_put_msecs(skb, NDTPA_LOCKTIME,
2170 NEIGH_VAR(parms, LOCKTIME), NDTPA_PAD) ||
2171 nla_put_msecs(skb, NDTPA_INTERVAL_PROBE_TIME_MS,
2172 NEIGH_VAR(parms, INTERVAL_PROBE_TIME_MS), NDTPA_PAD))
2173 goto nla_put_failure;
2174 return nla_nest_end(skb, nest);
2177 nla_nest_cancel(skb, nest);
2181 static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
2182 u32 pid, u32 seq, int type, int flags)
2184 struct nlmsghdr *nlh;
2185 struct ndtmsg *ndtmsg;
2187 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
2191 ndtmsg = nlmsg_data(nlh);
2193 read_lock_bh(&tbl->lock);
2194 ndtmsg->ndtm_family = tbl->family;
2195 ndtmsg->ndtm_pad1 = 0;
2196 ndtmsg->ndtm_pad2 = 0;
2198 if (nla_put_string(skb, NDTA_NAME, tbl->id) ||
2199 nla_put_msecs(skb, NDTA_GC_INTERVAL, tbl->gc_interval, NDTA_PAD) ||
2200 nla_put_u32(skb, NDTA_THRESH1, tbl->gc_thresh1) ||
2201 nla_put_u32(skb, NDTA_THRESH2, tbl->gc_thresh2) ||
2202 nla_put_u32(skb, NDTA_THRESH3, tbl->gc_thresh3))
2203 goto nla_put_failure;
2205 unsigned long now = jiffies;
2206 long flush_delta = now - tbl->last_flush;
2207 long rand_delta = now - tbl->last_rand;
2208 struct neigh_hash_table *nht;
2209 struct ndt_config ndc = {
2210 .ndtc_key_len = tbl->key_len,
2211 .ndtc_entry_size = tbl->entry_size,
2212 .ndtc_entries = atomic_read(&tbl->entries),
2213 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
2214 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
2215 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
2219 nht = rcu_dereference_bh(tbl->nht);
2220 ndc.ndtc_hash_rnd = nht->hash_rnd[0];
2221 ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1);
2222 rcu_read_unlock_bh();
2224 if (nla_put(skb, NDTA_CONFIG, sizeof(ndc), &ndc))
2225 goto nla_put_failure;
2230 struct ndt_stats ndst;
2232 memset(&ndst, 0, sizeof(ndst));
2234 for_each_possible_cpu(cpu) {
2235 struct neigh_statistics *st;
2237 st = per_cpu_ptr(tbl->stats, cpu);
2238 ndst.ndts_allocs += st->allocs;
2239 ndst.ndts_destroys += st->destroys;
2240 ndst.ndts_hash_grows += st->hash_grows;
2241 ndst.ndts_res_failed += st->res_failed;
2242 ndst.ndts_lookups += st->lookups;
2243 ndst.ndts_hits += st->hits;
2244 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
2245 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
2246 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
2247 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
2248 ndst.ndts_table_fulls += st->table_fulls;
2251 if (nla_put_64bit(skb, NDTA_STATS, sizeof(ndst), &ndst,
2253 goto nla_put_failure;
2256 BUG_ON(tbl->parms.dev);
2257 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
2258 goto nla_put_failure;
2260 read_unlock_bh(&tbl->lock);
2261 nlmsg_end(skb, nlh);
2265 read_unlock_bh(&tbl->lock);
2266 nlmsg_cancel(skb, nlh);
2270 static int neightbl_fill_param_info(struct sk_buff *skb,
2271 struct neigh_table *tbl,
2272 struct neigh_parms *parms,
2273 u32 pid, u32 seq, int type,
2276 struct ndtmsg *ndtmsg;
2277 struct nlmsghdr *nlh;
2279 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
2283 ndtmsg = nlmsg_data(nlh);
2285 read_lock_bh(&tbl->lock);
2286 ndtmsg->ndtm_family = tbl->family;
2287 ndtmsg->ndtm_pad1 = 0;
2288 ndtmsg->ndtm_pad2 = 0;
2290 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
2291 neightbl_fill_parms(skb, parms) < 0)
2294 read_unlock_bh(&tbl->lock);
2295 nlmsg_end(skb, nlh);
2298 read_unlock_bh(&tbl->lock);
2299 nlmsg_cancel(skb, nlh);
2303 static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
2304 [NDTA_NAME] = { .type = NLA_STRING },
2305 [NDTA_THRESH1] = { .type = NLA_U32 },
2306 [NDTA_THRESH2] = { .type = NLA_U32 },
2307 [NDTA_THRESH3] = { .type = NLA_U32 },
2308 [NDTA_GC_INTERVAL] = { .type = NLA_U64 },
2309 [NDTA_PARMS] = { .type = NLA_NESTED },
2312 static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
2313 [NDTPA_IFINDEX] = { .type = NLA_U32 },
2314 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 },
2315 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 },
2316 [NDTPA_APP_PROBES] = { .type = NLA_U32 },
2317 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 },
2318 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 },
2319 [NDTPA_MCAST_REPROBES] = { .type = NLA_U32 },
2320 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 },
2321 [NDTPA_GC_STALETIME] = { .type = NLA_U64 },
2322 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 },
2323 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 },
2324 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 },
2325 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 },
2326 [NDTPA_LOCKTIME] = { .type = NLA_U64 },
2327 [NDTPA_INTERVAL_PROBE_TIME_MS] = { .type = NLA_U64, .min = 1 },
2330 static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh,
2331 struct netlink_ext_ack *extack)
2333 struct net *net = sock_net(skb->sk);
2334 struct neigh_table *tbl;
2335 struct ndtmsg *ndtmsg;
2336 struct nlattr *tb[NDTA_MAX+1];
2340 err = nlmsg_parse_deprecated(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
2341 nl_neightbl_policy, extack);
2345 if (tb[NDTA_NAME] == NULL) {
2350 ndtmsg = nlmsg_data(nlh);
2352 for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) {
2353 tbl = neigh_tables[tidx];
2356 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
2358 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0) {
2368 * We acquire tbl->lock to be nice to the periodic timers and
2369 * make sure they always see a consistent set of values.
2371 write_lock_bh(&tbl->lock);
2373 if (tb[NDTA_PARMS]) {
2374 struct nlattr *tbp[NDTPA_MAX+1];
2375 struct neigh_parms *p;
2378 err = nla_parse_nested_deprecated(tbp, NDTPA_MAX,
2380 nl_ntbl_parm_policy, extack);
2382 goto errout_tbl_lock;
2384 if (tbp[NDTPA_IFINDEX])
2385 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
2387 p = lookup_neigh_parms(tbl, net, ifindex);
2390 goto errout_tbl_lock;
2393 for (i = 1; i <= NDTPA_MAX; i++) {
2398 case NDTPA_QUEUE_LEN:
2399 NEIGH_VAR_SET(p, QUEUE_LEN_BYTES,
2400 nla_get_u32(tbp[i]) *
2401 SKB_TRUESIZE(ETH_FRAME_LEN));
2403 case NDTPA_QUEUE_LENBYTES:
2404 NEIGH_VAR_SET(p, QUEUE_LEN_BYTES,
2405 nla_get_u32(tbp[i]));
2407 case NDTPA_PROXY_QLEN:
2408 NEIGH_VAR_SET(p, PROXY_QLEN,
2409 nla_get_u32(tbp[i]));
2411 case NDTPA_APP_PROBES:
2412 NEIGH_VAR_SET(p, APP_PROBES,
2413 nla_get_u32(tbp[i]));
2415 case NDTPA_UCAST_PROBES:
2416 NEIGH_VAR_SET(p, UCAST_PROBES,
2417 nla_get_u32(tbp[i]));
2419 case NDTPA_MCAST_PROBES:
2420 NEIGH_VAR_SET(p, MCAST_PROBES,
2421 nla_get_u32(tbp[i]));
2423 case NDTPA_MCAST_REPROBES:
2424 NEIGH_VAR_SET(p, MCAST_REPROBES,
2425 nla_get_u32(tbp[i]));
2427 case NDTPA_BASE_REACHABLE_TIME:
2428 NEIGH_VAR_SET(p, BASE_REACHABLE_TIME,
2429 nla_get_msecs(tbp[i]));
2430 /* update reachable_time as well, otherwise, the change will
2431 * only be effective after the next time neigh_periodic_work
2432 * decides to recompute it (can be multiple minutes)
2435 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
2437 case NDTPA_GC_STALETIME:
2438 NEIGH_VAR_SET(p, GC_STALETIME,
2439 nla_get_msecs(tbp[i]));
2441 case NDTPA_DELAY_PROBE_TIME:
2442 NEIGH_VAR_SET(p, DELAY_PROBE_TIME,
2443 nla_get_msecs(tbp[i]));
2444 call_netevent_notifiers(NETEVENT_DELAY_PROBE_TIME_UPDATE, p);
2446 case NDTPA_INTERVAL_PROBE_TIME_MS:
2447 NEIGH_VAR_SET(p, INTERVAL_PROBE_TIME_MS,
2448 nla_get_msecs(tbp[i]));
2450 case NDTPA_RETRANS_TIME:
2451 NEIGH_VAR_SET(p, RETRANS_TIME,
2452 nla_get_msecs(tbp[i]));
2454 case NDTPA_ANYCAST_DELAY:
2455 NEIGH_VAR_SET(p, ANYCAST_DELAY,
2456 nla_get_msecs(tbp[i]));
2458 case NDTPA_PROXY_DELAY:
2459 NEIGH_VAR_SET(p, PROXY_DELAY,
2460 nla_get_msecs(tbp[i]));
2462 case NDTPA_LOCKTIME:
2463 NEIGH_VAR_SET(p, LOCKTIME,
2464 nla_get_msecs(tbp[i]));
2471 if ((tb[NDTA_THRESH1] || tb[NDTA_THRESH2] ||
2472 tb[NDTA_THRESH3] || tb[NDTA_GC_INTERVAL]) &&
2473 !net_eq(net, &init_net))
2474 goto errout_tbl_lock;
2476 if (tb[NDTA_THRESH1])
2477 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
2479 if (tb[NDTA_THRESH2])
2480 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
2482 if (tb[NDTA_THRESH3])
2483 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
2485 if (tb[NDTA_GC_INTERVAL])
2486 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
2491 write_unlock_bh(&tbl->lock);
2496 static int neightbl_valid_dump_info(const struct nlmsghdr *nlh,
2497 struct netlink_ext_ack *extack)
2499 struct ndtmsg *ndtm;
2501 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndtm))) {
2502 NL_SET_ERR_MSG(extack, "Invalid header for neighbor table dump request");
2506 ndtm = nlmsg_data(nlh);
2507 if (ndtm->ndtm_pad1 || ndtm->ndtm_pad2) {
2508 NL_SET_ERR_MSG(extack, "Invalid values in header for neighbor table dump request");
2512 if (nlmsg_attrlen(nlh, sizeof(*ndtm))) {
2513 NL_SET_ERR_MSG(extack, "Invalid data after header in neighbor table dump request");
2520 static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
2522 const struct nlmsghdr *nlh = cb->nlh;
2523 struct net *net = sock_net(skb->sk);
2524 int family, tidx, nidx = 0;
2525 int tbl_skip = cb->args[0];
2526 int neigh_skip = cb->args[1];
2527 struct neigh_table *tbl;
2529 if (cb->strict_check) {
2530 int err = neightbl_valid_dump_info(nlh, cb->extack);
2536 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
2538 for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) {
2539 struct neigh_parms *p;
2541 tbl = neigh_tables[tidx];
2545 if (tidx < tbl_skip || (family && tbl->family != family))
2548 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).portid,
2549 nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
2554 p = list_next_entry(&tbl->parms, list);
2555 list_for_each_entry_from(p, &tbl->parms_list, list) {
2556 if (!net_eq(neigh_parms_net(p), net))
2559 if (nidx < neigh_skip)
2562 if (neightbl_fill_param_info(skb, tbl, p,
2563 NETLINK_CB(cb->skb).portid,
2581 static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
2582 u32 pid, u32 seq, int type, unsigned int flags)
2584 u32 neigh_flags, neigh_flags_ext;
2585 unsigned long now = jiffies;
2586 struct nda_cacheinfo ci;
2587 struct nlmsghdr *nlh;
2590 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2594 neigh_flags_ext = neigh->flags >> NTF_EXT_SHIFT;
2595 neigh_flags = neigh->flags & NTF_OLD_MASK;
2597 ndm = nlmsg_data(nlh);
2598 ndm->ndm_family = neigh->ops->family;
2601 ndm->ndm_flags = neigh_flags;
2602 ndm->ndm_type = neigh->type;
2603 ndm->ndm_ifindex = neigh->dev->ifindex;
2605 if (nla_put(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key))
2606 goto nla_put_failure;
2608 read_lock_bh(&neigh->lock);
2609 ndm->ndm_state = neigh->nud_state;
2610 if (neigh->nud_state & NUD_VALID) {
2611 char haddr[MAX_ADDR_LEN];
2613 neigh_ha_snapshot(haddr, neigh, neigh->dev);
2614 if (nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, haddr) < 0) {
2615 read_unlock_bh(&neigh->lock);
2616 goto nla_put_failure;
2620 ci.ndm_used = jiffies_to_clock_t(now - neigh->used);
2621 ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
2622 ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated);
2623 ci.ndm_refcnt = refcount_read(&neigh->refcnt) - 1;
2624 read_unlock_bh(&neigh->lock);
2626 if (nla_put_u32(skb, NDA_PROBES, atomic_read(&neigh->probes)) ||
2627 nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
2628 goto nla_put_failure;
2630 if (neigh->protocol && nla_put_u8(skb, NDA_PROTOCOL, neigh->protocol))
2631 goto nla_put_failure;
2632 if (neigh_flags_ext && nla_put_u32(skb, NDA_FLAGS_EXT, neigh_flags_ext))
2633 goto nla_put_failure;
2635 nlmsg_end(skb, nlh);
2639 nlmsg_cancel(skb, nlh);
2643 static int pneigh_fill_info(struct sk_buff *skb, struct pneigh_entry *pn,
2644 u32 pid, u32 seq, int type, unsigned int flags,
2645 struct neigh_table *tbl)
2647 u32 neigh_flags, neigh_flags_ext;
2648 struct nlmsghdr *nlh;
2651 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2655 neigh_flags_ext = pn->flags >> NTF_EXT_SHIFT;
2656 neigh_flags = pn->flags & NTF_OLD_MASK;
2658 ndm = nlmsg_data(nlh);
2659 ndm->ndm_family = tbl->family;
2662 ndm->ndm_flags = neigh_flags | NTF_PROXY;
2663 ndm->ndm_type = RTN_UNICAST;
2664 ndm->ndm_ifindex = pn->dev ? pn->dev->ifindex : 0;
2665 ndm->ndm_state = NUD_NONE;
2667 if (nla_put(skb, NDA_DST, tbl->key_len, pn->key))
2668 goto nla_put_failure;
2670 if (pn->protocol && nla_put_u8(skb, NDA_PROTOCOL, pn->protocol))
2671 goto nla_put_failure;
2672 if (neigh_flags_ext && nla_put_u32(skb, NDA_FLAGS_EXT, neigh_flags_ext))
2673 goto nla_put_failure;
2675 nlmsg_end(skb, nlh);
2679 nlmsg_cancel(skb, nlh);
2683 static void neigh_update_notify(struct neighbour *neigh, u32 nlmsg_pid)
2685 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2686 __neigh_notify(neigh, RTM_NEWNEIGH, 0, nlmsg_pid);
2689 static bool neigh_master_filtered(struct net_device *dev, int master_idx)
2691 struct net_device *master;
2696 master = dev ? netdev_master_upper_dev_get(dev) : NULL;
2698 /* 0 is already used to denote NDA_MASTER wasn't passed, therefore need another
2699 * invalid value for ifindex to denote "no master".
2701 if (master_idx == -1)
2704 if (!master || master->ifindex != master_idx)
2710 static bool neigh_ifindex_filtered(struct net_device *dev, int filter_idx)
2712 if (filter_idx && (!dev || dev->ifindex != filter_idx))
2718 struct neigh_dump_filter {
2723 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2724 struct netlink_callback *cb,
2725 struct neigh_dump_filter *filter)
2727 struct net *net = sock_net(skb->sk);
2728 struct neighbour *n;
2729 int rc, h, s_h = cb->args[1];
2730 int idx, s_idx = idx = cb->args[2];
2731 struct neigh_hash_table *nht;
2732 unsigned int flags = NLM_F_MULTI;
2734 if (filter->dev_idx || filter->master_idx)
2735 flags |= NLM_F_DUMP_FILTERED;
2738 nht = rcu_dereference_bh(tbl->nht);
2740 for (h = s_h; h < (1 << nht->hash_shift); h++) {
2743 for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0;
2745 n = rcu_dereference_bh(n->next)) {
2746 if (idx < s_idx || !net_eq(dev_net(n->dev), net))
2748 if (neigh_ifindex_filtered(n->dev, filter->dev_idx) ||
2749 neigh_master_filtered(n->dev, filter->master_idx))
2751 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
2764 rcu_read_unlock_bh();
2770 static int pneigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2771 struct netlink_callback *cb,
2772 struct neigh_dump_filter *filter)
2774 struct pneigh_entry *n;
2775 struct net *net = sock_net(skb->sk);
2776 int rc, h, s_h = cb->args[3];
2777 int idx, s_idx = idx = cb->args[4];
2778 unsigned int flags = NLM_F_MULTI;
2780 if (filter->dev_idx || filter->master_idx)
2781 flags |= NLM_F_DUMP_FILTERED;
2783 read_lock_bh(&tbl->lock);
2785 for (h = s_h; h <= PNEIGH_HASHMASK; h++) {
2788 for (n = tbl->phash_buckets[h], idx = 0; n; n = n->next) {
2789 if (idx < s_idx || pneigh_net(n) != net)
2791 if (neigh_ifindex_filtered(n->dev, filter->dev_idx) ||
2792 neigh_master_filtered(n->dev, filter->master_idx))
2794 if (pneigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
2796 RTM_NEWNEIGH, flags, tbl) < 0) {
2797 read_unlock_bh(&tbl->lock);
2806 read_unlock_bh(&tbl->lock);
2815 static int neigh_valid_dump_req(const struct nlmsghdr *nlh,
2817 struct neigh_dump_filter *filter,
2818 struct netlink_ext_ack *extack)
2820 struct nlattr *tb[NDA_MAX + 1];
2826 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
2827 NL_SET_ERR_MSG(extack, "Invalid header for neighbor dump request");
2831 ndm = nlmsg_data(nlh);
2832 if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_ifindex ||
2833 ndm->ndm_state || ndm->ndm_type) {
2834 NL_SET_ERR_MSG(extack, "Invalid values in header for neighbor dump request");
2838 if (ndm->ndm_flags & ~NTF_PROXY) {
2839 NL_SET_ERR_MSG(extack, "Invalid flags in header for neighbor dump request");
2843 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg),
2844 tb, NDA_MAX, nda_policy,
2847 err = nlmsg_parse_deprecated(nlh, sizeof(struct ndmsg), tb,
2848 NDA_MAX, nda_policy, extack);
2853 for (i = 0; i <= NDA_MAX; ++i) {
2857 /* all new attributes should require strict_check */
2860 filter->dev_idx = nla_get_u32(tb[i]);
2863 filter->master_idx = nla_get_u32(tb[i]);
2867 NL_SET_ERR_MSG(extack, "Unsupported attribute in neighbor dump request");
2876 static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
2878 const struct nlmsghdr *nlh = cb->nlh;
2879 struct neigh_dump_filter filter = {};
2880 struct neigh_table *tbl;
2885 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
2887 /* check for full ndmsg structure presence, family member is
2888 * the same for both structures
2890 if (nlmsg_len(nlh) >= sizeof(struct ndmsg) &&
2891 ((struct ndmsg *)nlmsg_data(nlh))->ndm_flags == NTF_PROXY)
2894 err = neigh_valid_dump_req(nlh, cb->strict_check, &filter, cb->extack);
2895 if (err < 0 && cb->strict_check)
2900 for (t = 0; t < NEIGH_NR_TABLES; t++) {
2901 tbl = neigh_tables[t];
2905 if (t < s_t || (family && tbl->family != family))
2908 memset(&cb->args[1], 0, sizeof(cb->args) -
2909 sizeof(cb->args[0]));
2911 err = pneigh_dump_table(tbl, skb, cb, &filter);
2913 err = neigh_dump_table(tbl, skb, cb, &filter);
2922 static int neigh_valid_get_req(const struct nlmsghdr *nlh,
2923 struct neigh_table **tbl,
2924 void **dst, int *dev_idx, u8 *ndm_flags,
2925 struct netlink_ext_ack *extack)
2927 struct nlattr *tb[NDA_MAX + 1];
2931 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
2932 NL_SET_ERR_MSG(extack, "Invalid header for neighbor get request");
2936 ndm = nlmsg_data(nlh);
2937 if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_state ||
2939 NL_SET_ERR_MSG(extack, "Invalid values in header for neighbor get request");
2943 if (ndm->ndm_flags & ~NTF_PROXY) {
2944 NL_SET_ERR_MSG(extack, "Invalid flags in header for neighbor get request");
2948 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
2949 NDA_MAX, nda_policy, extack);
2953 *ndm_flags = ndm->ndm_flags;
2954 *dev_idx = ndm->ndm_ifindex;
2955 *tbl = neigh_find_table(ndm->ndm_family);
2957 NL_SET_ERR_MSG(extack, "Unsupported family in header for neighbor get request");
2958 return -EAFNOSUPPORT;
2961 for (i = 0; i <= NDA_MAX; ++i) {
2967 if (nla_len(tb[i]) != (int)(*tbl)->key_len) {
2968 NL_SET_ERR_MSG(extack, "Invalid network address in neighbor get request");
2971 *dst = nla_data(tb[i]);
2974 NL_SET_ERR_MSG(extack, "Unsupported attribute in neighbor get request");
2982 static inline size_t neigh_nlmsg_size(void)
2984 return NLMSG_ALIGN(sizeof(struct ndmsg))
2985 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2986 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2987 + nla_total_size(sizeof(struct nda_cacheinfo))
2988 + nla_total_size(4) /* NDA_PROBES */
2989 + nla_total_size(4) /* NDA_FLAGS_EXT */
2990 + nla_total_size(1); /* NDA_PROTOCOL */
2993 static int neigh_get_reply(struct net *net, struct neighbour *neigh,
2996 struct sk_buff *skb;
2999 skb = nlmsg_new(neigh_nlmsg_size(), GFP_KERNEL);
3003 err = neigh_fill_info(skb, neigh, pid, seq, RTM_NEWNEIGH, 0);
3009 err = rtnl_unicast(skb, net, pid);
3014 static inline size_t pneigh_nlmsg_size(void)
3016 return NLMSG_ALIGN(sizeof(struct ndmsg))
3017 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
3018 + nla_total_size(4) /* NDA_FLAGS_EXT */
3019 + nla_total_size(1); /* NDA_PROTOCOL */
3022 static int pneigh_get_reply(struct net *net, struct pneigh_entry *neigh,
3023 u32 pid, u32 seq, struct neigh_table *tbl)
3025 struct sk_buff *skb;
3028 skb = nlmsg_new(pneigh_nlmsg_size(), GFP_KERNEL);
3032 err = pneigh_fill_info(skb, neigh, pid, seq, RTM_NEWNEIGH, 0, tbl);
3038 err = rtnl_unicast(skb, net, pid);
3043 static int neigh_get(struct sk_buff *in_skb, struct nlmsghdr *nlh,
3044 struct netlink_ext_ack *extack)
3046 struct net *net = sock_net(in_skb->sk);
3047 struct net_device *dev = NULL;
3048 struct neigh_table *tbl = NULL;
3049 struct neighbour *neigh;
3055 err = neigh_valid_get_req(nlh, &tbl, &dst, &dev_idx, &ndm_flags,
3061 dev = __dev_get_by_index(net, dev_idx);
3063 NL_SET_ERR_MSG(extack, "Unknown device ifindex");
3069 NL_SET_ERR_MSG(extack, "Network address not specified");
3073 if (ndm_flags & NTF_PROXY) {
3074 struct pneigh_entry *pn;
3076 pn = pneigh_lookup(tbl, net, dst, dev, 0);
3078 NL_SET_ERR_MSG(extack, "Proxy neighbour entry not found");
3081 return pneigh_get_reply(net, pn, NETLINK_CB(in_skb).portid,
3082 nlh->nlmsg_seq, tbl);
3086 NL_SET_ERR_MSG(extack, "No device specified");
3090 neigh = neigh_lookup(tbl, dst, dev);
3092 NL_SET_ERR_MSG(extack, "Neighbour entry not found");
3096 err = neigh_get_reply(net, neigh, NETLINK_CB(in_skb).portid,
3099 neigh_release(neigh);
3104 void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
3107 struct neigh_hash_table *nht;
3110 nht = rcu_dereference_bh(tbl->nht);
3112 read_lock(&tbl->lock); /* avoid resizes */
3113 for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
3114 struct neighbour *n;
3116 for (n = rcu_dereference_bh(nht->hash_buckets[chain]);
3118 n = rcu_dereference_bh(n->next))
3121 read_unlock(&tbl->lock);
3122 rcu_read_unlock_bh();
3124 EXPORT_SYMBOL(neigh_for_each);
3126 /* The tbl->lock must be held as a writer and BH disabled. */
3127 void __neigh_for_each_release(struct neigh_table *tbl,
3128 int (*cb)(struct neighbour *))
3131 struct neigh_hash_table *nht;
3133 nht = rcu_dereference_protected(tbl->nht,
3134 lockdep_is_held(&tbl->lock));
3135 for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
3136 struct neighbour *n;
3137 struct neighbour __rcu **np;
3139 np = &nht->hash_buckets[chain];
3140 while ((n = rcu_dereference_protected(*np,
3141 lockdep_is_held(&tbl->lock))) != NULL) {
3144 write_lock(&n->lock);
3147 rcu_assign_pointer(*np,
3148 rcu_dereference_protected(n->next,
3149 lockdep_is_held(&tbl->lock)));
3153 write_unlock(&n->lock);
3155 neigh_cleanup_and_release(n);
3159 EXPORT_SYMBOL(__neigh_for_each_release);
3161 int neigh_xmit(int index, struct net_device *dev,
3162 const void *addr, struct sk_buff *skb)
3164 int err = -EAFNOSUPPORT;
3165 if (likely(index < NEIGH_NR_TABLES)) {
3166 struct neigh_table *tbl;
3167 struct neighbour *neigh;
3169 tbl = neigh_tables[index];
3173 if (index == NEIGH_ARP_TABLE) {
3174 u32 key = *((u32 *)addr);
3176 neigh = __ipv4_neigh_lookup_noref(dev, key);
3178 neigh = __neigh_lookup_noref(tbl, addr, dev);
3181 neigh = __neigh_create(tbl, addr, dev, false);
3182 err = PTR_ERR(neigh);
3183 if (IS_ERR(neigh)) {
3184 rcu_read_unlock_bh();
3187 err = neigh->output(neigh, skb);
3188 rcu_read_unlock_bh();
3190 else if (index == NEIGH_LINK_TABLE) {
3191 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
3192 addr, NULL, skb->len);
3195 err = dev_queue_xmit(skb);
3203 EXPORT_SYMBOL(neigh_xmit);
3205 #ifdef CONFIG_PROC_FS
3207 static struct neighbour *neigh_get_first(struct seq_file *seq)
3209 struct neigh_seq_state *state = seq->private;
3210 struct net *net = seq_file_net(seq);
3211 struct neigh_hash_table *nht = state->nht;
3212 struct neighbour *n = NULL;
3215 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
3216 for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) {
3217 n = rcu_dereference_bh(nht->hash_buckets[bucket]);
3220 if (!net_eq(dev_net(n->dev), net))
3222 if (state->neigh_sub_iter) {
3226 v = state->neigh_sub_iter(state, n, &fakep);
3230 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
3232 if (n->nud_state & ~NUD_NOARP)
3235 n = rcu_dereference_bh(n->next);
3241 state->bucket = bucket;
3246 static struct neighbour *neigh_get_next(struct seq_file *seq,
3247 struct neighbour *n,
3250 struct neigh_seq_state *state = seq->private;
3251 struct net *net = seq_file_net(seq);
3252 struct neigh_hash_table *nht = state->nht;
3254 if (state->neigh_sub_iter) {
3255 void *v = state->neigh_sub_iter(state, n, pos);
3259 n = rcu_dereference_bh(n->next);
3263 if (!net_eq(dev_net(n->dev), net))
3265 if (state->neigh_sub_iter) {
3266 void *v = state->neigh_sub_iter(state, n, pos);
3271 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
3274 if (n->nud_state & ~NUD_NOARP)
3277 n = rcu_dereference_bh(n->next);
3283 if (++state->bucket >= (1 << nht->hash_shift))
3286 n = rcu_dereference_bh(nht->hash_buckets[state->bucket]);
3294 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
3296 struct neighbour *n = neigh_get_first(seq);
3301 n = neigh_get_next(seq, n, pos);
3306 return *pos ? NULL : n;
3309 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
3311 struct neigh_seq_state *state = seq->private;
3312 struct net *net = seq_file_net(seq);
3313 struct neigh_table *tbl = state->tbl;
3314 struct pneigh_entry *pn = NULL;
3317 state->flags |= NEIGH_SEQ_IS_PNEIGH;
3318 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
3319 pn = tbl->phash_buckets[bucket];
3320 while (pn && !net_eq(pneigh_net(pn), net))
3325 state->bucket = bucket;
3330 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
3331 struct pneigh_entry *pn,
3334 struct neigh_seq_state *state = seq->private;
3335 struct net *net = seq_file_net(seq);
3336 struct neigh_table *tbl = state->tbl;
3340 } while (pn && !net_eq(pneigh_net(pn), net));
3343 if (++state->bucket > PNEIGH_HASHMASK)
3345 pn = tbl->phash_buckets[state->bucket];
3346 while (pn && !net_eq(pneigh_net(pn), net))
3358 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
3360 struct pneigh_entry *pn = pneigh_get_first(seq);
3365 pn = pneigh_get_next(seq, pn, pos);
3370 return *pos ? NULL : pn;
3373 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
3375 struct neigh_seq_state *state = seq->private;
3377 loff_t idxpos = *pos;
3379 rc = neigh_get_idx(seq, &idxpos);
3380 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
3381 rc = pneigh_get_idx(seq, &idxpos);
3386 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
3387 __acquires(tbl->lock)
3390 struct neigh_seq_state *state = seq->private;
3394 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
3397 state->nht = rcu_dereference_bh(tbl->nht);
3398 read_lock(&tbl->lock);
3400 return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN;
3402 EXPORT_SYMBOL(neigh_seq_start);
3404 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3406 struct neigh_seq_state *state;
3409 if (v == SEQ_START_TOKEN) {
3410 rc = neigh_get_first(seq);
3414 state = seq->private;
3415 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
3416 rc = neigh_get_next(seq, v, NULL);
3419 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
3420 rc = pneigh_get_first(seq);
3422 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
3423 rc = pneigh_get_next(seq, v, NULL);
3429 EXPORT_SYMBOL(neigh_seq_next);
3431 void neigh_seq_stop(struct seq_file *seq, void *v)
3432 __releases(tbl->lock)
3435 struct neigh_seq_state *state = seq->private;
3436 struct neigh_table *tbl = state->tbl;
3438 read_unlock(&tbl->lock);
3439 rcu_read_unlock_bh();
3441 EXPORT_SYMBOL(neigh_seq_stop);
3443 /* statistics via seq_file */
3445 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
3447 struct neigh_table *tbl = pde_data(file_inode(seq->file));
3451 return SEQ_START_TOKEN;
3453 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
3454 if (!cpu_possible(cpu))
3457 return per_cpu_ptr(tbl->stats, cpu);
3462 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3464 struct neigh_table *tbl = pde_data(file_inode(seq->file));
3467 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
3468 if (!cpu_possible(cpu))
3471 return per_cpu_ptr(tbl->stats, cpu);
3477 static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
3482 static int neigh_stat_seq_show(struct seq_file *seq, void *v)
3484 struct neigh_table *tbl = pde_data(file_inode(seq->file));
3485 struct neigh_statistics *st = v;
3487 if (v == SEQ_START_TOKEN) {
3488 seq_puts(seq, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs unresolved_discards table_fulls\n");
3492 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
3493 "%08lx %08lx %08lx "
3494 "%08lx %08lx %08lx\n",
3495 atomic_read(&tbl->entries),
3506 st->rcv_probes_mcast,
3507 st->rcv_probes_ucast,
3509 st->periodic_gc_runs,
3518 static const struct seq_operations neigh_stat_seq_ops = {
3519 .start = neigh_stat_seq_start,
3520 .next = neigh_stat_seq_next,
3521 .stop = neigh_stat_seq_stop,
3522 .show = neigh_stat_seq_show,
3524 #endif /* CONFIG_PROC_FS */
3526 static void __neigh_notify(struct neighbour *n, int type, int flags,
3529 struct net *net = dev_net(n->dev);
3530 struct sk_buff *skb;
3533 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
3537 err = neigh_fill_info(skb, n, pid, 0, type, flags);
3539 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
3540 WARN_ON(err == -EMSGSIZE);
3544 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
3548 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
3551 void neigh_app_ns(struct neighbour *n)
3553 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST, 0);
3555 EXPORT_SYMBOL(neigh_app_ns);
3557 #ifdef CONFIG_SYSCTL
3558 static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN);
3560 static int proc_unres_qlen(struct ctl_table *ctl, int write,
3561 void *buffer, size_t *lenp, loff_t *ppos)
3564 struct ctl_table tmp = *ctl;
3566 tmp.extra1 = SYSCTL_ZERO;
3567 tmp.extra2 = &unres_qlen_max;
3570 size = *(int *)ctl->data / SKB_TRUESIZE(ETH_FRAME_LEN);
3571 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
3574 *(int *)ctl->data = size * SKB_TRUESIZE(ETH_FRAME_LEN);
3578 static void neigh_copy_dflt_parms(struct net *net, struct neigh_parms *p,
3581 struct net_device *dev;
3582 int family = neigh_parms_family(p);
3585 for_each_netdev_rcu(net, dev) {
3586 struct neigh_parms *dst_p =
3587 neigh_get_dev_parms_rcu(dev, family);
3589 if (dst_p && !test_bit(index, dst_p->data_state))
3590 dst_p->data[index] = p->data[index];
3595 static void neigh_proc_update(struct ctl_table *ctl, int write)
3597 struct net_device *dev = ctl->extra1;
3598 struct neigh_parms *p = ctl->extra2;
3599 struct net *net = neigh_parms_net(p);
3600 int index = (int *) ctl->data - p->data;
3605 set_bit(index, p->data_state);
3606 if (index == NEIGH_VAR_DELAY_PROBE_TIME)
3607 call_netevent_notifiers(NETEVENT_DELAY_PROBE_TIME_UPDATE, p);
3608 if (!dev) /* NULL dev means this is default value */
3609 neigh_copy_dflt_parms(net, p, index);
3612 static int neigh_proc_dointvec_zero_intmax(struct ctl_table *ctl, int write,
3613 void *buffer, size_t *lenp,
3616 struct ctl_table tmp = *ctl;
3619 tmp.extra1 = SYSCTL_ZERO;
3620 tmp.extra2 = SYSCTL_INT_MAX;
3622 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
3623 neigh_proc_update(ctl, write);
3627 static int neigh_proc_dointvec_ms_jiffies_positive(struct ctl_table *ctl, int write,
3628 void *buffer, size_t *lenp, loff_t *ppos)
3630 struct ctl_table tmp = *ctl;
3633 int min = msecs_to_jiffies(1);
3638 ret = proc_dointvec_ms_jiffies_minmax(&tmp, write, buffer, lenp, ppos);
3639 neigh_proc_update(ctl, write);
3643 int neigh_proc_dointvec(struct ctl_table *ctl, int write, void *buffer,
3644 size_t *lenp, loff_t *ppos)
3646 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
3648 neigh_proc_update(ctl, write);
3651 EXPORT_SYMBOL(neigh_proc_dointvec);
3653 int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write, void *buffer,
3654 size_t *lenp, loff_t *ppos)
3656 int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
3658 neigh_proc_update(ctl, write);
3661 EXPORT_SYMBOL(neigh_proc_dointvec_jiffies);
3663 static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table *ctl, int write,
3664 void *buffer, size_t *lenp,
3667 int ret = proc_dointvec_userhz_jiffies(ctl, write, buffer, lenp, ppos);
3669 neigh_proc_update(ctl, write);
3673 int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write,
3674 void *buffer, size_t *lenp, loff_t *ppos)
3676 int ret = proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
3678 neigh_proc_update(ctl, write);
3681 EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies);
3683 static int neigh_proc_dointvec_unres_qlen(struct ctl_table *ctl, int write,
3684 void *buffer, size_t *lenp,
3687 int ret = proc_unres_qlen(ctl, write, buffer, lenp, ppos);
3689 neigh_proc_update(ctl, write);
3693 static int neigh_proc_base_reachable_time(struct ctl_table *ctl, int write,
3694 void *buffer, size_t *lenp,
3697 struct neigh_parms *p = ctl->extra2;
3700 if (strcmp(ctl->procname, "base_reachable_time") == 0)
3701 ret = neigh_proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
3702 else if (strcmp(ctl->procname, "base_reachable_time_ms") == 0)
3703 ret = neigh_proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
3707 if (write && ret == 0) {
3708 /* update reachable_time as well, otherwise, the change will
3709 * only be effective after the next time neigh_periodic_work
3710 * decides to recompute it
3713 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
3718 #define NEIGH_PARMS_DATA_OFFSET(index) \
3719 (&((struct neigh_parms *) 0)->data[index])
3721 #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \
3722 [NEIGH_VAR_ ## attr] = { \
3724 .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \
3725 .maxlen = sizeof(int), \
3727 .proc_handler = proc, \
3730 #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \
3731 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax)
3733 #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \
3734 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies)
3736 #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \
3737 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies)
3739 #define NEIGH_SYSCTL_MS_JIFFIES_POSITIVE_ENTRY(attr, name) \
3740 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies_positive)
3742 #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \
3743 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
3745 #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \
3746 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen)
3748 static struct neigh_sysctl_table {
3749 struct ctl_table_header *sysctl_header;
3750 struct ctl_table neigh_vars[NEIGH_VAR_MAX + 1];
3751 } neigh_sysctl_template __read_mostly = {
3753 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES, "mcast_solicit"),
3754 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES, "ucast_solicit"),
3755 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES, "app_solicit"),
3756 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_REPROBES, "mcast_resolicit"),
3757 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME, "retrans_time"),
3758 NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME, "base_reachable_time"),
3759 NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME, "delay_first_probe_time"),
3760 NEIGH_SYSCTL_MS_JIFFIES_POSITIVE_ENTRY(INTERVAL_PROBE_TIME_MS,
3761 "interval_probe_time_ms"),
3762 NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME, "gc_stale_time"),
3763 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES, "unres_qlen_bytes"),
3764 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN, "proxy_qlen"),
3765 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY, "anycast_delay"),
3766 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY, "proxy_delay"),
3767 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME, "locktime"),
3768 NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN, QUEUE_LEN_BYTES, "unres_qlen"),
3769 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS, RETRANS_TIME, "retrans_time_ms"),
3770 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS, BASE_REACHABLE_TIME, "base_reachable_time_ms"),
3771 [NEIGH_VAR_GC_INTERVAL] = {
3772 .procname = "gc_interval",
3773 .maxlen = sizeof(int),
3775 .proc_handler = proc_dointvec_jiffies,
3777 [NEIGH_VAR_GC_THRESH1] = {
3778 .procname = "gc_thresh1",
3779 .maxlen = sizeof(int),
3781 .extra1 = SYSCTL_ZERO,
3782 .extra2 = SYSCTL_INT_MAX,
3783 .proc_handler = proc_dointvec_minmax,
3785 [NEIGH_VAR_GC_THRESH2] = {
3786 .procname = "gc_thresh2",
3787 .maxlen = sizeof(int),
3789 .extra1 = SYSCTL_ZERO,
3790 .extra2 = SYSCTL_INT_MAX,
3791 .proc_handler = proc_dointvec_minmax,
3793 [NEIGH_VAR_GC_THRESH3] = {
3794 .procname = "gc_thresh3",
3795 .maxlen = sizeof(int),
3797 .extra1 = SYSCTL_ZERO,
3798 .extra2 = SYSCTL_INT_MAX,
3799 .proc_handler = proc_dointvec_minmax,
3805 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
3806 proc_handler *handler)
3809 struct neigh_sysctl_table *t;
3810 const char *dev_name_source;
3811 char neigh_path[ sizeof("net//neigh/") + IFNAMSIZ + IFNAMSIZ ];
3814 t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL_ACCOUNT);
3818 for (i = 0; i < NEIGH_VAR_GC_INTERVAL; i++) {
3819 t->neigh_vars[i].data += (long) p;
3820 t->neigh_vars[i].extra1 = dev;
3821 t->neigh_vars[i].extra2 = p;
3825 dev_name_source = dev->name;
3826 /* Terminate the table early */
3827 memset(&t->neigh_vars[NEIGH_VAR_GC_INTERVAL], 0,
3828 sizeof(t->neigh_vars[NEIGH_VAR_GC_INTERVAL]));
3830 struct neigh_table *tbl = p->tbl;
3831 dev_name_source = "default";
3832 t->neigh_vars[NEIGH_VAR_GC_INTERVAL].data = &tbl->gc_interval;
3833 t->neigh_vars[NEIGH_VAR_GC_THRESH1].data = &tbl->gc_thresh1;
3834 t->neigh_vars[NEIGH_VAR_GC_THRESH2].data = &tbl->gc_thresh2;
3835 t->neigh_vars[NEIGH_VAR_GC_THRESH3].data = &tbl->gc_thresh3;
3840 t->neigh_vars[NEIGH_VAR_RETRANS_TIME].proc_handler = handler;
3842 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = handler;
3843 /* RetransTime (in milliseconds)*/
3844 t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].proc_handler = handler;
3845 /* ReachableTime (in milliseconds) */
3846 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = handler;
3848 /* Those handlers will update p->reachable_time after
3849 * base_reachable_time(_ms) is set to ensure the new timer starts being
3850 * applied after the next neighbour update instead of waiting for
3851 * neigh_periodic_work to update its value (can be multiple minutes)
3852 * So any handler that replaces them should do this as well
3855 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler =
3856 neigh_proc_base_reachable_time;
3857 /* ReachableTime (in milliseconds) */
3858 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler =
3859 neigh_proc_base_reachable_time;
3862 switch (neigh_parms_family(p)) {
3873 snprintf(neigh_path, sizeof(neigh_path), "net/%s/neigh/%s",
3874 p_name, dev_name_source);
3876 register_net_sysctl(neigh_parms_net(p), neigh_path, t->neigh_vars);
3877 if (!t->sysctl_header)
3880 p->sysctl_table = t;
3888 EXPORT_SYMBOL(neigh_sysctl_register);
3890 void neigh_sysctl_unregister(struct neigh_parms *p)
3892 if (p->sysctl_table) {
3893 struct neigh_sysctl_table *t = p->sysctl_table;
3894 p->sysctl_table = NULL;
3895 unregister_net_sysctl_table(t->sysctl_header);
3899 EXPORT_SYMBOL(neigh_sysctl_unregister);
3901 #endif /* CONFIG_SYSCTL */
3903 static int __init neigh_init(void)
3905 rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, 0);
3906 rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, 0);
3907 rtnl_register(PF_UNSPEC, RTM_GETNEIGH, neigh_get, neigh_dump_info, 0);
3909 rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info,
3911 rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, 0);
3916 subsys_initcall(neigh_init);