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/kmemleak.h>
22 #include <linux/types.h>
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/socket.h>
26 #include <linux/netdevice.h>
27 #include <linux/proc_fs.h>
29 #include <linux/sysctl.h>
31 #include <linux/times.h>
32 #include <net/net_namespace.h>
33 #include <net/neighbour.h>
37 #include <net/netevent.h>
38 #include <net/netlink.h>
39 #include <linux/rtnetlink.h>
40 #include <linux/random.h>
41 #include <linux/string.h>
42 #include <linux/log2.h>
43 #include <linux/inetdevice.h>
44 #include <net/addrconf.h>
48 #define neigh_dbg(level, fmt, ...) \
50 if (level <= NEIGH_DEBUG) \
51 pr_debug(fmt, ##__VA_ARGS__); \
54 #define PNEIGH_HASHMASK 0xF
56 static void neigh_timer_handler(struct timer_list
*t
);
57 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
,
59 static void neigh_update_notify(struct neighbour
*neigh
, u32 nlmsg_pid
);
60 static int pneigh_ifdown_and_unlock(struct neigh_table
*tbl
,
61 struct net_device
*dev
);
64 static const struct file_operations neigh_stat_seq_fops
;
68 Neighbour hash table buckets are protected with rwlock tbl->lock.
70 - All the scans/updates to hash buckets MUST be made under this lock.
71 - NOTHING clever should be made under this lock: no callbacks
72 to protocol backends, no attempts to send something to network.
73 It will result in deadlocks, if backend/driver wants to use neighbour
75 - If the entry requires some non-trivial actions, increase
76 its reference count and release table lock.
78 Neighbour entries are protected:
79 - with reference count.
80 - with rwlock neigh->lock
82 Reference count prevents destruction.
84 neigh->lock mainly serializes ll address data and its validity state.
85 However, the same lock is used to protect another entry fields:
89 Again, nothing clever shall be made under neigh->lock,
90 the most complicated procedure, which we allow is dev->hard_header.
91 It is supposed, that dev->hard_header is simplistic and does
92 not make callbacks to neighbour tables.
95 static int neigh_blackhole(struct neighbour
*neigh
, struct sk_buff
*skb
)
101 static void neigh_cleanup_and_release(struct neighbour
*neigh
)
103 if (neigh
->parms
->neigh_cleanup
)
104 neigh
->parms
->neigh_cleanup(neigh
);
106 __neigh_notify(neigh
, RTM_DELNEIGH
, 0, 0);
107 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
108 neigh_release(neigh
);
112 * It is random distribution in the interval (1/2)*base...(3/2)*base.
113 * It corresponds to default IPv6 settings and is not overridable,
114 * because it is really reasonable choice.
117 unsigned long neigh_rand_reach_time(unsigned long base
)
119 return base
? (prandom_u32() % base
) + (base
>> 1) : 0;
121 EXPORT_SYMBOL(neigh_rand_reach_time
);
124 static bool neigh_del(struct neighbour
*n
, __u8 state
,
125 struct neighbour __rcu
**np
, struct neigh_table
*tbl
)
129 write_lock(&n
->lock
);
130 if (refcount_read(&n
->refcnt
) == 1 && !(n
->nud_state
& state
)) {
131 struct neighbour
*neigh
;
133 neigh
= rcu_dereference_protected(n
->next
,
134 lockdep_is_held(&tbl
->lock
));
135 rcu_assign_pointer(*np
, neigh
);
139 write_unlock(&n
->lock
);
141 neigh_cleanup_and_release(n
);
145 bool neigh_remove_one(struct neighbour
*ndel
, struct neigh_table
*tbl
)
147 struct neigh_hash_table
*nht
;
148 void *pkey
= ndel
->primary_key
;
151 struct neighbour __rcu
**np
;
153 nht
= rcu_dereference_protected(tbl
->nht
,
154 lockdep_is_held(&tbl
->lock
));
155 hash_val
= tbl
->hash(pkey
, ndel
->dev
, nht
->hash_rnd
);
156 hash_val
= hash_val
>> (32 - nht
->hash_shift
);
158 np
= &nht
->hash_buckets
[hash_val
];
159 while ((n
= rcu_dereference_protected(*np
,
160 lockdep_is_held(&tbl
->lock
)))) {
162 return neigh_del(n
, 0, np
, tbl
);
168 static int neigh_forced_gc(struct neigh_table
*tbl
)
172 struct neigh_hash_table
*nht
;
174 NEIGH_CACHE_STAT_INC(tbl
, forced_gc_runs
);
176 write_lock_bh(&tbl
->lock
);
177 nht
= rcu_dereference_protected(tbl
->nht
,
178 lockdep_is_held(&tbl
->lock
));
179 for (i
= 0; i
< (1 << nht
->hash_shift
); i
++) {
181 struct neighbour __rcu
**np
;
183 np
= &nht
->hash_buckets
[i
];
184 while ((n
= rcu_dereference_protected(*np
,
185 lockdep_is_held(&tbl
->lock
))) != NULL
) {
186 /* Neighbour record may be discarded if:
187 * - nobody refers to it.
188 * - it is not permanent
190 if (neigh_del(n
, NUD_PERMANENT
, np
, tbl
)) {
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
,
371 kmemleak_alloc(buckets
, size
, 1, GFP_ATOMIC
);
377 ret
->hash_buckets
= buckets
;
378 ret
->hash_shift
= shift
;
379 for (i
= 0; i
< NEIGH_NUM_HASH_RND
; i
++)
380 neigh_get_hash_rnd(&ret
->hash_rnd
[i
]);
384 static void neigh_hash_free_rcu(struct rcu_head
*head
)
386 struct neigh_hash_table
*nht
= container_of(head
,
387 struct neigh_hash_table
,
389 size_t size
= (1 << nht
->hash_shift
) * sizeof(struct neighbour
*);
390 struct neighbour __rcu
**buckets
= nht
->hash_buckets
;
392 if (size
<= PAGE_SIZE
) {
395 kmemleak_free(buckets
);
396 free_pages((unsigned long)buckets
, get_order(size
));
401 static struct neigh_hash_table
*neigh_hash_grow(struct neigh_table
*tbl
,
402 unsigned long new_shift
)
404 unsigned int i
, hash
;
405 struct neigh_hash_table
*new_nht
, *old_nht
;
407 NEIGH_CACHE_STAT_INC(tbl
, hash_grows
);
409 old_nht
= rcu_dereference_protected(tbl
->nht
,
410 lockdep_is_held(&tbl
->lock
));
411 new_nht
= neigh_hash_alloc(new_shift
);
415 for (i
= 0; i
< (1 << old_nht
->hash_shift
); i
++) {
416 struct neighbour
*n
, *next
;
418 for (n
= rcu_dereference_protected(old_nht
->hash_buckets
[i
],
419 lockdep_is_held(&tbl
->lock
));
422 hash
= tbl
->hash(n
->primary_key
, n
->dev
,
425 hash
>>= (32 - new_nht
->hash_shift
);
426 next
= rcu_dereference_protected(n
->next
,
427 lockdep_is_held(&tbl
->lock
));
429 rcu_assign_pointer(n
->next
,
430 rcu_dereference_protected(
431 new_nht
->hash_buckets
[hash
],
432 lockdep_is_held(&tbl
->lock
)));
433 rcu_assign_pointer(new_nht
->hash_buckets
[hash
], n
);
437 rcu_assign_pointer(tbl
->nht
, new_nht
);
438 call_rcu(&old_nht
->rcu
, neigh_hash_free_rcu
);
442 struct neighbour
*neigh_lookup(struct neigh_table
*tbl
, const void *pkey
,
443 struct net_device
*dev
)
447 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
450 n
= __neigh_lookup_noref(tbl
, pkey
, dev
);
452 if (!refcount_inc_not_zero(&n
->refcnt
))
454 NEIGH_CACHE_STAT_INC(tbl
, hits
);
457 rcu_read_unlock_bh();
460 EXPORT_SYMBOL(neigh_lookup
);
462 struct neighbour
*neigh_lookup_nodev(struct neigh_table
*tbl
, struct net
*net
,
466 unsigned int key_len
= tbl
->key_len
;
468 struct neigh_hash_table
*nht
;
470 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
473 nht
= rcu_dereference_bh(tbl
->nht
);
474 hash_val
= tbl
->hash(pkey
, NULL
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
476 for (n
= rcu_dereference_bh(nht
->hash_buckets
[hash_val
]);
478 n
= rcu_dereference_bh(n
->next
)) {
479 if (!memcmp(n
->primary_key
, pkey
, key_len
) &&
480 net_eq(dev_net(n
->dev
), net
)) {
481 if (!refcount_inc_not_zero(&n
->refcnt
))
483 NEIGH_CACHE_STAT_INC(tbl
, hits
);
488 rcu_read_unlock_bh();
491 EXPORT_SYMBOL(neigh_lookup_nodev
);
493 struct neighbour
*__neigh_create(struct neigh_table
*tbl
, const void *pkey
,
494 struct net_device
*dev
, bool want_ref
)
497 unsigned int key_len
= tbl
->key_len
;
499 struct neighbour
*n1
, *rc
, *n
= neigh_alloc(tbl
, dev
);
500 struct neigh_hash_table
*nht
;
503 rc
= ERR_PTR(-ENOBUFS
);
507 memcpy(n
->primary_key
, pkey
, key_len
);
511 /* Protocol specific setup. */
512 if (tbl
->constructor
&& (error
= tbl
->constructor(n
)) < 0) {
514 goto out_neigh_release
;
517 if (dev
->netdev_ops
->ndo_neigh_construct
) {
518 error
= dev
->netdev_ops
->ndo_neigh_construct(dev
, n
);
521 goto out_neigh_release
;
525 /* Device specific setup. */
526 if (n
->parms
->neigh_setup
&&
527 (error
= n
->parms
->neigh_setup(n
)) < 0) {
529 goto out_neigh_release
;
532 n
->confirmed
= jiffies
- (NEIGH_VAR(n
->parms
, BASE_REACHABLE_TIME
) << 1);
534 write_lock_bh(&tbl
->lock
);
535 nht
= rcu_dereference_protected(tbl
->nht
,
536 lockdep_is_held(&tbl
->lock
));
538 if (atomic_read(&tbl
->entries
) > (1 << nht
->hash_shift
))
539 nht
= neigh_hash_grow(tbl
, nht
->hash_shift
+ 1);
541 hash_val
= tbl
->hash(n
->primary_key
, dev
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
543 if (n
->parms
->dead
) {
544 rc
= ERR_PTR(-EINVAL
);
548 for (n1
= rcu_dereference_protected(nht
->hash_buckets
[hash_val
],
549 lockdep_is_held(&tbl
->lock
));
551 n1
= rcu_dereference_protected(n1
->next
,
552 lockdep_is_held(&tbl
->lock
))) {
553 if (dev
== n1
->dev
&& !memcmp(n1
->primary_key
, n
->primary_key
, key_len
)) {
564 rcu_assign_pointer(n
->next
,
565 rcu_dereference_protected(nht
->hash_buckets
[hash_val
],
566 lockdep_is_held(&tbl
->lock
)));
567 rcu_assign_pointer(nht
->hash_buckets
[hash_val
], n
);
568 write_unlock_bh(&tbl
->lock
);
569 neigh_dbg(2, "neigh %p is created\n", n
);
574 write_unlock_bh(&tbl
->lock
);
579 EXPORT_SYMBOL(__neigh_create
);
581 static u32
pneigh_hash(const void *pkey
, unsigned int key_len
)
583 u32 hash_val
= *(u32
*)(pkey
+ key_len
- 4);
584 hash_val
^= (hash_val
>> 16);
585 hash_val
^= hash_val
>> 8;
586 hash_val
^= hash_val
>> 4;
587 hash_val
&= PNEIGH_HASHMASK
;
591 static struct pneigh_entry
*__pneigh_lookup_1(struct pneigh_entry
*n
,
594 unsigned int key_len
,
595 struct net_device
*dev
)
598 if (!memcmp(n
->key
, pkey
, key_len
) &&
599 net_eq(pneigh_net(n
), net
) &&
600 (n
->dev
== dev
|| !n
->dev
))
607 struct pneigh_entry
*__pneigh_lookup(struct neigh_table
*tbl
,
608 struct net
*net
, const void *pkey
, struct net_device
*dev
)
610 unsigned int key_len
= tbl
->key_len
;
611 u32 hash_val
= pneigh_hash(pkey
, key_len
);
613 return __pneigh_lookup_1(tbl
->phash_buckets
[hash_val
],
614 net
, pkey
, key_len
, dev
);
616 EXPORT_SYMBOL_GPL(__pneigh_lookup
);
618 struct pneigh_entry
* pneigh_lookup(struct neigh_table
*tbl
,
619 struct net
*net
, const void *pkey
,
620 struct net_device
*dev
, int creat
)
622 struct pneigh_entry
*n
;
623 unsigned int key_len
= tbl
->key_len
;
624 u32 hash_val
= pneigh_hash(pkey
, key_len
);
626 read_lock_bh(&tbl
->lock
);
627 n
= __pneigh_lookup_1(tbl
->phash_buckets
[hash_val
],
628 net
, pkey
, key_len
, dev
);
629 read_unlock_bh(&tbl
->lock
);
636 n
= kmalloc(sizeof(*n
) + key_len
, GFP_KERNEL
);
640 write_pnet(&n
->net
, net
);
641 memcpy(n
->key
, pkey
, key_len
);
646 if (tbl
->pconstructor
&& tbl
->pconstructor(n
)) {
654 write_lock_bh(&tbl
->lock
);
655 n
->next
= tbl
->phash_buckets
[hash_val
];
656 tbl
->phash_buckets
[hash_val
] = n
;
657 write_unlock_bh(&tbl
->lock
);
661 EXPORT_SYMBOL(pneigh_lookup
);
664 int pneigh_delete(struct neigh_table
*tbl
, struct net
*net
, const void *pkey
,
665 struct net_device
*dev
)
667 struct pneigh_entry
*n
, **np
;
668 unsigned int key_len
= tbl
->key_len
;
669 u32 hash_val
= pneigh_hash(pkey
, key_len
);
671 write_lock_bh(&tbl
->lock
);
672 for (np
= &tbl
->phash_buckets
[hash_val
]; (n
= *np
) != NULL
;
674 if (!memcmp(n
->key
, pkey
, key_len
) && n
->dev
== dev
&&
675 net_eq(pneigh_net(n
), net
)) {
677 write_unlock_bh(&tbl
->lock
);
678 if (tbl
->pdestructor
)
686 write_unlock_bh(&tbl
->lock
);
690 static int pneigh_ifdown_and_unlock(struct neigh_table
*tbl
,
691 struct net_device
*dev
)
693 struct pneigh_entry
*n
, **np
, *freelist
= NULL
;
696 for (h
= 0; h
<= PNEIGH_HASHMASK
; h
++) {
697 np
= &tbl
->phash_buckets
[h
];
698 while ((n
= *np
) != NULL
) {
699 if (!dev
|| n
->dev
== dev
) {
708 write_unlock_bh(&tbl
->lock
);
709 while ((n
= freelist
)) {
712 if (tbl
->pdestructor
)
721 static void neigh_parms_destroy(struct neigh_parms
*parms
);
723 static inline void neigh_parms_put(struct neigh_parms
*parms
)
725 if (refcount_dec_and_test(&parms
->refcnt
))
726 neigh_parms_destroy(parms
);
730 * neighbour must already be out of the table;
733 void neigh_destroy(struct neighbour
*neigh
)
735 struct net_device
*dev
= neigh
->dev
;
737 NEIGH_CACHE_STAT_INC(neigh
->tbl
, destroys
);
740 pr_warn("Destroying alive neighbour %p\n", neigh
);
745 if (neigh_del_timer(neigh
))
746 pr_warn("Impossible event\n");
748 write_lock_bh(&neigh
->lock
);
749 __skb_queue_purge(&neigh
->arp_queue
);
750 write_unlock_bh(&neigh
->lock
);
751 neigh
->arp_queue_len_bytes
= 0;
753 if (dev
->netdev_ops
->ndo_neigh_destroy
)
754 dev
->netdev_ops
->ndo_neigh_destroy(dev
, neigh
);
757 neigh_parms_put(neigh
->parms
);
759 neigh_dbg(2, "neigh %p is destroyed\n", neigh
);
761 atomic_dec(&neigh
->tbl
->entries
);
762 kfree_rcu(neigh
, rcu
);
764 EXPORT_SYMBOL(neigh_destroy
);
766 /* Neighbour state is suspicious;
769 Called with write_locked neigh.
771 static void neigh_suspect(struct neighbour
*neigh
)
773 neigh_dbg(2, "neigh %p is suspected\n", neigh
);
775 neigh
->output
= neigh
->ops
->output
;
778 /* Neighbour state is OK;
781 Called with write_locked neigh.
783 static void neigh_connect(struct neighbour
*neigh
)
785 neigh_dbg(2, "neigh %p is connected\n", neigh
);
787 neigh
->output
= neigh
->ops
->connected_output
;
790 static void neigh_periodic_work(struct work_struct
*work
)
792 struct neigh_table
*tbl
= container_of(work
, struct neigh_table
, gc_work
.work
);
794 struct neighbour __rcu
**np
;
796 struct neigh_hash_table
*nht
;
798 NEIGH_CACHE_STAT_INC(tbl
, periodic_gc_runs
);
800 write_lock_bh(&tbl
->lock
);
801 nht
= rcu_dereference_protected(tbl
->nht
,
802 lockdep_is_held(&tbl
->lock
));
805 * periodically recompute ReachableTime from random function
808 if (time_after(jiffies
, tbl
->last_rand
+ 300 * HZ
)) {
809 struct neigh_parms
*p
;
810 tbl
->last_rand
= jiffies
;
811 list_for_each_entry(p
, &tbl
->parms_list
, list
)
813 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
816 if (atomic_read(&tbl
->entries
) < tbl
->gc_thresh1
)
819 for (i
= 0 ; i
< (1 << nht
->hash_shift
); i
++) {
820 np
= &nht
->hash_buckets
[i
];
822 while ((n
= rcu_dereference_protected(*np
,
823 lockdep_is_held(&tbl
->lock
))) != NULL
) {
826 write_lock(&n
->lock
);
828 state
= n
->nud_state
;
829 if (state
& (NUD_PERMANENT
| NUD_IN_TIMER
)) {
830 write_unlock(&n
->lock
);
834 if (time_before(n
->used
, n
->confirmed
))
835 n
->used
= n
->confirmed
;
837 if (refcount_read(&n
->refcnt
) == 1 &&
838 (state
== NUD_FAILED
||
839 time_after(jiffies
, n
->used
+ NEIGH_VAR(n
->parms
, GC_STALETIME
)))) {
842 write_unlock(&n
->lock
);
843 neigh_cleanup_and_release(n
);
846 write_unlock(&n
->lock
);
852 * It's fine to release lock here, even if hash table
853 * grows while we are preempted.
855 write_unlock_bh(&tbl
->lock
);
857 write_lock_bh(&tbl
->lock
);
858 nht
= rcu_dereference_protected(tbl
->nht
,
859 lockdep_is_held(&tbl
->lock
));
862 /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks.
863 * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2
864 * BASE_REACHABLE_TIME.
866 queue_delayed_work(system_power_efficient_wq
, &tbl
->gc_work
,
867 NEIGH_VAR(&tbl
->parms
, BASE_REACHABLE_TIME
) >> 1);
868 write_unlock_bh(&tbl
->lock
);
871 static __inline__
int neigh_max_probes(struct neighbour
*n
)
873 struct neigh_parms
*p
= n
->parms
;
874 return NEIGH_VAR(p
, UCAST_PROBES
) + NEIGH_VAR(p
, APP_PROBES
) +
875 (n
->nud_state
& NUD_PROBE
? NEIGH_VAR(p
, MCAST_REPROBES
) :
876 NEIGH_VAR(p
, MCAST_PROBES
));
879 static void neigh_invalidate(struct neighbour
*neigh
)
880 __releases(neigh
->lock
)
881 __acquires(neigh
->lock
)
885 NEIGH_CACHE_STAT_INC(neigh
->tbl
, res_failed
);
886 neigh_dbg(2, "neigh %p is failed\n", neigh
);
887 neigh
->updated
= jiffies
;
889 /* It is very thin place. report_unreachable is very complicated
890 routine. Particularly, it can hit the same neighbour entry!
892 So that, we try to be accurate and avoid dead loop. --ANK
894 while (neigh
->nud_state
== NUD_FAILED
&&
895 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
896 write_unlock(&neigh
->lock
);
897 neigh
->ops
->error_report(neigh
, skb
);
898 write_lock(&neigh
->lock
);
900 __skb_queue_purge(&neigh
->arp_queue
);
901 neigh
->arp_queue_len_bytes
= 0;
904 static void neigh_probe(struct neighbour
*neigh
)
905 __releases(neigh
->lock
)
907 struct sk_buff
*skb
= skb_peek_tail(&neigh
->arp_queue
);
908 /* keep skb alive even if arp_queue overflows */
910 skb
= skb_clone(skb
, GFP_ATOMIC
);
911 write_unlock(&neigh
->lock
);
912 if (neigh
->ops
->solicit
)
913 neigh
->ops
->solicit(neigh
, skb
);
914 atomic_inc(&neigh
->probes
);
918 /* Called when a timer expires for a neighbour entry. */
920 static void neigh_timer_handler(struct timer_list
*t
)
922 unsigned long now
, next
;
923 struct neighbour
*neigh
= from_timer(neigh
, t
, timer
);
927 write_lock(&neigh
->lock
);
929 state
= neigh
->nud_state
;
933 if (!(state
& NUD_IN_TIMER
))
936 if (state
& NUD_REACHABLE
) {
937 if (time_before_eq(now
,
938 neigh
->confirmed
+ neigh
->parms
->reachable_time
)) {
939 neigh_dbg(2, "neigh %p is still alive\n", neigh
);
940 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
941 } else if (time_before_eq(now
,
943 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
))) {
944 neigh_dbg(2, "neigh %p is delayed\n", neigh
);
945 neigh
->nud_state
= NUD_DELAY
;
946 neigh
->updated
= jiffies
;
947 neigh_suspect(neigh
);
948 next
= now
+ NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
);
950 neigh_dbg(2, "neigh %p is suspected\n", neigh
);
951 neigh
->nud_state
= NUD_STALE
;
952 neigh
->updated
= jiffies
;
953 neigh_suspect(neigh
);
956 } else if (state
& NUD_DELAY
) {
957 if (time_before_eq(now
,
959 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
))) {
960 neigh_dbg(2, "neigh %p is now reachable\n", neigh
);
961 neigh
->nud_state
= NUD_REACHABLE
;
962 neigh
->updated
= jiffies
;
963 neigh_connect(neigh
);
965 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
967 neigh_dbg(2, "neigh %p is probed\n", neigh
);
968 neigh
->nud_state
= NUD_PROBE
;
969 neigh
->updated
= jiffies
;
970 atomic_set(&neigh
->probes
, 0);
972 next
= now
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
);
975 /* NUD_PROBE|NUD_INCOMPLETE */
976 next
= now
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
);
979 if ((neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
980 atomic_read(&neigh
->probes
) >= neigh_max_probes(neigh
)) {
981 neigh
->nud_state
= NUD_FAILED
;
983 neigh_invalidate(neigh
);
987 if (neigh
->nud_state
& NUD_IN_TIMER
) {
988 if (time_before(next
, jiffies
+ HZ
/2))
989 next
= jiffies
+ HZ
/2;
990 if (!mod_timer(&neigh
->timer
, next
))
993 if (neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) {
997 write_unlock(&neigh
->lock
);
1001 neigh_update_notify(neigh
, 0);
1003 neigh_release(neigh
);
1006 int __neigh_event_send(struct neighbour
*neigh
, struct sk_buff
*skb
)
1009 bool immediate_probe
= false;
1011 write_lock_bh(&neigh
->lock
);
1014 if (neigh
->nud_state
& (NUD_CONNECTED
| NUD_DELAY
| NUD_PROBE
))
1019 if (!(neigh
->nud_state
& (NUD_STALE
| NUD_INCOMPLETE
))) {
1020 if (NEIGH_VAR(neigh
->parms
, MCAST_PROBES
) +
1021 NEIGH_VAR(neigh
->parms
, APP_PROBES
)) {
1022 unsigned long next
, now
= jiffies
;
1024 atomic_set(&neigh
->probes
,
1025 NEIGH_VAR(neigh
->parms
, UCAST_PROBES
));
1026 neigh_del_timer(neigh
);
1027 neigh
->nud_state
= NUD_INCOMPLETE
;
1028 neigh
->updated
= now
;
1029 next
= now
+ max(NEIGH_VAR(neigh
->parms
, RETRANS_TIME
),
1031 neigh_add_timer(neigh
, next
);
1032 immediate_probe
= true;
1034 neigh
->nud_state
= NUD_FAILED
;
1035 neigh
->updated
= jiffies
;
1036 write_unlock_bh(&neigh
->lock
);
1041 } else if (neigh
->nud_state
& NUD_STALE
) {
1042 neigh_dbg(2, "neigh %p is delayed\n", neigh
);
1043 neigh_del_timer(neigh
);
1044 neigh
->nud_state
= NUD_DELAY
;
1045 neigh
->updated
= jiffies
;
1046 neigh_add_timer(neigh
, jiffies
+
1047 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
));
1050 if (neigh
->nud_state
== NUD_INCOMPLETE
) {
1052 while (neigh
->arp_queue_len_bytes
+ skb
->truesize
>
1053 NEIGH_VAR(neigh
->parms
, QUEUE_LEN_BYTES
)) {
1054 struct sk_buff
*buff
;
1056 buff
= __skb_dequeue(&neigh
->arp_queue
);
1059 neigh
->arp_queue_len_bytes
-= buff
->truesize
;
1061 NEIGH_CACHE_STAT_INC(neigh
->tbl
, unres_discards
);
1064 __skb_queue_tail(&neigh
->arp_queue
, skb
);
1065 neigh
->arp_queue_len_bytes
+= skb
->truesize
;
1070 if (immediate_probe
)
1073 write_unlock(&neigh
->lock
);
1078 if (neigh
->nud_state
& NUD_STALE
)
1080 write_unlock_bh(&neigh
->lock
);
1084 EXPORT_SYMBOL(__neigh_event_send
);
1086 static void neigh_update_hhs(struct neighbour
*neigh
)
1088 struct hh_cache
*hh
;
1089 void (*update
)(struct hh_cache
*, const struct net_device
*, const unsigned char *)
1092 if (neigh
->dev
->header_ops
)
1093 update
= neigh
->dev
->header_ops
->cache_update
;
1097 if (READ_ONCE(hh
->hh_len
)) {
1098 write_seqlock_bh(&hh
->hh_lock
);
1099 update(hh
, neigh
->dev
, neigh
->ha
);
1100 write_sequnlock_bh(&hh
->hh_lock
);
1107 /* Generic update routine.
1108 -- lladdr is new lladdr or NULL, if it is not supplied.
1109 -- new is new state.
1111 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
1113 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
1114 lladdr instead of overriding it
1116 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
1118 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
1120 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1123 Caller MUST hold reference count on the entry.
1126 int neigh_update(struct neighbour
*neigh
, const u8
*lladdr
, u8
new,
1127 u32 flags
, u32 nlmsg_pid
)
1132 struct net_device
*dev
;
1133 int update_isrouter
= 0;
1135 write_lock_bh(&neigh
->lock
);
1138 old
= neigh
->nud_state
;
1141 if (!(flags
& NEIGH_UPDATE_F_ADMIN
) &&
1142 (old
& (NUD_NOARP
| NUD_PERMANENT
)))
1147 if (!(new & NUD_VALID
)) {
1148 neigh_del_timer(neigh
);
1149 if (old
& NUD_CONNECTED
)
1150 neigh_suspect(neigh
);
1151 neigh
->nud_state
= new;
1153 notify
= old
& NUD_VALID
;
1154 if ((old
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
1155 (new & NUD_FAILED
)) {
1156 neigh_invalidate(neigh
);
1162 /* Compare new lladdr with cached one */
1163 if (!dev
->addr_len
) {
1164 /* First case: device needs no address. */
1166 } else if (lladdr
) {
1167 /* The second case: if something is already cached
1168 and a new address is proposed:
1170 - if they are different, check override flag
1172 if ((old
& NUD_VALID
) &&
1173 !memcmp(lladdr
, neigh
->ha
, dev
->addr_len
))
1176 /* No address is supplied; if we know something,
1177 use it, otherwise discard the request.
1180 if (!(old
& NUD_VALID
))
1185 /* Update confirmed timestamp for neighbour entry after we
1186 * received ARP packet even if it doesn't change IP to MAC binding.
1188 if (new & NUD_CONNECTED
)
1189 neigh
->confirmed
= jiffies
;
1191 /* If entry was valid and address is not changed,
1192 do not change entry state, if new one is STALE.
1195 update_isrouter
= flags
& NEIGH_UPDATE_F_OVERRIDE_ISROUTER
;
1196 if (old
& NUD_VALID
) {
1197 if (lladdr
!= neigh
->ha
&& !(flags
& NEIGH_UPDATE_F_OVERRIDE
)) {
1198 update_isrouter
= 0;
1199 if ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) &&
1200 (old
& NUD_CONNECTED
)) {
1206 if (lladdr
== neigh
->ha
&& new == NUD_STALE
&&
1207 !(flags
& NEIGH_UPDATE_F_ADMIN
))
1212 /* Update timestamp only once we know we will make a change to the
1213 * neighbour entry. Otherwise we risk to move the locktime window with
1214 * noop updates and ignore relevant ARP updates.
1216 if (new != old
|| lladdr
!= neigh
->ha
)
1217 neigh
->updated
= jiffies
;
1220 neigh_del_timer(neigh
);
1221 if (new & NUD_PROBE
)
1222 atomic_set(&neigh
->probes
, 0);
1223 if (new & NUD_IN_TIMER
)
1224 neigh_add_timer(neigh
, (jiffies
+
1225 ((new & NUD_REACHABLE
) ?
1226 neigh
->parms
->reachable_time
:
1228 neigh
->nud_state
= new;
1232 if (lladdr
!= neigh
->ha
) {
1233 write_seqlock(&neigh
->ha_lock
);
1234 memcpy(&neigh
->ha
, lladdr
, dev
->addr_len
);
1235 write_sequnlock(&neigh
->ha_lock
);
1236 neigh_update_hhs(neigh
);
1237 if (!(new & NUD_CONNECTED
))
1238 neigh
->confirmed
= jiffies
-
1239 (NEIGH_VAR(neigh
->parms
, BASE_REACHABLE_TIME
) << 1);
1244 if (new & NUD_CONNECTED
)
1245 neigh_connect(neigh
);
1247 neigh_suspect(neigh
);
1248 if (!(old
& NUD_VALID
)) {
1249 struct sk_buff
*skb
;
1251 /* Again: avoid dead loop if something went wrong */
1253 while (neigh
->nud_state
& NUD_VALID
&&
1254 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
1255 struct dst_entry
*dst
= skb_dst(skb
);
1256 struct neighbour
*n2
, *n1
= neigh
;
1257 write_unlock_bh(&neigh
->lock
);
1261 /* Why not just use 'neigh' as-is? The problem is that
1262 * things such as shaper, eql, and sch_teql can end up
1263 * using alternative, different, neigh objects to output
1264 * the packet in the output path. So what we need to do
1265 * here is re-lookup the top-level neigh in the path so
1266 * we can reinject the packet there.
1270 n2
= dst_neigh_lookup_skb(dst
, skb
);
1274 n1
->output(n1
, skb
);
1279 write_lock_bh(&neigh
->lock
);
1281 __skb_queue_purge(&neigh
->arp_queue
);
1282 neigh
->arp_queue_len_bytes
= 0;
1285 if (update_isrouter
) {
1286 neigh
->flags
= (flags
& NEIGH_UPDATE_F_ISROUTER
) ?
1287 (neigh
->flags
| NTF_ROUTER
) :
1288 (neigh
->flags
& ~NTF_ROUTER
);
1290 write_unlock_bh(&neigh
->lock
);
1293 neigh_update_notify(neigh
, nlmsg_pid
);
1297 EXPORT_SYMBOL(neigh_update
);
1299 /* Update the neigh to listen temporarily for probe responses, even if it is
1300 * in a NUD_FAILED state. The caller has to hold neigh->lock for writing.
1302 void __neigh_set_probe_once(struct neighbour
*neigh
)
1306 neigh
->updated
= jiffies
;
1307 if (!(neigh
->nud_state
& NUD_FAILED
))
1309 neigh
->nud_state
= NUD_INCOMPLETE
;
1310 atomic_set(&neigh
->probes
, neigh_max_probes(neigh
));
1311 neigh_add_timer(neigh
,
1312 jiffies
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
));
1314 EXPORT_SYMBOL(__neigh_set_probe_once
);
1316 struct neighbour
*neigh_event_ns(struct neigh_table
*tbl
,
1317 u8
*lladdr
, void *saddr
,
1318 struct net_device
*dev
)
1320 struct neighbour
*neigh
= __neigh_lookup(tbl
, saddr
, dev
,
1321 lladdr
|| !dev
->addr_len
);
1323 neigh_update(neigh
, lladdr
, NUD_STALE
,
1324 NEIGH_UPDATE_F_OVERRIDE
, 0);
1327 EXPORT_SYMBOL(neigh_event_ns
);
1329 /* called with read_lock_bh(&n->lock); */
1330 static void neigh_hh_init(struct neighbour
*n
)
1332 struct net_device
*dev
= n
->dev
;
1333 __be16 prot
= n
->tbl
->protocol
;
1334 struct hh_cache
*hh
= &n
->hh
;
1336 write_lock_bh(&n
->lock
);
1338 /* Only one thread can come in here and initialize the
1342 dev
->header_ops
->cache(n
, hh
, prot
);
1344 write_unlock_bh(&n
->lock
);
1347 /* Slow and careful. */
1349 int neigh_resolve_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1353 if (!neigh_event_send(neigh
, skb
)) {
1355 struct net_device
*dev
= neigh
->dev
;
1358 if (dev
->header_ops
->cache
&& !READ_ONCE(neigh
->hh
.hh_len
))
1359 neigh_hh_init(neigh
);
1362 __skb_pull(skb
, skb_network_offset(skb
));
1363 seq
= read_seqbegin(&neigh
->ha_lock
);
1364 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1365 neigh
->ha
, NULL
, skb
->len
);
1366 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1369 rc
= dev_queue_xmit(skb
);
1380 EXPORT_SYMBOL(neigh_resolve_output
);
1382 /* As fast as possible without hh cache */
1384 int neigh_connected_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1386 struct net_device
*dev
= neigh
->dev
;
1391 __skb_pull(skb
, skb_network_offset(skb
));
1392 seq
= read_seqbegin(&neigh
->ha_lock
);
1393 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1394 neigh
->ha
, NULL
, skb
->len
);
1395 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1398 err
= dev_queue_xmit(skb
);
1405 EXPORT_SYMBOL(neigh_connected_output
);
1407 int neigh_direct_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1409 return dev_queue_xmit(skb
);
1411 EXPORT_SYMBOL(neigh_direct_output
);
1413 static void neigh_proxy_process(struct timer_list
*t
)
1415 struct neigh_table
*tbl
= from_timer(tbl
, t
, proxy_timer
);
1416 long sched_next
= 0;
1417 unsigned long now
= jiffies
;
1418 struct sk_buff
*skb
, *n
;
1420 spin_lock(&tbl
->proxy_queue
.lock
);
1422 skb_queue_walk_safe(&tbl
->proxy_queue
, skb
, n
) {
1423 long tdif
= NEIGH_CB(skb
)->sched_next
- now
;
1426 struct net_device
*dev
= skb
->dev
;
1428 __skb_unlink(skb
, &tbl
->proxy_queue
);
1429 if (tbl
->proxy_redo
&& netif_running(dev
)) {
1431 tbl
->proxy_redo(skb
);
1438 } else if (!sched_next
|| tdif
< sched_next
)
1441 del_timer(&tbl
->proxy_timer
);
1443 mod_timer(&tbl
->proxy_timer
, jiffies
+ sched_next
);
1444 spin_unlock(&tbl
->proxy_queue
.lock
);
1447 void pneigh_enqueue(struct neigh_table
*tbl
, struct neigh_parms
*p
,
1448 struct sk_buff
*skb
)
1450 unsigned long now
= jiffies
;
1452 unsigned long sched_next
= now
+ (prandom_u32() %
1453 NEIGH_VAR(p
, PROXY_DELAY
));
1455 if (tbl
->proxy_queue
.qlen
> NEIGH_VAR(p
, PROXY_QLEN
)) {
1460 NEIGH_CB(skb
)->sched_next
= sched_next
;
1461 NEIGH_CB(skb
)->flags
|= LOCALLY_ENQUEUED
;
1463 spin_lock(&tbl
->proxy_queue
.lock
);
1464 if (del_timer(&tbl
->proxy_timer
)) {
1465 if (time_before(tbl
->proxy_timer
.expires
, sched_next
))
1466 sched_next
= tbl
->proxy_timer
.expires
;
1470 __skb_queue_tail(&tbl
->proxy_queue
, skb
);
1471 mod_timer(&tbl
->proxy_timer
, sched_next
);
1472 spin_unlock(&tbl
->proxy_queue
.lock
);
1474 EXPORT_SYMBOL(pneigh_enqueue
);
1476 static inline struct neigh_parms
*lookup_neigh_parms(struct neigh_table
*tbl
,
1477 struct net
*net
, int ifindex
)
1479 struct neigh_parms
*p
;
1481 list_for_each_entry(p
, &tbl
->parms_list
, list
) {
1482 if ((p
->dev
&& p
->dev
->ifindex
== ifindex
&& net_eq(neigh_parms_net(p
), net
)) ||
1483 (!p
->dev
&& !ifindex
&& net_eq(net
, &init_net
)))
1490 struct neigh_parms
*neigh_parms_alloc(struct net_device
*dev
,
1491 struct neigh_table
*tbl
)
1493 struct neigh_parms
*p
;
1494 struct net
*net
= dev_net(dev
);
1495 const struct net_device_ops
*ops
= dev
->netdev_ops
;
1497 p
= kmemdup(&tbl
->parms
, sizeof(*p
), GFP_KERNEL
);
1500 refcount_set(&p
->refcnt
, 1);
1502 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
1505 write_pnet(&p
->net
, net
);
1506 p
->sysctl_table
= NULL
;
1508 if (ops
->ndo_neigh_setup
&& ops
->ndo_neigh_setup(dev
, p
)) {
1514 write_lock_bh(&tbl
->lock
);
1515 list_add(&p
->list
, &tbl
->parms
.list
);
1516 write_unlock_bh(&tbl
->lock
);
1518 neigh_parms_data_state_cleanall(p
);
1522 EXPORT_SYMBOL(neigh_parms_alloc
);
1524 static void neigh_rcu_free_parms(struct rcu_head
*head
)
1526 struct neigh_parms
*parms
=
1527 container_of(head
, struct neigh_parms
, rcu_head
);
1529 neigh_parms_put(parms
);
1532 void neigh_parms_release(struct neigh_table
*tbl
, struct neigh_parms
*parms
)
1534 if (!parms
|| parms
== &tbl
->parms
)
1536 write_lock_bh(&tbl
->lock
);
1537 list_del(&parms
->list
);
1539 write_unlock_bh(&tbl
->lock
);
1541 dev_put(parms
->dev
);
1542 call_rcu(&parms
->rcu_head
, neigh_rcu_free_parms
);
1544 EXPORT_SYMBOL(neigh_parms_release
);
1546 static void neigh_parms_destroy(struct neigh_parms
*parms
)
1551 static struct lock_class_key neigh_table_proxy_queue_class
;
1553 static struct neigh_table
*neigh_tables
[NEIGH_NR_TABLES
] __read_mostly
;
1555 void neigh_table_init(int index
, struct neigh_table
*tbl
)
1557 unsigned long now
= jiffies
;
1558 unsigned long phsize
;
1560 INIT_LIST_HEAD(&tbl
->parms_list
);
1561 list_add(&tbl
->parms
.list
, &tbl
->parms_list
);
1562 write_pnet(&tbl
->parms
.net
, &init_net
);
1563 refcount_set(&tbl
->parms
.refcnt
, 1);
1564 tbl
->parms
.reachable_time
=
1565 neigh_rand_reach_time(NEIGH_VAR(&tbl
->parms
, BASE_REACHABLE_TIME
));
1567 tbl
->stats
= alloc_percpu(struct neigh_statistics
);
1569 panic("cannot create neighbour cache statistics");
1571 #ifdef CONFIG_PROC_FS
1572 if (!proc_create_data(tbl
->id
, 0, init_net
.proc_net_stat
,
1573 &neigh_stat_seq_fops
, tbl
))
1574 panic("cannot create neighbour proc dir entry");
1577 RCU_INIT_POINTER(tbl
->nht
, neigh_hash_alloc(3));
1579 phsize
= (PNEIGH_HASHMASK
+ 1) * sizeof(struct pneigh_entry
*);
1580 tbl
->phash_buckets
= kzalloc(phsize
, GFP_KERNEL
);
1582 if (!tbl
->nht
|| !tbl
->phash_buckets
)
1583 panic("cannot allocate neighbour cache hashes");
1585 if (!tbl
->entry_size
)
1586 tbl
->entry_size
= ALIGN(offsetof(struct neighbour
, primary_key
) +
1587 tbl
->key_len
, NEIGH_PRIV_ALIGN
);
1589 WARN_ON(tbl
->entry_size
% NEIGH_PRIV_ALIGN
);
1591 rwlock_init(&tbl
->lock
);
1592 INIT_DEFERRABLE_WORK(&tbl
->gc_work
, neigh_periodic_work
);
1593 queue_delayed_work(system_power_efficient_wq
, &tbl
->gc_work
,
1594 tbl
->parms
.reachable_time
);
1595 timer_setup(&tbl
->proxy_timer
, neigh_proxy_process
, 0);
1596 skb_queue_head_init_class(&tbl
->proxy_queue
,
1597 &neigh_table_proxy_queue_class
);
1599 tbl
->last_flush
= now
;
1600 tbl
->last_rand
= now
+ tbl
->parms
.reachable_time
* 20;
1602 neigh_tables
[index
] = tbl
;
1604 EXPORT_SYMBOL(neigh_table_init
);
1606 int neigh_table_clear(int index
, struct neigh_table
*tbl
)
1608 neigh_tables
[index
] = NULL
;
1609 /* It is not clean... Fix it to unload IPv6 module safely */
1610 cancel_delayed_work_sync(&tbl
->gc_work
);
1611 del_timer_sync(&tbl
->proxy_timer
);
1612 pneigh_queue_purge(&tbl
->proxy_queue
);
1613 neigh_ifdown(tbl
, NULL
);
1614 if (atomic_read(&tbl
->entries
))
1615 pr_crit("neighbour leakage\n");
1617 call_rcu(&rcu_dereference_protected(tbl
->nht
, 1)->rcu
,
1618 neigh_hash_free_rcu
);
1621 kfree(tbl
->phash_buckets
);
1622 tbl
->phash_buckets
= NULL
;
1624 remove_proc_entry(tbl
->id
, init_net
.proc_net_stat
);
1626 free_percpu(tbl
->stats
);
1631 EXPORT_SYMBOL(neigh_table_clear
);
1633 static struct neigh_table
*neigh_find_table(int family
)
1635 struct neigh_table
*tbl
= NULL
;
1639 tbl
= neigh_tables
[NEIGH_ARP_TABLE
];
1642 tbl
= neigh_tables
[NEIGH_ND_TABLE
];
1645 tbl
= neigh_tables
[NEIGH_DN_TABLE
];
1652 static int neigh_delete(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
1653 struct netlink_ext_ack
*extack
)
1655 struct net
*net
= sock_net(skb
->sk
);
1657 struct nlattr
*dst_attr
;
1658 struct neigh_table
*tbl
;
1659 struct neighbour
*neigh
;
1660 struct net_device
*dev
= NULL
;
1664 if (nlmsg_len(nlh
) < sizeof(*ndm
))
1667 dst_attr
= nlmsg_find_attr(nlh
, sizeof(*ndm
), NDA_DST
);
1668 if (dst_attr
== NULL
)
1671 ndm
= nlmsg_data(nlh
);
1672 if (ndm
->ndm_ifindex
) {
1673 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1680 tbl
= neigh_find_table(ndm
->ndm_family
);
1682 return -EAFNOSUPPORT
;
1684 if (nla_len(dst_attr
) < (int)tbl
->key_len
)
1687 if (ndm
->ndm_flags
& NTF_PROXY
) {
1688 err
= pneigh_delete(tbl
, net
, nla_data(dst_attr
), dev
);
1695 neigh
= neigh_lookup(tbl
, nla_data(dst_attr
), dev
);
1696 if (neigh
== NULL
) {
1701 err
= neigh_update(neigh
, NULL
, NUD_FAILED
,
1702 NEIGH_UPDATE_F_OVERRIDE
|
1703 NEIGH_UPDATE_F_ADMIN
,
1704 NETLINK_CB(skb
).portid
);
1705 write_lock_bh(&tbl
->lock
);
1706 neigh_release(neigh
);
1707 neigh_remove_one(neigh
, tbl
);
1708 write_unlock_bh(&tbl
->lock
);
1714 static int neigh_add(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
1715 struct netlink_ext_ack
*extack
)
1717 int flags
= NEIGH_UPDATE_F_ADMIN
| NEIGH_UPDATE_F_OVERRIDE
;
1718 struct net
*net
= sock_net(skb
->sk
);
1720 struct nlattr
*tb
[NDA_MAX
+1];
1721 struct neigh_table
*tbl
;
1722 struct net_device
*dev
= NULL
;
1723 struct neighbour
*neigh
;
1728 err
= nlmsg_parse(nlh
, sizeof(*ndm
), tb
, NDA_MAX
, NULL
, extack
);
1733 if (tb
[NDA_DST
] == NULL
)
1736 ndm
= nlmsg_data(nlh
);
1737 if (ndm
->ndm_ifindex
) {
1738 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1744 if (tb
[NDA_LLADDR
] && nla_len(tb
[NDA_LLADDR
]) < dev
->addr_len
)
1748 tbl
= neigh_find_table(ndm
->ndm_family
);
1750 return -EAFNOSUPPORT
;
1752 if (nla_len(tb
[NDA_DST
]) < (int)tbl
->key_len
)
1754 dst
= nla_data(tb
[NDA_DST
]);
1755 lladdr
= tb
[NDA_LLADDR
] ? nla_data(tb
[NDA_LLADDR
]) : NULL
;
1757 if (ndm
->ndm_flags
& NTF_PROXY
) {
1758 struct pneigh_entry
*pn
;
1761 pn
= pneigh_lookup(tbl
, net
, dst
, dev
, 1);
1763 pn
->flags
= ndm
->ndm_flags
;
1772 neigh
= neigh_lookup(tbl
, dst
, dev
);
1773 if (neigh
== NULL
) {
1774 if (!(nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
1779 neigh
= __neigh_lookup_errno(tbl
, dst
, dev
);
1780 if (IS_ERR(neigh
)) {
1781 err
= PTR_ERR(neigh
);
1785 if (nlh
->nlmsg_flags
& NLM_F_EXCL
) {
1787 neigh_release(neigh
);
1791 if (!(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
1792 flags
&= ~NEIGH_UPDATE_F_OVERRIDE
;
1795 if (ndm
->ndm_flags
& NTF_USE
) {
1796 neigh_event_send(neigh
, NULL
);
1799 err
= neigh_update(neigh
, lladdr
, ndm
->ndm_state
, flags
,
1800 NETLINK_CB(skb
).portid
);
1801 neigh_release(neigh
);
1807 static int neightbl_fill_parms(struct sk_buff
*skb
, struct neigh_parms
*parms
)
1809 struct nlattr
*nest
;
1811 nest
= nla_nest_start(skb
, NDTA_PARMS
);
1816 nla_put_u32(skb
, NDTPA_IFINDEX
, parms
->dev
->ifindex
)) ||
1817 nla_put_u32(skb
, NDTPA_REFCNT
, refcount_read(&parms
->refcnt
)) ||
1818 nla_put_u32(skb
, NDTPA_QUEUE_LENBYTES
,
1819 NEIGH_VAR(parms
, QUEUE_LEN_BYTES
)) ||
1820 /* approximative value for deprecated QUEUE_LEN (in packets) */
1821 nla_put_u32(skb
, NDTPA_QUEUE_LEN
,
1822 NEIGH_VAR(parms
, QUEUE_LEN_BYTES
) / SKB_TRUESIZE(ETH_FRAME_LEN
)) ||
1823 nla_put_u32(skb
, NDTPA_PROXY_QLEN
, NEIGH_VAR(parms
, PROXY_QLEN
)) ||
1824 nla_put_u32(skb
, NDTPA_APP_PROBES
, NEIGH_VAR(parms
, APP_PROBES
)) ||
1825 nla_put_u32(skb
, NDTPA_UCAST_PROBES
,
1826 NEIGH_VAR(parms
, UCAST_PROBES
)) ||
1827 nla_put_u32(skb
, NDTPA_MCAST_PROBES
,
1828 NEIGH_VAR(parms
, MCAST_PROBES
)) ||
1829 nla_put_u32(skb
, NDTPA_MCAST_REPROBES
,
1830 NEIGH_VAR(parms
, MCAST_REPROBES
)) ||
1831 nla_put_msecs(skb
, NDTPA_REACHABLE_TIME
, parms
->reachable_time
,
1833 nla_put_msecs(skb
, NDTPA_BASE_REACHABLE_TIME
,
1834 NEIGH_VAR(parms
, BASE_REACHABLE_TIME
), NDTPA_PAD
) ||
1835 nla_put_msecs(skb
, NDTPA_GC_STALETIME
,
1836 NEIGH_VAR(parms
, GC_STALETIME
), NDTPA_PAD
) ||
1837 nla_put_msecs(skb
, NDTPA_DELAY_PROBE_TIME
,
1838 NEIGH_VAR(parms
, DELAY_PROBE_TIME
), NDTPA_PAD
) ||
1839 nla_put_msecs(skb
, NDTPA_RETRANS_TIME
,
1840 NEIGH_VAR(parms
, RETRANS_TIME
), NDTPA_PAD
) ||
1841 nla_put_msecs(skb
, NDTPA_ANYCAST_DELAY
,
1842 NEIGH_VAR(parms
, ANYCAST_DELAY
), NDTPA_PAD
) ||
1843 nla_put_msecs(skb
, NDTPA_PROXY_DELAY
,
1844 NEIGH_VAR(parms
, PROXY_DELAY
), NDTPA_PAD
) ||
1845 nla_put_msecs(skb
, NDTPA_LOCKTIME
,
1846 NEIGH_VAR(parms
, LOCKTIME
), NDTPA_PAD
))
1847 goto nla_put_failure
;
1848 return nla_nest_end(skb
, nest
);
1851 nla_nest_cancel(skb
, nest
);
1855 static int neightbl_fill_info(struct sk_buff
*skb
, struct neigh_table
*tbl
,
1856 u32 pid
, u32 seq
, int type
, int flags
)
1858 struct nlmsghdr
*nlh
;
1859 struct ndtmsg
*ndtmsg
;
1861 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1865 ndtmsg
= nlmsg_data(nlh
);
1867 read_lock_bh(&tbl
->lock
);
1868 ndtmsg
->ndtm_family
= tbl
->family
;
1869 ndtmsg
->ndtm_pad1
= 0;
1870 ndtmsg
->ndtm_pad2
= 0;
1872 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) ||
1873 nla_put_msecs(skb
, NDTA_GC_INTERVAL
, tbl
->gc_interval
, NDTA_PAD
) ||
1874 nla_put_u32(skb
, NDTA_THRESH1
, tbl
->gc_thresh1
) ||
1875 nla_put_u32(skb
, NDTA_THRESH2
, tbl
->gc_thresh2
) ||
1876 nla_put_u32(skb
, NDTA_THRESH3
, tbl
->gc_thresh3
))
1877 goto nla_put_failure
;
1879 unsigned long now
= jiffies
;
1880 long flush_delta
= now
- tbl
->last_flush
;
1881 long rand_delta
= now
- tbl
->last_rand
;
1882 struct neigh_hash_table
*nht
;
1883 struct ndt_config ndc
= {
1884 .ndtc_key_len
= tbl
->key_len
,
1885 .ndtc_entry_size
= tbl
->entry_size
,
1886 .ndtc_entries
= atomic_read(&tbl
->entries
),
1887 .ndtc_last_flush
= jiffies_to_msecs(flush_delta
),
1888 .ndtc_last_rand
= jiffies_to_msecs(rand_delta
),
1889 .ndtc_proxy_qlen
= tbl
->proxy_queue
.qlen
,
1893 nht
= rcu_dereference_bh(tbl
->nht
);
1894 ndc
.ndtc_hash_rnd
= nht
->hash_rnd
[0];
1895 ndc
.ndtc_hash_mask
= ((1 << nht
->hash_shift
) - 1);
1896 rcu_read_unlock_bh();
1898 if (nla_put(skb
, NDTA_CONFIG
, sizeof(ndc
), &ndc
))
1899 goto nla_put_failure
;
1904 struct ndt_stats ndst
;
1906 memset(&ndst
, 0, sizeof(ndst
));
1908 for_each_possible_cpu(cpu
) {
1909 struct neigh_statistics
*st
;
1911 st
= per_cpu_ptr(tbl
->stats
, cpu
);
1912 ndst
.ndts_allocs
+= st
->allocs
;
1913 ndst
.ndts_destroys
+= st
->destroys
;
1914 ndst
.ndts_hash_grows
+= st
->hash_grows
;
1915 ndst
.ndts_res_failed
+= st
->res_failed
;
1916 ndst
.ndts_lookups
+= st
->lookups
;
1917 ndst
.ndts_hits
+= st
->hits
;
1918 ndst
.ndts_rcv_probes_mcast
+= st
->rcv_probes_mcast
;
1919 ndst
.ndts_rcv_probes_ucast
+= st
->rcv_probes_ucast
;
1920 ndst
.ndts_periodic_gc_runs
+= st
->periodic_gc_runs
;
1921 ndst
.ndts_forced_gc_runs
+= st
->forced_gc_runs
;
1922 ndst
.ndts_table_fulls
+= st
->table_fulls
;
1925 if (nla_put_64bit(skb
, NDTA_STATS
, sizeof(ndst
), &ndst
,
1927 goto nla_put_failure
;
1930 BUG_ON(tbl
->parms
.dev
);
1931 if (neightbl_fill_parms(skb
, &tbl
->parms
) < 0)
1932 goto nla_put_failure
;
1934 read_unlock_bh(&tbl
->lock
);
1935 nlmsg_end(skb
, nlh
);
1939 read_unlock_bh(&tbl
->lock
);
1940 nlmsg_cancel(skb
, nlh
);
1944 static int neightbl_fill_param_info(struct sk_buff
*skb
,
1945 struct neigh_table
*tbl
,
1946 struct neigh_parms
*parms
,
1947 u32 pid
, u32 seq
, int type
,
1950 struct ndtmsg
*ndtmsg
;
1951 struct nlmsghdr
*nlh
;
1953 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1957 ndtmsg
= nlmsg_data(nlh
);
1959 read_lock_bh(&tbl
->lock
);
1960 ndtmsg
->ndtm_family
= tbl
->family
;
1961 ndtmsg
->ndtm_pad1
= 0;
1962 ndtmsg
->ndtm_pad2
= 0;
1964 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) < 0 ||
1965 neightbl_fill_parms(skb
, parms
) < 0)
1968 read_unlock_bh(&tbl
->lock
);
1969 nlmsg_end(skb
, nlh
);
1972 read_unlock_bh(&tbl
->lock
);
1973 nlmsg_cancel(skb
, nlh
);
1977 static const struct nla_policy nl_neightbl_policy
[NDTA_MAX
+1] = {
1978 [NDTA_NAME
] = { .type
= NLA_STRING
},
1979 [NDTA_THRESH1
] = { .type
= NLA_U32
},
1980 [NDTA_THRESH2
] = { .type
= NLA_U32
},
1981 [NDTA_THRESH3
] = { .type
= NLA_U32
},
1982 [NDTA_GC_INTERVAL
] = { .type
= NLA_U64
},
1983 [NDTA_PARMS
] = { .type
= NLA_NESTED
},
1986 static const struct nla_policy nl_ntbl_parm_policy
[NDTPA_MAX
+1] = {
1987 [NDTPA_IFINDEX
] = { .type
= NLA_U32
},
1988 [NDTPA_QUEUE_LEN
] = { .type
= NLA_U32
},
1989 [NDTPA_PROXY_QLEN
] = { .type
= NLA_U32
},
1990 [NDTPA_APP_PROBES
] = { .type
= NLA_U32
},
1991 [NDTPA_UCAST_PROBES
] = { .type
= NLA_U32
},
1992 [NDTPA_MCAST_PROBES
] = { .type
= NLA_U32
},
1993 [NDTPA_MCAST_REPROBES
] = { .type
= NLA_U32
},
1994 [NDTPA_BASE_REACHABLE_TIME
] = { .type
= NLA_U64
},
1995 [NDTPA_GC_STALETIME
] = { .type
= NLA_U64
},
1996 [NDTPA_DELAY_PROBE_TIME
] = { .type
= NLA_U64
},
1997 [NDTPA_RETRANS_TIME
] = { .type
= NLA_U64
},
1998 [NDTPA_ANYCAST_DELAY
] = { .type
= NLA_U64
},
1999 [NDTPA_PROXY_DELAY
] = { .type
= NLA_U64
},
2000 [NDTPA_LOCKTIME
] = { .type
= NLA_U64
},
2003 static int neightbl_set(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
2004 struct netlink_ext_ack
*extack
)
2006 struct net
*net
= sock_net(skb
->sk
);
2007 struct neigh_table
*tbl
;
2008 struct ndtmsg
*ndtmsg
;
2009 struct nlattr
*tb
[NDTA_MAX
+1];
2013 err
= nlmsg_parse(nlh
, sizeof(*ndtmsg
), tb
, NDTA_MAX
,
2014 nl_neightbl_policy
, extack
);
2018 if (tb
[NDTA_NAME
] == NULL
) {
2023 ndtmsg
= nlmsg_data(nlh
);
2025 for (tidx
= 0; tidx
< NEIGH_NR_TABLES
; tidx
++) {
2026 tbl
= neigh_tables
[tidx
];
2029 if (ndtmsg
->ndtm_family
&& tbl
->family
!= ndtmsg
->ndtm_family
)
2031 if (nla_strcmp(tb
[NDTA_NAME
], tbl
->id
) == 0) {
2041 * We acquire tbl->lock to be nice to the periodic timers and
2042 * make sure they always see a consistent set of values.
2044 write_lock_bh(&tbl
->lock
);
2046 if (tb
[NDTA_PARMS
]) {
2047 struct nlattr
*tbp
[NDTPA_MAX
+1];
2048 struct neigh_parms
*p
;
2051 err
= nla_parse_nested(tbp
, NDTPA_MAX
, tb
[NDTA_PARMS
],
2052 nl_ntbl_parm_policy
, extack
);
2054 goto errout_tbl_lock
;
2056 if (tbp
[NDTPA_IFINDEX
])
2057 ifindex
= nla_get_u32(tbp
[NDTPA_IFINDEX
]);
2059 p
= lookup_neigh_parms(tbl
, net
, ifindex
);
2062 goto errout_tbl_lock
;
2065 for (i
= 1; i
<= NDTPA_MAX
; i
++) {
2070 case NDTPA_QUEUE_LEN
:
2071 NEIGH_VAR_SET(p
, QUEUE_LEN_BYTES
,
2072 nla_get_u32(tbp
[i
]) *
2073 SKB_TRUESIZE(ETH_FRAME_LEN
));
2075 case NDTPA_QUEUE_LENBYTES
:
2076 NEIGH_VAR_SET(p
, QUEUE_LEN_BYTES
,
2077 nla_get_u32(tbp
[i
]));
2079 case NDTPA_PROXY_QLEN
:
2080 NEIGH_VAR_SET(p
, PROXY_QLEN
,
2081 nla_get_u32(tbp
[i
]));
2083 case NDTPA_APP_PROBES
:
2084 NEIGH_VAR_SET(p
, APP_PROBES
,
2085 nla_get_u32(tbp
[i
]));
2087 case NDTPA_UCAST_PROBES
:
2088 NEIGH_VAR_SET(p
, UCAST_PROBES
,
2089 nla_get_u32(tbp
[i
]));
2091 case NDTPA_MCAST_PROBES
:
2092 NEIGH_VAR_SET(p
, MCAST_PROBES
,
2093 nla_get_u32(tbp
[i
]));
2095 case NDTPA_MCAST_REPROBES
:
2096 NEIGH_VAR_SET(p
, MCAST_REPROBES
,
2097 nla_get_u32(tbp
[i
]));
2099 case NDTPA_BASE_REACHABLE_TIME
:
2100 NEIGH_VAR_SET(p
, BASE_REACHABLE_TIME
,
2101 nla_get_msecs(tbp
[i
]));
2102 /* update reachable_time as well, otherwise, the change will
2103 * only be effective after the next time neigh_periodic_work
2104 * decides to recompute it (can be multiple minutes)
2107 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
2109 case NDTPA_GC_STALETIME
:
2110 NEIGH_VAR_SET(p
, GC_STALETIME
,
2111 nla_get_msecs(tbp
[i
]));
2113 case NDTPA_DELAY_PROBE_TIME
:
2114 NEIGH_VAR_SET(p
, DELAY_PROBE_TIME
,
2115 nla_get_msecs(tbp
[i
]));
2116 call_netevent_notifiers(NETEVENT_DELAY_PROBE_TIME_UPDATE
, p
);
2118 case NDTPA_RETRANS_TIME
:
2119 NEIGH_VAR_SET(p
, RETRANS_TIME
,
2120 nla_get_msecs(tbp
[i
]));
2122 case NDTPA_ANYCAST_DELAY
:
2123 NEIGH_VAR_SET(p
, ANYCAST_DELAY
,
2124 nla_get_msecs(tbp
[i
]));
2126 case NDTPA_PROXY_DELAY
:
2127 NEIGH_VAR_SET(p
, PROXY_DELAY
,
2128 nla_get_msecs(tbp
[i
]));
2130 case NDTPA_LOCKTIME
:
2131 NEIGH_VAR_SET(p
, LOCKTIME
,
2132 nla_get_msecs(tbp
[i
]));
2139 if ((tb
[NDTA_THRESH1
] || tb
[NDTA_THRESH2
] ||
2140 tb
[NDTA_THRESH3
] || tb
[NDTA_GC_INTERVAL
]) &&
2141 !net_eq(net
, &init_net
))
2142 goto errout_tbl_lock
;
2144 if (tb
[NDTA_THRESH1
])
2145 tbl
->gc_thresh1
= nla_get_u32(tb
[NDTA_THRESH1
]);
2147 if (tb
[NDTA_THRESH2
])
2148 tbl
->gc_thresh2
= nla_get_u32(tb
[NDTA_THRESH2
]);
2150 if (tb
[NDTA_THRESH3
])
2151 tbl
->gc_thresh3
= nla_get_u32(tb
[NDTA_THRESH3
]);
2153 if (tb
[NDTA_GC_INTERVAL
])
2154 tbl
->gc_interval
= nla_get_msecs(tb
[NDTA_GC_INTERVAL
]);
2159 write_unlock_bh(&tbl
->lock
);
2164 static int neightbl_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2166 struct net
*net
= sock_net(skb
->sk
);
2167 int family
, tidx
, nidx
= 0;
2168 int tbl_skip
= cb
->args
[0];
2169 int neigh_skip
= cb
->args
[1];
2170 struct neigh_table
*tbl
;
2172 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2174 for (tidx
= 0; tidx
< NEIGH_NR_TABLES
; tidx
++) {
2175 struct neigh_parms
*p
;
2177 tbl
= neigh_tables
[tidx
];
2181 if (tidx
< tbl_skip
|| (family
&& tbl
->family
!= family
))
2184 if (neightbl_fill_info(skb
, tbl
, NETLINK_CB(cb
->skb
).portid
,
2185 cb
->nlh
->nlmsg_seq
, RTM_NEWNEIGHTBL
,
2190 p
= list_next_entry(&tbl
->parms
, list
);
2191 list_for_each_entry_from(p
, &tbl
->parms_list
, list
) {
2192 if (!net_eq(neigh_parms_net(p
), net
))
2195 if (nidx
< neigh_skip
)
2198 if (neightbl_fill_param_info(skb
, tbl
, p
,
2199 NETLINK_CB(cb
->skb
).portid
,
2217 static int neigh_fill_info(struct sk_buff
*skb
, struct neighbour
*neigh
,
2218 u32 pid
, u32 seq
, int type
, unsigned int flags
)
2220 unsigned long now
= jiffies
;
2221 struct nda_cacheinfo ci
;
2222 struct nlmsghdr
*nlh
;
2225 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2229 ndm
= nlmsg_data(nlh
);
2230 ndm
->ndm_family
= neigh
->ops
->family
;
2233 ndm
->ndm_flags
= neigh
->flags
;
2234 ndm
->ndm_type
= neigh
->type
;
2235 ndm
->ndm_ifindex
= neigh
->dev
->ifindex
;
2237 if (nla_put(skb
, NDA_DST
, neigh
->tbl
->key_len
, neigh
->primary_key
))
2238 goto nla_put_failure
;
2240 read_lock_bh(&neigh
->lock
);
2241 ndm
->ndm_state
= neigh
->nud_state
;
2242 if (neigh
->nud_state
& NUD_VALID
) {
2243 char haddr
[MAX_ADDR_LEN
];
2245 neigh_ha_snapshot(haddr
, neigh
, neigh
->dev
);
2246 if (nla_put(skb
, NDA_LLADDR
, neigh
->dev
->addr_len
, haddr
) < 0) {
2247 read_unlock_bh(&neigh
->lock
);
2248 goto nla_put_failure
;
2252 ci
.ndm_used
= jiffies_to_clock_t(now
- neigh
->used
);
2253 ci
.ndm_confirmed
= jiffies_to_clock_t(now
- neigh
->confirmed
);
2254 ci
.ndm_updated
= jiffies_to_clock_t(now
- neigh
->updated
);
2255 ci
.ndm_refcnt
= refcount_read(&neigh
->refcnt
) - 1;
2256 read_unlock_bh(&neigh
->lock
);
2258 if (nla_put_u32(skb
, NDA_PROBES
, atomic_read(&neigh
->probes
)) ||
2259 nla_put(skb
, NDA_CACHEINFO
, sizeof(ci
), &ci
))
2260 goto nla_put_failure
;
2262 nlmsg_end(skb
, nlh
);
2266 nlmsg_cancel(skb
, nlh
);
2270 static int pneigh_fill_info(struct sk_buff
*skb
, struct pneigh_entry
*pn
,
2271 u32 pid
, u32 seq
, int type
, unsigned int flags
,
2272 struct neigh_table
*tbl
)
2274 struct nlmsghdr
*nlh
;
2277 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2281 ndm
= nlmsg_data(nlh
);
2282 ndm
->ndm_family
= tbl
->family
;
2285 ndm
->ndm_flags
= pn
->flags
| NTF_PROXY
;
2286 ndm
->ndm_type
= RTN_UNICAST
;
2287 ndm
->ndm_ifindex
= pn
->dev
? pn
->dev
->ifindex
: 0;
2288 ndm
->ndm_state
= NUD_NONE
;
2290 if (nla_put(skb
, NDA_DST
, tbl
->key_len
, pn
->key
))
2291 goto nla_put_failure
;
2293 nlmsg_end(skb
, nlh
);
2297 nlmsg_cancel(skb
, nlh
);
2301 static void neigh_update_notify(struct neighbour
*neigh
, u32 nlmsg_pid
)
2303 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
2304 __neigh_notify(neigh
, RTM_NEWNEIGH
, 0, nlmsg_pid
);
2307 static bool neigh_master_filtered(struct net_device
*dev
, int master_idx
)
2309 struct net_device
*master
;
2314 master
= netdev_master_upper_dev_get(dev
);
2315 if (!master
|| master
->ifindex
!= master_idx
)
2321 static bool neigh_ifindex_filtered(struct net_device
*dev
, int filter_idx
)
2323 if (filter_idx
&& dev
->ifindex
!= filter_idx
)
2329 static int neigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2330 struct netlink_callback
*cb
)
2332 struct net
*net
= sock_net(skb
->sk
);
2333 const struct nlmsghdr
*nlh
= cb
->nlh
;
2334 struct nlattr
*tb
[NDA_MAX
+ 1];
2335 struct neighbour
*n
;
2336 int rc
, h
, s_h
= cb
->args
[1];
2337 int idx
, s_idx
= idx
= cb
->args
[2];
2338 struct neigh_hash_table
*nht
;
2339 int filter_master_idx
= 0, filter_idx
= 0;
2340 unsigned int flags
= NLM_F_MULTI
;
2343 err
= nlmsg_parse(nlh
, sizeof(struct ndmsg
), tb
, NDA_MAX
, NULL
, NULL
);
2345 if (tb
[NDA_IFINDEX
]) {
2346 if (nla_len(tb
[NDA_IFINDEX
]) != sizeof(u32
))
2348 filter_idx
= nla_get_u32(tb
[NDA_IFINDEX
]);
2350 if (tb
[NDA_MASTER
]) {
2351 if (nla_len(tb
[NDA_MASTER
]) != sizeof(u32
))
2353 filter_master_idx
= nla_get_u32(tb
[NDA_MASTER
]);
2355 if (filter_idx
|| filter_master_idx
)
2356 flags
|= NLM_F_DUMP_FILTERED
;
2360 nht
= rcu_dereference_bh(tbl
->nht
);
2362 for (h
= s_h
; h
< (1 << nht
->hash_shift
); h
++) {
2365 for (n
= rcu_dereference_bh(nht
->hash_buckets
[h
]), idx
= 0;
2367 n
= rcu_dereference_bh(n
->next
)) {
2368 if (idx
< s_idx
|| !net_eq(dev_net(n
->dev
), net
))
2370 if (neigh_ifindex_filtered(n
->dev
, filter_idx
) ||
2371 neigh_master_filtered(n
->dev
, filter_master_idx
))
2373 if (neigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).portid
,
2386 rcu_read_unlock_bh();
2392 static int pneigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2393 struct netlink_callback
*cb
)
2395 struct pneigh_entry
*n
;
2396 struct net
*net
= sock_net(skb
->sk
);
2397 int rc
, h
, s_h
= cb
->args
[3];
2398 int idx
, s_idx
= idx
= cb
->args
[4];
2400 read_lock_bh(&tbl
->lock
);
2402 for (h
= s_h
; h
<= PNEIGH_HASHMASK
; h
++) {
2405 for (n
= tbl
->phash_buckets
[h
], idx
= 0; n
; n
= n
->next
) {
2406 if (idx
< s_idx
|| pneigh_net(n
) != net
)
2408 if (pneigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).portid
,
2411 NLM_F_MULTI
, tbl
) < 0) {
2412 read_unlock_bh(&tbl
->lock
);
2421 read_unlock_bh(&tbl
->lock
);
2430 static int neigh_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2432 struct neigh_table
*tbl
;
2437 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2439 /* check for full ndmsg structure presence, family member is
2440 * the same for both structures
2442 if (nlmsg_len(cb
->nlh
) >= sizeof(struct ndmsg
) &&
2443 ((struct ndmsg
*) nlmsg_data(cb
->nlh
))->ndm_flags
== NTF_PROXY
)
2448 for (t
= 0; t
< NEIGH_NR_TABLES
; t
++) {
2449 tbl
= neigh_tables
[t
];
2453 if (t
< s_t
|| (family
&& tbl
->family
!= family
))
2456 memset(&cb
->args
[1], 0, sizeof(cb
->args
) -
2457 sizeof(cb
->args
[0]));
2459 err
= pneigh_dump_table(tbl
, skb
, cb
);
2461 err
= neigh_dump_table(tbl
, skb
, cb
);
2470 void neigh_for_each(struct neigh_table
*tbl
, void (*cb
)(struct neighbour
*, void *), void *cookie
)
2473 struct neigh_hash_table
*nht
;
2476 nht
= rcu_dereference_bh(tbl
->nht
);
2478 read_lock(&tbl
->lock
); /* avoid resizes */
2479 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2480 struct neighbour
*n
;
2482 for (n
= rcu_dereference_bh(nht
->hash_buckets
[chain
]);
2484 n
= rcu_dereference_bh(n
->next
))
2487 read_unlock(&tbl
->lock
);
2488 rcu_read_unlock_bh();
2490 EXPORT_SYMBOL(neigh_for_each
);
2492 /* The tbl->lock must be held as a writer and BH disabled. */
2493 void __neigh_for_each_release(struct neigh_table
*tbl
,
2494 int (*cb
)(struct neighbour
*))
2497 struct neigh_hash_table
*nht
;
2499 nht
= rcu_dereference_protected(tbl
->nht
,
2500 lockdep_is_held(&tbl
->lock
));
2501 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2502 struct neighbour
*n
;
2503 struct neighbour __rcu
**np
;
2505 np
= &nht
->hash_buckets
[chain
];
2506 while ((n
= rcu_dereference_protected(*np
,
2507 lockdep_is_held(&tbl
->lock
))) != NULL
) {
2510 write_lock(&n
->lock
);
2513 rcu_assign_pointer(*np
,
2514 rcu_dereference_protected(n
->next
,
2515 lockdep_is_held(&tbl
->lock
)));
2519 write_unlock(&n
->lock
);
2521 neigh_cleanup_and_release(n
);
2525 EXPORT_SYMBOL(__neigh_for_each_release
);
2527 int neigh_xmit(int index
, struct net_device
*dev
,
2528 const void *addr
, struct sk_buff
*skb
)
2530 int err
= -EAFNOSUPPORT
;
2531 if (likely(index
< NEIGH_NR_TABLES
)) {
2532 struct neigh_table
*tbl
;
2533 struct neighbour
*neigh
;
2535 tbl
= neigh_tables
[index
];
2539 if (index
== NEIGH_ARP_TABLE
) {
2540 u32 key
= *((u32
*)addr
);
2542 neigh
= __ipv4_neigh_lookup_noref(dev
, key
);
2544 neigh
= __neigh_lookup_noref(tbl
, addr
, dev
);
2547 neigh
= __neigh_create(tbl
, addr
, dev
, false);
2548 err
= PTR_ERR(neigh
);
2549 if (IS_ERR(neigh
)) {
2550 rcu_read_unlock_bh();
2553 err
= neigh
->output(neigh
, skb
);
2554 rcu_read_unlock_bh();
2556 else if (index
== NEIGH_LINK_TABLE
) {
2557 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
2558 addr
, NULL
, skb
->len
);
2561 err
= dev_queue_xmit(skb
);
2569 EXPORT_SYMBOL(neigh_xmit
);
2571 #ifdef CONFIG_PROC_FS
2573 static struct neighbour
*neigh_get_first(struct seq_file
*seq
)
2575 struct neigh_seq_state
*state
= seq
->private;
2576 struct net
*net
= seq_file_net(seq
);
2577 struct neigh_hash_table
*nht
= state
->nht
;
2578 struct neighbour
*n
= NULL
;
2579 int bucket
= state
->bucket
;
2581 state
->flags
&= ~NEIGH_SEQ_IS_PNEIGH
;
2582 for (bucket
= 0; bucket
< (1 << nht
->hash_shift
); bucket
++) {
2583 n
= rcu_dereference_bh(nht
->hash_buckets
[bucket
]);
2586 if (!net_eq(dev_net(n
->dev
), net
))
2588 if (state
->neigh_sub_iter
) {
2592 v
= state
->neigh_sub_iter(state
, n
, &fakep
);
2596 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2598 if (n
->nud_state
& ~NUD_NOARP
)
2601 n
= rcu_dereference_bh(n
->next
);
2607 state
->bucket
= bucket
;
2612 static struct neighbour
*neigh_get_next(struct seq_file
*seq
,
2613 struct neighbour
*n
,
2616 struct neigh_seq_state
*state
= seq
->private;
2617 struct net
*net
= seq_file_net(seq
);
2618 struct neigh_hash_table
*nht
= state
->nht
;
2620 if (state
->neigh_sub_iter
) {
2621 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2625 n
= rcu_dereference_bh(n
->next
);
2629 if (!net_eq(dev_net(n
->dev
), net
))
2631 if (state
->neigh_sub_iter
) {
2632 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2637 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2640 if (n
->nud_state
& ~NUD_NOARP
)
2643 n
= rcu_dereference_bh(n
->next
);
2649 if (++state
->bucket
>= (1 << nht
->hash_shift
))
2652 n
= rcu_dereference_bh(nht
->hash_buckets
[state
->bucket
]);
2660 static struct neighbour
*neigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2662 struct neighbour
*n
= neigh_get_first(seq
);
2667 n
= neigh_get_next(seq
, n
, pos
);
2672 return *pos
? NULL
: n
;
2675 static struct pneigh_entry
*pneigh_get_first(struct seq_file
*seq
)
2677 struct neigh_seq_state
*state
= seq
->private;
2678 struct net
*net
= seq_file_net(seq
);
2679 struct neigh_table
*tbl
= state
->tbl
;
2680 struct pneigh_entry
*pn
= NULL
;
2681 int bucket
= state
->bucket
;
2683 state
->flags
|= NEIGH_SEQ_IS_PNEIGH
;
2684 for (bucket
= 0; bucket
<= PNEIGH_HASHMASK
; bucket
++) {
2685 pn
= tbl
->phash_buckets
[bucket
];
2686 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2691 state
->bucket
= bucket
;
2696 static struct pneigh_entry
*pneigh_get_next(struct seq_file
*seq
,
2697 struct pneigh_entry
*pn
,
2700 struct neigh_seq_state
*state
= seq
->private;
2701 struct net
*net
= seq_file_net(seq
);
2702 struct neigh_table
*tbl
= state
->tbl
;
2706 } while (pn
&& !net_eq(pneigh_net(pn
), net
));
2709 if (++state
->bucket
> PNEIGH_HASHMASK
)
2711 pn
= tbl
->phash_buckets
[state
->bucket
];
2712 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2724 static struct pneigh_entry
*pneigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2726 struct pneigh_entry
*pn
= pneigh_get_first(seq
);
2731 pn
= pneigh_get_next(seq
, pn
, pos
);
2736 return *pos
? NULL
: pn
;
2739 static void *neigh_get_idx_any(struct seq_file
*seq
, loff_t
*pos
)
2741 struct neigh_seq_state
*state
= seq
->private;
2743 loff_t idxpos
= *pos
;
2745 rc
= neigh_get_idx(seq
, &idxpos
);
2746 if (!rc
&& !(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2747 rc
= pneigh_get_idx(seq
, &idxpos
);
2752 void *neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
, struct neigh_table
*tbl
, unsigned int neigh_seq_flags
)
2753 __acquires(tbl
->lock
)
2756 struct neigh_seq_state
*state
= seq
->private;
2760 state
->flags
= (neigh_seq_flags
& ~NEIGH_SEQ_IS_PNEIGH
);
2763 state
->nht
= rcu_dereference_bh(tbl
->nht
);
2764 read_lock(&tbl
->lock
);
2766 return *pos
? neigh_get_idx_any(seq
, pos
) : SEQ_START_TOKEN
;
2768 EXPORT_SYMBOL(neigh_seq_start
);
2770 void *neigh_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2772 struct neigh_seq_state
*state
;
2775 if (v
== SEQ_START_TOKEN
) {
2776 rc
= neigh_get_first(seq
);
2780 state
= seq
->private;
2781 if (!(state
->flags
& NEIGH_SEQ_IS_PNEIGH
)) {
2782 rc
= neigh_get_next(seq
, v
, NULL
);
2785 if (!(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2786 rc
= pneigh_get_first(seq
);
2788 BUG_ON(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
);
2789 rc
= pneigh_get_next(seq
, v
, NULL
);
2795 EXPORT_SYMBOL(neigh_seq_next
);
2797 void neigh_seq_stop(struct seq_file
*seq
, void *v
)
2798 __releases(tbl
->lock
)
2801 struct neigh_seq_state
*state
= seq
->private;
2802 struct neigh_table
*tbl
= state
->tbl
;
2804 read_unlock(&tbl
->lock
);
2805 rcu_read_unlock_bh();
2807 EXPORT_SYMBOL(neigh_seq_stop
);
2809 /* statistics via seq_file */
2811 static void *neigh_stat_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2813 struct neigh_table
*tbl
= seq
->private;
2817 return SEQ_START_TOKEN
;
2819 for (cpu
= *pos
-1; cpu
< nr_cpu_ids
; ++cpu
) {
2820 if (!cpu_possible(cpu
))
2823 return per_cpu_ptr(tbl
->stats
, cpu
);
2828 static void *neigh_stat_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2830 struct neigh_table
*tbl
= seq
->private;
2833 for (cpu
= *pos
; cpu
< nr_cpu_ids
; ++cpu
) {
2834 if (!cpu_possible(cpu
))
2837 return per_cpu_ptr(tbl
->stats
, cpu
);
2842 static void neigh_stat_seq_stop(struct seq_file
*seq
, void *v
)
2847 static int neigh_stat_seq_show(struct seq_file
*seq
, void *v
)
2849 struct neigh_table
*tbl
= seq
->private;
2850 struct neigh_statistics
*st
= v
;
2852 if (v
== SEQ_START_TOKEN
) {
2853 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");
2857 seq_printf(seq
, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2858 "%08lx %08lx %08lx %08lx %08lx %08lx\n",
2859 atomic_read(&tbl
->entries
),
2870 st
->rcv_probes_mcast
,
2871 st
->rcv_probes_ucast
,
2873 st
->periodic_gc_runs
,
2882 static const struct seq_operations neigh_stat_seq_ops
= {
2883 .start
= neigh_stat_seq_start
,
2884 .next
= neigh_stat_seq_next
,
2885 .stop
= neigh_stat_seq_stop
,
2886 .show
= neigh_stat_seq_show
,
2889 static int neigh_stat_seq_open(struct inode
*inode
, struct file
*file
)
2891 int ret
= seq_open(file
, &neigh_stat_seq_ops
);
2894 struct seq_file
*sf
= file
->private_data
;
2895 sf
->private = PDE_DATA(inode
);
2900 static const struct file_operations neigh_stat_seq_fops
= {
2901 .owner
= THIS_MODULE
,
2902 .open
= neigh_stat_seq_open
,
2904 .llseek
= seq_lseek
,
2905 .release
= seq_release
,
2908 #endif /* CONFIG_PROC_FS */
2910 static inline size_t neigh_nlmsg_size(void)
2912 return NLMSG_ALIGN(sizeof(struct ndmsg
))
2913 + nla_total_size(MAX_ADDR_LEN
) /* NDA_DST */
2914 + nla_total_size(MAX_ADDR_LEN
) /* NDA_LLADDR */
2915 + nla_total_size(sizeof(struct nda_cacheinfo
))
2916 + nla_total_size(4); /* NDA_PROBES */
2919 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
,
2922 struct net
*net
= dev_net(n
->dev
);
2923 struct sk_buff
*skb
;
2926 skb
= nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC
);
2930 err
= neigh_fill_info(skb
, n
, pid
, 0, type
, flags
);
2932 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2933 WARN_ON(err
== -EMSGSIZE
);
2937 rtnl_notify(skb
, net
, 0, RTNLGRP_NEIGH
, NULL
, GFP_ATOMIC
);
2941 rtnl_set_sk_err(net
, RTNLGRP_NEIGH
, err
);
2944 void neigh_app_ns(struct neighbour
*n
)
2946 __neigh_notify(n
, RTM_GETNEIGH
, NLM_F_REQUEST
, 0);
2948 EXPORT_SYMBOL(neigh_app_ns
);
2950 #ifdef CONFIG_SYSCTL
2952 static int int_max
= INT_MAX
;
2953 static int unres_qlen_max
= INT_MAX
/ SKB_TRUESIZE(ETH_FRAME_LEN
);
2955 static int proc_unres_qlen(struct ctl_table
*ctl
, int write
,
2956 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2959 struct ctl_table tmp
= *ctl
;
2962 tmp
.extra2
= &unres_qlen_max
;
2965 size
= *(int *)ctl
->data
/ SKB_TRUESIZE(ETH_FRAME_LEN
);
2966 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
2969 *(int *)ctl
->data
= size
* SKB_TRUESIZE(ETH_FRAME_LEN
);
2973 static struct neigh_parms
*neigh_get_dev_parms_rcu(struct net_device
*dev
,
2978 return __in_dev_arp_parms_get_rcu(dev
);
2980 return __in6_dev_nd_parms_get_rcu(dev
);
2985 static void neigh_copy_dflt_parms(struct net
*net
, struct neigh_parms
*p
,
2988 struct net_device
*dev
;
2989 int family
= neigh_parms_family(p
);
2992 for_each_netdev_rcu(net
, dev
) {
2993 struct neigh_parms
*dst_p
=
2994 neigh_get_dev_parms_rcu(dev
, family
);
2996 if (dst_p
&& !test_bit(index
, dst_p
->data_state
))
2997 dst_p
->data
[index
] = p
->data
[index
];
3002 static void neigh_proc_update(struct ctl_table
*ctl
, int write
)
3004 struct net_device
*dev
= ctl
->extra1
;
3005 struct neigh_parms
*p
= ctl
->extra2
;
3006 struct net
*net
= neigh_parms_net(p
);
3007 int index
= (int *) ctl
->data
- p
->data
;
3012 set_bit(index
, p
->data_state
);
3013 if (index
== NEIGH_VAR_DELAY_PROBE_TIME
)
3014 call_netevent_notifiers(NETEVENT_DELAY_PROBE_TIME_UPDATE
, p
);
3015 if (!dev
) /* NULL dev means this is default value */
3016 neigh_copy_dflt_parms(net
, p
, index
);
3019 static int neigh_proc_dointvec_zero_intmax(struct ctl_table
*ctl
, int write
,
3020 void __user
*buffer
,
3021 size_t *lenp
, loff_t
*ppos
)
3023 struct ctl_table tmp
= *ctl
;
3027 tmp
.extra2
= &int_max
;
3029 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
3030 neigh_proc_update(ctl
, write
);
3034 int neigh_proc_dointvec(struct ctl_table
*ctl
, int write
,
3035 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
3037 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
3039 neigh_proc_update(ctl
, write
);
3042 EXPORT_SYMBOL(neigh_proc_dointvec
);
3044 int neigh_proc_dointvec_jiffies(struct ctl_table
*ctl
, int write
,
3045 void __user
*buffer
,
3046 size_t *lenp
, loff_t
*ppos
)
3048 int ret
= proc_dointvec_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
3050 neigh_proc_update(ctl
, write
);
3053 EXPORT_SYMBOL(neigh_proc_dointvec_jiffies
);
3055 static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table
*ctl
, int write
,
3056 void __user
*buffer
,
3057 size_t *lenp
, loff_t
*ppos
)
3059 int ret
= proc_dointvec_userhz_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
3061 neigh_proc_update(ctl
, write
);
3065 int neigh_proc_dointvec_ms_jiffies(struct ctl_table
*ctl
, int write
,
3066 void __user
*buffer
,
3067 size_t *lenp
, loff_t
*ppos
)
3069 int ret
= proc_dointvec_ms_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
3071 neigh_proc_update(ctl
, write
);
3074 EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies
);
3076 static int neigh_proc_dointvec_unres_qlen(struct ctl_table
*ctl
, int write
,
3077 void __user
*buffer
,
3078 size_t *lenp
, loff_t
*ppos
)
3080 int ret
= proc_unres_qlen(ctl
, write
, buffer
, lenp
, ppos
);
3082 neigh_proc_update(ctl
, write
);
3086 static int neigh_proc_base_reachable_time(struct ctl_table
*ctl
, int write
,
3087 void __user
*buffer
,
3088 size_t *lenp
, loff_t
*ppos
)
3090 struct neigh_parms
*p
= ctl
->extra2
;
3093 if (strcmp(ctl
->procname
, "base_reachable_time") == 0)
3094 ret
= neigh_proc_dointvec_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
3095 else if (strcmp(ctl
->procname
, "base_reachable_time_ms") == 0)
3096 ret
= neigh_proc_dointvec_ms_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
3100 if (write
&& ret
== 0) {
3101 /* update reachable_time as well, otherwise, the change will
3102 * only be effective after the next time neigh_periodic_work
3103 * decides to recompute it
3106 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
3111 #define NEIGH_PARMS_DATA_OFFSET(index) \
3112 (&((struct neigh_parms *) 0)->data[index])
3114 #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \
3115 [NEIGH_VAR_ ## attr] = { \
3117 .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \
3118 .maxlen = sizeof(int), \
3120 .proc_handler = proc, \
3123 #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \
3124 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax)
3126 #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \
3127 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies)
3129 #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \
3130 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies)
3132 #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \
3133 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
3135 #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \
3136 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
3138 #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \
3139 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen)
3141 static struct neigh_sysctl_table
{
3142 struct ctl_table_header
*sysctl_header
;
3143 struct ctl_table neigh_vars
[NEIGH_VAR_MAX
+ 1];
3144 } neigh_sysctl_template __read_mostly
= {
3146 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES
, "mcast_solicit"),
3147 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES
, "ucast_solicit"),
3148 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES
, "app_solicit"),
3149 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_REPROBES
, "mcast_resolicit"),
3150 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME
, "retrans_time"),
3151 NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME
, "base_reachable_time"),
3152 NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME
, "delay_first_probe_time"),
3153 NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME
, "gc_stale_time"),
3154 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES
, "unres_qlen_bytes"),
3155 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN
, "proxy_qlen"),
3156 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY
, "anycast_delay"),
3157 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY
, "proxy_delay"),
3158 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME
, "locktime"),
3159 NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN
, QUEUE_LEN_BYTES
, "unres_qlen"),
3160 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS
, RETRANS_TIME
, "retrans_time_ms"),
3161 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS
, BASE_REACHABLE_TIME
, "base_reachable_time_ms"),
3162 [NEIGH_VAR_GC_INTERVAL
] = {
3163 .procname
= "gc_interval",
3164 .maxlen
= sizeof(int),
3166 .proc_handler
= proc_dointvec_jiffies
,
3168 [NEIGH_VAR_GC_THRESH1
] = {
3169 .procname
= "gc_thresh1",
3170 .maxlen
= sizeof(int),
3174 .proc_handler
= proc_dointvec_minmax
,
3176 [NEIGH_VAR_GC_THRESH2
] = {
3177 .procname
= "gc_thresh2",
3178 .maxlen
= sizeof(int),
3182 .proc_handler
= proc_dointvec_minmax
,
3184 [NEIGH_VAR_GC_THRESH3
] = {
3185 .procname
= "gc_thresh3",
3186 .maxlen
= sizeof(int),
3190 .proc_handler
= proc_dointvec_minmax
,
3196 int neigh_sysctl_register(struct net_device
*dev
, struct neigh_parms
*p
,
3197 proc_handler
*handler
)
3200 struct neigh_sysctl_table
*t
;
3201 const char *dev_name_source
;
3202 char neigh_path
[ sizeof("net//neigh/") + IFNAMSIZ
+ IFNAMSIZ
];
3205 t
= kmemdup(&neigh_sysctl_template
, sizeof(*t
), GFP_KERNEL
);
3209 for (i
= 0; i
< NEIGH_VAR_GC_INTERVAL
; i
++) {
3210 t
->neigh_vars
[i
].data
+= (long) p
;
3211 t
->neigh_vars
[i
].extra1
= dev
;
3212 t
->neigh_vars
[i
].extra2
= p
;
3216 dev_name_source
= dev
->name
;
3217 /* Terminate the table early */
3218 memset(&t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
], 0,
3219 sizeof(t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
]));
3221 struct neigh_table
*tbl
= p
->tbl
;
3222 dev_name_source
= "default";
3223 t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
].data
= &tbl
->gc_interval
;
3224 t
->neigh_vars
[NEIGH_VAR_GC_THRESH1
].data
= &tbl
->gc_thresh1
;
3225 t
->neigh_vars
[NEIGH_VAR_GC_THRESH2
].data
= &tbl
->gc_thresh2
;
3226 t
->neigh_vars
[NEIGH_VAR_GC_THRESH3
].data
= &tbl
->gc_thresh3
;
3231 t
->neigh_vars
[NEIGH_VAR_RETRANS_TIME
].proc_handler
= handler
;
3233 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME
].proc_handler
= handler
;
3234 /* RetransTime (in milliseconds)*/
3235 t
->neigh_vars
[NEIGH_VAR_RETRANS_TIME_MS
].proc_handler
= handler
;
3236 /* ReachableTime (in milliseconds) */
3237 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME_MS
].proc_handler
= handler
;
3239 /* Those handlers will update p->reachable_time after
3240 * base_reachable_time(_ms) is set to ensure the new timer starts being
3241 * applied after the next neighbour update instead of waiting for
3242 * neigh_periodic_work to update its value (can be multiple minutes)
3243 * So any handler that replaces them should do this as well
3246 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME
].proc_handler
=
3247 neigh_proc_base_reachable_time
;
3248 /* ReachableTime (in milliseconds) */
3249 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME_MS
].proc_handler
=
3250 neigh_proc_base_reachable_time
;
3253 /* Don't export sysctls to unprivileged users */
3254 if (neigh_parms_net(p
)->user_ns
!= &init_user_ns
)
3255 t
->neigh_vars
[0].procname
= NULL
;
3257 switch (neigh_parms_family(p
)) {
3268 snprintf(neigh_path
, sizeof(neigh_path
), "net/%s/neigh/%s",
3269 p_name
, dev_name_source
);
3271 register_net_sysctl(neigh_parms_net(p
), neigh_path
, t
->neigh_vars
);
3272 if (!t
->sysctl_header
)
3275 p
->sysctl_table
= t
;
3283 EXPORT_SYMBOL(neigh_sysctl_register
);
3285 void neigh_sysctl_unregister(struct neigh_parms
*p
)
3287 if (p
->sysctl_table
) {
3288 struct neigh_sysctl_table
*t
= p
->sysctl_table
;
3289 p
->sysctl_table
= NULL
;
3290 unregister_net_sysctl_table(t
->sysctl_header
);
3294 EXPORT_SYMBOL(neigh_sysctl_unregister
);
3296 #endif /* CONFIG_SYSCTL */
3298 static int __init
neigh_init(void)
3300 rtnl_register(PF_UNSPEC
, RTM_NEWNEIGH
, neigh_add
, NULL
, 0);
3301 rtnl_register(PF_UNSPEC
, RTM_DELNEIGH
, neigh_delete
, NULL
, 0);
3302 rtnl_register(PF_UNSPEC
, RTM_GETNEIGH
, NULL
, neigh_dump_info
, 0);
3304 rtnl_register(PF_UNSPEC
, RTM_GETNEIGHTBL
, NULL
, neightbl_dump_info
,
3306 rtnl_register(PF_UNSPEC
, RTM_SETNEIGHTBL
, neightbl_set
, NULL
, 0);
3311 subsys_initcall(neigh_init
);