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(unsigned long arg
);
55 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
);
56 static void neigh_update_notify(struct neighbour
*neigh
);
57 static int pneigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
);
60 static const struct file_operations neigh_stat_seq_fops
;
64 Neighbour hash table buckets are protected with rwlock tbl->lock.
66 - All the scans/updates to hash buckets MUST be made under this lock.
67 - NOTHING clever should be made under this lock: no callbacks
68 to protocol backends, no attempts to send something to network.
69 It will result in deadlocks, if backend/driver wants to use neighbour
71 - If the entry requires some non-trivial actions, increase
72 its reference count and release table lock.
74 Neighbour entries are protected:
75 - with reference count.
76 - with rwlock neigh->lock
78 Reference count prevents destruction.
80 neigh->lock mainly serializes ll address data and its validity state.
81 However, the same lock is used to protect another entry fields:
85 Again, nothing clever shall be made under neigh->lock,
86 the most complicated procedure, which we allow is dev->hard_header.
87 It is supposed, that dev->hard_header is simplistic and does
88 not make callbacks to neighbour tables.
91 static int neigh_blackhole(struct neighbour
*neigh
, struct sk_buff
*skb
)
97 static void neigh_cleanup_and_release(struct neighbour
*neigh
)
99 if (neigh
->parms
->neigh_cleanup
)
100 neigh
->parms
->neigh_cleanup(neigh
);
102 __neigh_notify(neigh
, RTM_DELNEIGH
, 0);
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
? (prandom_u32() % base
) + (base
>> 1) : 0;
116 EXPORT_SYMBOL(neigh_rand_reach_time
);
119 static int neigh_forced_gc(struct neigh_table
*tbl
)
123 struct neigh_hash_table
*nht
;
125 NEIGH_CACHE_STAT_INC(tbl
, forced_gc_runs
);
127 write_lock_bh(&tbl
->lock
);
128 nht
= rcu_dereference_protected(tbl
->nht
,
129 lockdep_is_held(&tbl
->lock
));
130 for (i
= 0; i
< (1 << nht
->hash_shift
); i
++) {
132 struct neighbour __rcu
**np
;
134 np
= &nht
->hash_buckets
[i
];
135 while ((n
= rcu_dereference_protected(*np
,
136 lockdep_is_held(&tbl
->lock
))) != NULL
) {
137 /* Neighbour record may be discarded if:
138 * - nobody refers to it.
139 * - it is not permanent
141 write_lock(&n
->lock
);
142 if (atomic_read(&n
->refcnt
) == 1 &&
143 !(n
->nud_state
& NUD_PERMANENT
)) {
144 rcu_assign_pointer(*np
,
145 rcu_dereference_protected(n
->next
,
146 lockdep_is_held(&tbl
->lock
)));
149 write_unlock(&n
->lock
);
150 neigh_cleanup_and_release(n
);
153 write_unlock(&n
->lock
);
158 tbl
->last_flush
= jiffies
;
160 write_unlock_bh(&tbl
->lock
);
165 static void neigh_add_timer(struct neighbour
*n
, unsigned long when
)
168 if (unlikely(mod_timer(&n
->timer
, when
))) {
169 printk("NEIGH: BUG, double timer add, state is %x\n",
175 static int neigh_del_timer(struct neighbour
*n
)
177 if ((n
->nud_state
& NUD_IN_TIMER
) &&
178 del_timer(&n
->timer
)) {
185 static void pneigh_queue_purge(struct sk_buff_head
*list
)
189 while ((skb
= skb_dequeue(list
)) != NULL
) {
195 static void neigh_flush_dev(struct neigh_table
*tbl
, struct net_device
*dev
)
198 struct neigh_hash_table
*nht
;
200 nht
= rcu_dereference_protected(tbl
->nht
,
201 lockdep_is_held(&tbl
->lock
));
203 for (i
= 0; i
< (1 << nht
->hash_shift
); i
++) {
205 struct neighbour __rcu
**np
= &nht
->hash_buckets
[i
];
207 while ((n
= rcu_dereference_protected(*np
,
208 lockdep_is_held(&tbl
->lock
))) != NULL
) {
209 if (dev
&& n
->dev
!= dev
) {
213 rcu_assign_pointer(*np
,
214 rcu_dereference_protected(n
->next
,
215 lockdep_is_held(&tbl
->lock
)));
216 write_lock(&n
->lock
);
220 if (atomic_read(&n
->refcnt
) != 1) {
221 /* The most unpleasant situation.
222 We must destroy neighbour entry,
223 but someone still uses it.
225 The destroy will be delayed until
226 the last user releases us, but
227 we must kill timers etc. and move
230 __skb_queue_purge(&n
->arp_queue
);
231 n
->arp_queue_len_bytes
= 0;
232 n
->output
= neigh_blackhole
;
233 if (n
->nud_state
& NUD_VALID
)
234 n
->nud_state
= NUD_NOARP
;
236 n
->nud_state
= NUD_NONE
;
237 neigh_dbg(2, "neigh %p is stray\n", n
);
239 write_unlock(&n
->lock
);
240 neigh_cleanup_and_release(n
);
245 void neigh_changeaddr(struct neigh_table
*tbl
, struct net_device
*dev
)
247 write_lock_bh(&tbl
->lock
);
248 neigh_flush_dev(tbl
, dev
);
249 write_unlock_bh(&tbl
->lock
);
251 EXPORT_SYMBOL(neigh_changeaddr
);
253 int neigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
)
255 write_lock_bh(&tbl
->lock
);
256 neigh_flush_dev(tbl
, dev
);
257 pneigh_ifdown(tbl
, dev
);
258 write_unlock_bh(&tbl
->lock
);
260 del_timer_sync(&tbl
->proxy_timer
);
261 pneigh_queue_purge(&tbl
->proxy_queue
);
264 EXPORT_SYMBOL(neigh_ifdown
);
266 static struct neighbour
*neigh_alloc(struct neigh_table
*tbl
, struct net_device
*dev
)
268 struct neighbour
*n
= NULL
;
269 unsigned long now
= jiffies
;
272 entries
= atomic_inc_return(&tbl
->entries
) - 1;
273 if (entries
>= tbl
->gc_thresh3
||
274 (entries
>= tbl
->gc_thresh2
&&
275 time_after(now
, tbl
->last_flush
+ 5 * HZ
))) {
276 if (!neigh_forced_gc(tbl
) &&
277 entries
>= tbl
->gc_thresh3
)
281 n
= kzalloc(tbl
->entry_size
+ dev
->neigh_priv_len
, GFP_ATOMIC
);
285 __skb_queue_head_init(&n
->arp_queue
);
286 rwlock_init(&n
->lock
);
287 seqlock_init(&n
->ha_lock
);
288 n
->updated
= n
->used
= now
;
289 n
->nud_state
= NUD_NONE
;
290 n
->output
= neigh_blackhole
;
291 seqlock_init(&n
->hh
.hh_lock
);
292 n
->parms
= neigh_parms_clone(&tbl
->parms
);
293 setup_timer(&n
->timer
, neigh_timer_handler
, (unsigned long)n
);
295 NEIGH_CACHE_STAT_INC(tbl
, allocs
);
297 atomic_set(&n
->refcnt
, 1);
303 atomic_dec(&tbl
->entries
);
307 static void neigh_get_hash_rnd(u32
*x
)
309 get_random_bytes(x
, sizeof(*x
));
313 static struct neigh_hash_table
*neigh_hash_alloc(unsigned int shift
)
315 size_t size
= (1 << shift
) * sizeof(struct neighbour
*);
316 struct neigh_hash_table
*ret
;
317 struct neighbour __rcu
**buckets
;
320 ret
= kmalloc(sizeof(*ret
), GFP_ATOMIC
);
323 if (size
<= PAGE_SIZE
)
324 buckets
= kzalloc(size
, GFP_ATOMIC
);
326 buckets
= (struct neighbour __rcu
**)
327 __get_free_pages(GFP_ATOMIC
| __GFP_ZERO
,
333 ret
->hash_buckets
= buckets
;
334 ret
->hash_shift
= shift
;
335 for (i
= 0; i
< NEIGH_NUM_HASH_RND
; i
++)
336 neigh_get_hash_rnd(&ret
->hash_rnd
[i
]);
340 static void neigh_hash_free_rcu(struct rcu_head
*head
)
342 struct neigh_hash_table
*nht
= container_of(head
,
343 struct neigh_hash_table
,
345 size_t size
= (1 << nht
->hash_shift
) * sizeof(struct neighbour
*);
346 struct neighbour __rcu
**buckets
= nht
->hash_buckets
;
348 if (size
<= PAGE_SIZE
)
351 free_pages((unsigned long)buckets
, get_order(size
));
355 static struct neigh_hash_table
*neigh_hash_grow(struct neigh_table
*tbl
,
356 unsigned long new_shift
)
358 unsigned int i
, hash
;
359 struct neigh_hash_table
*new_nht
, *old_nht
;
361 NEIGH_CACHE_STAT_INC(tbl
, hash_grows
);
363 old_nht
= rcu_dereference_protected(tbl
->nht
,
364 lockdep_is_held(&tbl
->lock
));
365 new_nht
= neigh_hash_alloc(new_shift
);
369 for (i
= 0; i
< (1 << old_nht
->hash_shift
); i
++) {
370 struct neighbour
*n
, *next
;
372 for (n
= rcu_dereference_protected(old_nht
->hash_buckets
[i
],
373 lockdep_is_held(&tbl
->lock
));
376 hash
= tbl
->hash(n
->primary_key
, n
->dev
,
379 hash
>>= (32 - new_nht
->hash_shift
);
380 next
= rcu_dereference_protected(n
->next
,
381 lockdep_is_held(&tbl
->lock
));
383 rcu_assign_pointer(n
->next
,
384 rcu_dereference_protected(
385 new_nht
->hash_buckets
[hash
],
386 lockdep_is_held(&tbl
->lock
)));
387 rcu_assign_pointer(new_nht
->hash_buckets
[hash
], n
);
391 rcu_assign_pointer(tbl
->nht
, new_nht
);
392 call_rcu(&old_nht
->rcu
, neigh_hash_free_rcu
);
396 struct neighbour
*neigh_lookup(struct neigh_table
*tbl
, const void *pkey
,
397 struct net_device
*dev
)
400 int key_len
= tbl
->key_len
;
402 struct neigh_hash_table
*nht
;
404 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
407 nht
= rcu_dereference_bh(tbl
->nht
);
408 hash_val
= tbl
->hash(pkey
, dev
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
410 for (n
= rcu_dereference_bh(nht
->hash_buckets
[hash_val
]);
412 n
= rcu_dereference_bh(n
->next
)) {
413 if (dev
== n
->dev
&& !memcmp(n
->primary_key
, pkey
, key_len
)) {
414 if (!atomic_inc_not_zero(&n
->refcnt
))
416 NEIGH_CACHE_STAT_INC(tbl
, hits
);
421 rcu_read_unlock_bh();
424 EXPORT_SYMBOL(neigh_lookup
);
426 struct neighbour
*neigh_lookup_nodev(struct neigh_table
*tbl
, struct net
*net
,
430 int key_len
= tbl
->key_len
;
432 struct neigh_hash_table
*nht
;
434 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
437 nht
= rcu_dereference_bh(tbl
->nht
);
438 hash_val
= tbl
->hash(pkey
, NULL
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
440 for (n
= rcu_dereference_bh(nht
->hash_buckets
[hash_val
]);
442 n
= rcu_dereference_bh(n
->next
)) {
443 if (!memcmp(n
->primary_key
, pkey
, key_len
) &&
444 net_eq(dev_net(n
->dev
), net
)) {
445 if (!atomic_inc_not_zero(&n
->refcnt
))
447 NEIGH_CACHE_STAT_INC(tbl
, hits
);
452 rcu_read_unlock_bh();
455 EXPORT_SYMBOL(neigh_lookup_nodev
);
457 struct neighbour
*__neigh_create(struct neigh_table
*tbl
, const void *pkey
,
458 struct net_device
*dev
, bool want_ref
)
461 int key_len
= tbl
->key_len
;
463 struct neighbour
*n1
, *rc
, *n
= neigh_alloc(tbl
, dev
);
464 struct neigh_hash_table
*nht
;
467 rc
= ERR_PTR(-ENOBUFS
);
471 memcpy(n
->primary_key
, pkey
, key_len
);
475 /* Protocol specific setup. */
476 if (tbl
->constructor
&& (error
= tbl
->constructor(n
)) < 0) {
478 goto out_neigh_release
;
481 if (dev
->netdev_ops
->ndo_neigh_construct
) {
482 error
= dev
->netdev_ops
->ndo_neigh_construct(n
);
485 goto out_neigh_release
;
489 /* Device specific setup. */
490 if (n
->parms
->neigh_setup
&&
491 (error
= n
->parms
->neigh_setup(n
)) < 0) {
493 goto out_neigh_release
;
496 n
->confirmed
= jiffies
- (NEIGH_VAR(n
->parms
, BASE_REACHABLE_TIME
) << 1);
498 write_lock_bh(&tbl
->lock
);
499 nht
= rcu_dereference_protected(tbl
->nht
,
500 lockdep_is_held(&tbl
->lock
));
502 if (atomic_read(&tbl
->entries
) > (1 << nht
->hash_shift
))
503 nht
= neigh_hash_grow(tbl
, nht
->hash_shift
+ 1);
505 hash_val
= tbl
->hash(pkey
, dev
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
507 if (n
->parms
->dead
) {
508 rc
= ERR_PTR(-EINVAL
);
512 for (n1
= rcu_dereference_protected(nht
->hash_buckets
[hash_val
],
513 lockdep_is_held(&tbl
->lock
));
515 n1
= rcu_dereference_protected(n1
->next
,
516 lockdep_is_held(&tbl
->lock
))) {
517 if (dev
== n1
->dev
&& !memcmp(n1
->primary_key
, pkey
, key_len
)) {
528 rcu_assign_pointer(n
->next
,
529 rcu_dereference_protected(nht
->hash_buckets
[hash_val
],
530 lockdep_is_held(&tbl
->lock
)));
531 rcu_assign_pointer(nht
->hash_buckets
[hash_val
], n
);
532 write_unlock_bh(&tbl
->lock
);
533 neigh_dbg(2, "neigh %p is created\n", n
);
538 write_unlock_bh(&tbl
->lock
);
543 EXPORT_SYMBOL(__neigh_create
);
545 static u32
pneigh_hash(const void *pkey
, int key_len
)
547 u32 hash_val
= *(u32
*)(pkey
+ key_len
- 4);
548 hash_val
^= (hash_val
>> 16);
549 hash_val
^= hash_val
>> 8;
550 hash_val
^= hash_val
>> 4;
551 hash_val
&= PNEIGH_HASHMASK
;
555 static struct pneigh_entry
*__pneigh_lookup_1(struct pneigh_entry
*n
,
559 struct net_device
*dev
)
562 if (!memcmp(n
->key
, pkey
, key_len
) &&
563 net_eq(pneigh_net(n
), net
) &&
564 (n
->dev
== dev
|| !n
->dev
))
571 struct pneigh_entry
*__pneigh_lookup(struct neigh_table
*tbl
,
572 struct net
*net
, const void *pkey
, struct net_device
*dev
)
574 int key_len
= tbl
->key_len
;
575 u32 hash_val
= pneigh_hash(pkey
, key_len
);
577 return __pneigh_lookup_1(tbl
->phash_buckets
[hash_val
],
578 net
, pkey
, key_len
, dev
);
580 EXPORT_SYMBOL_GPL(__pneigh_lookup
);
582 struct pneigh_entry
* pneigh_lookup(struct neigh_table
*tbl
,
583 struct net
*net
, const void *pkey
,
584 struct net_device
*dev
, int creat
)
586 struct pneigh_entry
*n
;
587 int key_len
= tbl
->key_len
;
588 u32 hash_val
= pneigh_hash(pkey
, key_len
);
590 read_lock_bh(&tbl
->lock
);
591 n
= __pneigh_lookup_1(tbl
->phash_buckets
[hash_val
],
592 net
, pkey
, key_len
, dev
);
593 read_unlock_bh(&tbl
->lock
);
600 n
= kmalloc(sizeof(*n
) + key_len
, GFP_KERNEL
);
604 write_pnet(&n
->net
, hold_net(net
));
605 memcpy(n
->key
, pkey
, key_len
);
610 if (tbl
->pconstructor
&& tbl
->pconstructor(n
)) {
619 write_lock_bh(&tbl
->lock
);
620 n
->next
= tbl
->phash_buckets
[hash_val
];
621 tbl
->phash_buckets
[hash_val
] = n
;
622 write_unlock_bh(&tbl
->lock
);
626 EXPORT_SYMBOL(pneigh_lookup
);
629 int pneigh_delete(struct neigh_table
*tbl
, struct net
*net
, const void *pkey
,
630 struct net_device
*dev
)
632 struct pneigh_entry
*n
, **np
;
633 int key_len
= tbl
->key_len
;
634 u32 hash_val
= pneigh_hash(pkey
, key_len
);
636 write_lock_bh(&tbl
->lock
);
637 for (np
= &tbl
->phash_buckets
[hash_val
]; (n
= *np
) != NULL
;
639 if (!memcmp(n
->key
, pkey
, key_len
) && n
->dev
== dev
&&
640 net_eq(pneigh_net(n
), net
)) {
642 write_unlock_bh(&tbl
->lock
);
643 if (tbl
->pdestructor
)
647 release_net(pneigh_net(n
));
652 write_unlock_bh(&tbl
->lock
);
656 static int pneigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
)
658 struct pneigh_entry
*n
, **np
;
661 for (h
= 0; h
<= PNEIGH_HASHMASK
; h
++) {
662 np
= &tbl
->phash_buckets
[h
];
663 while ((n
= *np
) != NULL
) {
664 if (!dev
|| n
->dev
== dev
) {
666 if (tbl
->pdestructor
)
670 release_net(pneigh_net(n
));
680 static void neigh_parms_destroy(struct neigh_parms
*parms
);
682 static inline void neigh_parms_put(struct neigh_parms
*parms
)
684 if (atomic_dec_and_test(&parms
->refcnt
))
685 neigh_parms_destroy(parms
);
689 * neighbour must already be out of the table;
692 void neigh_destroy(struct neighbour
*neigh
)
694 struct net_device
*dev
= neigh
->dev
;
696 NEIGH_CACHE_STAT_INC(neigh
->tbl
, destroys
);
699 pr_warn("Destroying alive neighbour %p\n", neigh
);
704 if (neigh_del_timer(neigh
))
705 pr_warn("Impossible event\n");
707 write_lock_bh(&neigh
->lock
);
708 __skb_queue_purge(&neigh
->arp_queue
);
709 write_unlock_bh(&neigh
->lock
);
710 neigh
->arp_queue_len_bytes
= 0;
712 if (dev
->netdev_ops
->ndo_neigh_destroy
)
713 dev
->netdev_ops
->ndo_neigh_destroy(neigh
);
716 neigh_parms_put(neigh
->parms
);
718 neigh_dbg(2, "neigh %p is destroyed\n", neigh
);
720 atomic_dec(&neigh
->tbl
->entries
);
721 kfree_rcu(neigh
, rcu
);
723 EXPORT_SYMBOL(neigh_destroy
);
725 /* Neighbour state is suspicious;
728 Called with write_locked neigh.
730 static void neigh_suspect(struct neighbour
*neigh
)
732 neigh_dbg(2, "neigh %p is suspected\n", neigh
);
734 neigh
->output
= neigh
->ops
->output
;
737 /* Neighbour state is OK;
740 Called with write_locked neigh.
742 static void neigh_connect(struct neighbour
*neigh
)
744 neigh_dbg(2, "neigh %p is connected\n", neigh
);
746 neigh
->output
= neigh
->ops
->connected_output
;
749 static void neigh_periodic_work(struct work_struct
*work
)
751 struct neigh_table
*tbl
= container_of(work
, struct neigh_table
, gc_work
.work
);
753 struct neighbour __rcu
**np
;
755 struct neigh_hash_table
*nht
;
757 NEIGH_CACHE_STAT_INC(tbl
, periodic_gc_runs
);
759 write_lock_bh(&tbl
->lock
);
760 nht
= rcu_dereference_protected(tbl
->nht
,
761 lockdep_is_held(&tbl
->lock
));
764 * periodically recompute ReachableTime from random function
767 if (time_after(jiffies
, tbl
->last_rand
+ 300 * HZ
)) {
768 struct neigh_parms
*p
;
769 tbl
->last_rand
= jiffies
;
770 list_for_each_entry(p
, &tbl
->parms_list
, list
)
772 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
775 if (atomic_read(&tbl
->entries
) < tbl
->gc_thresh1
)
778 for (i
= 0 ; i
< (1 << nht
->hash_shift
); i
++) {
779 np
= &nht
->hash_buckets
[i
];
781 while ((n
= rcu_dereference_protected(*np
,
782 lockdep_is_held(&tbl
->lock
))) != NULL
) {
785 write_lock(&n
->lock
);
787 state
= n
->nud_state
;
788 if (state
& (NUD_PERMANENT
| NUD_IN_TIMER
)) {
789 write_unlock(&n
->lock
);
793 if (time_before(n
->used
, n
->confirmed
))
794 n
->used
= n
->confirmed
;
796 if (atomic_read(&n
->refcnt
) == 1 &&
797 (state
== NUD_FAILED
||
798 time_after(jiffies
, n
->used
+ NEIGH_VAR(n
->parms
, GC_STALETIME
)))) {
801 write_unlock(&n
->lock
);
802 neigh_cleanup_and_release(n
);
805 write_unlock(&n
->lock
);
811 * It's fine to release lock here, even if hash table
812 * grows while we are preempted.
814 write_unlock_bh(&tbl
->lock
);
816 write_lock_bh(&tbl
->lock
);
817 nht
= rcu_dereference_protected(tbl
->nht
,
818 lockdep_is_held(&tbl
->lock
));
821 /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks.
822 * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2
823 * BASE_REACHABLE_TIME.
825 queue_delayed_work(system_power_efficient_wq
, &tbl
->gc_work
,
826 NEIGH_VAR(&tbl
->parms
, BASE_REACHABLE_TIME
) >> 1);
827 write_unlock_bh(&tbl
->lock
);
830 static __inline__
int neigh_max_probes(struct neighbour
*n
)
832 struct neigh_parms
*p
= n
->parms
;
833 int max_probes
= NEIGH_VAR(p
, UCAST_PROBES
) + NEIGH_VAR(p
, APP_PROBES
);
834 if (!(n
->nud_state
& NUD_PROBE
))
835 max_probes
+= NEIGH_VAR(p
, MCAST_PROBES
);
839 static void neigh_invalidate(struct neighbour
*neigh
)
840 __releases(neigh
->lock
)
841 __acquires(neigh
->lock
)
845 NEIGH_CACHE_STAT_INC(neigh
->tbl
, res_failed
);
846 neigh_dbg(2, "neigh %p is failed\n", neigh
);
847 neigh
->updated
= jiffies
;
849 /* It is very thin place. report_unreachable is very complicated
850 routine. Particularly, it can hit the same neighbour entry!
852 So that, we try to be accurate and avoid dead loop. --ANK
854 while (neigh
->nud_state
== NUD_FAILED
&&
855 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
856 write_unlock(&neigh
->lock
);
857 neigh
->ops
->error_report(neigh
, skb
);
858 write_lock(&neigh
->lock
);
860 __skb_queue_purge(&neigh
->arp_queue
);
861 neigh
->arp_queue_len_bytes
= 0;
864 static void neigh_probe(struct neighbour
*neigh
)
865 __releases(neigh
->lock
)
867 struct sk_buff
*skb
= skb_peek_tail(&neigh
->arp_queue
);
868 /* keep skb alive even if arp_queue overflows */
870 skb
= skb_copy(skb
, GFP_ATOMIC
);
871 write_unlock(&neigh
->lock
);
872 neigh
->ops
->solicit(neigh
, skb
);
873 atomic_inc(&neigh
->probes
);
877 /* Called when a timer expires for a neighbour entry. */
879 static void neigh_timer_handler(unsigned long arg
)
881 unsigned long now
, next
;
882 struct neighbour
*neigh
= (struct neighbour
*)arg
;
886 write_lock(&neigh
->lock
);
888 state
= neigh
->nud_state
;
892 if (!(state
& NUD_IN_TIMER
))
895 if (state
& NUD_REACHABLE
) {
896 if (time_before_eq(now
,
897 neigh
->confirmed
+ neigh
->parms
->reachable_time
)) {
898 neigh_dbg(2, "neigh %p is still alive\n", neigh
);
899 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
900 } else if (time_before_eq(now
,
902 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
))) {
903 neigh_dbg(2, "neigh %p is delayed\n", neigh
);
904 neigh
->nud_state
= NUD_DELAY
;
905 neigh
->updated
= jiffies
;
906 neigh_suspect(neigh
);
907 next
= now
+ NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
);
909 neigh_dbg(2, "neigh %p is suspected\n", neigh
);
910 neigh
->nud_state
= NUD_STALE
;
911 neigh
->updated
= jiffies
;
912 neigh_suspect(neigh
);
915 } else if (state
& NUD_DELAY
) {
916 if (time_before_eq(now
,
918 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
))) {
919 neigh_dbg(2, "neigh %p is now reachable\n", neigh
);
920 neigh
->nud_state
= NUD_REACHABLE
;
921 neigh
->updated
= jiffies
;
922 neigh_connect(neigh
);
924 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
926 neigh_dbg(2, "neigh %p is probed\n", neigh
);
927 neigh
->nud_state
= NUD_PROBE
;
928 neigh
->updated
= jiffies
;
929 atomic_set(&neigh
->probes
, 0);
930 next
= now
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
);
933 /* NUD_PROBE|NUD_INCOMPLETE */
934 next
= now
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
);
937 if ((neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
938 atomic_read(&neigh
->probes
) >= neigh_max_probes(neigh
)) {
939 neigh
->nud_state
= NUD_FAILED
;
941 neigh_invalidate(neigh
);
945 if (neigh
->nud_state
& NUD_IN_TIMER
) {
946 if (time_before(next
, jiffies
+ HZ
/2))
947 next
= jiffies
+ HZ
/2;
948 if (!mod_timer(&neigh
->timer
, next
))
951 if (neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) {
955 write_unlock(&neigh
->lock
);
959 neigh_update_notify(neigh
);
961 neigh_release(neigh
);
964 int __neigh_event_send(struct neighbour
*neigh
, struct sk_buff
*skb
)
967 bool immediate_probe
= false;
969 write_lock_bh(&neigh
->lock
);
972 if (neigh
->nud_state
& (NUD_CONNECTED
| NUD_DELAY
| NUD_PROBE
))
975 if (!(neigh
->nud_state
& (NUD_STALE
| NUD_INCOMPLETE
))) {
976 if (NEIGH_VAR(neigh
->parms
, MCAST_PROBES
) +
977 NEIGH_VAR(neigh
->parms
, APP_PROBES
)) {
978 unsigned long next
, now
= jiffies
;
980 atomic_set(&neigh
->probes
,
981 NEIGH_VAR(neigh
->parms
, UCAST_PROBES
));
982 neigh
->nud_state
= NUD_INCOMPLETE
;
983 neigh
->updated
= now
;
984 next
= now
+ max(NEIGH_VAR(neigh
->parms
, RETRANS_TIME
),
986 neigh_add_timer(neigh
, next
);
987 immediate_probe
= true;
989 neigh
->nud_state
= NUD_FAILED
;
990 neigh
->updated
= jiffies
;
991 write_unlock_bh(&neigh
->lock
);
996 } else if (neigh
->nud_state
& NUD_STALE
) {
997 neigh_dbg(2, "neigh %p is delayed\n", neigh
);
998 neigh
->nud_state
= NUD_DELAY
;
999 neigh
->updated
= jiffies
;
1000 neigh_add_timer(neigh
, jiffies
+
1001 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
));
1004 if (neigh
->nud_state
== NUD_INCOMPLETE
) {
1006 while (neigh
->arp_queue_len_bytes
+ skb
->truesize
>
1007 NEIGH_VAR(neigh
->parms
, QUEUE_LEN_BYTES
)) {
1008 struct sk_buff
*buff
;
1010 buff
= __skb_dequeue(&neigh
->arp_queue
);
1013 neigh
->arp_queue_len_bytes
-= buff
->truesize
;
1015 NEIGH_CACHE_STAT_INC(neigh
->tbl
, unres_discards
);
1018 __skb_queue_tail(&neigh
->arp_queue
, skb
);
1019 neigh
->arp_queue_len_bytes
+= skb
->truesize
;
1024 if (immediate_probe
)
1027 write_unlock(&neigh
->lock
);
1031 EXPORT_SYMBOL(__neigh_event_send
);
1033 static void neigh_update_hhs(struct neighbour
*neigh
)
1035 struct hh_cache
*hh
;
1036 void (*update
)(struct hh_cache
*, const struct net_device
*, const unsigned char *)
1039 if (neigh
->dev
->header_ops
)
1040 update
= neigh
->dev
->header_ops
->cache_update
;
1045 write_seqlock_bh(&hh
->hh_lock
);
1046 update(hh
, neigh
->dev
, neigh
->ha
);
1047 write_sequnlock_bh(&hh
->hh_lock
);
1054 /* Generic update routine.
1055 -- lladdr is new lladdr or NULL, if it is not supplied.
1056 -- new is new state.
1058 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
1060 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
1061 lladdr instead of overriding it
1063 It also allows to retain current state
1064 if lladdr is unchanged.
1065 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
1067 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
1069 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1072 Caller MUST hold reference count on the entry.
1075 int neigh_update(struct neighbour
*neigh
, const u8
*lladdr
, u8
new,
1081 struct net_device
*dev
;
1082 int update_isrouter
= 0;
1084 write_lock_bh(&neigh
->lock
);
1087 old
= neigh
->nud_state
;
1090 if (!(flags
& NEIGH_UPDATE_F_ADMIN
) &&
1091 (old
& (NUD_NOARP
| NUD_PERMANENT
)))
1094 if (!(new & NUD_VALID
)) {
1095 neigh_del_timer(neigh
);
1096 if (old
& NUD_CONNECTED
)
1097 neigh_suspect(neigh
);
1098 neigh
->nud_state
= new;
1100 notify
= old
& NUD_VALID
;
1101 if ((old
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
1102 (new & NUD_FAILED
)) {
1103 neigh_invalidate(neigh
);
1109 /* Compare new lladdr with cached one */
1110 if (!dev
->addr_len
) {
1111 /* First case: device needs no address. */
1113 } else if (lladdr
) {
1114 /* The second case: if something is already cached
1115 and a new address is proposed:
1117 - if they are different, check override flag
1119 if ((old
& NUD_VALID
) &&
1120 !memcmp(lladdr
, neigh
->ha
, dev
->addr_len
))
1123 /* No address is supplied; if we know something,
1124 use it, otherwise discard the request.
1127 if (!(old
& NUD_VALID
))
1132 if (new & NUD_CONNECTED
)
1133 neigh
->confirmed
= jiffies
;
1134 neigh
->updated
= jiffies
;
1136 /* If entry was valid and address is not changed,
1137 do not change entry state, if new one is STALE.
1140 update_isrouter
= flags
& NEIGH_UPDATE_F_OVERRIDE_ISROUTER
;
1141 if (old
& NUD_VALID
) {
1142 if (lladdr
!= neigh
->ha
&& !(flags
& NEIGH_UPDATE_F_OVERRIDE
)) {
1143 update_isrouter
= 0;
1144 if ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) &&
1145 (old
& NUD_CONNECTED
)) {
1151 if (lladdr
== neigh
->ha
&& new == NUD_STALE
&&
1152 ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) ||
1153 (old
& NUD_CONNECTED
))
1160 neigh_del_timer(neigh
);
1161 if (new & NUD_IN_TIMER
)
1162 neigh_add_timer(neigh
, (jiffies
+
1163 ((new & NUD_REACHABLE
) ?
1164 neigh
->parms
->reachable_time
:
1166 neigh
->nud_state
= new;
1170 if (lladdr
!= neigh
->ha
) {
1171 write_seqlock(&neigh
->ha_lock
);
1172 memcpy(&neigh
->ha
, lladdr
, dev
->addr_len
);
1173 write_sequnlock(&neigh
->ha_lock
);
1174 neigh_update_hhs(neigh
);
1175 if (!(new & NUD_CONNECTED
))
1176 neigh
->confirmed
= jiffies
-
1177 (NEIGH_VAR(neigh
->parms
, BASE_REACHABLE_TIME
) << 1);
1182 if (new & NUD_CONNECTED
)
1183 neigh_connect(neigh
);
1185 neigh_suspect(neigh
);
1186 if (!(old
& NUD_VALID
)) {
1187 struct sk_buff
*skb
;
1189 /* Again: avoid dead loop if something went wrong */
1191 while (neigh
->nud_state
& NUD_VALID
&&
1192 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
1193 struct dst_entry
*dst
= skb_dst(skb
);
1194 struct neighbour
*n2
, *n1
= neigh
;
1195 write_unlock_bh(&neigh
->lock
);
1199 /* Why not just use 'neigh' as-is? The problem is that
1200 * things such as shaper, eql, and sch_teql can end up
1201 * using alternative, different, neigh objects to output
1202 * the packet in the output path. So what we need to do
1203 * here is re-lookup the top-level neigh in the path so
1204 * we can reinject the packet there.
1208 n2
= dst_neigh_lookup_skb(dst
, skb
);
1212 n1
->output(n1
, skb
);
1217 write_lock_bh(&neigh
->lock
);
1219 __skb_queue_purge(&neigh
->arp_queue
);
1220 neigh
->arp_queue_len_bytes
= 0;
1223 if (update_isrouter
) {
1224 neigh
->flags
= (flags
& NEIGH_UPDATE_F_ISROUTER
) ?
1225 (neigh
->flags
| NTF_ROUTER
) :
1226 (neigh
->flags
& ~NTF_ROUTER
);
1228 write_unlock_bh(&neigh
->lock
);
1231 neigh_update_notify(neigh
);
1235 EXPORT_SYMBOL(neigh_update
);
1237 /* Update the neigh to listen temporarily for probe responses, even if it is
1238 * in a NUD_FAILED state. The caller has to hold neigh->lock for writing.
1240 void __neigh_set_probe_once(struct neighbour
*neigh
)
1242 neigh
->updated
= jiffies
;
1243 if (!(neigh
->nud_state
& NUD_FAILED
))
1245 neigh
->nud_state
= NUD_INCOMPLETE
;
1246 atomic_set(&neigh
->probes
, neigh_max_probes(neigh
));
1247 neigh_add_timer(neigh
,
1248 jiffies
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
));
1250 EXPORT_SYMBOL(__neigh_set_probe_once
);
1252 struct neighbour
*neigh_event_ns(struct neigh_table
*tbl
,
1253 u8
*lladdr
, void *saddr
,
1254 struct net_device
*dev
)
1256 struct neighbour
*neigh
= __neigh_lookup(tbl
, saddr
, dev
,
1257 lladdr
|| !dev
->addr_len
);
1259 neigh_update(neigh
, lladdr
, NUD_STALE
,
1260 NEIGH_UPDATE_F_OVERRIDE
);
1263 EXPORT_SYMBOL(neigh_event_ns
);
1265 /* called with read_lock_bh(&n->lock); */
1266 static void neigh_hh_init(struct neighbour
*n
)
1268 struct net_device
*dev
= n
->dev
;
1269 __be16 prot
= n
->tbl
->protocol
;
1270 struct hh_cache
*hh
= &n
->hh
;
1272 write_lock_bh(&n
->lock
);
1274 /* Only one thread can come in here and initialize the
1278 dev
->header_ops
->cache(n
, hh
, prot
);
1280 write_unlock_bh(&n
->lock
);
1283 /* Slow and careful. */
1285 int neigh_resolve_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1289 if (!neigh_event_send(neigh
, skb
)) {
1291 struct net_device
*dev
= neigh
->dev
;
1294 if (dev
->header_ops
->cache
&& !neigh
->hh
.hh_len
)
1295 neigh_hh_init(neigh
);
1298 __skb_pull(skb
, skb_network_offset(skb
));
1299 seq
= read_seqbegin(&neigh
->ha_lock
);
1300 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1301 neigh
->ha
, NULL
, skb
->len
);
1302 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1305 rc
= dev_queue_xmit(skb
);
1316 EXPORT_SYMBOL(neigh_resolve_output
);
1318 /* As fast as possible without hh cache */
1320 int neigh_connected_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1322 struct net_device
*dev
= neigh
->dev
;
1327 __skb_pull(skb
, skb_network_offset(skb
));
1328 seq
= read_seqbegin(&neigh
->ha_lock
);
1329 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1330 neigh
->ha
, NULL
, skb
->len
);
1331 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1334 err
= dev_queue_xmit(skb
);
1341 EXPORT_SYMBOL(neigh_connected_output
);
1343 int neigh_direct_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1345 return dev_queue_xmit(skb
);
1347 EXPORT_SYMBOL(neigh_direct_output
);
1349 static void neigh_proxy_process(unsigned long arg
)
1351 struct neigh_table
*tbl
= (struct neigh_table
*)arg
;
1352 long sched_next
= 0;
1353 unsigned long now
= jiffies
;
1354 struct sk_buff
*skb
, *n
;
1356 spin_lock(&tbl
->proxy_queue
.lock
);
1358 skb_queue_walk_safe(&tbl
->proxy_queue
, skb
, n
) {
1359 long tdif
= NEIGH_CB(skb
)->sched_next
- now
;
1362 struct net_device
*dev
= skb
->dev
;
1364 __skb_unlink(skb
, &tbl
->proxy_queue
);
1365 if (tbl
->proxy_redo
&& netif_running(dev
)) {
1367 tbl
->proxy_redo(skb
);
1374 } else if (!sched_next
|| tdif
< sched_next
)
1377 del_timer(&tbl
->proxy_timer
);
1379 mod_timer(&tbl
->proxy_timer
, jiffies
+ sched_next
);
1380 spin_unlock(&tbl
->proxy_queue
.lock
);
1383 void pneigh_enqueue(struct neigh_table
*tbl
, struct neigh_parms
*p
,
1384 struct sk_buff
*skb
)
1386 unsigned long now
= jiffies
;
1388 unsigned long sched_next
= now
+ (prandom_u32() %
1389 NEIGH_VAR(p
, PROXY_DELAY
));
1391 if (tbl
->proxy_queue
.qlen
> NEIGH_VAR(p
, PROXY_QLEN
)) {
1396 NEIGH_CB(skb
)->sched_next
= sched_next
;
1397 NEIGH_CB(skb
)->flags
|= LOCALLY_ENQUEUED
;
1399 spin_lock(&tbl
->proxy_queue
.lock
);
1400 if (del_timer(&tbl
->proxy_timer
)) {
1401 if (time_before(tbl
->proxy_timer
.expires
, sched_next
))
1402 sched_next
= tbl
->proxy_timer
.expires
;
1406 __skb_queue_tail(&tbl
->proxy_queue
, skb
);
1407 mod_timer(&tbl
->proxy_timer
, sched_next
);
1408 spin_unlock(&tbl
->proxy_queue
.lock
);
1410 EXPORT_SYMBOL(pneigh_enqueue
);
1412 static inline struct neigh_parms
*lookup_neigh_parms(struct neigh_table
*tbl
,
1413 struct net
*net
, int ifindex
)
1415 struct neigh_parms
*p
;
1417 list_for_each_entry(p
, &tbl
->parms_list
, list
) {
1418 if ((p
->dev
&& p
->dev
->ifindex
== ifindex
&& net_eq(neigh_parms_net(p
), net
)) ||
1419 (!p
->dev
&& !ifindex
&& net_eq(net
, &init_net
)))
1426 struct neigh_parms
*neigh_parms_alloc(struct net_device
*dev
,
1427 struct neigh_table
*tbl
)
1429 struct neigh_parms
*p
;
1430 struct net
*net
= dev_net(dev
);
1431 const struct net_device_ops
*ops
= dev
->netdev_ops
;
1433 p
= kmemdup(&tbl
->parms
, sizeof(*p
), GFP_KERNEL
);
1436 atomic_set(&p
->refcnt
, 1);
1438 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
1441 write_pnet(&p
->net
, hold_net(net
));
1442 p
->sysctl_table
= NULL
;
1444 if (ops
->ndo_neigh_setup
&& ops
->ndo_neigh_setup(dev
, p
)) {
1451 write_lock_bh(&tbl
->lock
);
1452 list_add(&p
->list
, &tbl
->parms
.list
);
1453 write_unlock_bh(&tbl
->lock
);
1455 neigh_parms_data_state_cleanall(p
);
1459 EXPORT_SYMBOL(neigh_parms_alloc
);
1461 static void neigh_rcu_free_parms(struct rcu_head
*head
)
1463 struct neigh_parms
*parms
=
1464 container_of(head
, struct neigh_parms
, rcu_head
);
1466 neigh_parms_put(parms
);
1469 void neigh_parms_release(struct neigh_table
*tbl
, struct neigh_parms
*parms
)
1471 if (!parms
|| parms
== &tbl
->parms
)
1473 write_lock_bh(&tbl
->lock
);
1474 list_del(&parms
->list
);
1476 write_unlock_bh(&tbl
->lock
);
1478 dev_put(parms
->dev
);
1479 call_rcu(&parms
->rcu_head
, neigh_rcu_free_parms
);
1481 EXPORT_SYMBOL(neigh_parms_release
);
1483 static void neigh_parms_destroy(struct neigh_parms
*parms
)
1485 release_net(neigh_parms_net(parms
));
1489 static struct lock_class_key neigh_table_proxy_queue_class
;
1491 static struct neigh_table
*neigh_tables
[NEIGH_NR_TABLES
] __read_mostly
;
1493 void neigh_table_init(int index
, struct neigh_table
*tbl
)
1495 unsigned long now
= jiffies
;
1496 unsigned long phsize
;
1498 INIT_LIST_HEAD(&tbl
->parms_list
);
1499 list_add(&tbl
->parms
.list
, &tbl
->parms_list
);
1500 write_pnet(&tbl
->parms
.net
, &init_net
);
1501 atomic_set(&tbl
->parms
.refcnt
, 1);
1502 tbl
->parms
.reachable_time
=
1503 neigh_rand_reach_time(NEIGH_VAR(&tbl
->parms
, BASE_REACHABLE_TIME
));
1505 tbl
->stats
= alloc_percpu(struct neigh_statistics
);
1507 panic("cannot create neighbour cache statistics");
1509 #ifdef CONFIG_PROC_FS
1510 if (!proc_create_data(tbl
->id
, 0, init_net
.proc_net_stat
,
1511 &neigh_stat_seq_fops
, tbl
))
1512 panic("cannot create neighbour proc dir entry");
1515 RCU_INIT_POINTER(tbl
->nht
, neigh_hash_alloc(3));
1517 phsize
= (PNEIGH_HASHMASK
+ 1) * sizeof(struct pneigh_entry
*);
1518 tbl
->phash_buckets
= kzalloc(phsize
, GFP_KERNEL
);
1520 if (!tbl
->nht
|| !tbl
->phash_buckets
)
1521 panic("cannot allocate neighbour cache hashes");
1523 if (!tbl
->entry_size
)
1524 tbl
->entry_size
= ALIGN(offsetof(struct neighbour
, primary_key
) +
1525 tbl
->key_len
, NEIGH_PRIV_ALIGN
);
1527 WARN_ON(tbl
->entry_size
% NEIGH_PRIV_ALIGN
);
1529 rwlock_init(&tbl
->lock
);
1530 INIT_DEFERRABLE_WORK(&tbl
->gc_work
, neigh_periodic_work
);
1531 queue_delayed_work(system_power_efficient_wq
, &tbl
->gc_work
,
1532 tbl
->parms
.reachable_time
);
1533 setup_timer(&tbl
->proxy_timer
, neigh_proxy_process
, (unsigned long)tbl
);
1534 skb_queue_head_init_class(&tbl
->proxy_queue
,
1535 &neigh_table_proxy_queue_class
);
1537 tbl
->last_flush
= now
;
1538 tbl
->last_rand
= now
+ tbl
->parms
.reachable_time
* 20;
1540 neigh_tables
[index
] = tbl
;
1542 EXPORT_SYMBOL(neigh_table_init
);
1544 int neigh_table_clear(int index
, struct neigh_table
*tbl
)
1546 neigh_tables
[index
] = NULL
;
1547 /* It is not clean... Fix it to unload IPv6 module safely */
1548 cancel_delayed_work_sync(&tbl
->gc_work
);
1549 del_timer_sync(&tbl
->proxy_timer
);
1550 pneigh_queue_purge(&tbl
->proxy_queue
);
1551 neigh_ifdown(tbl
, NULL
);
1552 if (atomic_read(&tbl
->entries
))
1553 pr_crit("neighbour leakage\n");
1555 call_rcu(&rcu_dereference_protected(tbl
->nht
, 1)->rcu
,
1556 neigh_hash_free_rcu
);
1559 kfree(tbl
->phash_buckets
);
1560 tbl
->phash_buckets
= NULL
;
1562 remove_proc_entry(tbl
->id
, init_net
.proc_net_stat
);
1564 free_percpu(tbl
->stats
);
1569 EXPORT_SYMBOL(neigh_table_clear
);
1571 static struct neigh_table
*neigh_find_table(int family
)
1573 struct neigh_table
*tbl
= NULL
;
1577 tbl
= neigh_tables
[NEIGH_ARP_TABLE
];
1580 tbl
= neigh_tables
[NEIGH_ND_TABLE
];
1583 tbl
= neigh_tables
[NEIGH_DN_TABLE
];
1590 static int neigh_delete(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1592 struct net
*net
= sock_net(skb
->sk
);
1594 struct nlattr
*dst_attr
;
1595 struct neigh_table
*tbl
;
1596 struct neighbour
*neigh
;
1597 struct net_device
*dev
= NULL
;
1601 if (nlmsg_len(nlh
) < sizeof(*ndm
))
1604 dst_attr
= nlmsg_find_attr(nlh
, sizeof(*ndm
), NDA_DST
);
1605 if (dst_attr
== NULL
)
1608 ndm
= nlmsg_data(nlh
);
1609 if (ndm
->ndm_ifindex
) {
1610 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1617 tbl
= neigh_find_table(ndm
->ndm_family
);
1619 return -EAFNOSUPPORT
;
1621 if (nla_len(dst_attr
) < tbl
->key_len
)
1624 if (ndm
->ndm_flags
& NTF_PROXY
) {
1625 err
= pneigh_delete(tbl
, net
, nla_data(dst_attr
), dev
);
1632 neigh
= neigh_lookup(tbl
, nla_data(dst_attr
), dev
);
1633 if (neigh
== NULL
) {
1638 err
= neigh_update(neigh
, NULL
, NUD_FAILED
,
1639 NEIGH_UPDATE_F_OVERRIDE
|
1640 NEIGH_UPDATE_F_ADMIN
);
1641 neigh_release(neigh
);
1647 static int neigh_add(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1649 int flags
= NEIGH_UPDATE_F_ADMIN
| NEIGH_UPDATE_F_OVERRIDE
;
1650 struct net
*net
= sock_net(skb
->sk
);
1652 struct nlattr
*tb
[NDA_MAX
+1];
1653 struct neigh_table
*tbl
;
1654 struct net_device
*dev
= NULL
;
1655 struct neighbour
*neigh
;
1660 err
= nlmsg_parse(nlh
, sizeof(*ndm
), tb
, NDA_MAX
, NULL
);
1665 if (tb
[NDA_DST
] == NULL
)
1668 ndm
= nlmsg_data(nlh
);
1669 if (ndm
->ndm_ifindex
) {
1670 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1676 if (tb
[NDA_LLADDR
] && nla_len(tb
[NDA_LLADDR
]) < dev
->addr_len
)
1680 tbl
= neigh_find_table(ndm
->ndm_family
);
1682 return -EAFNOSUPPORT
;
1684 if (nla_len(tb
[NDA_DST
]) < tbl
->key_len
)
1686 dst
= nla_data(tb
[NDA_DST
]);
1687 lladdr
= tb
[NDA_LLADDR
] ? nla_data(tb
[NDA_LLADDR
]) : NULL
;
1689 if (ndm
->ndm_flags
& NTF_PROXY
) {
1690 struct pneigh_entry
*pn
;
1693 pn
= pneigh_lookup(tbl
, net
, dst
, dev
, 1);
1695 pn
->flags
= ndm
->ndm_flags
;
1704 neigh
= neigh_lookup(tbl
, dst
, dev
);
1705 if (neigh
== NULL
) {
1706 if (!(nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
1711 neigh
= __neigh_lookup_errno(tbl
, dst
, dev
);
1712 if (IS_ERR(neigh
)) {
1713 err
= PTR_ERR(neigh
);
1717 if (nlh
->nlmsg_flags
& NLM_F_EXCL
) {
1719 neigh_release(neigh
);
1723 if (!(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
1724 flags
&= ~NEIGH_UPDATE_F_OVERRIDE
;
1727 if (ndm
->ndm_flags
& NTF_USE
) {
1728 neigh_event_send(neigh
, NULL
);
1731 err
= neigh_update(neigh
, lladdr
, ndm
->ndm_state
, flags
);
1732 neigh_release(neigh
);
1738 static int neightbl_fill_parms(struct sk_buff
*skb
, struct neigh_parms
*parms
)
1740 struct nlattr
*nest
;
1742 nest
= nla_nest_start(skb
, NDTA_PARMS
);
1747 nla_put_u32(skb
, NDTPA_IFINDEX
, parms
->dev
->ifindex
)) ||
1748 nla_put_u32(skb
, NDTPA_REFCNT
, atomic_read(&parms
->refcnt
)) ||
1749 nla_put_u32(skb
, NDTPA_QUEUE_LENBYTES
,
1750 NEIGH_VAR(parms
, QUEUE_LEN_BYTES
)) ||
1751 /* approximative value for deprecated QUEUE_LEN (in packets) */
1752 nla_put_u32(skb
, NDTPA_QUEUE_LEN
,
1753 NEIGH_VAR(parms
, QUEUE_LEN_BYTES
) / SKB_TRUESIZE(ETH_FRAME_LEN
)) ||
1754 nla_put_u32(skb
, NDTPA_PROXY_QLEN
, NEIGH_VAR(parms
, PROXY_QLEN
)) ||
1755 nla_put_u32(skb
, NDTPA_APP_PROBES
, NEIGH_VAR(parms
, APP_PROBES
)) ||
1756 nla_put_u32(skb
, NDTPA_UCAST_PROBES
,
1757 NEIGH_VAR(parms
, UCAST_PROBES
)) ||
1758 nla_put_u32(skb
, NDTPA_MCAST_PROBES
,
1759 NEIGH_VAR(parms
, MCAST_PROBES
)) ||
1760 nla_put_msecs(skb
, NDTPA_REACHABLE_TIME
, parms
->reachable_time
) ||
1761 nla_put_msecs(skb
, NDTPA_BASE_REACHABLE_TIME
,
1762 NEIGH_VAR(parms
, BASE_REACHABLE_TIME
)) ||
1763 nla_put_msecs(skb
, NDTPA_GC_STALETIME
,
1764 NEIGH_VAR(parms
, GC_STALETIME
)) ||
1765 nla_put_msecs(skb
, NDTPA_DELAY_PROBE_TIME
,
1766 NEIGH_VAR(parms
, DELAY_PROBE_TIME
)) ||
1767 nla_put_msecs(skb
, NDTPA_RETRANS_TIME
,
1768 NEIGH_VAR(parms
, RETRANS_TIME
)) ||
1769 nla_put_msecs(skb
, NDTPA_ANYCAST_DELAY
,
1770 NEIGH_VAR(parms
, ANYCAST_DELAY
)) ||
1771 nla_put_msecs(skb
, NDTPA_PROXY_DELAY
,
1772 NEIGH_VAR(parms
, PROXY_DELAY
)) ||
1773 nla_put_msecs(skb
, NDTPA_LOCKTIME
,
1774 NEIGH_VAR(parms
, LOCKTIME
)))
1775 goto nla_put_failure
;
1776 return nla_nest_end(skb
, nest
);
1779 nla_nest_cancel(skb
, nest
);
1783 static int neightbl_fill_info(struct sk_buff
*skb
, struct neigh_table
*tbl
,
1784 u32 pid
, u32 seq
, int type
, int flags
)
1786 struct nlmsghdr
*nlh
;
1787 struct ndtmsg
*ndtmsg
;
1789 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1793 ndtmsg
= nlmsg_data(nlh
);
1795 read_lock_bh(&tbl
->lock
);
1796 ndtmsg
->ndtm_family
= tbl
->family
;
1797 ndtmsg
->ndtm_pad1
= 0;
1798 ndtmsg
->ndtm_pad2
= 0;
1800 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) ||
1801 nla_put_msecs(skb
, NDTA_GC_INTERVAL
, tbl
->gc_interval
) ||
1802 nla_put_u32(skb
, NDTA_THRESH1
, tbl
->gc_thresh1
) ||
1803 nla_put_u32(skb
, NDTA_THRESH2
, tbl
->gc_thresh2
) ||
1804 nla_put_u32(skb
, NDTA_THRESH3
, tbl
->gc_thresh3
))
1805 goto nla_put_failure
;
1807 unsigned long now
= jiffies
;
1808 unsigned int flush_delta
= now
- tbl
->last_flush
;
1809 unsigned int rand_delta
= now
- tbl
->last_rand
;
1810 struct neigh_hash_table
*nht
;
1811 struct ndt_config ndc
= {
1812 .ndtc_key_len
= tbl
->key_len
,
1813 .ndtc_entry_size
= tbl
->entry_size
,
1814 .ndtc_entries
= atomic_read(&tbl
->entries
),
1815 .ndtc_last_flush
= jiffies_to_msecs(flush_delta
),
1816 .ndtc_last_rand
= jiffies_to_msecs(rand_delta
),
1817 .ndtc_proxy_qlen
= tbl
->proxy_queue
.qlen
,
1821 nht
= rcu_dereference_bh(tbl
->nht
);
1822 ndc
.ndtc_hash_rnd
= nht
->hash_rnd
[0];
1823 ndc
.ndtc_hash_mask
= ((1 << nht
->hash_shift
) - 1);
1824 rcu_read_unlock_bh();
1826 if (nla_put(skb
, NDTA_CONFIG
, sizeof(ndc
), &ndc
))
1827 goto nla_put_failure
;
1832 struct ndt_stats ndst
;
1834 memset(&ndst
, 0, sizeof(ndst
));
1836 for_each_possible_cpu(cpu
) {
1837 struct neigh_statistics
*st
;
1839 st
= per_cpu_ptr(tbl
->stats
, cpu
);
1840 ndst
.ndts_allocs
+= st
->allocs
;
1841 ndst
.ndts_destroys
+= st
->destroys
;
1842 ndst
.ndts_hash_grows
+= st
->hash_grows
;
1843 ndst
.ndts_res_failed
+= st
->res_failed
;
1844 ndst
.ndts_lookups
+= st
->lookups
;
1845 ndst
.ndts_hits
+= st
->hits
;
1846 ndst
.ndts_rcv_probes_mcast
+= st
->rcv_probes_mcast
;
1847 ndst
.ndts_rcv_probes_ucast
+= st
->rcv_probes_ucast
;
1848 ndst
.ndts_periodic_gc_runs
+= st
->periodic_gc_runs
;
1849 ndst
.ndts_forced_gc_runs
+= st
->forced_gc_runs
;
1852 if (nla_put(skb
, NDTA_STATS
, sizeof(ndst
), &ndst
))
1853 goto nla_put_failure
;
1856 BUG_ON(tbl
->parms
.dev
);
1857 if (neightbl_fill_parms(skb
, &tbl
->parms
) < 0)
1858 goto nla_put_failure
;
1860 read_unlock_bh(&tbl
->lock
);
1861 nlmsg_end(skb
, nlh
);
1865 read_unlock_bh(&tbl
->lock
);
1866 nlmsg_cancel(skb
, nlh
);
1870 static int neightbl_fill_param_info(struct sk_buff
*skb
,
1871 struct neigh_table
*tbl
,
1872 struct neigh_parms
*parms
,
1873 u32 pid
, u32 seq
, int type
,
1876 struct ndtmsg
*ndtmsg
;
1877 struct nlmsghdr
*nlh
;
1879 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1883 ndtmsg
= nlmsg_data(nlh
);
1885 read_lock_bh(&tbl
->lock
);
1886 ndtmsg
->ndtm_family
= tbl
->family
;
1887 ndtmsg
->ndtm_pad1
= 0;
1888 ndtmsg
->ndtm_pad2
= 0;
1890 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) < 0 ||
1891 neightbl_fill_parms(skb
, parms
) < 0)
1894 read_unlock_bh(&tbl
->lock
);
1895 nlmsg_end(skb
, nlh
);
1898 read_unlock_bh(&tbl
->lock
);
1899 nlmsg_cancel(skb
, nlh
);
1903 static const struct nla_policy nl_neightbl_policy
[NDTA_MAX
+1] = {
1904 [NDTA_NAME
] = { .type
= NLA_STRING
},
1905 [NDTA_THRESH1
] = { .type
= NLA_U32
},
1906 [NDTA_THRESH2
] = { .type
= NLA_U32
},
1907 [NDTA_THRESH3
] = { .type
= NLA_U32
},
1908 [NDTA_GC_INTERVAL
] = { .type
= NLA_U64
},
1909 [NDTA_PARMS
] = { .type
= NLA_NESTED
},
1912 static const struct nla_policy nl_ntbl_parm_policy
[NDTPA_MAX
+1] = {
1913 [NDTPA_IFINDEX
] = { .type
= NLA_U32
},
1914 [NDTPA_QUEUE_LEN
] = { .type
= NLA_U32
},
1915 [NDTPA_PROXY_QLEN
] = { .type
= NLA_U32
},
1916 [NDTPA_APP_PROBES
] = { .type
= NLA_U32
},
1917 [NDTPA_UCAST_PROBES
] = { .type
= NLA_U32
},
1918 [NDTPA_MCAST_PROBES
] = { .type
= NLA_U32
},
1919 [NDTPA_BASE_REACHABLE_TIME
] = { .type
= NLA_U64
},
1920 [NDTPA_GC_STALETIME
] = { .type
= NLA_U64
},
1921 [NDTPA_DELAY_PROBE_TIME
] = { .type
= NLA_U64
},
1922 [NDTPA_RETRANS_TIME
] = { .type
= NLA_U64
},
1923 [NDTPA_ANYCAST_DELAY
] = { .type
= NLA_U64
},
1924 [NDTPA_PROXY_DELAY
] = { .type
= NLA_U64
},
1925 [NDTPA_LOCKTIME
] = { .type
= NLA_U64
},
1928 static int neightbl_set(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1930 struct net
*net
= sock_net(skb
->sk
);
1931 struct neigh_table
*tbl
;
1932 struct ndtmsg
*ndtmsg
;
1933 struct nlattr
*tb
[NDTA_MAX
+1];
1937 err
= nlmsg_parse(nlh
, sizeof(*ndtmsg
), tb
, NDTA_MAX
,
1938 nl_neightbl_policy
);
1942 if (tb
[NDTA_NAME
] == NULL
) {
1947 ndtmsg
= nlmsg_data(nlh
);
1949 for (tidx
= 0; tidx
< NEIGH_NR_TABLES
; tidx
++) {
1950 tbl
= neigh_tables
[tidx
];
1953 if (ndtmsg
->ndtm_family
&& tbl
->family
!= ndtmsg
->ndtm_family
)
1955 if (nla_strcmp(tb
[NDTA_NAME
], tbl
->id
) == 0) {
1965 * We acquire tbl->lock to be nice to the periodic timers and
1966 * make sure they always see a consistent set of values.
1968 write_lock_bh(&tbl
->lock
);
1970 if (tb
[NDTA_PARMS
]) {
1971 struct nlattr
*tbp
[NDTPA_MAX
+1];
1972 struct neigh_parms
*p
;
1975 err
= nla_parse_nested(tbp
, NDTPA_MAX
, tb
[NDTA_PARMS
],
1976 nl_ntbl_parm_policy
);
1978 goto errout_tbl_lock
;
1980 if (tbp
[NDTPA_IFINDEX
])
1981 ifindex
= nla_get_u32(tbp
[NDTPA_IFINDEX
]);
1983 p
= lookup_neigh_parms(tbl
, net
, ifindex
);
1986 goto errout_tbl_lock
;
1989 for (i
= 1; i
<= NDTPA_MAX
; i
++) {
1994 case NDTPA_QUEUE_LEN
:
1995 NEIGH_VAR_SET(p
, QUEUE_LEN_BYTES
,
1996 nla_get_u32(tbp
[i
]) *
1997 SKB_TRUESIZE(ETH_FRAME_LEN
));
1999 case NDTPA_QUEUE_LENBYTES
:
2000 NEIGH_VAR_SET(p
, QUEUE_LEN_BYTES
,
2001 nla_get_u32(tbp
[i
]));
2003 case NDTPA_PROXY_QLEN
:
2004 NEIGH_VAR_SET(p
, PROXY_QLEN
,
2005 nla_get_u32(tbp
[i
]));
2007 case NDTPA_APP_PROBES
:
2008 NEIGH_VAR_SET(p
, APP_PROBES
,
2009 nla_get_u32(tbp
[i
]));
2011 case NDTPA_UCAST_PROBES
:
2012 NEIGH_VAR_SET(p
, UCAST_PROBES
,
2013 nla_get_u32(tbp
[i
]));
2015 case NDTPA_MCAST_PROBES
:
2016 NEIGH_VAR_SET(p
, MCAST_PROBES
,
2017 nla_get_u32(tbp
[i
]));
2019 case NDTPA_BASE_REACHABLE_TIME
:
2020 NEIGH_VAR_SET(p
, BASE_REACHABLE_TIME
,
2021 nla_get_msecs(tbp
[i
]));
2022 /* update reachable_time as well, otherwise, the change will
2023 * only be effective after the next time neigh_periodic_work
2024 * decides to recompute it (can be multiple minutes)
2027 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
2029 case NDTPA_GC_STALETIME
:
2030 NEIGH_VAR_SET(p
, GC_STALETIME
,
2031 nla_get_msecs(tbp
[i
]));
2033 case NDTPA_DELAY_PROBE_TIME
:
2034 NEIGH_VAR_SET(p
, DELAY_PROBE_TIME
,
2035 nla_get_msecs(tbp
[i
]));
2037 case NDTPA_RETRANS_TIME
:
2038 NEIGH_VAR_SET(p
, RETRANS_TIME
,
2039 nla_get_msecs(tbp
[i
]));
2041 case NDTPA_ANYCAST_DELAY
:
2042 NEIGH_VAR_SET(p
, ANYCAST_DELAY
,
2043 nla_get_msecs(tbp
[i
]));
2045 case NDTPA_PROXY_DELAY
:
2046 NEIGH_VAR_SET(p
, PROXY_DELAY
,
2047 nla_get_msecs(tbp
[i
]));
2049 case NDTPA_LOCKTIME
:
2050 NEIGH_VAR_SET(p
, LOCKTIME
,
2051 nla_get_msecs(tbp
[i
]));
2058 if ((tb
[NDTA_THRESH1
] || tb
[NDTA_THRESH2
] ||
2059 tb
[NDTA_THRESH3
] || tb
[NDTA_GC_INTERVAL
]) &&
2060 !net_eq(net
, &init_net
))
2061 goto errout_tbl_lock
;
2063 if (tb
[NDTA_THRESH1
])
2064 tbl
->gc_thresh1
= nla_get_u32(tb
[NDTA_THRESH1
]);
2066 if (tb
[NDTA_THRESH2
])
2067 tbl
->gc_thresh2
= nla_get_u32(tb
[NDTA_THRESH2
]);
2069 if (tb
[NDTA_THRESH3
])
2070 tbl
->gc_thresh3
= nla_get_u32(tb
[NDTA_THRESH3
]);
2072 if (tb
[NDTA_GC_INTERVAL
])
2073 tbl
->gc_interval
= nla_get_msecs(tb
[NDTA_GC_INTERVAL
]);
2078 write_unlock_bh(&tbl
->lock
);
2083 static int neightbl_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2085 struct net
*net
= sock_net(skb
->sk
);
2086 int family
, tidx
, nidx
= 0;
2087 int tbl_skip
= cb
->args
[0];
2088 int neigh_skip
= cb
->args
[1];
2089 struct neigh_table
*tbl
;
2091 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2093 for (tidx
= 0; tidx
< NEIGH_NR_TABLES
; tidx
++) {
2094 struct neigh_parms
*p
;
2096 tbl
= neigh_tables
[tidx
];
2100 if (tidx
< tbl_skip
|| (family
&& tbl
->family
!= family
))
2103 if (neightbl_fill_info(skb
, tbl
, NETLINK_CB(cb
->skb
).portid
,
2104 cb
->nlh
->nlmsg_seq
, RTM_NEWNEIGHTBL
,
2109 p
= list_next_entry(&tbl
->parms
, list
);
2110 list_for_each_entry_from(p
, &tbl
->parms_list
, list
) {
2111 if (!net_eq(neigh_parms_net(p
), net
))
2114 if (nidx
< neigh_skip
)
2117 if (neightbl_fill_param_info(skb
, tbl
, p
,
2118 NETLINK_CB(cb
->skb
).portid
,
2136 static int neigh_fill_info(struct sk_buff
*skb
, struct neighbour
*neigh
,
2137 u32 pid
, u32 seq
, int type
, unsigned int flags
)
2139 unsigned long now
= jiffies
;
2140 struct nda_cacheinfo ci
;
2141 struct nlmsghdr
*nlh
;
2144 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2148 ndm
= nlmsg_data(nlh
);
2149 ndm
->ndm_family
= neigh
->ops
->family
;
2152 ndm
->ndm_flags
= neigh
->flags
;
2153 ndm
->ndm_type
= neigh
->type
;
2154 ndm
->ndm_ifindex
= neigh
->dev
->ifindex
;
2156 if (nla_put(skb
, NDA_DST
, neigh
->tbl
->key_len
, neigh
->primary_key
))
2157 goto nla_put_failure
;
2159 read_lock_bh(&neigh
->lock
);
2160 ndm
->ndm_state
= neigh
->nud_state
;
2161 if (neigh
->nud_state
& NUD_VALID
) {
2162 char haddr
[MAX_ADDR_LEN
];
2164 neigh_ha_snapshot(haddr
, neigh
, neigh
->dev
);
2165 if (nla_put(skb
, NDA_LLADDR
, neigh
->dev
->addr_len
, haddr
) < 0) {
2166 read_unlock_bh(&neigh
->lock
);
2167 goto nla_put_failure
;
2171 ci
.ndm_used
= jiffies_to_clock_t(now
- neigh
->used
);
2172 ci
.ndm_confirmed
= jiffies_to_clock_t(now
- neigh
->confirmed
);
2173 ci
.ndm_updated
= jiffies_to_clock_t(now
- neigh
->updated
);
2174 ci
.ndm_refcnt
= atomic_read(&neigh
->refcnt
) - 1;
2175 read_unlock_bh(&neigh
->lock
);
2177 if (nla_put_u32(skb
, NDA_PROBES
, atomic_read(&neigh
->probes
)) ||
2178 nla_put(skb
, NDA_CACHEINFO
, sizeof(ci
), &ci
))
2179 goto nla_put_failure
;
2181 nlmsg_end(skb
, nlh
);
2185 nlmsg_cancel(skb
, nlh
);
2189 static int pneigh_fill_info(struct sk_buff
*skb
, struct pneigh_entry
*pn
,
2190 u32 pid
, u32 seq
, int type
, unsigned int flags
,
2191 struct neigh_table
*tbl
)
2193 struct nlmsghdr
*nlh
;
2196 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2200 ndm
= nlmsg_data(nlh
);
2201 ndm
->ndm_family
= tbl
->family
;
2204 ndm
->ndm_flags
= pn
->flags
| NTF_PROXY
;
2205 ndm
->ndm_type
= RTN_UNICAST
;
2206 ndm
->ndm_ifindex
= pn
->dev
->ifindex
;
2207 ndm
->ndm_state
= NUD_NONE
;
2209 if (nla_put(skb
, NDA_DST
, tbl
->key_len
, pn
->key
))
2210 goto nla_put_failure
;
2212 nlmsg_end(skb
, nlh
);
2216 nlmsg_cancel(skb
, nlh
);
2220 static void neigh_update_notify(struct neighbour
*neigh
)
2222 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
2223 __neigh_notify(neigh
, RTM_NEWNEIGH
, 0);
2226 static int neigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2227 struct netlink_callback
*cb
)
2229 struct net
*net
= sock_net(skb
->sk
);
2230 struct neighbour
*n
;
2231 int rc
, h
, s_h
= cb
->args
[1];
2232 int idx
, s_idx
= idx
= cb
->args
[2];
2233 struct neigh_hash_table
*nht
;
2236 nht
= rcu_dereference_bh(tbl
->nht
);
2238 for (h
= s_h
; h
< (1 << nht
->hash_shift
); h
++) {
2241 for (n
= rcu_dereference_bh(nht
->hash_buckets
[h
]), idx
= 0;
2243 n
= rcu_dereference_bh(n
->next
)) {
2244 if (!net_eq(dev_net(n
->dev
), net
))
2248 if (neigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).portid
,
2261 rcu_read_unlock_bh();
2267 static int pneigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2268 struct netlink_callback
*cb
)
2270 struct pneigh_entry
*n
;
2271 struct net
*net
= sock_net(skb
->sk
);
2272 int rc
, h
, s_h
= cb
->args
[3];
2273 int idx
, s_idx
= idx
= cb
->args
[4];
2275 read_lock_bh(&tbl
->lock
);
2277 for (h
= s_h
; h
<= PNEIGH_HASHMASK
; h
++) {
2280 for (n
= tbl
->phash_buckets
[h
], idx
= 0; n
; n
= n
->next
) {
2281 if (dev_net(n
->dev
) != net
)
2285 if (pneigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).portid
,
2288 NLM_F_MULTI
, tbl
) < 0) {
2289 read_unlock_bh(&tbl
->lock
);
2298 read_unlock_bh(&tbl
->lock
);
2307 static int neigh_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2309 struct neigh_table
*tbl
;
2314 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2316 /* check for full ndmsg structure presence, family member is
2317 * the same for both structures
2319 if (nlmsg_len(cb
->nlh
) >= sizeof(struct ndmsg
) &&
2320 ((struct ndmsg
*) nlmsg_data(cb
->nlh
))->ndm_flags
== NTF_PROXY
)
2325 for (t
= 0; t
< NEIGH_NR_TABLES
; t
++) {
2326 tbl
= neigh_tables
[t
];
2330 if (t
< s_t
|| (family
&& tbl
->family
!= family
))
2333 memset(&cb
->args
[1], 0, sizeof(cb
->args
) -
2334 sizeof(cb
->args
[0]));
2336 err
= pneigh_dump_table(tbl
, skb
, cb
);
2338 err
= neigh_dump_table(tbl
, skb
, cb
);
2347 void neigh_for_each(struct neigh_table
*tbl
, void (*cb
)(struct neighbour
*, void *), void *cookie
)
2350 struct neigh_hash_table
*nht
;
2353 nht
= rcu_dereference_bh(tbl
->nht
);
2355 read_lock(&tbl
->lock
); /* avoid resizes */
2356 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2357 struct neighbour
*n
;
2359 for (n
= rcu_dereference_bh(nht
->hash_buckets
[chain
]);
2361 n
= rcu_dereference_bh(n
->next
))
2364 read_unlock(&tbl
->lock
);
2365 rcu_read_unlock_bh();
2367 EXPORT_SYMBOL(neigh_for_each
);
2369 /* The tbl->lock must be held as a writer and BH disabled. */
2370 void __neigh_for_each_release(struct neigh_table
*tbl
,
2371 int (*cb
)(struct neighbour
*))
2374 struct neigh_hash_table
*nht
;
2376 nht
= rcu_dereference_protected(tbl
->nht
,
2377 lockdep_is_held(&tbl
->lock
));
2378 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2379 struct neighbour
*n
;
2380 struct neighbour __rcu
**np
;
2382 np
= &nht
->hash_buckets
[chain
];
2383 while ((n
= rcu_dereference_protected(*np
,
2384 lockdep_is_held(&tbl
->lock
))) != NULL
) {
2387 write_lock(&n
->lock
);
2390 rcu_assign_pointer(*np
,
2391 rcu_dereference_protected(n
->next
,
2392 lockdep_is_held(&tbl
->lock
)));
2396 write_unlock(&n
->lock
);
2398 neigh_cleanup_and_release(n
);
2402 EXPORT_SYMBOL(__neigh_for_each_release
);
2404 #ifdef CONFIG_PROC_FS
2406 static struct neighbour
*neigh_get_first(struct seq_file
*seq
)
2408 struct neigh_seq_state
*state
= seq
->private;
2409 struct net
*net
= seq_file_net(seq
);
2410 struct neigh_hash_table
*nht
= state
->nht
;
2411 struct neighbour
*n
= NULL
;
2412 int bucket
= state
->bucket
;
2414 state
->flags
&= ~NEIGH_SEQ_IS_PNEIGH
;
2415 for (bucket
= 0; bucket
< (1 << nht
->hash_shift
); bucket
++) {
2416 n
= rcu_dereference_bh(nht
->hash_buckets
[bucket
]);
2419 if (!net_eq(dev_net(n
->dev
), net
))
2421 if (state
->neigh_sub_iter
) {
2425 v
= state
->neigh_sub_iter(state
, n
, &fakep
);
2429 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2431 if (n
->nud_state
& ~NUD_NOARP
)
2434 n
= rcu_dereference_bh(n
->next
);
2440 state
->bucket
= bucket
;
2445 static struct neighbour
*neigh_get_next(struct seq_file
*seq
,
2446 struct neighbour
*n
,
2449 struct neigh_seq_state
*state
= seq
->private;
2450 struct net
*net
= seq_file_net(seq
);
2451 struct neigh_hash_table
*nht
= state
->nht
;
2453 if (state
->neigh_sub_iter
) {
2454 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2458 n
= rcu_dereference_bh(n
->next
);
2462 if (!net_eq(dev_net(n
->dev
), net
))
2464 if (state
->neigh_sub_iter
) {
2465 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2470 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2473 if (n
->nud_state
& ~NUD_NOARP
)
2476 n
= rcu_dereference_bh(n
->next
);
2482 if (++state
->bucket
>= (1 << nht
->hash_shift
))
2485 n
= rcu_dereference_bh(nht
->hash_buckets
[state
->bucket
]);
2493 static struct neighbour
*neigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2495 struct neighbour
*n
= neigh_get_first(seq
);
2500 n
= neigh_get_next(seq
, n
, pos
);
2505 return *pos
? NULL
: n
;
2508 static struct pneigh_entry
*pneigh_get_first(struct seq_file
*seq
)
2510 struct neigh_seq_state
*state
= seq
->private;
2511 struct net
*net
= seq_file_net(seq
);
2512 struct neigh_table
*tbl
= state
->tbl
;
2513 struct pneigh_entry
*pn
= NULL
;
2514 int bucket
= state
->bucket
;
2516 state
->flags
|= NEIGH_SEQ_IS_PNEIGH
;
2517 for (bucket
= 0; bucket
<= PNEIGH_HASHMASK
; bucket
++) {
2518 pn
= tbl
->phash_buckets
[bucket
];
2519 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2524 state
->bucket
= bucket
;
2529 static struct pneigh_entry
*pneigh_get_next(struct seq_file
*seq
,
2530 struct pneigh_entry
*pn
,
2533 struct neigh_seq_state
*state
= seq
->private;
2534 struct net
*net
= seq_file_net(seq
);
2535 struct neigh_table
*tbl
= state
->tbl
;
2539 } while (pn
&& !net_eq(pneigh_net(pn
), net
));
2542 if (++state
->bucket
> PNEIGH_HASHMASK
)
2544 pn
= tbl
->phash_buckets
[state
->bucket
];
2545 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2557 static struct pneigh_entry
*pneigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2559 struct pneigh_entry
*pn
= pneigh_get_first(seq
);
2564 pn
= pneigh_get_next(seq
, pn
, pos
);
2569 return *pos
? NULL
: pn
;
2572 static void *neigh_get_idx_any(struct seq_file
*seq
, loff_t
*pos
)
2574 struct neigh_seq_state
*state
= seq
->private;
2576 loff_t idxpos
= *pos
;
2578 rc
= neigh_get_idx(seq
, &idxpos
);
2579 if (!rc
&& !(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2580 rc
= pneigh_get_idx(seq
, &idxpos
);
2585 void *neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
, struct neigh_table
*tbl
, unsigned int neigh_seq_flags
)
2588 struct neigh_seq_state
*state
= seq
->private;
2592 state
->flags
= (neigh_seq_flags
& ~NEIGH_SEQ_IS_PNEIGH
);
2595 state
->nht
= rcu_dereference_bh(tbl
->nht
);
2597 return *pos
? neigh_get_idx_any(seq
, pos
) : SEQ_START_TOKEN
;
2599 EXPORT_SYMBOL(neigh_seq_start
);
2601 void *neigh_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2603 struct neigh_seq_state
*state
;
2606 if (v
== SEQ_START_TOKEN
) {
2607 rc
= neigh_get_first(seq
);
2611 state
= seq
->private;
2612 if (!(state
->flags
& NEIGH_SEQ_IS_PNEIGH
)) {
2613 rc
= neigh_get_next(seq
, v
, NULL
);
2616 if (!(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2617 rc
= pneigh_get_first(seq
);
2619 BUG_ON(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
);
2620 rc
= pneigh_get_next(seq
, v
, NULL
);
2626 EXPORT_SYMBOL(neigh_seq_next
);
2628 void neigh_seq_stop(struct seq_file
*seq
, void *v
)
2631 rcu_read_unlock_bh();
2633 EXPORT_SYMBOL(neigh_seq_stop
);
2635 /* statistics via seq_file */
2637 static void *neigh_stat_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2639 struct neigh_table
*tbl
= seq
->private;
2643 return SEQ_START_TOKEN
;
2645 for (cpu
= *pos
-1; cpu
< nr_cpu_ids
; ++cpu
) {
2646 if (!cpu_possible(cpu
))
2649 return per_cpu_ptr(tbl
->stats
, cpu
);
2654 static void *neigh_stat_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2656 struct neigh_table
*tbl
= seq
->private;
2659 for (cpu
= *pos
; cpu
< nr_cpu_ids
; ++cpu
) {
2660 if (!cpu_possible(cpu
))
2663 return per_cpu_ptr(tbl
->stats
, cpu
);
2668 static void neigh_stat_seq_stop(struct seq_file
*seq
, void *v
)
2673 static int neigh_stat_seq_show(struct seq_file
*seq
, void *v
)
2675 struct neigh_table
*tbl
= seq
->private;
2676 struct neigh_statistics
*st
= v
;
2678 if (v
== SEQ_START_TOKEN
) {
2679 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\n");
2683 seq_printf(seq
, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2684 "%08lx %08lx %08lx %08lx %08lx\n",
2685 atomic_read(&tbl
->entries
),
2696 st
->rcv_probes_mcast
,
2697 st
->rcv_probes_ucast
,
2699 st
->periodic_gc_runs
,
2707 static const struct seq_operations neigh_stat_seq_ops
= {
2708 .start
= neigh_stat_seq_start
,
2709 .next
= neigh_stat_seq_next
,
2710 .stop
= neigh_stat_seq_stop
,
2711 .show
= neigh_stat_seq_show
,
2714 static int neigh_stat_seq_open(struct inode
*inode
, struct file
*file
)
2716 int ret
= seq_open(file
, &neigh_stat_seq_ops
);
2719 struct seq_file
*sf
= file
->private_data
;
2720 sf
->private = PDE_DATA(inode
);
2725 static const struct file_operations neigh_stat_seq_fops
= {
2726 .owner
= THIS_MODULE
,
2727 .open
= neigh_stat_seq_open
,
2729 .llseek
= seq_lseek
,
2730 .release
= seq_release
,
2733 #endif /* CONFIG_PROC_FS */
2735 static inline size_t neigh_nlmsg_size(void)
2737 return NLMSG_ALIGN(sizeof(struct ndmsg
))
2738 + nla_total_size(MAX_ADDR_LEN
) /* NDA_DST */
2739 + nla_total_size(MAX_ADDR_LEN
) /* NDA_LLADDR */
2740 + nla_total_size(sizeof(struct nda_cacheinfo
))
2741 + nla_total_size(4); /* NDA_PROBES */
2744 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
)
2746 struct net
*net
= dev_net(n
->dev
);
2747 struct sk_buff
*skb
;
2750 skb
= nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC
);
2754 err
= neigh_fill_info(skb
, n
, 0, 0, type
, flags
);
2756 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2757 WARN_ON(err
== -EMSGSIZE
);
2761 rtnl_notify(skb
, net
, 0, RTNLGRP_NEIGH
, NULL
, GFP_ATOMIC
);
2765 rtnl_set_sk_err(net
, RTNLGRP_NEIGH
, err
);
2768 void neigh_app_ns(struct neighbour
*n
)
2770 __neigh_notify(n
, RTM_GETNEIGH
, NLM_F_REQUEST
);
2772 EXPORT_SYMBOL(neigh_app_ns
);
2774 #ifdef CONFIG_SYSCTL
2776 static int int_max
= INT_MAX
;
2777 static int unres_qlen_max
= INT_MAX
/ SKB_TRUESIZE(ETH_FRAME_LEN
);
2779 static int proc_unres_qlen(struct ctl_table
*ctl
, int write
,
2780 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2783 struct ctl_table tmp
= *ctl
;
2786 tmp
.extra2
= &unres_qlen_max
;
2789 size
= *(int *)ctl
->data
/ SKB_TRUESIZE(ETH_FRAME_LEN
);
2790 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
2793 *(int *)ctl
->data
= size
* SKB_TRUESIZE(ETH_FRAME_LEN
);
2797 static struct neigh_parms
*neigh_get_dev_parms_rcu(struct net_device
*dev
,
2802 return __in_dev_arp_parms_get_rcu(dev
);
2804 return __in6_dev_nd_parms_get_rcu(dev
);
2809 static void neigh_copy_dflt_parms(struct net
*net
, struct neigh_parms
*p
,
2812 struct net_device
*dev
;
2813 int family
= neigh_parms_family(p
);
2816 for_each_netdev_rcu(net
, dev
) {
2817 struct neigh_parms
*dst_p
=
2818 neigh_get_dev_parms_rcu(dev
, family
);
2820 if (dst_p
&& !test_bit(index
, dst_p
->data_state
))
2821 dst_p
->data
[index
] = p
->data
[index
];
2826 static void neigh_proc_update(struct ctl_table
*ctl
, int write
)
2828 struct net_device
*dev
= ctl
->extra1
;
2829 struct neigh_parms
*p
= ctl
->extra2
;
2830 struct net
*net
= neigh_parms_net(p
);
2831 int index
= (int *) ctl
->data
- p
->data
;
2836 set_bit(index
, p
->data_state
);
2837 if (!dev
) /* NULL dev means this is default value */
2838 neigh_copy_dflt_parms(net
, p
, index
);
2841 static int neigh_proc_dointvec_zero_intmax(struct ctl_table
*ctl
, int write
,
2842 void __user
*buffer
,
2843 size_t *lenp
, loff_t
*ppos
)
2845 struct ctl_table tmp
= *ctl
;
2849 tmp
.extra2
= &int_max
;
2851 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
2852 neigh_proc_update(ctl
, write
);
2856 int neigh_proc_dointvec(struct ctl_table
*ctl
, int write
,
2857 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2859 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2861 neigh_proc_update(ctl
, write
);
2864 EXPORT_SYMBOL(neigh_proc_dointvec
);
2866 int neigh_proc_dointvec_jiffies(struct ctl_table
*ctl
, int write
,
2867 void __user
*buffer
,
2868 size_t *lenp
, loff_t
*ppos
)
2870 int ret
= proc_dointvec_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2872 neigh_proc_update(ctl
, write
);
2875 EXPORT_SYMBOL(neigh_proc_dointvec_jiffies
);
2877 static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table
*ctl
, int write
,
2878 void __user
*buffer
,
2879 size_t *lenp
, loff_t
*ppos
)
2881 int ret
= proc_dointvec_userhz_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2883 neigh_proc_update(ctl
, write
);
2887 int neigh_proc_dointvec_ms_jiffies(struct ctl_table
*ctl
, int write
,
2888 void __user
*buffer
,
2889 size_t *lenp
, loff_t
*ppos
)
2891 int ret
= proc_dointvec_ms_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2893 neigh_proc_update(ctl
, write
);
2896 EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies
);
2898 static int neigh_proc_dointvec_unres_qlen(struct ctl_table
*ctl
, int write
,
2899 void __user
*buffer
,
2900 size_t *lenp
, loff_t
*ppos
)
2902 int ret
= proc_unres_qlen(ctl
, write
, buffer
, lenp
, ppos
);
2904 neigh_proc_update(ctl
, write
);
2908 static int neigh_proc_base_reachable_time(struct ctl_table
*ctl
, int write
,
2909 void __user
*buffer
,
2910 size_t *lenp
, loff_t
*ppos
)
2912 struct neigh_parms
*p
= ctl
->extra2
;
2915 if (strcmp(ctl
->procname
, "base_reachable_time") == 0)
2916 ret
= neigh_proc_dointvec_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2917 else if (strcmp(ctl
->procname
, "base_reachable_time_ms") == 0)
2918 ret
= neigh_proc_dointvec_ms_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2922 if (write
&& ret
== 0) {
2923 /* update reachable_time as well, otherwise, the change will
2924 * only be effective after the next time neigh_periodic_work
2925 * decides to recompute it
2928 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
2933 #define NEIGH_PARMS_DATA_OFFSET(index) \
2934 (&((struct neigh_parms *) 0)->data[index])
2936 #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \
2937 [NEIGH_VAR_ ## attr] = { \
2939 .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \
2940 .maxlen = sizeof(int), \
2942 .proc_handler = proc, \
2945 #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \
2946 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax)
2948 #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \
2949 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies)
2951 #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \
2952 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies)
2954 #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \
2955 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
2957 #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \
2958 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
2960 #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \
2961 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen)
2963 static struct neigh_sysctl_table
{
2964 struct ctl_table_header
*sysctl_header
;
2965 struct ctl_table neigh_vars
[NEIGH_VAR_MAX
+ 1];
2966 } neigh_sysctl_template __read_mostly
= {
2968 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES
, "mcast_solicit"),
2969 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES
, "ucast_solicit"),
2970 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES
, "app_solicit"),
2971 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME
, "retrans_time"),
2972 NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME
, "base_reachable_time"),
2973 NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME
, "delay_first_probe_time"),
2974 NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME
, "gc_stale_time"),
2975 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES
, "unres_qlen_bytes"),
2976 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN
, "proxy_qlen"),
2977 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY
, "anycast_delay"),
2978 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY
, "proxy_delay"),
2979 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME
, "locktime"),
2980 NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN
, QUEUE_LEN_BYTES
, "unres_qlen"),
2981 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS
, RETRANS_TIME
, "retrans_time_ms"),
2982 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS
, BASE_REACHABLE_TIME
, "base_reachable_time_ms"),
2983 [NEIGH_VAR_GC_INTERVAL
] = {
2984 .procname
= "gc_interval",
2985 .maxlen
= sizeof(int),
2987 .proc_handler
= proc_dointvec_jiffies
,
2989 [NEIGH_VAR_GC_THRESH1
] = {
2990 .procname
= "gc_thresh1",
2991 .maxlen
= sizeof(int),
2995 .proc_handler
= proc_dointvec_minmax
,
2997 [NEIGH_VAR_GC_THRESH2
] = {
2998 .procname
= "gc_thresh2",
2999 .maxlen
= sizeof(int),
3003 .proc_handler
= proc_dointvec_minmax
,
3005 [NEIGH_VAR_GC_THRESH3
] = {
3006 .procname
= "gc_thresh3",
3007 .maxlen
= sizeof(int),
3011 .proc_handler
= proc_dointvec_minmax
,
3017 int neigh_sysctl_register(struct net_device
*dev
, struct neigh_parms
*p
,
3018 proc_handler
*handler
)
3021 struct neigh_sysctl_table
*t
;
3022 const char *dev_name_source
;
3023 char neigh_path
[ sizeof("net//neigh/") + IFNAMSIZ
+ IFNAMSIZ
];
3026 t
= kmemdup(&neigh_sysctl_template
, sizeof(*t
), GFP_KERNEL
);
3030 for (i
= 0; i
< NEIGH_VAR_GC_INTERVAL
; i
++) {
3031 t
->neigh_vars
[i
].data
+= (long) p
;
3032 t
->neigh_vars
[i
].extra1
= dev
;
3033 t
->neigh_vars
[i
].extra2
= p
;
3037 dev_name_source
= dev
->name
;
3038 /* Terminate the table early */
3039 memset(&t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
], 0,
3040 sizeof(t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
]));
3042 struct neigh_table
*tbl
= p
->tbl
;
3043 dev_name_source
= "default";
3044 t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
].data
= &tbl
->gc_interval
;
3045 t
->neigh_vars
[NEIGH_VAR_GC_THRESH1
].data
= &tbl
->gc_thresh1
;
3046 t
->neigh_vars
[NEIGH_VAR_GC_THRESH2
].data
= &tbl
->gc_thresh2
;
3047 t
->neigh_vars
[NEIGH_VAR_GC_THRESH3
].data
= &tbl
->gc_thresh3
;
3052 t
->neigh_vars
[NEIGH_VAR_RETRANS_TIME
].proc_handler
= handler
;
3054 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME
].proc_handler
= handler
;
3055 /* RetransTime (in milliseconds)*/
3056 t
->neigh_vars
[NEIGH_VAR_RETRANS_TIME_MS
].proc_handler
= handler
;
3057 /* ReachableTime (in milliseconds) */
3058 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME_MS
].proc_handler
= handler
;
3060 /* Those handlers will update p->reachable_time after
3061 * base_reachable_time(_ms) is set to ensure the new timer starts being
3062 * applied after the next neighbour update instead of waiting for
3063 * neigh_periodic_work to update its value (can be multiple minutes)
3064 * So any handler that replaces them should do this as well
3067 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME
].proc_handler
=
3068 neigh_proc_base_reachable_time
;
3069 /* ReachableTime (in milliseconds) */
3070 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME_MS
].proc_handler
=
3071 neigh_proc_base_reachable_time
;
3074 /* Don't export sysctls to unprivileged users */
3075 if (neigh_parms_net(p
)->user_ns
!= &init_user_ns
)
3076 t
->neigh_vars
[0].procname
= NULL
;
3078 switch (neigh_parms_family(p
)) {
3089 snprintf(neigh_path
, sizeof(neigh_path
), "net/%s/neigh/%s",
3090 p_name
, dev_name_source
);
3092 register_net_sysctl(neigh_parms_net(p
), neigh_path
, t
->neigh_vars
);
3093 if (!t
->sysctl_header
)
3096 p
->sysctl_table
= t
;
3104 EXPORT_SYMBOL(neigh_sysctl_register
);
3106 void neigh_sysctl_unregister(struct neigh_parms
*p
)
3108 if (p
->sysctl_table
) {
3109 struct neigh_sysctl_table
*t
= p
->sysctl_table
;
3110 p
->sysctl_table
= NULL
;
3111 unregister_net_sysctl_table(t
->sysctl_header
);
3115 EXPORT_SYMBOL(neigh_sysctl_unregister
);
3117 #endif /* CONFIG_SYSCTL */
3119 static int __init
neigh_init(void)
3121 rtnl_register(PF_UNSPEC
, RTM_NEWNEIGH
, neigh_add
, NULL
, NULL
);
3122 rtnl_register(PF_UNSPEC
, RTM_DELNEIGH
, neigh_delete
, NULL
, NULL
);
3123 rtnl_register(PF_UNSPEC
, RTM_GETNEIGH
, NULL
, neigh_dump_info
, NULL
);
3125 rtnl_register(PF_UNSPEC
, RTM_GETNEIGHTBL
, NULL
, neightbl_dump_info
,
3127 rtnl_register(PF_UNSPEC
, RTM_SETNEIGHTBL
, neightbl_set
, NULL
, NULL
);
3132 subsys_initcall(neigh_init
);