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
)
1287 struct dst_entry
*dst
= skb_dst(skb
);
1293 if (!neigh_event_send(neigh
, skb
)) {
1295 struct net_device
*dev
= neigh
->dev
;
1298 if (dev
->header_ops
->cache
&& !neigh
->hh
.hh_len
)
1299 neigh_hh_init(neigh
);
1302 __skb_pull(skb
, skb_network_offset(skb
));
1303 seq
= read_seqbegin(&neigh
->ha_lock
);
1304 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1305 neigh
->ha
, NULL
, skb
->len
);
1306 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1309 rc
= dev_queue_xmit(skb
);
1316 neigh_dbg(1, "%s: dst=%p neigh=%p\n", __func__
, dst
, neigh
);
1322 EXPORT_SYMBOL(neigh_resolve_output
);
1324 /* As fast as possible without hh cache */
1326 int neigh_connected_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1328 struct net_device
*dev
= neigh
->dev
;
1333 __skb_pull(skb
, skb_network_offset(skb
));
1334 seq
= read_seqbegin(&neigh
->ha_lock
);
1335 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1336 neigh
->ha
, NULL
, skb
->len
);
1337 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1340 err
= dev_queue_xmit(skb
);
1347 EXPORT_SYMBOL(neigh_connected_output
);
1349 int neigh_direct_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1351 return dev_queue_xmit(skb
);
1353 EXPORT_SYMBOL(neigh_direct_output
);
1355 static void neigh_proxy_process(unsigned long arg
)
1357 struct neigh_table
*tbl
= (struct neigh_table
*)arg
;
1358 long sched_next
= 0;
1359 unsigned long now
= jiffies
;
1360 struct sk_buff
*skb
, *n
;
1362 spin_lock(&tbl
->proxy_queue
.lock
);
1364 skb_queue_walk_safe(&tbl
->proxy_queue
, skb
, n
) {
1365 long tdif
= NEIGH_CB(skb
)->sched_next
- now
;
1368 struct net_device
*dev
= skb
->dev
;
1370 __skb_unlink(skb
, &tbl
->proxy_queue
);
1371 if (tbl
->proxy_redo
&& netif_running(dev
)) {
1373 tbl
->proxy_redo(skb
);
1380 } else if (!sched_next
|| tdif
< sched_next
)
1383 del_timer(&tbl
->proxy_timer
);
1385 mod_timer(&tbl
->proxy_timer
, jiffies
+ sched_next
);
1386 spin_unlock(&tbl
->proxy_queue
.lock
);
1389 void pneigh_enqueue(struct neigh_table
*tbl
, struct neigh_parms
*p
,
1390 struct sk_buff
*skb
)
1392 unsigned long now
= jiffies
;
1394 unsigned long sched_next
= now
+ (prandom_u32() %
1395 NEIGH_VAR(p
, PROXY_DELAY
));
1397 if (tbl
->proxy_queue
.qlen
> NEIGH_VAR(p
, PROXY_QLEN
)) {
1402 NEIGH_CB(skb
)->sched_next
= sched_next
;
1403 NEIGH_CB(skb
)->flags
|= LOCALLY_ENQUEUED
;
1405 spin_lock(&tbl
->proxy_queue
.lock
);
1406 if (del_timer(&tbl
->proxy_timer
)) {
1407 if (time_before(tbl
->proxy_timer
.expires
, sched_next
))
1408 sched_next
= tbl
->proxy_timer
.expires
;
1412 __skb_queue_tail(&tbl
->proxy_queue
, skb
);
1413 mod_timer(&tbl
->proxy_timer
, sched_next
);
1414 spin_unlock(&tbl
->proxy_queue
.lock
);
1416 EXPORT_SYMBOL(pneigh_enqueue
);
1418 static inline struct neigh_parms
*lookup_neigh_parms(struct neigh_table
*tbl
,
1419 struct net
*net
, int ifindex
)
1421 struct neigh_parms
*p
;
1423 list_for_each_entry(p
, &tbl
->parms_list
, list
) {
1424 if ((p
->dev
&& p
->dev
->ifindex
== ifindex
&& net_eq(neigh_parms_net(p
), net
)) ||
1425 (!p
->dev
&& !ifindex
&& net_eq(net
, &init_net
)))
1432 struct neigh_parms
*neigh_parms_alloc(struct net_device
*dev
,
1433 struct neigh_table
*tbl
)
1435 struct neigh_parms
*p
;
1436 struct net
*net
= dev_net(dev
);
1437 const struct net_device_ops
*ops
= dev
->netdev_ops
;
1439 p
= kmemdup(&tbl
->parms
, sizeof(*p
), GFP_KERNEL
);
1442 atomic_set(&p
->refcnt
, 1);
1444 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
1447 write_pnet(&p
->net
, hold_net(net
));
1448 p
->sysctl_table
= NULL
;
1450 if (ops
->ndo_neigh_setup
&& ops
->ndo_neigh_setup(dev
, p
)) {
1457 write_lock_bh(&tbl
->lock
);
1458 list_add(&p
->list
, &tbl
->parms
.list
);
1459 write_unlock_bh(&tbl
->lock
);
1461 neigh_parms_data_state_cleanall(p
);
1465 EXPORT_SYMBOL(neigh_parms_alloc
);
1467 static void neigh_rcu_free_parms(struct rcu_head
*head
)
1469 struct neigh_parms
*parms
=
1470 container_of(head
, struct neigh_parms
, rcu_head
);
1472 neigh_parms_put(parms
);
1475 void neigh_parms_release(struct neigh_table
*tbl
, struct neigh_parms
*parms
)
1477 if (!parms
|| parms
== &tbl
->parms
)
1479 write_lock_bh(&tbl
->lock
);
1480 list_del(&parms
->list
);
1482 write_unlock_bh(&tbl
->lock
);
1484 dev_put(parms
->dev
);
1485 call_rcu(&parms
->rcu_head
, neigh_rcu_free_parms
);
1487 EXPORT_SYMBOL(neigh_parms_release
);
1489 static void neigh_parms_destroy(struct neigh_parms
*parms
)
1491 release_net(neigh_parms_net(parms
));
1495 static struct lock_class_key neigh_table_proxy_queue_class
;
1497 static struct neigh_table
*neigh_tables
[NEIGH_NR_TABLES
] __read_mostly
;
1499 void neigh_table_init(int index
, struct neigh_table
*tbl
)
1501 unsigned long now
= jiffies
;
1502 unsigned long phsize
;
1504 INIT_LIST_HEAD(&tbl
->parms_list
);
1505 list_add(&tbl
->parms
.list
, &tbl
->parms_list
);
1506 write_pnet(&tbl
->parms
.net
, &init_net
);
1507 atomic_set(&tbl
->parms
.refcnt
, 1);
1508 tbl
->parms
.reachable_time
=
1509 neigh_rand_reach_time(NEIGH_VAR(&tbl
->parms
, BASE_REACHABLE_TIME
));
1511 tbl
->stats
= alloc_percpu(struct neigh_statistics
);
1513 panic("cannot create neighbour cache statistics");
1515 #ifdef CONFIG_PROC_FS
1516 if (!proc_create_data(tbl
->id
, 0, init_net
.proc_net_stat
,
1517 &neigh_stat_seq_fops
, tbl
))
1518 panic("cannot create neighbour proc dir entry");
1521 RCU_INIT_POINTER(tbl
->nht
, neigh_hash_alloc(3));
1523 phsize
= (PNEIGH_HASHMASK
+ 1) * sizeof(struct pneigh_entry
*);
1524 tbl
->phash_buckets
= kzalloc(phsize
, GFP_KERNEL
);
1526 if (!tbl
->nht
|| !tbl
->phash_buckets
)
1527 panic("cannot allocate neighbour cache hashes");
1529 if (!tbl
->entry_size
)
1530 tbl
->entry_size
= ALIGN(offsetof(struct neighbour
, primary_key
) +
1531 tbl
->key_len
, NEIGH_PRIV_ALIGN
);
1533 WARN_ON(tbl
->entry_size
% NEIGH_PRIV_ALIGN
);
1535 rwlock_init(&tbl
->lock
);
1536 INIT_DEFERRABLE_WORK(&tbl
->gc_work
, neigh_periodic_work
);
1537 queue_delayed_work(system_power_efficient_wq
, &tbl
->gc_work
,
1538 tbl
->parms
.reachable_time
);
1539 setup_timer(&tbl
->proxy_timer
, neigh_proxy_process
, (unsigned long)tbl
);
1540 skb_queue_head_init_class(&tbl
->proxy_queue
,
1541 &neigh_table_proxy_queue_class
);
1543 tbl
->last_flush
= now
;
1544 tbl
->last_rand
= now
+ tbl
->parms
.reachable_time
* 20;
1546 neigh_tables
[index
] = tbl
;
1548 EXPORT_SYMBOL(neigh_table_init
);
1550 int neigh_table_clear(int index
, struct neigh_table
*tbl
)
1552 neigh_tables
[index
] = NULL
;
1553 /* It is not clean... Fix it to unload IPv6 module safely */
1554 cancel_delayed_work_sync(&tbl
->gc_work
);
1555 del_timer_sync(&tbl
->proxy_timer
);
1556 pneigh_queue_purge(&tbl
->proxy_queue
);
1557 neigh_ifdown(tbl
, NULL
);
1558 if (atomic_read(&tbl
->entries
))
1559 pr_crit("neighbour leakage\n");
1561 call_rcu(&rcu_dereference_protected(tbl
->nht
, 1)->rcu
,
1562 neigh_hash_free_rcu
);
1565 kfree(tbl
->phash_buckets
);
1566 tbl
->phash_buckets
= NULL
;
1568 remove_proc_entry(tbl
->id
, init_net
.proc_net_stat
);
1570 free_percpu(tbl
->stats
);
1575 EXPORT_SYMBOL(neigh_table_clear
);
1577 static struct neigh_table
*neigh_find_table(int family
)
1579 struct neigh_table
*tbl
= NULL
;
1583 tbl
= neigh_tables
[NEIGH_ARP_TABLE
];
1586 tbl
= neigh_tables
[NEIGH_ND_TABLE
];
1589 tbl
= neigh_tables
[NEIGH_DN_TABLE
];
1596 static int neigh_delete(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1598 struct net
*net
= sock_net(skb
->sk
);
1600 struct nlattr
*dst_attr
;
1601 struct neigh_table
*tbl
;
1602 struct neighbour
*neigh
;
1603 struct net_device
*dev
= NULL
;
1607 if (nlmsg_len(nlh
) < sizeof(*ndm
))
1610 dst_attr
= nlmsg_find_attr(nlh
, sizeof(*ndm
), NDA_DST
);
1611 if (dst_attr
== NULL
)
1614 ndm
= nlmsg_data(nlh
);
1615 if (ndm
->ndm_ifindex
) {
1616 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1623 tbl
= neigh_find_table(ndm
->ndm_family
);
1625 return -EAFNOSUPPORT
;
1627 if (nla_len(dst_attr
) < tbl
->key_len
)
1630 if (ndm
->ndm_flags
& NTF_PROXY
) {
1631 err
= pneigh_delete(tbl
, net
, nla_data(dst_attr
), dev
);
1638 neigh
= neigh_lookup(tbl
, nla_data(dst_attr
), dev
);
1639 if (neigh
== NULL
) {
1644 err
= neigh_update(neigh
, NULL
, NUD_FAILED
,
1645 NEIGH_UPDATE_F_OVERRIDE
|
1646 NEIGH_UPDATE_F_ADMIN
);
1647 neigh_release(neigh
);
1653 static int neigh_add(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1655 int flags
= NEIGH_UPDATE_F_ADMIN
| NEIGH_UPDATE_F_OVERRIDE
;
1656 struct net
*net
= sock_net(skb
->sk
);
1658 struct nlattr
*tb
[NDA_MAX
+1];
1659 struct neigh_table
*tbl
;
1660 struct net_device
*dev
= NULL
;
1661 struct neighbour
*neigh
;
1666 err
= nlmsg_parse(nlh
, sizeof(*ndm
), tb
, NDA_MAX
, NULL
);
1671 if (tb
[NDA_DST
] == NULL
)
1674 ndm
= nlmsg_data(nlh
);
1675 if (ndm
->ndm_ifindex
) {
1676 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1682 if (tb
[NDA_LLADDR
] && nla_len(tb
[NDA_LLADDR
]) < dev
->addr_len
)
1686 tbl
= neigh_find_table(ndm
->ndm_family
);
1688 return -EAFNOSUPPORT
;
1690 if (nla_len(tb
[NDA_DST
]) < tbl
->key_len
)
1692 dst
= nla_data(tb
[NDA_DST
]);
1693 lladdr
= tb
[NDA_LLADDR
] ? nla_data(tb
[NDA_LLADDR
]) : NULL
;
1695 if (ndm
->ndm_flags
& NTF_PROXY
) {
1696 struct pneigh_entry
*pn
;
1699 pn
= pneigh_lookup(tbl
, net
, dst
, dev
, 1);
1701 pn
->flags
= ndm
->ndm_flags
;
1710 neigh
= neigh_lookup(tbl
, dst
, dev
);
1711 if (neigh
== NULL
) {
1712 if (!(nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
1717 neigh
= __neigh_lookup_errno(tbl
, dst
, dev
);
1718 if (IS_ERR(neigh
)) {
1719 err
= PTR_ERR(neigh
);
1723 if (nlh
->nlmsg_flags
& NLM_F_EXCL
) {
1725 neigh_release(neigh
);
1729 if (!(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
1730 flags
&= ~NEIGH_UPDATE_F_OVERRIDE
;
1733 if (ndm
->ndm_flags
& NTF_USE
) {
1734 neigh_event_send(neigh
, NULL
);
1737 err
= neigh_update(neigh
, lladdr
, ndm
->ndm_state
, flags
);
1738 neigh_release(neigh
);
1744 static int neightbl_fill_parms(struct sk_buff
*skb
, struct neigh_parms
*parms
)
1746 struct nlattr
*nest
;
1748 nest
= nla_nest_start(skb
, NDTA_PARMS
);
1753 nla_put_u32(skb
, NDTPA_IFINDEX
, parms
->dev
->ifindex
)) ||
1754 nla_put_u32(skb
, NDTPA_REFCNT
, atomic_read(&parms
->refcnt
)) ||
1755 nla_put_u32(skb
, NDTPA_QUEUE_LENBYTES
,
1756 NEIGH_VAR(parms
, QUEUE_LEN_BYTES
)) ||
1757 /* approximative value for deprecated QUEUE_LEN (in packets) */
1758 nla_put_u32(skb
, NDTPA_QUEUE_LEN
,
1759 NEIGH_VAR(parms
, QUEUE_LEN_BYTES
) / SKB_TRUESIZE(ETH_FRAME_LEN
)) ||
1760 nla_put_u32(skb
, NDTPA_PROXY_QLEN
, NEIGH_VAR(parms
, PROXY_QLEN
)) ||
1761 nla_put_u32(skb
, NDTPA_APP_PROBES
, NEIGH_VAR(parms
, APP_PROBES
)) ||
1762 nla_put_u32(skb
, NDTPA_UCAST_PROBES
,
1763 NEIGH_VAR(parms
, UCAST_PROBES
)) ||
1764 nla_put_u32(skb
, NDTPA_MCAST_PROBES
,
1765 NEIGH_VAR(parms
, MCAST_PROBES
)) ||
1766 nla_put_msecs(skb
, NDTPA_REACHABLE_TIME
, parms
->reachable_time
) ||
1767 nla_put_msecs(skb
, NDTPA_BASE_REACHABLE_TIME
,
1768 NEIGH_VAR(parms
, BASE_REACHABLE_TIME
)) ||
1769 nla_put_msecs(skb
, NDTPA_GC_STALETIME
,
1770 NEIGH_VAR(parms
, GC_STALETIME
)) ||
1771 nla_put_msecs(skb
, NDTPA_DELAY_PROBE_TIME
,
1772 NEIGH_VAR(parms
, DELAY_PROBE_TIME
)) ||
1773 nla_put_msecs(skb
, NDTPA_RETRANS_TIME
,
1774 NEIGH_VAR(parms
, RETRANS_TIME
)) ||
1775 nla_put_msecs(skb
, NDTPA_ANYCAST_DELAY
,
1776 NEIGH_VAR(parms
, ANYCAST_DELAY
)) ||
1777 nla_put_msecs(skb
, NDTPA_PROXY_DELAY
,
1778 NEIGH_VAR(parms
, PROXY_DELAY
)) ||
1779 nla_put_msecs(skb
, NDTPA_LOCKTIME
,
1780 NEIGH_VAR(parms
, LOCKTIME
)))
1781 goto nla_put_failure
;
1782 return nla_nest_end(skb
, nest
);
1785 nla_nest_cancel(skb
, nest
);
1789 static int neightbl_fill_info(struct sk_buff
*skb
, struct neigh_table
*tbl
,
1790 u32 pid
, u32 seq
, int type
, int flags
)
1792 struct nlmsghdr
*nlh
;
1793 struct ndtmsg
*ndtmsg
;
1795 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1799 ndtmsg
= nlmsg_data(nlh
);
1801 read_lock_bh(&tbl
->lock
);
1802 ndtmsg
->ndtm_family
= tbl
->family
;
1803 ndtmsg
->ndtm_pad1
= 0;
1804 ndtmsg
->ndtm_pad2
= 0;
1806 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) ||
1807 nla_put_msecs(skb
, NDTA_GC_INTERVAL
, tbl
->gc_interval
) ||
1808 nla_put_u32(skb
, NDTA_THRESH1
, tbl
->gc_thresh1
) ||
1809 nla_put_u32(skb
, NDTA_THRESH2
, tbl
->gc_thresh2
) ||
1810 nla_put_u32(skb
, NDTA_THRESH3
, tbl
->gc_thresh3
))
1811 goto nla_put_failure
;
1813 unsigned long now
= jiffies
;
1814 unsigned int flush_delta
= now
- tbl
->last_flush
;
1815 unsigned int rand_delta
= now
- tbl
->last_rand
;
1816 struct neigh_hash_table
*nht
;
1817 struct ndt_config ndc
= {
1818 .ndtc_key_len
= tbl
->key_len
,
1819 .ndtc_entry_size
= tbl
->entry_size
,
1820 .ndtc_entries
= atomic_read(&tbl
->entries
),
1821 .ndtc_last_flush
= jiffies_to_msecs(flush_delta
),
1822 .ndtc_last_rand
= jiffies_to_msecs(rand_delta
),
1823 .ndtc_proxy_qlen
= tbl
->proxy_queue
.qlen
,
1827 nht
= rcu_dereference_bh(tbl
->nht
);
1828 ndc
.ndtc_hash_rnd
= nht
->hash_rnd
[0];
1829 ndc
.ndtc_hash_mask
= ((1 << nht
->hash_shift
) - 1);
1830 rcu_read_unlock_bh();
1832 if (nla_put(skb
, NDTA_CONFIG
, sizeof(ndc
), &ndc
))
1833 goto nla_put_failure
;
1838 struct ndt_stats ndst
;
1840 memset(&ndst
, 0, sizeof(ndst
));
1842 for_each_possible_cpu(cpu
) {
1843 struct neigh_statistics
*st
;
1845 st
= per_cpu_ptr(tbl
->stats
, cpu
);
1846 ndst
.ndts_allocs
+= st
->allocs
;
1847 ndst
.ndts_destroys
+= st
->destroys
;
1848 ndst
.ndts_hash_grows
+= st
->hash_grows
;
1849 ndst
.ndts_res_failed
+= st
->res_failed
;
1850 ndst
.ndts_lookups
+= st
->lookups
;
1851 ndst
.ndts_hits
+= st
->hits
;
1852 ndst
.ndts_rcv_probes_mcast
+= st
->rcv_probes_mcast
;
1853 ndst
.ndts_rcv_probes_ucast
+= st
->rcv_probes_ucast
;
1854 ndst
.ndts_periodic_gc_runs
+= st
->periodic_gc_runs
;
1855 ndst
.ndts_forced_gc_runs
+= st
->forced_gc_runs
;
1858 if (nla_put(skb
, NDTA_STATS
, sizeof(ndst
), &ndst
))
1859 goto nla_put_failure
;
1862 BUG_ON(tbl
->parms
.dev
);
1863 if (neightbl_fill_parms(skb
, &tbl
->parms
) < 0)
1864 goto nla_put_failure
;
1866 read_unlock_bh(&tbl
->lock
);
1867 nlmsg_end(skb
, nlh
);
1871 read_unlock_bh(&tbl
->lock
);
1872 nlmsg_cancel(skb
, nlh
);
1876 static int neightbl_fill_param_info(struct sk_buff
*skb
,
1877 struct neigh_table
*tbl
,
1878 struct neigh_parms
*parms
,
1879 u32 pid
, u32 seq
, int type
,
1882 struct ndtmsg
*ndtmsg
;
1883 struct nlmsghdr
*nlh
;
1885 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1889 ndtmsg
= nlmsg_data(nlh
);
1891 read_lock_bh(&tbl
->lock
);
1892 ndtmsg
->ndtm_family
= tbl
->family
;
1893 ndtmsg
->ndtm_pad1
= 0;
1894 ndtmsg
->ndtm_pad2
= 0;
1896 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) < 0 ||
1897 neightbl_fill_parms(skb
, parms
) < 0)
1900 read_unlock_bh(&tbl
->lock
);
1901 nlmsg_end(skb
, nlh
);
1904 read_unlock_bh(&tbl
->lock
);
1905 nlmsg_cancel(skb
, nlh
);
1909 static const struct nla_policy nl_neightbl_policy
[NDTA_MAX
+1] = {
1910 [NDTA_NAME
] = { .type
= NLA_STRING
},
1911 [NDTA_THRESH1
] = { .type
= NLA_U32
},
1912 [NDTA_THRESH2
] = { .type
= NLA_U32
},
1913 [NDTA_THRESH3
] = { .type
= NLA_U32
},
1914 [NDTA_GC_INTERVAL
] = { .type
= NLA_U64
},
1915 [NDTA_PARMS
] = { .type
= NLA_NESTED
},
1918 static const struct nla_policy nl_ntbl_parm_policy
[NDTPA_MAX
+1] = {
1919 [NDTPA_IFINDEX
] = { .type
= NLA_U32
},
1920 [NDTPA_QUEUE_LEN
] = { .type
= NLA_U32
},
1921 [NDTPA_PROXY_QLEN
] = { .type
= NLA_U32
},
1922 [NDTPA_APP_PROBES
] = { .type
= NLA_U32
},
1923 [NDTPA_UCAST_PROBES
] = { .type
= NLA_U32
},
1924 [NDTPA_MCAST_PROBES
] = { .type
= NLA_U32
},
1925 [NDTPA_BASE_REACHABLE_TIME
] = { .type
= NLA_U64
},
1926 [NDTPA_GC_STALETIME
] = { .type
= NLA_U64
},
1927 [NDTPA_DELAY_PROBE_TIME
] = { .type
= NLA_U64
},
1928 [NDTPA_RETRANS_TIME
] = { .type
= NLA_U64
},
1929 [NDTPA_ANYCAST_DELAY
] = { .type
= NLA_U64
},
1930 [NDTPA_PROXY_DELAY
] = { .type
= NLA_U64
},
1931 [NDTPA_LOCKTIME
] = { .type
= NLA_U64
},
1934 static int neightbl_set(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1936 struct net
*net
= sock_net(skb
->sk
);
1937 struct neigh_table
*tbl
;
1938 struct ndtmsg
*ndtmsg
;
1939 struct nlattr
*tb
[NDTA_MAX
+1];
1943 err
= nlmsg_parse(nlh
, sizeof(*ndtmsg
), tb
, NDTA_MAX
,
1944 nl_neightbl_policy
);
1948 if (tb
[NDTA_NAME
] == NULL
) {
1953 ndtmsg
= nlmsg_data(nlh
);
1955 for (tidx
= 0; tidx
< NEIGH_NR_TABLES
; tidx
++) {
1956 tbl
= neigh_tables
[tidx
];
1959 if (ndtmsg
->ndtm_family
&& tbl
->family
!= ndtmsg
->ndtm_family
)
1961 if (nla_strcmp(tb
[NDTA_NAME
], tbl
->id
) == 0) {
1971 * We acquire tbl->lock to be nice to the periodic timers and
1972 * make sure they always see a consistent set of values.
1974 write_lock_bh(&tbl
->lock
);
1976 if (tb
[NDTA_PARMS
]) {
1977 struct nlattr
*tbp
[NDTPA_MAX
+1];
1978 struct neigh_parms
*p
;
1981 err
= nla_parse_nested(tbp
, NDTPA_MAX
, tb
[NDTA_PARMS
],
1982 nl_ntbl_parm_policy
);
1984 goto errout_tbl_lock
;
1986 if (tbp
[NDTPA_IFINDEX
])
1987 ifindex
= nla_get_u32(tbp
[NDTPA_IFINDEX
]);
1989 p
= lookup_neigh_parms(tbl
, net
, ifindex
);
1992 goto errout_tbl_lock
;
1995 for (i
= 1; i
<= NDTPA_MAX
; i
++) {
2000 case NDTPA_QUEUE_LEN
:
2001 NEIGH_VAR_SET(p
, QUEUE_LEN_BYTES
,
2002 nla_get_u32(tbp
[i
]) *
2003 SKB_TRUESIZE(ETH_FRAME_LEN
));
2005 case NDTPA_QUEUE_LENBYTES
:
2006 NEIGH_VAR_SET(p
, QUEUE_LEN_BYTES
,
2007 nla_get_u32(tbp
[i
]));
2009 case NDTPA_PROXY_QLEN
:
2010 NEIGH_VAR_SET(p
, PROXY_QLEN
,
2011 nla_get_u32(tbp
[i
]));
2013 case NDTPA_APP_PROBES
:
2014 NEIGH_VAR_SET(p
, APP_PROBES
,
2015 nla_get_u32(tbp
[i
]));
2017 case NDTPA_UCAST_PROBES
:
2018 NEIGH_VAR_SET(p
, UCAST_PROBES
,
2019 nla_get_u32(tbp
[i
]));
2021 case NDTPA_MCAST_PROBES
:
2022 NEIGH_VAR_SET(p
, MCAST_PROBES
,
2023 nla_get_u32(tbp
[i
]));
2025 case NDTPA_BASE_REACHABLE_TIME
:
2026 NEIGH_VAR_SET(p
, BASE_REACHABLE_TIME
,
2027 nla_get_msecs(tbp
[i
]));
2028 /* update reachable_time as well, otherwise, the change will
2029 * only be effective after the next time neigh_periodic_work
2030 * decides to recompute it (can be multiple minutes)
2033 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
2035 case NDTPA_GC_STALETIME
:
2036 NEIGH_VAR_SET(p
, GC_STALETIME
,
2037 nla_get_msecs(tbp
[i
]));
2039 case NDTPA_DELAY_PROBE_TIME
:
2040 NEIGH_VAR_SET(p
, DELAY_PROBE_TIME
,
2041 nla_get_msecs(tbp
[i
]));
2043 case NDTPA_RETRANS_TIME
:
2044 NEIGH_VAR_SET(p
, RETRANS_TIME
,
2045 nla_get_msecs(tbp
[i
]));
2047 case NDTPA_ANYCAST_DELAY
:
2048 NEIGH_VAR_SET(p
, ANYCAST_DELAY
,
2049 nla_get_msecs(tbp
[i
]));
2051 case NDTPA_PROXY_DELAY
:
2052 NEIGH_VAR_SET(p
, PROXY_DELAY
,
2053 nla_get_msecs(tbp
[i
]));
2055 case NDTPA_LOCKTIME
:
2056 NEIGH_VAR_SET(p
, LOCKTIME
,
2057 nla_get_msecs(tbp
[i
]));
2064 if ((tb
[NDTA_THRESH1
] || tb
[NDTA_THRESH2
] ||
2065 tb
[NDTA_THRESH3
] || tb
[NDTA_GC_INTERVAL
]) &&
2066 !net_eq(net
, &init_net
))
2067 goto errout_tbl_lock
;
2069 if (tb
[NDTA_THRESH1
])
2070 tbl
->gc_thresh1
= nla_get_u32(tb
[NDTA_THRESH1
]);
2072 if (tb
[NDTA_THRESH2
])
2073 tbl
->gc_thresh2
= nla_get_u32(tb
[NDTA_THRESH2
]);
2075 if (tb
[NDTA_THRESH3
])
2076 tbl
->gc_thresh3
= nla_get_u32(tb
[NDTA_THRESH3
]);
2078 if (tb
[NDTA_GC_INTERVAL
])
2079 tbl
->gc_interval
= nla_get_msecs(tb
[NDTA_GC_INTERVAL
]);
2084 write_unlock_bh(&tbl
->lock
);
2089 static int neightbl_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2091 struct net
*net
= sock_net(skb
->sk
);
2092 int family
, tidx
, nidx
= 0;
2093 int tbl_skip
= cb
->args
[0];
2094 int neigh_skip
= cb
->args
[1];
2095 struct neigh_table
*tbl
;
2097 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2099 for (tidx
= 0; tidx
< NEIGH_NR_TABLES
; tidx
++) {
2100 struct neigh_parms
*p
;
2102 tbl
= neigh_tables
[tidx
];
2106 if (tidx
< tbl_skip
|| (family
&& tbl
->family
!= family
))
2109 if (neightbl_fill_info(skb
, tbl
, NETLINK_CB(cb
->skb
).portid
,
2110 cb
->nlh
->nlmsg_seq
, RTM_NEWNEIGHTBL
,
2115 p
= list_next_entry(&tbl
->parms
, list
);
2116 list_for_each_entry_from(p
, &tbl
->parms_list
, list
) {
2117 if (!net_eq(neigh_parms_net(p
), net
))
2120 if (nidx
< neigh_skip
)
2123 if (neightbl_fill_param_info(skb
, tbl
, p
,
2124 NETLINK_CB(cb
->skb
).portid
,
2142 static int neigh_fill_info(struct sk_buff
*skb
, struct neighbour
*neigh
,
2143 u32 pid
, u32 seq
, int type
, unsigned int flags
)
2145 unsigned long now
= jiffies
;
2146 struct nda_cacheinfo ci
;
2147 struct nlmsghdr
*nlh
;
2150 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2154 ndm
= nlmsg_data(nlh
);
2155 ndm
->ndm_family
= neigh
->ops
->family
;
2158 ndm
->ndm_flags
= neigh
->flags
;
2159 ndm
->ndm_type
= neigh
->type
;
2160 ndm
->ndm_ifindex
= neigh
->dev
->ifindex
;
2162 if (nla_put(skb
, NDA_DST
, neigh
->tbl
->key_len
, neigh
->primary_key
))
2163 goto nla_put_failure
;
2165 read_lock_bh(&neigh
->lock
);
2166 ndm
->ndm_state
= neigh
->nud_state
;
2167 if (neigh
->nud_state
& NUD_VALID
) {
2168 char haddr
[MAX_ADDR_LEN
];
2170 neigh_ha_snapshot(haddr
, neigh
, neigh
->dev
);
2171 if (nla_put(skb
, NDA_LLADDR
, neigh
->dev
->addr_len
, haddr
) < 0) {
2172 read_unlock_bh(&neigh
->lock
);
2173 goto nla_put_failure
;
2177 ci
.ndm_used
= jiffies_to_clock_t(now
- neigh
->used
);
2178 ci
.ndm_confirmed
= jiffies_to_clock_t(now
- neigh
->confirmed
);
2179 ci
.ndm_updated
= jiffies_to_clock_t(now
- neigh
->updated
);
2180 ci
.ndm_refcnt
= atomic_read(&neigh
->refcnt
) - 1;
2181 read_unlock_bh(&neigh
->lock
);
2183 if (nla_put_u32(skb
, NDA_PROBES
, atomic_read(&neigh
->probes
)) ||
2184 nla_put(skb
, NDA_CACHEINFO
, sizeof(ci
), &ci
))
2185 goto nla_put_failure
;
2187 nlmsg_end(skb
, nlh
);
2191 nlmsg_cancel(skb
, nlh
);
2195 static int pneigh_fill_info(struct sk_buff
*skb
, struct pneigh_entry
*pn
,
2196 u32 pid
, u32 seq
, int type
, unsigned int flags
,
2197 struct neigh_table
*tbl
)
2199 struct nlmsghdr
*nlh
;
2202 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2206 ndm
= nlmsg_data(nlh
);
2207 ndm
->ndm_family
= tbl
->family
;
2210 ndm
->ndm_flags
= pn
->flags
| NTF_PROXY
;
2211 ndm
->ndm_type
= RTN_UNICAST
;
2212 ndm
->ndm_ifindex
= pn
->dev
->ifindex
;
2213 ndm
->ndm_state
= NUD_NONE
;
2215 if (nla_put(skb
, NDA_DST
, tbl
->key_len
, pn
->key
))
2216 goto nla_put_failure
;
2218 nlmsg_end(skb
, nlh
);
2222 nlmsg_cancel(skb
, nlh
);
2226 static void neigh_update_notify(struct neighbour
*neigh
)
2228 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
2229 __neigh_notify(neigh
, RTM_NEWNEIGH
, 0);
2232 static int neigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2233 struct netlink_callback
*cb
)
2235 struct net
*net
= sock_net(skb
->sk
);
2236 struct neighbour
*n
;
2237 int rc
, h
, s_h
= cb
->args
[1];
2238 int idx
, s_idx
= idx
= cb
->args
[2];
2239 struct neigh_hash_table
*nht
;
2242 nht
= rcu_dereference_bh(tbl
->nht
);
2244 for (h
= s_h
; h
< (1 << nht
->hash_shift
); h
++) {
2247 for (n
= rcu_dereference_bh(nht
->hash_buckets
[h
]), idx
= 0;
2249 n
= rcu_dereference_bh(n
->next
)) {
2250 if (!net_eq(dev_net(n
->dev
), net
))
2254 if (neigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).portid
,
2267 rcu_read_unlock_bh();
2273 static int pneigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2274 struct netlink_callback
*cb
)
2276 struct pneigh_entry
*n
;
2277 struct net
*net
= sock_net(skb
->sk
);
2278 int rc
, h
, s_h
= cb
->args
[3];
2279 int idx
, s_idx
= idx
= cb
->args
[4];
2281 read_lock_bh(&tbl
->lock
);
2283 for (h
= s_h
; h
<= PNEIGH_HASHMASK
; h
++) {
2286 for (n
= tbl
->phash_buckets
[h
], idx
= 0; n
; n
= n
->next
) {
2287 if (dev_net(n
->dev
) != net
)
2291 if (pneigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).portid
,
2294 NLM_F_MULTI
, tbl
) < 0) {
2295 read_unlock_bh(&tbl
->lock
);
2304 read_unlock_bh(&tbl
->lock
);
2313 static int neigh_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2315 struct neigh_table
*tbl
;
2320 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2322 /* check for full ndmsg structure presence, family member is
2323 * the same for both structures
2325 if (nlmsg_len(cb
->nlh
) >= sizeof(struct ndmsg
) &&
2326 ((struct ndmsg
*) nlmsg_data(cb
->nlh
))->ndm_flags
== NTF_PROXY
)
2331 for (t
= 0; t
< NEIGH_NR_TABLES
; t
++) {
2332 tbl
= neigh_tables
[t
];
2336 if (t
< s_t
|| (family
&& tbl
->family
!= family
))
2339 memset(&cb
->args
[1], 0, sizeof(cb
->args
) -
2340 sizeof(cb
->args
[0]));
2342 err
= pneigh_dump_table(tbl
, skb
, cb
);
2344 err
= neigh_dump_table(tbl
, skb
, cb
);
2353 void neigh_for_each(struct neigh_table
*tbl
, void (*cb
)(struct neighbour
*, void *), void *cookie
)
2356 struct neigh_hash_table
*nht
;
2359 nht
= rcu_dereference_bh(tbl
->nht
);
2361 read_lock(&tbl
->lock
); /* avoid resizes */
2362 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2363 struct neighbour
*n
;
2365 for (n
= rcu_dereference_bh(nht
->hash_buckets
[chain
]);
2367 n
= rcu_dereference_bh(n
->next
))
2370 read_unlock(&tbl
->lock
);
2371 rcu_read_unlock_bh();
2373 EXPORT_SYMBOL(neigh_for_each
);
2375 /* The tbl->lock must be held as a writer and BH disabled. */
2376 void __neigh_for_each_release(struct neigh_table
*tbl
,
2377 int (*cb
)(struct neighbour
*))
2380 struct neigh_hash_table
*nht
;
2382 nht
= rcu_dereference_protected(tbl
->nht
,
2383 lockdep_is_held(&tbl
->lock
));
2384 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2385 struct neighbour
*n
;
2386 struct neighbour __rcu
**np
;
2388 np
= &nht
->hash_buckets
[chain
];
2389 while ((n
= rcu_dereference_protected(*np
,
2390 lockdep_is_held(&tbl
->lock
))) != NULL
) {
2393 write_lock(&n
->lock
);
2396 rcu_assign_pointer(*np
,
2397 rcu_dereference_protected(n
->next
,
2398 lockdep_is_held(&tbl
->lock
)));
2402 write_unlock(&n
->lock
);
2404 neigh_cleanup_and_release(n
);
2408 EXPORT_SYMBOL(__neigh_for_each_release
);
2410 #ifdef CONFIG_PROC_FS
2412 static struct neighbour
*neigh_get_first(struct seq_file
*seq
)
2414 struct neigh_seq_state
*state
= seq
->private;
2415 struct net
*net
= seq_file_net(seq
);
2416 struct neigh_hash_table
*nht
= state
->nht
;
2417 struct neighbour
*n
= NULL
;
2418 int bucket
= state
->bucket
;
2420 state
->flags
&= ~NEIGH_SEQ_IS_PNEIGH
;
2421 for (bucket
= 0; bucket
< (1 << nht
->hash_shift
); bucket
++) {
2422 n
= rcu_dereference_bh(nht
->hash_buckets
[bucket
]);
2425 if (!net_eq(dev_net(n
->dev
), net
))
2427 if (state
->neigh_sub_iter
) {
2431 v
= state
->neigh_sub_iter(state
, n
, &fakep
);
2435 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2437 if (n
->nud_state
& ~NUD_NOARP
)
2440 n
= rcu_dereference_bh(n
->next
);
2446 state
->bucket
= bucket
;
2451 static struct neighbour
*neigh_get_next(struct seq_file
*seq
,
2452 struct neighbour
*n
,
2455 struct neigh_seq_state
*state
= seq
->private;
2456 struct net
*net
= seq_file_net(seq
);
2457 struct neigh_hash_table
*nht
= state
->nht
;
2459 if (state
->neigh_sub_iter
) {
2460 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2464 n
= rcu_dereference_bh(n
->next
);
2468 if (!net_eq(dev_net(n
->dev
), net
))
2470 if (state
->neigh_sub_iter
) {
2471 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2476 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2479 if (n
->nud_state
& ~NUD_NOARP
)
2482 n
= rcu_dereference_bh(n
->next
);
2488 if (++state
->bucket
>= (1 << nht
->hash_shift
))
2491 n
= rcu_dereference_bh(nht
->hash_buckets
[state
->bucket
]);
2499 static struct neighbour
*neigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2501 struct neighbour
*n
= neigh_get_first(seq
);
2506 n
= neigh_get_next(seq
, n
, pos
);
2511 return *pos
? NULL
: n
;
2514 static struct pneigh_entry
*pneigh_get_first(struct seq_file
*seq
)
2516 struct neigh_seq_state
*state
= seq
->private;
2517 struct net
*net
= seq_file_net(seq
);
2518 struct neigh_table
*tbl
= state
->tbl
;
2519 struct pneigh_entry
*pn
= NULL
;
2520 int bucket
= state
->bucket
;
2522 state
->flags
|= NEIGH_SEQ_IS_PNEIGH
;
2523 for (bucket
= 0; bucket
<= PNEIGH_HASHMASK
; bucket
++) {
2524 pn
= tbl
->phash_buckets
[bucket
];
2525 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2530 state
->bucket
= bucket
;
2535 static struct pneigh_entry
*pneigh_get_next(struct seq_file
*seq
,
2536 struct pneigh_entry
*pn
,
2539 struct neigh_seq_state
*state
= seq
->private;
2540 struct net
*net
= seq_file_net(seq
);
2541 struct neigh_table
*tbl
= state
->tbl
;
2545 } while (pn
&& !net_eq(pneigh_net(pn
), net
));
2548 if (++state
->bucket
> PNEIGH_HASHMASK
)
2550 pn
= tbl
->phash_buckets
[state
->bucket
];
2551 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2563 static struct pneigh_entry
*pneigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2565 struct pneigh_entry
*pn
= pneigh_get_first(seq
);
2570 pn
= pneigh_get_next(seq
, pn
, pos
);
2575 return *pos
? NULL
: pn
;
2578 static void *neigh_get_idx_any(struct seq_file
*seq
, loff_t
*pos
)
2580 struct neigh_seq_state
*state
= seq
->private;
2582 loff_t idxpos
= *pos
;
2584 rc
= neigh_get_idx(seq
, &idxpos
);
2585 if (!rc
&& !(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2586 rc
= pneigh_get_idx(seq
, &idxpos
);
2591 void *neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
, struct neigh_table
*tbl
, unsigned int neigh_seq_flags
)
2594 struct neigh_seq_state
*state
= seq
->private;
2598 state
->flags
= (neigh_seq_flags
& ~NEIGH_SEQ_IS_PNEIGH
);
2601 state
->nht
= rcu_dereference_bh(tbl
->nht
);
2603 return *pos
? neigh_get_idx_any(seq
, pos
) : SEQ_START_TOKEN
;
2605 EXPORT_SYMBOL(neigh_seq_start
);
2607 void *neigh_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2609 struct neigh_seq_state
*state
;
2612 if (v
== SEQ_START_TOKEN
) {
2613 rc
= neigh_get_first(seq
);
2617 state
= seq
->private;
2618 if (!(state
->flags
& NEIGH_SEQ_IS_PNEIGH
)) {
2619 rc
= neigh_get_next(seq
, v
, NULL
);
2622 if (!(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2623 rc
= pneigh_get_first(seq
);
2625 BUG_ON(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
);
2626 rc
= pneigh_get_next(seq
, v
, NULL
);
2632 EXPORT_SYMBOL(neigh_seq_next
);
2634 void neigh_seq_stop(struct seq_file
*seq
, void *v
)
2637 rcu_read_unlock_bh();
2639 EXPORT_SYMBOL(neigh_seq_stop
);
2641 /* statistics via seq_file */
2643 static void *neigh_stat_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2645 struct neigh_table
*tbl
= seq
->private;
2649 return SEQ_START_TOKEN
;
2651 for (cpu
= *pos
-1; cpu
< nr_cpu_ids
; ++cpu
) {
2652 if (!cpu_possible(cpu
))
2655 return per_cpu_ptr(tbl
->stats
, cpu
);
2660 static void *neigh_stat_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2662 struct neigh_table
*tbl
= seq
->private;
2665 for (cpu
= *pos
; cpu
< nr_cpu_ids
; ++cpu
) {
2666 if (!cpu_possible(cpu
))
2669 return per_cpu_ptr(tbl
->stats
, cpu
);
2674 static void neigh_stat_seq_stop(struct seq_file
*seq
, void *v
)
2679 static int neigh_stat_seq_show(struct seq_file
*seq
, void *v
)
2681 struct neigh_table
*tbl
= seq
->private;
2682 struct neigh_statistics
*st
= v
;
2684 if (v
== SEQ_START_TOKEN
) {
2685 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");
2689 seq_printf(seq
, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2690 "%08lx %08lx %08lx %08lx %08lx\n",
2691 atomic_read(&tbl
->entries
),
2702 st
->rcv_probes_mcast
,
2703 st
->rcv_probes_ucast
,
2705 st
->periodic_gc_runs
,
2713 static const struct seq_operations neigh_stat_seq_ops
= {
2714 .start
= neigh_stat_seq_start
,
2715 .next
= neigh_stat_seq_next
,
2716 .stop
= neigh_stat_seq_stop
,
2717 .show
= neigh_stat_seq_show
,
2720 static int neigh_stat_seq_open(struct inode
*inode
, struct file
*file
)
2722 int ret
= seq_open(file
, &neigh_stat_seq_ops
);
2725 struct seq_file
*sf
= file
->private_data
;
2726 sf
->private = PDE_DATA(inode
);
2731 static const struct file_operations neigh_stat_seq_fops
= {
2732 .owner
= THIS_MODULE
,
2733 .open
= neigh_stat_seq_open
,
2735 .llseek
= seq_lseek
,
2736 .release
= seq_release
,
2739 #endif /* CONFIG_PROC_FS */
2741 static inline size_t neigh_nlmsg_size(void)
2743 return NLMSG_ALIGN(sizeof(struct ndmsg
))
2744 + nla_total_size(MAX_ADDR_LEN
) /* NDA_DST */
2745 + nla_total_size(MAX_ADDR_LEN
) /* NDA_LLADDR */
2746 + nla_total_size(sizeof(struct nda_cacheinfo
))
2747 + nla_total_size(4); /* NDA_PROBES */
2750 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
)
2752 struct net
*net
= dev_net(n
->dev
);
2753 struct sk_buff
*skb
;
2756 skb
= nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC
);
2760 err
= neigh_fill_info(skb
, n
, 0, 0, type
, flags
);
2762 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2763 WARN_ON(err
== -EMSGSIZE
);
2767 rtnl_notify(skb
, net
, 0, RTNLGRP_NEIGH
, NULL
, GFP_ATOMIC
);
2771 rtnl_set_sk_err(net
, RTNLGRP_NEIGH
, err
);
2774 void neigh_app_ns(struct neighbour
*n
)
2776 __neigh_notify(n
, RTM_GETNEIGH
, NLM_F_REQUEST
);
2778 EXPORT_SYMBOL(neigh_app_ns
);
2780 #ifdef CONFIG_SYSCTL
2782 static int int_max
= INT_MAX
;
2783 static int unres_qlen_max
= INT_MAX
/ SKB_TRUESIZE(ETH_FRAME_LEN
);
2785 static int proc_unres_qlen(struct ctl_table
*ctl
, int write
,
2786 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2789 struct ctl_table tmp
= *ctl
;
2792 tmp
.extra2
= &unres_qlen_max
;
2795 size
= *(int *)ctl
->data
/ SKB_TRUESIZE(ETH_FRAME_LEN
);
2796 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
2799 *(int *)ctl
->data
= size
* SKB_TRUESIZE(ETH_FRAME_LEN
);
2803 static struct neigh_parms
*neigh_get_dev_parms_rcu(struct net_device
*dev
,
2808 return __in_dev_arp_parms_get_rcu(dev
);
2810 return __in6_dev_nd_parms_get_rcu(dev
);
2815 static void neigh_copy_dflt_parms(struct net
*net
, struct neigh_parms
*p
,
2818 struct net_device
*dev
;
2819 int family
= neigh_parms_family(p
);
2822 for_each_netdev_rcu(net
, dev
) {
2823 struct neigh_parms
*dst_p
=
2824 neigh_get_dev_parms_rcu(dev
, family
);
2826 if (dst_p
&& !test_bit(index
, dst_p
->data_state
))
2827 dst_p
->data
[index
] = p
->data
[index
];
2832 static void neigh_proc_update(struct ctl_table
*ctl
, int write
)
2834 struct net_device
*dev
= ctl
->extra1
;
2835 struct neigh_parms
*p
= ctl
->extra2
;
2836 struct net
*net
= neigh_parms_net(p
);
2837 int index
= (int *) ctl
->data
- p
->data
;
2842 set_bit(index
, p
->data_state
);
2843 if (!dev
) /* NULL dev means this is default value */
2844 neigh_copy_dflt_parms(net
, p
, index
);
2847 static int neigh_proc_dointvec_zero_intmax(struct ctl_table
*ctl
, int write
,
2848 void __user
*buffer
,
2849 size_t *lenp
, loff_t
*ppos
)
2851 struct ctl_table tmp
= *ctl
;
2855 tmp
.extra2
= &int_max
;
2857 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
2858 neigh_proc_update(ctl
, write
);
2862 int neigh_proc_dointvec(struct ctl_table
*ctl
, int write
,
2863 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2865 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2867 neigh_proc_update(ctl
, write
);
2870 EXPORT_SYMBOL(neigh_proc_dointvec
);
2872 int neigh_proc_dointvec_jiffies(struct ctl_table
*ctl
, int write
,
2873 void __user
*buffer
,
2874 size_t *lenp
, loff_t
*ppos
)
2876 int ret
= proc_dointvec_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2878 neigh_proc_update(ctl
, write
);
2881 EXPORT_SYMBOL(neigh_proc_dointvec_jiffies
);
2883 static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table
*ctl
, int write
,
2884 void __user
*buffer
,
2885 size_t *lenp
, loff_t
*ppos
)
2887 int ret
= proc_dointvec_userhz_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2889 neigh_proc_update(ctl
, write
);
2893 int neigh_proc_dointvec_ms_jiffies(struct ctl_table
*ctl
, int write
,
2894 void __user
*buffer
,
2895 size_t *lenp
, loff_t
*ppos
)
2897 int ret
= proc_dointvec_ms_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2899 neigh_proc_update(ctl
, write
);
2902 EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies
);
2904 static int neigh_proc_dointvec_unres_qlen(struct ctl_table
*ctl
, int write
,
2905 void __user
*buffer
,
2906 size_t *lenp
, loff_t
*ppos
)
2908 int ret
= proc_unres_qlen(ctl
, write
, buffer
, lenp
, ppos
);
2910 neigh_proc_update(ctl
, write
);
2914 static int neigh_proc_base_reachable_time(struct ctl_table
*ctl
, int write
,
2915 void __user
*buffer
,
2916 size_t *lenp
, loff_t
*ppos
)
2918 struct neigh_parms
*p
= ctl
->extra2
;
2921 if (strcmp(ctl
->procname
, "base_reachable_time") == 0)
2922 ret
= neigh_proc_dointvec_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2923 else if (strcmp(ctl
->procname
, "base_reachable_time_ms") == 0)
2924 ret
= neigh_proc_dointvec_ms_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2928 if (write
&& ret
== 0) {
2929 /* update reachable_time as well, otherwise, the change will
2930 * only be effective after the next time neigh_periodic_work
2931 * decides to recompute it
2934 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
2939 #define NEIGH_PARMS_DATA_OFFSET(index) \
2940 (&((struct neigh_parms *) 0)->data[index])
2942 #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \
2943 [NEIGH_VAR_ ## attr] = { \
2945 .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \
2946 .maxlen = sizeof(int), \
2948 .proc_handler = proc, \
2951 #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \
2952 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax)
2954 #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \
2955 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies)
2957 #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \
2958 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies)
2960 #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \
2961 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
2963 #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \
2964 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
2966 #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \
2967 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen)
2969 static struct neigh_sysctl_table
{
2970 struct ctl_table_header
*sysctl_header
;
2971 struct ctl_table neigh_vars
[NEIGH_VAR_MAX
+ 1];
2972 } neigh_sysctl_template __read_mostly
= {
2974 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES
, "mcast_solicit"),
2975 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES
, "ucast_solicit"),
2976 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES
, "app_solicit"),
2977 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME
, "retrans_time"),
2978 NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME
, "base_reachable_time"),
2979 NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME
, "delay_first_probe_time"),
2980 NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME
, "gc_stale_time"),
2981 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES
, "unres_qlen_bytes"),
2982 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN
, "proxy_qlen"),
2983 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY
, "anycast_delay"),
2984 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY
, "proxy_delay"),
2985 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME
, "locktime"),
2986 NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN
, QUEUE_LEN_BYTES
, "unres_qlen"),
2987 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS
, RETRANS_TIME
, "retrans_time_ms"),
2988 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS
, BASE_REACHABLE_TIME
, "base_reachable_time_ms"),
2989 [NEIGH_VAR_GC_INTERVAL
] = {
2990 .procname
= "gc_interval",
2991 .maxlen
= sizeof(int),
2993 .proc_handler
= proc_dointvec_jiffies
,
2995 [NEIGH_VAR_GC_THRESH1
] = {
2996 .procname
= "gc_thresh1",
2997 .maxlen
= sizeof(int),
3001 .proc_handler
= proc_dointvec_minmax
,
3003 [NEIGH_VAR_GC_THRESH2
] = {
3004 .procname
= "gc_thresh2",
3005 .maxlen
= sizeof(int),
3009 .proc_handler
= proc_dointvec_minmax
,
3011 [NEIGH_VAR_GC_THRESH3
] = {
3012 .procname
= "gc_thresh3",
3013 .maxlen
= sizeof(int),
3017 .proc_handler
= proc_dointvec_minmax
,
3023 int neigh_sysctl_register(struct net_device
*dev
, struct neigh_parms
*p
,
3024 proc_handler
*handler
)
3027 struct neigh_sysctl_table
*t
;
3028 const char *dev_name_source
;
3029 char neigh_path
[ sizeof("net//neigh/") + IFNAMSIZ
+ IFNAMSIZ
];
3032 t
= kmemdup(&neigh_sysctl_template
, sizeof(*t
), GFP_KERNEL
);
3036 for (i
= 0; i
< NEIGH_VAR_GC_INTERVAL
; i
++) {
3037 t
->neigh_vars
[i
].data
+= (long) p
;
3038 t
->neigh_vars
[i
].extra1
= dev
;
3039 t
->neigh_vars
[i
].extra2
= p
;
3043 dev_name_source
= dev
->name
;
3044 /* Terminate the table early */
3045 memset(&t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
], 0,
3046 sizeof(t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
]));
3048 struct neigh_table
*tbl
= p
->tbl
;
3049 dev_name_source
= "default";
3050 t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
].data
= &tbl
->gc_interval
;
3051 t
->neigh_vars
[NEIGH_VAR_GC_THRESH1
].data
= &tbl
->gc_thresh1
;
3052 t
->neigh_vars
[NEIGH_VAR_GC_THRESH2
].data
= &tbl
->gc_thresh2
;
3053 t
->neigh_vars
[NEIGH_VAR_GC_THRESH3
].data
= &tbl
->gc_thresh3
;
3058 t
->neigh_vars
[NEIGH_VAR_RETRANS_TIME
].proc_handler
= handler
;
3060 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME
].proc_handler
= handler
;
3061 /* RetransTime (in milliseconds)*/
3062 t
->neigh_vars
[NEIGH_VAR_RETRANS_TIME_MS
].proc_handler
= handler
;
3063 /* ReachableTime (in milliseconds) */
3064 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME_MS
].proc_handler
= handler
;
3066 /* Those handlers will update p->reachable_time after
3067 * base_reachable_time(_ms) is set to ensure the new timer starts being
3068 * applied after the next neighbour update instead of waiting for
3069 * neigh_periodic_work to update its value (can be multiple minutes)
3070 * So any handler that replaces them should do this as well
3073 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME
].proc_handler
=
3074 neigh_proc_base_reachable_time
;
3075 /* ReachableTime (in milliseconds) */
3076 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME_MS
].proc_handler
=
3077 neigh_proc_base_reachable_time
;
3080 /* Don't export sysctls to unprivileged users */
3081 if (neigh_parms_net(p
)->user_ns
!= &init_user_ns
)
3082 t
->neigh_vars
[0].procname
= NULL
;
3084 switch (neigh_parms_family(p
)) {
3095 snprintf(neigh_path
, sizeof(neigh_path
), "net/%s/neigh/%s",
3096 p_name
, dev_name_source
);
3098 register_net_sysctl(neigh_parms_net(p
), neigh_path
, t
->neigh_vars
);
3099 if (!t
->sysctl_header
)
3102 p
->sysctl_table
= t
;
3110 EXPORT_SYMBOL(neigh_sysctl_register
);
3112 void neigh_sysctl_unregister(struct neigh_parms
*p
)
3114 if (p
->sysctl_table
) {
3115 struct neigh_sysctl_table
*t
= p
->sysctl_table
;
3116 p
->sysctl_table
= NULL
;
3117 unregister_net_sysctl_table(t
->sysctl_header
);
3121 EXPORT_SYMBOL(neigh_sysctl_unregister
);
3123 #endif /* CONFIG_SYSCTL */
3125 static int __init
neigh_init(void)
3127 rtnl_register(PF_UNSPEC
, RTM_NEWNEIGH
, neigh_add
, NULL
, NULL
);
3128 rtnl_register(PF_UNSPEC
, RTM_DELNEIGH
, neigh_delete
, NULL
, NULL
);
3129 rtnl_register(PF_UNSPEC
, RTM_GETNEIGH
, NULL
, neigh_dump_info
, NULL
);
3131 rtnl_register(PF_UNSPEC
, RTM_GETNEIGHTBL
, NULL
, neightbl_dump_info
,
3133 rtnl_register(PF_UNSPEC
, RTM_SETNEIGHTBL
, neightbl_set
, NULL
, NULL
);
3138 subsys_initcall(neigh_init
);