2 * Generic address resolution entity
5 * Pedro Roque <roque@di.fc.ul.pt>
6 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
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.
14 * Vitaly E. Lavrov releasing NULL neighbor in neigh_add.
15 * Harald Welte Add neighbour cache statistics like rtstat
18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <linux/slab.h>
21 #include <linux/types.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/socket.h>
25 #include <linux/netdevice.h>
26 #include <linux/proc_fs.h>
28 #include <linux/sysctl.h>
30 #include <linux/times.h>
31 #include <net/net_namespace.h>
32 #include <net/neighbour.h>
35 #include <net/netevent.h>
36 #include <net/netlink.h>
37 #include <linux/rtnetlink.h>
38 #include <linux/random.h>
39 #include <linux/string.h>
40 #include <linux/log2.h>
41 #include <linux/inetdevice.h>
42 #include <net/addrconf.h>
46 #define neigh_dbg(level, fmt, ...) \
48 if (level <= NEIGH_DEBUG) \
49 pr_debug(fmt, ##__VA_ARGS__); \
52 #define PNEIGH_HASHMASK 0xF
54 static void neigh_timer_handler(struct timer_list *t);
55 static void __neigh_notify(struct neighbour *n, int type, int flags,
57 static void neigh_update_notify(struct neighbour *neigh, u32 nlmsg_pid);
58 static int pneigh_ifdown_and_unlock(struct neigh_table *tbl,
59 struct net_device *dev);
62 static const struct seq_operations neigh_stat_seq_ops;
66 Neighbour hash table buckets are protected with rwlock tbl->lock.
68 - All the scans/updates to hash buckets MUST be made under this lock.
69 - NOTHING clever should be made under this lock: no callbacks
70 to protocol backends, no attempts to send something to network.
71 It will result in deadlocks, if backend/driver wants to use neighbour
73 - If the entry requires some non-trivial actions, increase
74 its reference count and release table lock.
76 Neighbour entries are protected:
77 - with reference count.
78 - with rwlock neigh->lock
80 Reference count prevents destruction.
82 neigh->lock mainly serializes ll address data and its validity state.
83 However, the same lock is used to protect another entry fields:
87 Again, nothing clever shall be made under neigh->lock,
88 the most complicated procedure, which we allow is dev->hard_header.
89 It is supposed, that dev->hard_header is simplistic and does
90 not make callbacks to neighbour tables.
93 static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb)
99 static void neigh_cleanup_and_release(struct neighbour *neigh)
101 if (neigh->parms->neigh_cleanup)
102 neigh->parms->neigh_cleanup(neigh);
104 __neigh_notify(neigh, RTM_DELNEIGH, 0, 0);
105 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
106 neigh_release(neigh);
110 * It is random distribution in the interval (1/2)*base...(3/2)*base.
111 * It corresponds to default IPv6 settings and is not overridable,
112 * because it is really reasonable choice.
115 unsigned long neigh_rand_reach_time(unsigned long base)
117 return base ? (prandom_u32() % base) + (base >> 1) : 0;
119 EXPORT_SYMBOL(neigh_rand_reach_time);
122 static bool neigh_del(struct neighbour *n, __u8 state, __u8 flags,
123 struct neighbour __rcu **np, struct neigh_table *tbl)
127 write_lock(&n->lock);
128 if (refcount_read(&n->refcnt) == 1 && !(n->nud_state & state) &&
129 !(n->flags & flags)) {
130 struct neighbour *neigh;
132 neigh = rcu_dereference_protected(n->next,
133 lockdep_is_held(&tbl->lock));
134 rcu_assign_pointer(*np, neigh);
138 write_unlock(&n->lock);
140 neigh_cleanup_and_release(n);
144 bool neigh_remove_one(struct neighbour *ndel, struct neigh_table *tbl)
146 struct neigh_hash_table *nht;
147 void *pkey = ndel->primary_key;
150 struct neighbour __rcu **np;
152 nht = rcu_dereference_protected(tbl->nht,
153 lockdep_is_held(&tbl->lock));
154 hash_val = tbl->hash(pkey, ndel->dev, nht->hash_rnd);
155 hash_val = hash_val >> (32 - nht->hash_shift);
157 np = &nht->hash_buckets[hash_val];
158 while ((n = rcu_dereference_protected(*np,
159 lockdep_is_held(&tbl->lock)))) {
161 return neigh_del(n, 0, 0, np, tbl);
167 static int neigh_forced_gc(struct neigh_table *tbl)
171 struct neigh_hash_table *nht;
173 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
175 write_lock_bh(&tbl->lock);
176 nht = rcu_dereference_protected(tbl->nht,
177 lockdep_is_held(&tbl->lock));
178 for (i = 0; i < (1 << nht->hash_shift); i++) {
180 struct neighbour __rcu **np;
182 np = &nht->hash_buckets[i];
183 while ((n = rcu_dereference_protected(*np,
184 lockdep_is_held(&tbl->lock))) != NULL) {
185 /* Neighbour record may be discarded if:
186 * - nobody refers to it.
187 * - it is not permanent
189 if (neigh_del(n, NUD_PERMANENT, NTF_EXT_LEARNED, np,
198 tbl->last_flush = jiffies;
200 write_unlock_bh(&tbl->lock);
205 static void neigh_add_timer(struct neighbour *n, unsigned long when)
208 if (unlikely(mod_timer(&n->timer, when))) {
209 printk("NEIGH: BUG, double timer add, state is %x\n",
215 static int neigh_del_timer(struct neighbour *n)
217 if ((n->nud_state & NUD_IN_TIMER) &&
218 del_timer(&n->timer)) {
225 static void pneigh_queue_purge(struct sk_buff_head *list)
229 while ((skb = skb_dequeue(list)) != NULL) {
235 static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
238 struct neigh_hash_table *nht;
240 nht = rcu_dereference_protected(tbl->nht,
241 lockdep_is_held(&tbl->lock));
243 for (i = 0; i < (1 << nht->hash_shift); i++) {
245 struct neighbour __rcu **np = &nht->hash_buckets[i];
247 while ((n = rcu_dereference_protected(*np,
248 lockdep_is_held(&tbl->lock))) != NULL) {
249 if (dev && n->dev != dev) {
253 rcu_assign_pointer(*np,
254 rcu_dereference_protected(n->next,
255 lockdep_is_held(&tbl->lock)));
256 write_lock(&n->lock);
260 if (refcount_read(&n->refcnt) != 1) {
261 /* The most unpleasant situation.
262 We must destroy neighbour entry,
263 but someone still uses it.
265 The destroy will be delayed until
266 the last user releases us, but
267 we must kill timers etc. and move
270 __skb_queue_purge(&n->arp_queue);
271 n->arp_queue_len_bytes = 0;
272 n->output = neigh_blackhole;
273 if (n->nud_state & NUD_VALID)
274 n->nud_state = NUD_NOARP;
276 n->nud_state = NUD_NONE;
277 neigh_dbg(2, "neigh %p is stray\n", n);
279 write_unlock(&n->lock);
280 neigh_cleanup_and_release(n);
285 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
287 write_lock_bh(&tbl->lock);
288 neigh_flush_dev(tbl, dev);
289 write_unlock_bh(&tbl->lock);
291 EXPORT_SYMBOL(neigh_changeaddr);
293 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
295 write_lock_bh(&tbl->lock);
296 neigh_flush_dev(tbl, dev);
297 pneigh_ifdown_and_unlock(tbl, dev);
299 del_timer_sync(&tbl->proxy_timer);
300 pneigh_queue_purge(&tbl->proxy_queue);
303 EXPORT_SYMBOL(neigh_ifdown);
305 static struct neighbour *neigh_alloc(struct neigh_table *tbl, struct net_device *dev)
307 struct neighbour *n = NULL;
308 unsigned long now = jiffies;
311 entries = atomic_inc_return(&tbl->entries) - 1;
312 if (entries >= tbl->gc_thresh3 ||
313 (entries >= tbl->gc_thresh2 &&
314 time_after(now, tbl->last_flush + 5 * HZ))) {
315 if (!neigh_forced_gc(tbl) &&
316 entries >= tbl->gc_thresh3) {
317 net_info_ratelimited("%s: neighbor table overflow!\n",
319 NEIGH_CACHE_STAT_INC(tbl, table_fulls);
324 n = kzalloc(tbl->entry_size + dev->neigh_priv_len, GFP_ATOMIC);
328 __skb_queue_head_init(&n->arp_queue);
329 rwlock_init(&n->lock);
330 seqlock_init(&n->ha_lock);
331 n->updated = n->used = now;
332 n->nud_state = NUD_NONE;
333 n->output = neigh_blackhole;
334 seqlock_init(&n->hh.hh_lock);
335 n->parms = neigh_parms_clone(&tbl->parms);
336 timer_setup(&n->timer, neigh_timer_handler, 0);
338 NEIGH_CACHE_STAT_INC(tbl, allocs);
340 refcount_set(&n->refcnt, 1);
346 atomic_dec(&tbl->entries);
350 static void neigh_get_hash_rnd(u32 *x)
352 *x = get_random_u32() | 1;
355 static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift)
357 size_t size = (1 << shift) * sizeof(struct neighbour *);
358 struct neigh_hash_table *ret;
359 struct neighbour __rcu **buckets;
362 ret = kmalloc(sizeof(*ret), GFP_ATOMIC);
365 if (size <= PAGE_SIZE)
366 buckets = kzalloc(size, GFP_ATOMIC);
368 buckets = (struct neighbour __rcu **)
369 __get_free_pages(GFP_ATOMIC | __GFP_ZERO,
375 ret->hash_buckets = buckets;
376 ret->hash_shift = shift;
377 for (i = 0; i < NEIGH_NUM_HASH_RND; i++)
378 neigh_get_hash_rnd(&ret->hash_rnd[i]);
382 static void neigh_hash_free_rcu(struct rcu_head *head)
384 struct neigh_hash_table *nht = container_of(head,
385 struct neigh_hash_table,
387 size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *);
388 struct neighbour __rcu **buckets = nht->hash_buckets;
390 if (size <= PAGE_SIZE)
393 free_pages((unsigned long)buckets, get_order(size));
397 static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl,
398 unsigned long new_shift)
400 unsigned int i, hash;
401 struct neigh_hash_table *new_nht, *old_nht;
403 NEIGH_CACHE_STAT_INC(tbl, hash_grows);
405 old_nht = rcu_dereference_protected(tbl->nht,
406 lockdep_is_held(&tbl->lock));
407 new_nht = neigh_hash_alloc(new_shift);
411 for (i = 0; i < (1 << old_nht->hash_shift); i++) {
412 struct neighbour *n, *next;
414 for (n = rcu_dereference_protected(old_nht->hash_buckets[i],
415 lockdep_is_held(&tbl->lock));
418 hash = tbl->hash(n->primary_key, n->dev,
421 hash >>= (32 - new_nht->hash_shift);
422 next = rcu_dereference_protected(n->next,
423 lockdep_is_held(&tbl->lock));
425 rcu_assign_pointer(n->next,
426 rcu_dereference_protected(
427 new_nht->hash_buckets[hash],
428 lockdep_is_held(&tbl->lock)));
429 rcu_assign_pointer(new_nht->hash_buckets[hash], n);
433 rcu_assign_pointer(tbl->nht, new_nht);
434 call_rcu(&old_nht->rcu, neigh_hash_free_rcu);
438 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
439 struct net_device *dev)
443 NEIGH_CACHE_STAT_INC(tbl, lookups);
446 n = __neigh_lookup_noref(tbl, pkey, dev);
448 if (!refcount_inc_not_zero(&n->refcnt))
450 NEIGH_CACHE_STAT_INC(tbl, hits);
453 rcu_read_unlock_bh();
456 EXPORT_SYMBOL(neigh_lookup);
458 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
462 unsigned int key_len = tbl->key_len;
464 struct neigh_hash_table *nht;
466 NEIGH_CACHE_STAT_INC(tbl, lookups);
469 nht = rcu_dereference_bh(tbl->nht);
470 hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift);
472 for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
474 n = rcu_dereference_bh(n->next)) {
475 if (!memcmp(n->primary_key, pkey, key_len) &&
476 net_eq(dev_net(n->dev), net)) {
477 if (!refcount_inc_not_zero(&n->refcnt))
479 NEIGH_CACHE_STAT_INC(tbl, hits);
484 rcu_read_unlock_bh();
487 EXPORT_SYMBOL(neigh_lookup_nodev);
489 struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey,
490 struct net_device *dev, bool want_ref)
493 unsigned int key_len = tbl->key_len;
495 struct neighbour *n1, *rc, *n = neigh_alloc(tbl, dev);
496 struct neigh_hash_table *nht;
499 rc = ERR_PTR(-ENOBUFS);
503 memcpy(n->primary_key, pkey, key_len);
507 /* Protocol specific setup. */
508 if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
510 goto out_neigh_release;
513 if (dev->netdev_ops->ndo_neigh_construct) {
514 error = dev->netdev_ops->ndo_neigh_construct(dev, n);
517 goto out_neigh_release;
521 /* Device specific setup. */
522 if (n->parms->neigh_setup &&
523 (error = n->parms->neigh_setup(n)) < 0) {
525 goto out_neigh_release;
528 n->confirmed = jiffies - (NEIGH_VAR(n->parms, BASE_REACHABLE_TIME) << 1);
530 write_lock_bh(&tbl->lock);
531 nht = rcu_dereference_protected(tbl->nht,
532 lockdep_is_held(&tbl->lock));
534 if (atomic_read(&tbl->entries) > (1 << nht->hash_shift))
535 nht = neigh_hash_grow(tbl, nht->hash_shift + 1);
537 hash_val = tbl->hash(n->primary_key, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
539 if (n->parms->dead) {
540 rc = ERR_PTR(-EINVAL);
544 for (n1 = rcu_dereference_protected(nht->hash_buckets[hash_val],
545 lockdep_is_held(&tbl->lock));
547 n1 = rcu_dereference_protected(n1->next,
548 lockdep_is_held(&tbl->lock))) {
549 if (dev == n1->dev && !memcmp(n1->primary_key, n->primary_key, key_len)) {
560 rcu_assign_pointer(n->next,
561 rcu_dereference_protected(nht->hash_buckets[hash_val],
562 lockdep_is_held(&tbl->lock)));
563 rcu_assign_pointer(nht->hash_buckets[hash_val], n);
564 write_unlock_bh(&tbl->lock);
565 neigh_dbg(2, "neigh %p is created\n", n);
570 write_unlock_bh(&tbl->lock);
575 EXPORT_SYMBOL(__neigh_create);
577 static u32 pneigh_hash(const void *pkey, unsigned int key_len)
579 u32 hash_val = *(u32 *)(pkey + key_len - 4);
580 hash_val ^= (hash_val >> 16);
581 hash_val ^= hash_val >> 8;
582 hash_val ^= hash_val >> 4;
583 hash_val &= PNEIGH_HASHMASK;
587 static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n,
590 unsigned int key_len,
591 struct net_device *dev)
594 if (!memcmp(n->key, pkey, key_len) &&
595 net_eq(pneigh_net(n), net) &&
596 (n->dev == dev || !n->dev))
603 struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl,
604 struct net *net, const void *pkey, struct net_device *dev)
606 unsigned int key_len = tbl->key_len;
607 u32 hash_val = pneigh_hash(pkey, key_len);
609 return __pneigh_lookup_1(tbl->phash_buckets[hash_val],
610 net, pkey, key_len, dev);
612 EXPORT_SYMBOL_GPL(__pneigh_lookup);
614 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl,
615 struct net *net, const void *pkey,
616 struct net_device *dev, int creat)
618 struct pneigh_entry *n;
619 unsigned int key_len = tbl->key_len;
620 u32 hash_val = pneigh_hash(pkey, key_len);
622 read_lock_bh(&tbl->lock);
623 n = __pneigh_lookup_1(tbl->phash_buckets[hash_val],
624 net, pkey, key_len, dev);
625 read_unlock_bh(&tbl->lock);
632 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
636 write_pnet(&n->net, net);
637 memcpy(n->key, pkey, key_len);
642 if (tbl->pconstructor && tbl->pconstructor(n)) {
650 write_lock_bh(&tbl->lock);
651 n->next = tbl->phash_buckets[hash_val];
652 tbl->phash_buckets[hash_val] = n;
653 write_unlock_bh(&tbl->lock);
657 EXPORT_SYMBOL(pneigh_lookup);
660 int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey,
661 struct net_device *dev)
663 struct pneigh_entry *n, **np;
664 unsigned int key_len = tbl->key_len;
665 u32 hash_val = pneigh_hash(pkey, key_len);
667 write_lock_bh(&tbl->lock);
668 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
670 if (!memcmp(n->key, pkey, key_len) && n->dev == dev &&
671 net_eq(pneigh_net(n), net)) {
673 write_unlock_bh(&tbl->lock);
674 if (tbl->pdestructor)
682 write_unlock_bh(&tbl->lock);
686 static int pneigh_ifdown_and_unlock(struct neigh_table *tbl,
687 struct net_device *dev)
689 struct pneigh_entry *n, **np, *freelist = NULL;
692 for (h = 0; h <= PNEIGH_HASHMASK; h++) {
693 np = &tbl->phash_buckets[h];
694 while ((n = *np) != NULL) {
695 if (!dev || n->dev == dev) {
704 write_unlock_bh(&tbl->lock);
705 while ((n = freelist)) {
708 if (tbl->pdestructor)
717 static void neigh_parms_destroy(struct neigh_parms *parms);
719 static inline void neigh_parms_put(struct neigh_parms *parms)
721 if (refcount_dec_and_test(&parms->refcnt))
722 neigh_parms_destroy(parms);
726 * neighbour must already be out of the table;
729 void neigh_destroy(struct neighbour *neigh)
731 struct net_device *dev = neigh->dev;
733 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
736 pr_warn("Destroying alive neighbour %p\n", neigh);
741 if (neigh_del_timer(neigh))
742 pr_warn("Impossible event\n");
744 write_lock_bh(&neigh->lock);
745 __skb_queue_purge(&neigh->arp_queue);
746 write_unlock_bh(&neigh->lock);
747 neigh->arp_queue_len_bytes = 0;
749 if (dev->netdev_ops->ndo_neigh_destroy)
750 dev->netdev_ops->ndo_neigh_destroy(dev, neigh);
753 neigh_parms_put(neigh->parms);
755 neigh_dbg(2, "neigh %p is destroyed\n", neigh);
757 atomic_dec(&neigh->tbl->entries);
758 kfree_rcu(neigh, rcu);
760 EXPORT_SYMBOL(neigh_destroy);
762 /* Neighbour state is suspicious;
765 Called with write_locked neigh.
767 static void neigh_suspect(struct neighbour *neigh)
769 neigh_dbg(2, "neigh %p is suspected\n", neigh);
771 neigh->output = neigh->ops->output;
774 /* Neighbour state is OK;
777 Called with write_locked neigh.
779 static void neigh_connect(struct neighbour *neigh)
781 neigh_dbg(2, "neigh %p is connected\n", neigh);
783 neigh->output = neigh->ops->connected_output;
786 static void neigh_periodic_work(struct work_struct *work)
788 struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work);
790 struct neighbour __rcu **np;
792 struct neigh_hash_table *nht;
794 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
796 write_lock_bh(&tbl->lock);
797 nht = rcu_dereference_protected(tbl->nht,
798 lockdep_is_held(&tbl->lock));
801 * periodically recompute ReachableTime from random function
804 if (time_after(jiffies, tbl->last_rand + 300 * HZ)) {
805 struct neigh_parms *p;
806 tbl->last_rand = jiffies;
807 list_for_each_entry(p, &tbl->parms_list, list)
809 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
812 if (atomic_read(&tbl->entries) < tbl->gc_thresh1)
815 for (i = 0 ; i < (1 << nht->hash_shift); i++) {
816 np = &nht->hash_buckets[i];
818 while ((n = rcu_dereference_protected(*np,
819 lockdep_is_held(&tbl->lock))) != NULL) {
822 write_lock(&n->lock);
824 state = n->nud_state;
825 if ((state & (NUD_PERMANENT | NUD_IN_TIMER)) ||
826 (n->flags & NTF_EXT_LEARNED)) {
827 write_unlock(&n->lock);
831 if (time_before(n->used, n->confirmed))
832 n->used = n->confirmed;
834 if (refcount_read(&n->refcnt) == 1 &&
835 (state == NUD_FAILED ||
836 time_after(jiffies, n->used + NEIGH_VAR(n->parms, GC_STALETIME)))) {
839 write_unlock(&n->lock);
840 neigh_cleanup_and_release(n);
843 write_unlock(&n->lock);
849 * It's fine to release lock here, even if hash table
850 * grows while we are preempted.
852 write_unlock_bh(&tbl->lock);
854 write_lock_bh(&tbl->lock);
855 nht = rcu_dereference_protected(tbl->nht,
856 lockdep_is_held(&tbl->lock));
859 /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks.
860 * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2
861 * BASE_REACHABLE_TIME.
863 queue_delayed_work(system_power_efficient_wq, &tbl->gc_work,
864 NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME) >> 1);
865 write_unlock_bh(&tbl->lock);
868 static __inline__ int neigh_max_probes(struct neighbour *n)
870 struct neigh_parms *p = n->parms;
871 return NEIGH_VAR(p, UCAST_PROBES) + NEIGH_VAR(p, APP_PROBES) +
872 (n->nud_state & NUD_PROBE ? NEIGH_VAR(p, MCAST_REPROBES) :
873 NEIGH_VAR(p, MCAST_PROBES));
876 static void neigh_invalidate(struct neighbour *neigh)
877 __releases(neigh->lock)
878 __acquires(neigh->lock)
882 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
883 neigh_dbg(2, "neigh %p is failed\n", neigh);
884 neigh->updated = jiffies;
886 /* It is very thin place. report_unreachable is very complicated
887 routine. Particularly, it can hit the same neighbour entry!
889 So that, we try to be accurate and avoid dead loop. --ANK
891 while (neigh->nud_state == NUD_FAILED &&
892 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
893 write_unlock(&neigh->lock);
894 neigh->ops->error_report(neigh, skb);
895 write_lock(&neigh->lock);
897 __skb_queue_purge(&neigh->arp_queue);
898 neigh->arp_queue_len_bytes = 0;
901 static void neigh_probe(struct neighbour *neigh)
902 __releases(neigh->lock)
904 struct sk_buff *skb = skb_peek_tail(&neigh->arp_queue);
905 /* keep skb alive even if arp_queue overflows */
907 skb = skb_clone(skb, GFP_ATOMIC);
908 write_unlock(&neigh->lock);
909 if (neigh->ops->solicit)
910 neigh->ops->solicit(neigh, skb);
911 atomic_inc(&neigh->probes);
915 /* Called when a timer expires for a neighbour entry. */
917 static void neigh_timer_handler(struct timer_list *t)
919 unsigned long now, next;
920 struct neighbour *neigh = from_timer(neigh, t, timer);
924 write_lock(&neigh->lock);
926 state = neigh->nud_state;
930 if (!(state & NUD_IN_TIMER))
933 if (state & NUD_REACHABLE) {
934 if (time_before_eq(now,
935 neigh->confirmed + neigh->parms->reachable_time)) {
936 neigh_dbg(2, "neigh %p is still alive\n", neigh);
937 next = neigh->confirmed + neigh->parms->reachable_time;
938 } else if (time_before_eq(now,
940 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
941 neigh_dbg(2, "neigh %p is delayed\n", neigh);
942 neigh->nud_state = NUD_DELAY;
943 neigh->updated = jiffies;
944 neigh_suspect(neigh);
945 next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME);
947 neigh_dbg(2, "neigh %p is suspected\n", neigh);
948 neigh->nud_state = NUD_STALE;
949 neigh->updated = jiffies;
950 neigh_suspect(neigh);
953 } else if (state & NUD_DELAY) {
954 if (time_before_eq(now,
956 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
957 neigh_dbg(2, "neigh %p is now reachable\n", neigh);
958 neigh->nud_state = NUD_REACHABLE;
959 neigh->updated = jiffies;
960 neigh_connect(neigh);
962 next = neigh->confirmed + neigh->parms->reachable_time;
964 neigh_dbg(2, "neigh %p is probed\n", neigh);
965 neigh->nud_state = NUD_PROBE;
966 neigh->updated = jiffies;
967 atomic_set(&neigh->probes, 0);
969 next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME);
972 /* NUD_PROBE|NUD_INCOMPLETE */
973 next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME);
976 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
977 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
978 neigh->nud_state = NUD_FAILED;
980 neigh_invalidate(neigh);
984 if (neigh->nud_state & NUD_IN_TIMER) {
985 if (time_before(next, jiffies + HZ/2))
986 next = jiffies + HZ/2;
987 if (!mod_timer(&neigh->timer, next))
990 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
994 write_unlock(&neigh->lock);
998 neigh_update_notify(neigh, 0);
1000 neigh_release(neigh);
1003 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
1006 bool immediate_probe = false;
1008 write_lock_bh(&neigh->lock);
1011 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
1016 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
1017 if (NEIGH_VAR(neigh->parms, MCAST_PROBES) +
1018 NEIGH_VAR(neigh->parms, APP_PROBES)) {
1019 unsigned long next, now = jiffies;
1021 atomic_set(&neigh->probes,
1022 NEIGH_VAR(neigh->parms, UCAST_PROBES));
1023 neigh->nud_state = NUD_INCOMPLETE;
1024 neigh->updated = now;
1025 next = now + max(NEIGH_VAR(neigh->parms, RETRANS_TIME),
1027 neigh_add_timer(neigh, next);
1028 immediate_probe = true;
1030 neigh->nud_state = NUD_FAILED;
1031 neigh->updated = jiffies;
1032 write_unlock_bh(&neigh->lock);
1037 } else if (neigh->nud_state & NUD_STALE) {
1038 neigh_dbg(2, "neigh %p is delayed\n", neigh);
1039 neigh->nud_state = NUD_DELAY;
1040 neigh->updated = jiffies;
1041 neigh_add_timer(neigh, jiffies +
1042 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME));
1045 if (neigh->nud_state == NUD_INCOMPLETE) {
1047 while (neigh->arp_queue_len_bytes + skb->truesize >
1048 NEIGH_VAR(neigh->parms, QUEUE_LEN_BYTES)) {
1049 struct sk_buff *buff;
1051 buff = __skb_dequeue(&neigh->arp_queue);
1054 neigh->arp_queue_len_bytes -= buff->truesize;
1056 NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards);
1059 __skb_queue_tail(&neigh->arp_queue, skb);
1060 neigh->arp_queue_len_bytes += skb->truesize;
1065 if (immediate_probe)
1068 write_unlock(&neigh->lock);
1073 if (neigh->nud_state & NUD_STALE)
1075 write_unlock_bh(&neigh->lock);
1079 EXPORT_SYMBOL(__neigh_event_send);
1081 static void neigh_update_hhs(struct neighbour *neigh)
1083 struct hh_cache *hh;
1084 void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
1087 if (neigh->dev->header_ops)
1088 update = neigh->dev->header_ops->cache_update;
1093 write_seqlock_bh(&hh->hh_lock);
1094 update(hh, neigh->dev, neigh->ha);
1095 write_sequnlock_bh(&hh->hh_lock);
1102 /* Generic update routine.
1103 -- lladdr is new lladdr or NULL, if it is not supplied.
1104 -- new is new state.
1106 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
1108 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
1109 lladdr instead of overriding it
1111 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
1113 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
1115 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1118 Caller MUST hold reference count on the entry.
1121 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
1122 u32 flags, u32 nlmsg_pid)
1127 struct net_device *dev;
1128 int update_isrouter = 0;
1130 write_lock_bh(&neigh->lock);
1133 old = neigh->nud_state;
1136 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
1137 (old & (NUD_NOARP | NUD_PERMANENT)))
1142 neigh_update_ext_learned(neigh, flags, ¬ify);
1144 if (!(new & NUD_VALID)) {
1145 neigh_del_timer(neigh);
1146 if (old & NUD_CONNECTED)
1147 neigh_suspect(neigh);
1148 neigh->nud_state = new;
1150 notify = old & NUD_VALID;
1151 if (((old & (NUD_INCOMPLETE | NUD_PROBE)) ||
1152 (flags & NEIGH_UPDATE_F_ADMIN)) &&
1153 (new & NUD_FAILED)) {
1154 neigh_invalidate(neigh);
1160 /* Compare new lladdr with cached one */
1161 if (!dev->addr_len) {
1162 /* First case: device needs no address. */
1164 } else if (lladdr) {
1165 /* The second case: if something is already cached
1166 and a new address is proposed:
1168 - if they are different, check override flag
1170 if ((old & NUD_VALID) &&
1171 !memcmp(lladdr, neigh->ha, dev->addr_len))
1174 /* No address is supplied; if we know something,
1175 use it, otherwise discard the request.
1178 if (!(old & NUD_VALID))
1183 /* Update confirmed timestamp for neighbour entry after we
1184 * received ARP packet even if it doesn't change IP to MAC binding.
1186 if (new & NUD_CONNECTED)
1187 neigh->confirmed = jiffies;
1189 /* If entry was valid and address is not changed,
1190 do not change entry state, if new one is STALE.
1193 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1194 if (old & NUD_VALID) {
1195 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1196 update_isrouter = 0;
1197 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1198 (old & NUD_CONNECTED)) {
1204 if (lladdr == neigh->ha && new == NUD_STALE &&
1205 !(flags & NEIGH_UPDATE_F_ADMIN))
1210 /* Update timestamp only once we know we will make a change to the
1211 * neighbour entry. Otherwise we risk to move the locktime window with
1212 * noop updates and ignore relevant ARP updates.
1214 if (new != old || lladdr != neigh->ha)
1215 neigh->updated = jiffies;
1218 neigh_del_timer(neigh);
1219 if (new & NUD_PROBE)
1220 atomic_set(&neigh->probes, 0);
1221 if (new & NUD_IN_TIMER)
1222 neigh_add_timer(neigh, (jiffies +
1223 ((new & NUD_REACHABLE) ?
1224 neigh->parms->reachable_time :
1226 neigh->nud_state = new;
1230 if (lladdr != neigh->ha) {
1231 write_seqlock(&neigh->ha_lock);
1232 memcpy(&neigh->ha, lladdr, dev->addr_len);
1233 write_sequnlock(&neigh->ha_lock);
1234 neigh_update_hhs(neigh);
1235 if (!(new & NUD_CONNECTED))
1236 neigh->confirmed = jiffies -
1237 (NEIGH_VAR(neigh->parms, BASE_REACHABLE_TIME) << 1);
1242 if (new & NUD_CONNECTED)
1243 neigh_connect(neigh);
1245 neigh_suspect(neigh);
1246 if (!(old & NUD_VALID)) {
1247 struct sk_buff *skb;
1249 /* Again: avoid dead loop if something went wrong */
1251 while (neigh->nud_state & NUD_VALID &&
1252 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1253 struct dst_entry *dst = skb_dst(skb);
1254 struct neighbour *n2, *n1 = neigh;
1255 write_unlock_bh(&neigh->lock);
1259 /* Why not just use 'neigh' as-is? The problem is that
1260 * things such as shaper, eql, and sch_teql can end up
1261 * using alternative, different, neigh objects to output
1262 * the packet in the output path. So what we need to do
1263 * here is re-lookup the top-level neigh in the path so
1264 * we can reinject the packet there.
1268 n2 = dst_neigh_lookup_skb(dst, skb);
1272 n1->output(n1, skb);
1277 write_lock_bh(&neigh->lock);
1279 __skb_queue_purge(&neigh->arp_queue);
1280 neigh->arp_queue_len_bytes = 0;
1283 if (update_isrouter) {
1284 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1285 (neigh->flags | NTF_ROUTER) :
1286 (neigh->flags & ~NTF_ROUTER);
1288 write_unlock_bh(&neigh->lock);
1291 neigh_update_notify(neigh, nlmsg_pid);
1295 EXPORT_SYMBOL(neigh_update);
1297 /* Update the neigh to listen temporarily for probe responses, even if it is
1298 * in a NUD_FAILED state. The caller has to hold neigh->lock for writing.
1300 void __neigh_set_probe_once(struct neighbour *neigh)
1304 neigh->updated = jiffies;
1305 if (!(neigh->nud_state & NUD_FAILED))
1307 neigh->nud_state = NUD_INCOMPLETE;
1308 atomic_set(&neigh->probes, neigh_max_probes(neigh));
1309 neigh_add_timer(neigh,
1310 jiffies + NEIGH_VAR(neigh->parms, RETRANS_TIME));
1312 EXPORT_SYMBOL(__neigh_set_probe_once);
1314 struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1315 u8 *lladdr, void *saddr,
1316 struct net_device *dev)
1318 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1319 lladdr || !dev->addr_len);
1321 neigh_update(neigh, lladdr, NUD_STALE,
1322 NEIGH_UPDATE_F_OVERRIDE, 0);
1325 EXPORT_SYMBOL(neigh_event_ns);
1327 /* called with read_lock_bh(&n->lock); */
1328 static void neigh_hh_init(struct neighbour *n)
1330 struct net_device *dev = n->dev;
1331 __be16 prot = n->tbl->protocol;
1332 struct hh_cache *hh = &n->hh;
1334 write_lock_bh(&n->lock);
1336 /* Only one thread can come in here and initialize the
1340 dev->header_ops->cache(n, hh, prot);
1342 write_unlock_bh(&n->lock);
1345 /* Slow and careful. */
1347 int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb)
1351 if (!neigh_event_send(neigh, skb)) {
1353 struct net_device *dev = neigh->dev;
1356 if (dev->header_ops->cache && !neigh->hh.hh_len)
1357 neigh_hh_init(neigh);
1360 __skb_pull(skb, skb_network_offset(skb));
1361 seq = read_seqbegin(&neigh->ha_lock);
1362 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1363 neigh->ha, NULL, skb->len);
1364 } while (read_seqretry(&neigh->ha_lock, seq));
1367 rc = dev_queue_xmit(skb);
1378 EXPORT_SYMBOL(neigh_resolve_output);
1380 /* As fast as possible without hh cache */
1382 int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb)
1384 struct net_device *dev = neigh->dev;
1389 __skb_pull(skb, skb_network_offset(skb));
1390 seq = read_seqbegin(&neigh->ha_lock);
1391 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1392 neigh->ha, NULL, skb->len);
1393 } while (read_seqretry(&neigh->ha_lock, seq));
1396 err = dev_queue_xmit(skb);
1403 EXPORT_SYMBOL(neigh_connected_output);
1405 int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb)
1407 return dev_queue_xmit(skb);
1409 EXPORT_SYMBOL(neigh_direct_output);
1411 static void neigh_proxy_process(struct timer_list *t)
1413 struct neigh_table *tbl = from_timer(tbl, t, proxy_timer);
1414 long sched_next = 0;
1415 unsigned long now = jiffies;
1416 struct sk_buff *skb, *n;
1418 spin_lock(&tbl->proxy_queue.lock);
1420 skb_queue_walk_safe(&tbl->proxy_queue, skb, n) {
1421 long tdif = NEIGH_CB(skb)->sched_next - now;
1424 struct net_device *dev = skb->dev;
1426 __skb_unlink(skb, &tbl->proxy_queue);
1427 if (tbl->proxy_redo && netif_running(dev)) {
1429 tbl->proxy_redo(skb);
1436 } else if (!sched_next || tdif < sched_next)
1439 del_timer(&tbl->proxy_timer);
1441 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1442 spin_unlock(&tbl->proxy_queue.lock);
1445 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1446 struct sk_buff *skb)
1448 unsigned long now = jiffies;
1450 unsigned long sched_next = now + (prandom_u32() %
1451 NEIGH_VAR(p, PROXY_DELAY));
1453 if (tbl->proxy_queue.qlen > NEIGH_VAR(p, PROXY_QLEN)) {
1458 NEIGH_CB(skb)->sched_next = sched_next;
1459 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
1461 spin_lock(&tbl->proxy_queue.lock);
1462 if (del_timer(&tbl->proxy_timer)) {
1463 if (time_before(tbl->proxy_timer.expires, sched_next))
1464 sched_next = tbl->proxy_timer.expires;
1468 __skb_queue_tail(&tbl->proxy_queue, skb);
1469 mod_timer(&tbl->proxy_timer, sched_next);
1470 spin_unlock(&tbl->proxy_queue.lock);
1472 EXPORT_SYMBOL(pneigh_enqueue);
1474 static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl,
1475 struct net *net, int ifindex)
1477 struct neigh_parms *p;
1479 list_for_each_entry(p, &tbl->parms_list, list) {
1480 if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) ||
1481 (!p->dev && !ifindex && net_eq(net, &init_net)))
1488 struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1489 struct neigh_table *tbl)
1491 struct neigh_parms *p;
1492 struct net *net = dev_net(dev);
1493 const struct net_device_ops *ops = dev->netdev_ops;
1495 p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL);
1498 refcount_set(&p->refcnt, 1);
1500 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
1503 write_pnet(&p->net, net);
1504 p->sysctl_table = NULL;
1506 if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) {
1512 write_lock_bh(&tbl->lock);
1513 list_add(&p->list, &tbl->parms.list);
1514 write_unlock_bh(&tbl->lock);
1516 neigh_parms_data_state_cleanall(p);
1520 EXPORT_SYMBOL(neigh_parms_alloc);
1522 static void neigh_rcu_free_parms(struct rcu_head *head)
1524 struct neigh_parms *parms =
1525 container_of(head, struct neigh_parms, rcu_head);
1527 neigh_parms_put(parms);
1530 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1532 if (!parms || parms == &tbl->parms)
1534 write_lock_bh(&tbl->lock);
1535 list_del(&parms->list);
1537 write_unlock_bh(&tbl->lock);
1539 dev_put(parms->dev);
1540 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1542 EXPORT_SYMBOL(neigh_parms_release);
1544 static void neigh_parms_destroy(struct neigh_parms *parms)
1549 static struct lock_class_key neigh_table_proxy_queue_class;
1551 static struct neigh_table *neigh_tables[NEIGH_NR_TABLES] __read_mostly;
1553 void neigh_table_init(int index, struct neigh_table *tbl)
1555 unsigned long now = jiffies;
1556 unsigned long phsize;
1558 INIT_LIST_HEAD(&tbl->parms_list);
1559 list_add(&tbl->parms.list, &tbl->parms_list);
1560 write_pnet(&tbl->parms.net, &init_net);
1561 refcount_set(&tbl->parms.refcnt, 1);
1562 tbl->parms.reachable_time =
1563 neigh_rand_reach_time(NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME));
1565 tbl->stats = alloc_percpu(struct neigh_statistics);
1567 panic("cannot create neighbour cache statistics");
1569 #ifdef CONFIG_PROC_FS
1570 if (!proc_create_seq_data(tbl->id, 0, init_net.proc_net_stat,
1571 &neigh_stat_seq_ops, tbl))
1572 panic("cannot create neighbour proc dir entry");
1575 RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3));
1577 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
1578 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
1580 if (!tbl->nht || !tbl->phash_buckets)
1581 panic("cannot allocate neighbour cache hashes");
1583 if (!tbl->entry_size)
1584 tbl->entry_size = ALIGN(offsetof(struct neighbour, primary_key) +
1585 tbl->key_len, NEIGH_PRIV_ALIGN);
1587 WARN_ON(tbl->entry_size % NEIGH_PRIV_ALIGN);
1589 rwlock_init(&tbl->lock);
1590 INIT_DEFERRABLE_WORK(&tbl->gc_work, neigh_periodic_work);
1591 queue_delayed_work(system_power_efficient_wq, &tbl->gc_work,
1592 tbl->parms.reachable_time);
1593 timer_setup(&tbl->proxy_timer, neigh_proxy_process, 0);
1594 skb_queue_head_init_class(&tbl->proxy_queue,
1595 &neigh_table_proxy_queue_class);
1597 tbl->last_flush = now;
1598 tbl->last_rand = now + tbl->parms.reachable_time * 20;
1600 neigh_tables[index] = tbl;
1602 EXPORT_SYMBOL(neigh_table_init);
1604 int neigh_table_clear(int index, struct neigh_table *tbl)
1606 neigh_tables[index] = NULL;
1607 /* It is not clean... Fix it to unload IPv6 module safely */
1608 cancel_delayed_work_sync(&tbl->gc_work);
1609 del_timer_sync(&tbl->proxy_timer);
1610 pneigh_queue_purge(&tbl->proxy_queue);
1611 neigh_ifdown(tbl, NULL);
1612 if (atomic_read(&tbl->entries))
1613 pr_crit("neighbour leakage\n");
1615 call_rcu(&rcu_dereference_protected(tbl->nht, 1)->rcu,
1616 neigh_hash_free_rcu);
1619 kfree(tbl->phash_buckets);
1620 tbl->phash_buckets = NULL;
1622 remove_proc_entry(tbl->id, init_net.proc_net_stat);
1624 free_percpu(tbl->stats);
1629 EXPORT_SYMBOL(neigh_table_clear);
1631 static struct neigh_table *neigh_find_table(int family)
1633 struct neigh_table *tbl = NULL;
1637 tbl = neigh_tables[NEIGH_ARP_TABLE];
1640 tbl = neigh_tables[NEIGH_ND_TABLE];
1643 tbl = neigh_tables[NEIGH_DN_TABLE];
1650 static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh,
1651 struct netlink_ext_ack *extack)
1653 struct net *net = sock_net(skb->sk);
1655 struct nlattr *dst_attr;
1656 struct neigh_table *tbl;
1657 struct neighbour *neigh;
1658 struct net_device *dev = NULL;
1662 if (nlmsg_len(nlh) < sizeof(*ndm))
1665 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1666 if (dst_attr == NULL)
1669 ndm = nlmsg_data(nlh);
1670 if (ndm->ndm_ifindex) {
1671 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
1678 tbl = neigh_find_table(ndm->ndm_family);
1680 return -EAFNOSUPPORT;
1682 if (nla_len(dst_attr) < (int)tbl->key_len)
1685 if (ndm->ndm_flags & NTF_PROXY) {
1686 err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
1693 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1694 if (neigh == NULL) {
1699 err = neigh_update(neigh, NULL, NUD_FAILED,
1700 NEIGH_UPDATE_F_OVERRIDE |
1701 NEIGH_UPDATE_F_ADMIN,
1702 NETLINK_CB(skb).portid);
1703 write_lock_bh(&tbl->lock);
1704 neigh_release(neigh);
1705 neigh_remove_one(neigh, tbl);
1706 write_unlock_bh(&tbl->lock);
1712 static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh,
1713 struct netlink_ext_ack *extack)
1715 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
1716 struct net *net = sock_net(skb->sk);
1718 struct nlattr *tb[NDA_MAX+1];
1719 struct neigh_table *tbl;
1720 struct net_device *dev = NULL;
1721 struct neighbour *neigh;
1726 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL, extack);
1731 if (tb[NDA_DST] == NULL)
1734 ndm = nlmsg_data(nlh);
1735 if (ndm->ndm_ifindex) {
1736 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
1742 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
1746 tbl = neigh_find_table(ndm->ndm_family);
1748 return -EAFNOSUPPORT;
1750 if (nla_len(tb[NDA_DST]) < (int)tbl->key_len)
1752 dst = nla_data(tb[NDA_DST]);
1753 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
1755 if (ndm->ndm_flags & NTF_PROXY) {
1756 struct pneigh_entry *pn;
1759 pn = pneigh_lookup(tbl, net, dst, dev, 1);
1761 pn->flags = ndm->ndm_flags;
1770 neigh = neigh_lookup(tbl, dst, dev);
1771 if (neigh == NULL) {
1772 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1777 neigh = __neigh_lookup_errno(tbl, dst, dev);
1778 if (IS_ERR(neigh)) {
1779 err = PTR_ERR(neigh);
1783 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1785 neigh_release(neigh);
1789 if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
1790 flags &= ~NEIGH_UPDATE_F_OVERRIDE;
1793 if (ndm->ndm_flags & NTF_EXT_LEARNED)
1794 flags |= NEIGH_UPDATE_F_EXT_LEARNED;
1796 if (ndm->ndm_flags & NTF_USE) {
1797 neigh_event_send(neigh, NULL);
1800 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags,
1801 NETLINK_CB(skb).portid);
1802 neigh_release(neigh);
1808 static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1810 struct nlattr *nest;
1812 nest = nla_nest_start(skb, NDTA_PARMS);
1817 nla_put_u32(skb, NDTPA_IFINDEX, parms->dev->ifindex)) ||
1818 nla_put_u32(skb, NDTPA_REFCNT, refcount_read(&parms->refcnt)) ||
1819 nla_put_u32(skb, NDTPA_QUEUE_LENBYTES,
1820 NEIGH_VAR(parms, QUEUE_LEN_BYTES)) ||
1821 /* approximative value for deprecated QUEUE_LEN (in packets) */
1822 nla_put_u32(skb, NDTPA_QUEUE_LEN,
1823 NEIGH_VAR(parms, QUEUE_LEN_BYTES) / SKB_TRUESIZE(ETH_FRAME_LEN)) ||
1824 nla_put_u32(skb, NDTPA_PROXY_QLEN, NEIGH_VAR(parms, PROXY_QLEN)) ||
1825 nla_put_u32(skb, NDTPA_APP_PROBES, NEIGH_VAR(parms, APP_PROBES)) ||
1826 nla_put_u32(skb, NDTPA_UCAST_PROBES,
1827 NEIGH_VAR(parms, UCAST_PROBES)) ||
1828 nla_put_u32(skb, NDTPA_MCAST_PROBES,
1829 NEIGH_VAR(parms, MCAST_PROBES)) ||
1830 nla_put_u32(skb, NDTPA_MCAST_REPROBES,
1831 NEIGH_VAR(parms, MCAST_REPROBES)) ||
1832 nla_put_msecs(skb, NDTPA_REACHABLE_TIME, parms->reachable_time,
1834 nla_put_msecs(skb, NDTPA_BASE_REACHABLE_TIME,
1835 NEIGH_VAR(parms, BASE_REACHABLE_TIME), NDTPA_PAD) ||
1836 nla_put_msecs(skb, NDTPA_GC_STALETIME,
1837 NEIGH_VAR(parms, GC_STALETIME), NDTPA_PAD) ||
1838 nla_put_msecs(skb, NDTPA_DELAY_PROBE_TIME,
1839 NEIGH_VAR(parms, DELAY_PROBE_TIME), NDTPA_PAD) ||
1840 nla_put_msecs(skb, NDTPA_RETRANS_TIME,
1841 NEIGH_VAR(parms, RETRANS_TIME), NDTPA_PAD) ||
1842 nla_put_msecs(skb, NDTPA_ANYCAST_DELAY,
1843 NEIGH_VAR(parms, ANYCAST_DELAY), NDTPA_PAD) ||
1844 nla_put_msecs(skb, NDTPA_PROXY_DELAY,
1845 NEIGH_VAR(parms, PROXY_DELAY), NDTPA_PAD) ||
1846 nla_put_msecs(skb, NDTPA_LOCKTIME,
1847 NEIGH_VAR(parms, LOCKTIME), NDTPA_PAD))
1848 goto nla_put_failure;
1849 return nla_nest_end(skb, nest);
1852 nla_nest_cancel(skb, nest);
1856 static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
1857 u32 pid, u32 seq, int type, int flags)
1859 struct nlmsghdr *nlh;
1860 struct ndtmsg *ndtmsg;
1862 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1866 ndtmsg = nlmsg_data(nlh);
1868 read_lock_bh(&tbl->lock);
1869 ndtmsg->ndtm_family = tbl->family;
1870 ndtmsg->ndtm_pad1 = 0;
1871 ndtmsg->ndtm_pad2 = 0;
1873 if (nla_put_string(skb, NDTA_NAME, tbl->id) ||
1874 nla_put_msecs(skb, NDTA_GC_INTERVAL, tbl->gc_interval, NDTA_PAD) ||
1875 nla_put_u32(skb, NDTA_THRESH1, tbl->gc_thresh1) ||
1876 nla_put_u32(skb, NDTA_THRESH2, tbl->gc_thresh2) ||
1877 nla_put_u32(skb, NDTA_THRESH3, tbl->gc_thresh3))
1878 goto nla_put_failure;
1880 unsigned long now = jiffies;
1881 unsigned int flush_delta = now - tbl->last_flush;
1882 unsigned int rand_delta = now - tbl->last_rand;
1883 struct neigh_hash_table *nht;
1884 struct ndt_config ndc = {
1885 .ndtc_key_len = tbl->key_len,
1886 .ndtc_entry_size = tbl->entry_size,
1887 .ndtc_entries = atomic_read(&tbl->entries),
1888 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
1889 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
1890 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
1894 nht = rcu_dereference_bh(tbl->nht);
1895 ndc.ndtc_hash_rnd = nht->hash_rnd[0];
1896 ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1);
1897 rcu_read_unlock_bh();
1899 if (nla_put(skb, NDTA_CONFIG, sizeof(ndc), &ndc))
1900 goto nla_put_failure;
1905 struct ndt_stats ndst;
1907 memset(&ndst, 0, sizeof(ndst));
1909 for_each_possible_cpu(cpu) {
1910 struct neigh_statistics *st;
1912 st = per_cpu_ptr(tbl->stats, cpu);
1913 ndst.ndts_allocs += st->allocs;
1914 ndst.ndts_destroys += st->destroys;
1915 ndst.ndts_hash_grows += st->hash_grows;
1916 ndst.ndts_res_failed += st->res_failed;
1917 ndst.ndts_lookups += st->lookups;
1918 ndst.ndts_hits += st->hits;
1919 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1920 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1921 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1922 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1923 ndst.ndts_table_fulls += st->table_fulls;
1926 if (nla_put_64bit(skb, NDTA_STATS, sizeof(ndst), &ndst,
1928 goto nla_put_failure;
1931 BUG_ON(tbl->parms.dev);
1932 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
1933 goto nla_put_failure;
1935 read_unlock_bh(&tbl->lock);
1936 nlmsg_end(skb, nlh);
1940 read_unlock_bh(&tbl->lock);
1941 nlmsg_cancel(skb, nlh);
1945 static int neightbl_fill_param_info(struct sk_buff *skb,
1946 struct neigh_table *tbl,
1947 struct neigh_parms *parms,
1948 u32 pid, u32 seq, int type,
1951 struct ndtmsg *ndtmsg;
1952 struct nlmsghdr *nlh;
1954 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1958 ndtmsg = nlmsg_data(nlh);
1960 read_lock_bh(&tbl->lock);
1961 ndtmsg->ndtm_family = tbl->family;
1962 ndtmsg->ndtm_pad1 = 0;
1963 ndtmsg->ndtm_pad2 = 0;
1965 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
1966 neightbl_fill_parms(skb, parms) < 0)
1969 read_unlock_bh(&tbl->lock);
1970 nlmsg_end(skb, nlh);
1973 read_unlock_bh(&tbl->lock);
1974 nlmsg_cancel(skb, nlh);
1978 static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
1979 [NDTA_NAME] = { .type = NLA_STRING },
1980 [NDTA_THRESH1] = { .type = NLA_U32 },
1981 [NDTA_THRESH2] = { .type = NLA_U32 },
1982 [NDTA_THRESH3] = { .type = NLA_U32 },
1983 [NDTA_GC_INTERVAL] = { .type = NLA_U64 },
1984 [NDTA_PARMS] = { .type = NLA_NESTED },
1987 static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
1988 [NDTPA_IFINDEX] = { .type = NLA_U32 },
1989 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 },
1990 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 },
1991 [NDTPA_APP_PROBES] = { .type = NLA_U32 },
1992 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 },
1993 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 },
1994 [NDTPA_MCAST_REPROBES] = { .type = NLA_U32 },
1995 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 },
1996 [NDTPA_GC_STALETIME] = { .type = NLA_U64 },
1997 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 },
1998 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 },
1999 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 },
2000 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 },
2001 [NDTPA_LOCKTIME] = { .type = NLA_U64 },
2004 static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh,
2005 struct netlink_ext_ack *extack)
2007 struct net *net = sock_net(skb->sk);
2008 struct neigh_table *tbl;
2009 struct ndtmsg *ndtmsg;
2010 struct nlattr *tb[NDTA_MAX+1];
2014 err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
2015 nl_neightbl_policy, extack);
2019 if (tb[NDTA_NAME] == NULL) {
2024 ndtmsg = nlmsg_data(nlh);
2026 for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) {
2027 tbl = neigh_tables[tidx];
2030 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
2032 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0) {
2042 * We acquire tbl->lock to be nice to the periodic timers and
2043 * make sure they always see a consistent set of values.
2045 write_lock_bh(&tbl->lock);
2047 if (tb[NDTA_PARMS]) {
2048 struct nlattr *tbp[NDTPA_MAX+1];
2049 struct neigh_parms *p;
2052 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
2053 nl_ntbl_parm_policy, extack);
2055 goto errout_tbl_lock;
2057 if (tbp[NDTPA_IFINDEX])
2058 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
2060 p = lookup_neigh_parms(tbl, net, ifindex);
2063 goto errout_tbl_lock;
2066 for (i = 1; i <= NDTPA_MAX; i++) {
2071 case NDTPA_QUEUE_LEN:
2072 NEIGH_VAR_SET(p, QUEUE_LEN_BYTES,
2073 nla_get_u32(tbp[i]) *
2074 SKB_TRUESIZE(ETH_FRAME_LEN));
2076 case NDTPA_QUEUE_LENBYTES:
2077 NEIGH_VAR_SET(p, QUEUE_LEN_BYTES,
2078 nla_get_u32(tbp[i]));
2080 case NDTPA_PROXY_QLEN:
2081 NEIGH_VAR_SET(p, PROXY_QLEN,
2082 nla_get_u32(tbp[i]));
2084 case NDTPA_APP_PROBES:
2085 NEIGH_VAR_SET(p, APP_PROBES,
2086 nla_get_u32(tbp[i]));
2088 case NDTPA_UCAST_PROBES:
2089 NEIGH_VAR_SET(p, UCAST_PROBES,
2090 nla_get_u32(tbp[i]));
2092 case NDTPA_MCAST_PROBES:
2093 NEIGH_VAR_SET(p, MCAST_PROBES,
2094 nla_get_u32(tbp[i]));
2096 case NDTPA_MCAST_REPROBES:
2097 NEIGH_VAR_SET(p, MCAST_REPROBES,
2098 nla_get_u32(tbp[i]));
2100 case NDTPA_BASE_REACHABLE_TIME:
2101 NEIGH_VAR_SET(p, BASE_REACHABLE_TIME,
2102 nla_get_msecs(tbp[i]));
2103 /* update reachable_time as well, otherwise, the change will
2104 * only be effective after the next time neigh_periodic_work
2105 * decides to recompute it (can be multiple minutes)
2108 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
2110 case NDTPA_GC_STALETIME:
2111 NEIGH_VAR_SET(p, GC_STALETIME,
2112 nla_get_msecs(tbp[i]));
2114 case NDTPA_DELAY_PROBE_TIME:
2115 NEIGH_VAR_SET(p, DELAY_PROBE_TIME,
2116 nla_get_msecs(tbp[i]));
2117 call_netevent_notifiers(NETEVENT_DELAY_PROBE_TIME_UPDATE, p);
2119 case NDTPA_RETRANS_TIME:
2120 NEIGH_VAR_SET(p, RETRANS_TIME,
2121 nla_get_msecs(tbp[i]));
2123 case NDTPA_ANYCAST_DELAY:
2124 NEIGH_VAR_SET(p, ANYCAST_DELAY,
2125 nla_get_msecs(tbp[i]));
2127 case NDTPA_PROXY_DELAY:
2128 NEIGH_VAR_SET(p, PROXY_DELAY,
2129 nla_get_msecs(tbp[i]));
2131 case NDTPA_LOCKTIME:
2132 NEIGH_VAR_SET(p, LOCKTIME,
2133 nla_get_msecs(tbp[i]));
2140 if ((tb[NDTA_THRESH1] || tb[NDTA_THRESH2] ||
2141 tb[NDTA_THRESH3] || tb[NDTA_GC_INTERVAL]) &&
2142 !net_eq(net, &init_net))
2143 goto errout_tbl_lock;
2145 if (tb[NDTA_THRESH1])
2146 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
2148 if (tb[NDTA_THRESH2])
2149 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
2151 if (tb[NDTA_THRESH3])
2152 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
2154 if (tb[NDTA_GC_INTERVAL])
2155 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
2160 write_unlock_bh(&tbl->lock);
2165 static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
2167 struct net *net = sock_net(skb->sk);
2168 int family, tidx, nidx = 0;
2169 int tbl_skip = cb->args[0];
2170 int neigh_skip = cb->args[1];
2171 struct neigh_table *tbl;
2173 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
2175 for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) {
2176 struct neigh_parms *p;
2178 tbl = neigh_tables[tidx];
2182 if (tidx < tbl_skip || (family && tbl->family != family))
2185 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).portid,
2186 cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
2191 p = list_next_entry(&tbl->parms, list);
2192 list_for_each_entry_from(p, &tbl->parms_list, list) {
2193 if (!net_eq(neigh_parms_net(p), net))
2196 if (nidx < neigh_skip)
2199 if (neightbl_fill_param_info(skb, tbl, p,
2200 NETLINK_CB(cb->skb).portid,
2218 static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
2219 u32 pid, u32 seq, int type, unsigned int flags)
2221 unsigned long now = jiffies;
2222 struct nda_cacheinfo ci;
2223 struct nlmsghdr *nlh;
2226 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2230 ndm = nlmsg_data(nlh);
2231 ndm->ndm_family = neigh->ops->family;
2234 ndm->ndm_flags = neigh->flags;
2235 ndm->ndm_type = neigh->type;
2236 ndm->ndm_ifindex = neigh->dev->ifindex;
2238 if (nla_put(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key))
2239 goto nla_put_failure;
2241 read_lock_bh(&neigh->lock);
2242 ndm->ndm_state = neigh->nud_state;
2243 if (neigh->nud_state & NUD_VALID) {
2244 char haddr[MAX_ADDR_LEN];
2246 neigh_ha_snapshot(haddr, neigh, neigh->dev);
2247 if (nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, haddr) < 0) {
2248 read_unlock_bh(&neigh->lock);
2249 goto nla_put_failure;
2253 ci.ndm_used = jiffies_to_clock_t(now - neigh->used);
2254 ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
2255 ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated);
2256 ci.ndm_refcnt = refcount_read(&neigh->refcnt) - 1;
2257 read_unlock_bh(&neigh->lock);
2259 if (nla_put_u32(skb, NDA_PROBES, atomic_read(&neigh->probes)) ||
2260 nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
2261 goto nla_put_failure;
2263 nlmsg_end(skb, nlh);
2267 nlmsg_cancel(skb, nlh);
2271 static int pneigh_fill_info(struct sk_buff *skb, struct pneigh_entry *pn,
2272 u32 pid, u32 seq, int type, unsigned int flags,
2273 struct neigh_table *tbl)
2275 struct nlmsghdr *nlh;
2278 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2282 ndm = nlmsg_data(nlh);
2283 ndm->ndm_family = tbl->family;
2286 ndm->ndm_flags = pn->flags | NTF_PROXY;
2287 ndm->ndm_type = RTN_UNICAST;
2288 ndm->ndm_ifindex = pn->dev ? pn->dev->ifindex : 0;
2289 ndm->ndm_state = NUD_NONE;
2291 if (nla_put(skb, NDA_DST, tbl->key_len, pn->key))
2292 goto nla_put_failure;
2294 nlmsg_end(skb, nlh);
2298 nlmsg_cancel(skb, nlh);
2302 static void neigh_update_notify(struct neighbour *neigh, u32 nlmsg_pid)
2304 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2305 __neigh_notify(neigh, RTM_NEWNEIGH, 0, nlmsg_pid);
2308 static bool neigh_master_filtered(struct net_device *dev, int master_idx)
2310 struct net_device *master;
2315 master = netdev_master_upper_dev_get(dev);
2316 if (!master || master->ifindex != master_idx)
2322 static bool neigh_ifindex_filtered(struct net_device *dev, int filter_idx)
2324 if (filter_idx && dev->ifindex != filter_idx)
2330 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2331 struct netlink_callback *cb)
2333 struct net *net = sock_net(skb->sk);
2334 const struct nlmsghdr *nlh = cb->nlh;
2335 struct nlattr *tb[NDA_MAX + 1];
2336 struct neighbour *n;
2337 int rc, h, s_h = cb->args[1];
2338 int idx, s_idx = idx = cb->args[2];
2339 struct neigh_hash_table *nht;
2340 int filter_master_idx = 0, filter_idx = 0;
2341 unsigned int flags = NLM_F_MULTI;
2344 err = nlmsg_parse(nlh, sizeof(struct ndmsg), tb, NDA_MAX, NULL, NULL);
2346 if (tb[NDA_IFINDEX]) {
2347 if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
2349 filter_idx = nla_get_u32(tb[NDA_IFINDEX]);
2351 if (tb[NDA_MASTER]) {
2352 if (nla_len(tb[NDA_MASTER]) != sizeof(u32))
2354 filter_master_idx = nla_get_u32(tb[NDA_MASTER]);
2356 if (filter_idx || filter_master_idx)
2357 flags |= NLM_F_DUMP_FILTERED;
2361 nht = rcu_dereference_bh(tbl->nht);
2363 for (h = s_h; h < (1 << nht->hash_shift); h++) {
2366 for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0;
2368 n = rcu_dereference_bh(n->next)) {
2369 if (idx < s_idx || !net_eq(dev_net(n->dev), net))
2371 if (neigh_ifindex_filtered(n->dev, filter_idx) ||
2372 neigh_master_filtered(n->dev, filter_master_idx))
2374 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
2387 rcu_read_unlock_bh();
2393 static int pneigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2394 struct netlink_callback *cb)
2396 struct pneigh_entry *n;
2397 struct net *net = sock_net(skb->sk);
2398 int rc, h, s_h = cb->args[3];
2399 int idx, s_idx = idx = cb->args[4];
2401 read_lock_bh(&tbl->lock);
2403 for (h = s_h; h <= PNEIGH_HASHMASK; h++) {
2406 for (n = tbl->phash_buckets[h], idx = 0; n; n = n->next) {
2407 if (idx < s_idx || pneigh_net(n) != net)
2409 if (pneigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
2412 NLM_F_MULTI, tbl) < 0) {
2413 read_unlock_bh(&tbl->lock);
2422 read_unlock_bh(&tbl->lock);
2431 static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
2433 struct neigh_table *tbl;
2438 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
2440 /* check for full ndmsg structure presence, family member is
2441 * the same for both structures
2443 if (nlmsg_len(cb->nlh) >= sizeof(struct ndmsg) &&
2444 ((struct ndmsg *) nlmsg_data(cb->nlh))->ndm_flags == NTF_PROXY)
2449 for (t = 0; t < NEIGH_NR_TABLES; t++) {
2450 tbl = neigh_tables[t];
2454 if (t < s_t || (family && tbl->family != family))
2457 memset(&cb->args[1], 0, sizeof(cb->args) -
2458 sizeof(cb->args[0]));
2460 err = pneigh_dump_table(tbl, skb, cb);
2462 err = neigh_dump_table(tbl, skb, cb);
2471 void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2474 struct neigh_hash_table *nht;
2477 nht = rcu_dereference_bh(tbl->nht);
2479 read_lock(&tbl->lock); /* avoid resizes */
2480 for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
2481 struct neighbour *n;
2483 for (n = rcu_dereference_bh(nht->hash_buckets[chain]);
2485 n = rcu_dereference_bh(n->next))
2488 read_unlock(&tbl->lock);
2489 rcu_read_unlock_bh();
2491 EXPORT_SYMBOL(neigh_for_each);
2493 /* The tbl->lock must be held as a writer and BH disabled. */
2494 void __neigh_for_each_release(struct neigh_table *tbl,
2495 int (*cb)(struct neighbour *))
2498 struct neigh_hash_table *nht;
2500 nht = rcu_dereference_protected(tbl->nht,
2501 lockdep_is_held(&tbl->lock));
2502 for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
2503 struct neighbour *n;
2504 struct neighbour __rcu **np;
2506 np = &nht->hash_buckets[chain];
2507 while ((n = rcu_dereference_protected(*np,
2508 lockdep_is_held(&tbl->lock))) != NULL) {
2511 write_lock(&n->lock);
2514 rcu_assign_pointer(*np,
2515 rcu_dereference_protected(n->next,
2516 lockdep_is_held(&tbl->lock)));
2520 write_unlock(&n->lock);
2522 neigh_cleanup_and_release(n);
2526 EXPORT_SYMBOL(__neigh_for_each_release);
2528 int neigh_xmit(int index, struct net_device *dev,
2529 const void *addr, struct sk_buff *skb)
2531 int err = -EAFNOSUPPORT;
2532 if (likely(index < NEIGH_NR_TABLES)) {
2533 struct neigh_table *tbl;
2534 struct neighbour *neigh;
2536 tbl = neigh_tables[index];
2540 neigh = __neigh_lookup_noref(tbl, addr, dev);
2542 neigh = __neigh_create(tbl, addr, dev, false);
2543 err = PTR_ERR(neigh);
2544 if (IS_ERR(neigh)) {
2545 rcu_read_unlock_bh();
2548 err = neigh->output(neigh, skb);
2549 rcu_read_unlock_bh();
2551 else if (index == NEIGH_LINK_TABLE) {
2552 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
2553 addr, NULL, skb->len);
2556 err = dev_queue_xmit(skb);
2564 EXPORT_SYMBOL(neigh_xmit);
2566 #ifdef CONFIG_PROC_FS
2568 static struct neighbour *neigh_get_first(struct seq_file *seq)
2570 struct neigh_seq_state *state = seq->private;
2571 struct net *net = seq_file_net(seq);
2572 struct neigh_hash_table *nht = state->nht;
2573 struct neighbour *n = NULL;
2574 int bucket = state->bucket;
2576 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2577 for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) {
2578 n = rcu_dereference_bh(nht->hash_buckets[bucket]);
2581 if (!net_eq(dev_net(n->dev), net))
2583 if (state->neigh_sub_iter) {
2587 v = state->neigh_sub_iter(state, n, &fakep);
2591 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2593 if (n->nud_state & ~NUD_NOARP)
2596 n = rcu_dereference_bh(n->next);
2602 state->bucket = bucket;
2607 static struct neighbour *neigh_get_next(struct seq_file *seq,
2608 struct neighbour *n,
2611 struct neigh_seq_state *state = seq->private;
2612 struct net *net = seq_file_net(seq);
2613 struct neigh_hash_table *nht = state->nht;
2615 if (state->neigh_sub_iter) {
2616 void *v = state->neigh_sub_iter(state, n, pos);
2620 n = rcu_dereference_bh(n->next);
2624 if (!net_eq(dev_net(n->dev), net))
2626 if (state->neigh_sub_iter) {
2627 void *v = state->neigh_sub_iter(state, n, pos);
2632 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2635 if (n->nud_state & ~NUD_NOARP)
2638 n = rcu_dereference_bh(n->next);
2644 if (++state->bucket >= (1 << nht->hash_shift))
2647 n = rcu_dereference_bh(nht->hash_buckets[state->bucket]);
2655 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2657 struct neighbour *n = neigh_get_first(seq);
2662 n = neigh_get_next(seq, n, pos);
2667 return *pos ? NULL : n;
2670 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2672 struct neigh_seq_state *state = seq->private;
2673 struct net *net = seq_file_net(seq);
2674 struct neigh_table *tbl = state->tbl;
2675 struct pneigh_entry *pn = NULL;
2676 int bucket = state->bucket;
2678 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2679 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2680 pn = tbl->phash_buckets[bucket];
2681 while (pn && !net_eq(pneigh_net(pn), net))
2686 state->bucket = bucket;
2691 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2692 struct pneigh_entry *pn,
2695 struct neigh_seq_state *state = seq->private;
2696 struct net *net = seq_file_net(seq);
2697 struct neigh_table *tbl = state->tbl;
2701 } while (pn && !net_eq(pneigh_net(pn), net));
2704 if (++state->bucket > PNEIGH_HASHMASK)
2706 pn = tbl->phash_buckets[state->bucket];
2707 while (pn && !net_eq(pneigh_net(pn), net))
2719 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2721 struct pneigh_entry *pn = pneigh_get_first(seq);
2726 pn = pneigh_get_next(seq, pn, pos);
2731 return *pos ? NULL : pn;
2734 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2736 struct neigh_seq_state *state = seq->private;
2738 loff_t idxpos = *pos;
2740 rc = neigh_get_idx(seq, &idxpos);
2741 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2742 rc = pneigh_get_idx(seq, &idxpos);
2747 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
2750 struct neigh_seq_state *state = seq->private;
2754 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2757 state->nht = rcu_dereference_bh(tbl->nht);
2759 return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN;
2761 EXPORT_SYMBOL(neigh_seq_start);
2763 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2765 struct neigh_seq_state *state;
2768 if (v == SEQ_START_TOKEN) {
2769 rc = neigh_get_first(seq);
2773 state = seq->private;
2774 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2775 rc = neigh_get_next(seq, v, NULL);
2778 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2779 rc = pneigh_get_first(seq);
2781 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2782 rc = pneigh_get_next(seq, v, NULL);
2788 EXPORT_SYMBOL(neigh_seq_next);
2790 void neigh_seq_stop(struct seq_file *seq, void *v)
2793 rcu_read_unlock_bh();
2795 EXPORT_SYMBOL(neigh_seq_stop);
2797 /* statistics via seq_file */
2799 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2801 struct neigh_table *tbl = PDE_DATA(file_inode(seq->file));
2805 return SEQ_START_TOKEN;
2807 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
2808 if (!cpu_possible(cpu))
2811 return per_cpu_ptr(tbl->stats, cpu);
2816 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2818 struct neigh_table *tbl = PDE_DATA(file_inode(seq->file));
2821 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
2822 if (!cpu_possible(cpu))
2825 return per_cpu_ptr(tbl->stats, cpu);
2830 static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2835 static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2837 struct neigh_table *tbl = PDE_DATA(file_inode(seq->file));
2838 struct neigh_statistics *st = v;
2840 if (v == SEQ_START_TOKEN) {
2841 seq_printf(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");
2845 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2846 "%08lx %08lx %08lx %08lx %08lx %08lx\n",
2847 atomic_read(&tbl->entries),
2858 st->rcv_probes_mcast,
2859 st->rcv_probes_ucast,
2861 st->periodic_gc_runs,
2870 static const struct seq_operations neigh_stat_seq_ops = {
2871 .start = neigh_stat_seq_start,
2872 .next = neigh_stat_seq_next,
2873 .stop = neigh_stat_seq_stop,
2874 .show = neigh_stat_seq_show,
2876 #endif /* CONFIG_PROC_FS */
2878 static inline size_t neigh_nlmsg_size(void)
2880 return NLMSG_ALIGN(sizeof(struct ndmsg))
2881 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2882 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2883 + nla_total_size(sizeof(struct nda_cacheinfo))
2884 + nla_total_size(4); /* NDA_PROBES */
2887 static void __neigh_notify(struct neighbour *n, int type, int flags,
2890 struct net *net = dev_net(n->dev);
2891 struct sk_buff *skb;
2894 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
2898 err = neigh_fill_info(skb, n, pid, 0, type, flags);
2900 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2901 WARN_ON(err == -EMSGSIZE);
2905 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
2909 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
2912 void neigh_app_ns(struct neighbour *n)
2914 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST, 0);
2916 EXPORT_SYMBOL(neigh_app_ns);
2918 #ifdef CONFIG_SYSCTL
2920 static int int_max = INT_MAX;
2921 static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN);
2923 static int proc_unres_qlen(struct ctl_table *ctl, int write,
2924 void __user *buffer, size_t *lenp, loff_t *ppos)
2927 struct ctl_table tmp = *ctl;
2930 tmp.extra2 = &unres_qlen_max;
2933 size = *(int *)ctl->data / SKB_TRUESIZE(ETH_FRAME_LEN);
2934 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
2937 *(int *)ctl->data = size * SKB_TRUESIZE(ETH_FRAME_LEN);
2941 static struct neigh_parms *neigh_get_dev_parms_rcu(struct net_device *dev,
2946 return __in_dev_arp_parms_get_rcu(dev);
2948 return __in6_dev_nd_parms_get_rcu(dev);
2953 static void neigh_copy_dflt_parms(struct net *net, struct neigh_parms *p,
2956 struct net_device *dev;
2957 int family = neigh_parms_family(p);
2960 for_each_netdev_rcu(net, dev) {
2961 struct neigh_parms *dst_p =
2962 neigh_get_dev_parms_rcu(dev, family);
2964 if (dst_p && !test_bit(index, dst_p->data_state))
2965 dst_p->data[index] = p->data[index];
2970 static void neigh_proc_update(struct ctl_table *ctl, int write)
2972 struct net_device *dev = ctl->extra1;
2973 struct neigh_parms *p = ctl->extra2;
2974 struct net *net = neigh_parms_net(p);
2975 int index = (int *) ctl->data - p->data;
2980 set_bit(index, p->data_state);
2981 if (index == NEIGH_VAR_DELAY_PROBE_TIME)
2982 call_netevent_notifiers(NETEVENT_DELAY_PROBE_TIME_UPDATE, p);
2983 if (!dev) /* NULL dev means this is default value */
2984 neigh_copy_dflt_parms(net, p, index);
2987 static int neigh_proc_dointvec_zero_intmax(struct ctl_table *ctl, int write,
2988 void __user *buffer,
2989 size_t *lenp, loff_t *ppos)
2991 struct ctl_table tmp = *ctl;
2995 tmp.extra2 = &int_max;
2997 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
2998 neigh_proc_update(ctl, write);
3002 int neigh_proc_dointvec(struct ctl_table *ctl, int write,
3003 void __user *buffer, size_t *lenp, loff_t *ppos)
3005 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
3007 neigh_proc_update(ctl, write);
3010 EXPORT_SYMBOL(neigh_proc_dointvec);
3012 int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write,
3013 void __user *buffer,
3014 size_t *lenp, loff_t *ppos)
3016 int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
3018 neigh_proc_update(ctl, write);
3021 EXPORT_SYMBOL(neigh_proc_dointvec_jiffies);
3023 static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table *ctl, int write,
3024 void __user *buffer,
3025 size_t *lenp, loff_t *ppos)
3027 int ret = proc_dointvec_userhz_jiffies(ctl, write, buffer, lenp, ppos);
3029 neigh_proc_update(ctl, write);
3033 int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write,
3034 void __user *buffer,
3035 size_t *lenp, loff_t *ppos)
3037 int ret = proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
3039 neigh_proc_update(ctl, write);
3042 EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies);
3044 static int neigh_proc_dointvec_unres_qlen(struct ctl_table *ctl, int write,
3045 void __user *buffer,
3046 size_t *lenp, loff_t *ppos)
3048 int ret = proc_unres_qlen(ctl, write, buffer, lenp, ppos);
3050 neigh_proc_update(ctl, write);
3054 static int neigh_proc_base_reachable_time(struct ctl_table *ctl, int write,
3055 void __user *buffer,
3056 size_t *lenp, loff_t *ppos)
3058 struct neigh_parms *p = ctl->extra2;
3061 if (strcmp(ctl->procname, "base_reachable_time") == 0)
3062 ret = neigh_proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
3063 else if (strcmp(ctl->procname, "base_reachable_time_ms") == 0)
3064 ret = neigh_proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
3068 if (write && ret == 0) {
3069 /* update reachable_time as well, otherwise, the change will
3070 * only be effective after the next time neigh_periodic_work
3071 * decides to recompute it
3074 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
3079 #define NEIGH_PARMS_DATA_OFFSET(index) \
3080 (&((struct neigh_parms *) 0)->data[index])
3082 #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \
3083 [NEIGH_VAR_ ## attr] = { \
3085 .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \
3086 .maxlen = sizeof(int), \
3088 .proc_handler = proc, \
3091 #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \
3092 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax)
3094 #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \
3095 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies)
3097 #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \
3098 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies)
3100 #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \
3101 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
3103 #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \
3104 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
3106 #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \
3107 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen)
3109 static struct neigh_sysctl_table {
3110 struct ctl_table_header *sysctl_header;
3111 struct ctl_table neigh_vars[NEIGH_VAR_MAX + 1];
3112 } neigh_sysctl_template __read_mostly = {
3114 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES, "mcast_solicit"),
3115 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES, "ucast_solicit"),
3116 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES, "app_solicit"),
3117 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_REPROBES, "mcast_resolicit"),
3118 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME, "retrans_time"),
3119 NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME, "base_reachable_time"),
3120 NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME, "delay_first_probe_time"),
3121 NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME, "gc_stale_time"),
3122 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES, "unres_qlen_bytes"),
3123 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN, "proxy_qlen"),
3124 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY, "anycast_delay"),
3125 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY, "proxy_delay"),
3126 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME, "locktime"),
3127 NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN, QUEUE_LEN_BYTES, "unres_qlen"),
3128 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS, RETRANS_TIME, "retrans_time_ms"),
3129 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS, BASE_REACHABLE_TIME, "base_reachable_time_ms"),
3130 [NEIGH_VAR_GC_INTERVAL] = {
3131 .procname = "gc_interval",
3132 .maxlen = sizeof(int),
3134 .proc_handler = proc_dointvec_jiffies,
3136 [NEIGH_VAR_GC_THRESH1] = {
3137 .procname = "gc_thresh1",
3138 .maxlen = sizeof(int),
3142 .proc_handler = proc_dointvec_minmax,
3144 [NEIGH_VAR_GC_THRESH2] = {
3145 .procname = "gc_thresh2",
3146 .maxlen = sizeof(int),
3150 .proc_handler = proc_dointvec_minmax,
3152 [NEIGH_VAR_GC_THRESH3] = {
3153 .procname = "gc_thresh3",
3154 .maxlen = sizeof(int),
3158 .proc_handler = proc_dointvec_minmax,
3164 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
3165 proc_handler *handler)
3168 struct neigh_sysctl_table *t;
3169 const char *dev_name_source;
3170 char neigh_path[ sizeof("net//neigh/") + IFNAMSIZ + IFNAMSIZ ];
3173 t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
3177 for (i = 0; i < NEIGH_VAR_GC_INTERVAL; i++) {
3178 t->neigh_vars[i].data += (long) p;
3179 t->neigh_vars[i].extra1 = dev;
3180 t->neigh_vars[i].extra2 = p;
3184 dev_name_source = dev->name;
3185 /* Terminate the table early */
3186 memset(&t->neigh_vars[NEIGH_VAR_GC_INTERVAL], 0,
3187 sizeof(t->neigh_vars[NEIGH_VAR_GC_INTERVAL]));
3189 struct neigh_table *tbl = p->tbl;
3190 dev_name_source = "default";
3191 t->neigh_vars[NEIGH_VAR_GC_INTERVAL].data = &tbl->gc_interval;
3192 t->neigh_vars[NEIGH_VAR_GC_THRESH1].data = &tbl->gc_thresh1;
3193 t->neigh_vars[NEIGH_VAR_GC_THRESH2].data = &tbl->gc_thresh2;
3194 t->neigh_vars[NEIGH_VAR_GC_THRESH3].data = &tbl->gc_thresh3;
3199 t->neigh_vars[NEIGH_VAR_RETRANS_TIME].proc_handler = handler;
3201 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = handler;
3202 /* RetransTime (in milliseconds)*/
3203 t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].proc_handler = handler;
3204 /* ReachableTime (in milliseconds) */
3205 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = handler;
3207 /* Those handlers will update p->reachable_time after
3208 * base_reachable_time(_ms) is set to ensure the new timer starts being
3209 * applied after the next neighbour update instead of waiting for
3210 * neigh_periodic_work to update its value (can be multiple minutes)
3211 * So any handler that replaces them should do this as well
3214 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler =
3215 neigh_proc_base_reachable_time;
3216 /* ReachableTime (in milliseconds) */
3217 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler =
3218 neigh_proc_base_reachable_time;
3221 /* Don't export sysctls to unprivileged users */
3222 if (neigh_parms_net(p)->user_ns != &init_user_ns)
3223 t->neigh_vars[0].procname = NULL;
3225 switch (neigh_parms_family(p)) {
3236 snprintf(neigh_path, sizeof(neigh_path), "net/%s/neigh/%s",
3237 p_name, dev_name_source);
3239 register_net_sysctl(neigh_parms_net(p), neigh_path, t->neigh_vars);
3240 if (!t->sysctl_header)
3243 p->sysctl_table = t;
3251 EXPORT_SYMBOL(neigh_sysctl_register);
3253 void neigh_sysctl_unregister(struct neigh_parms *p)
3255 if (p->sysctl_table) {
3256 struct neigh_sysctl_table *t = p->sysctl_table;
3257 p->sysctl_table = NULL;
3258 unregister_net_sysctl_table(t->sysctl_header);
3262 EXPORT_SYMBOL(neigh_sysctl_unregister);
3264 #endif /* CONFIG_SYSCTL */
3266 static int __init neigh_init(void)
3268 rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, 0);
3269 rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, 0);
3270 rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info, 0);
3272 rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info,
3274 rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, 0);
3279 subsys_initcall(neigh_init);