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
) {
278 net_info_ratelimited("%s: neighbor table overflow!\n",
280 NEIGH_CACHE_STAT_INC(tbl
, table_fulls
);
285 n
= kzalloc(tbl
->entry_size
+ dev
->neigh_priv_len
, GFP_ATOMIC
);
289 __skb_queue_head_init(&n
->arp_queue
);
290 rwlock_init(&n
->lock
);
291 seqlock_init(&n
->ha_lock
);
292 n
->updated
= n
->used
= now
;
293 n
->nud_state
= NUD_NONE
;
294 n
->output
= neigh_blackhole
;
295 seqlock_init(&n
->hh
.hh_lock
);
296 n
->parms
= neigh_parms_clone(&tbl
->parms
);
297 setup_timer(&n
->timer
, neigh_timer_handler
, (unsigned long)n
);
299 NEIGH_CACHE_STAT_INC(tbl
, allocs
);
301 atomic_set(&n
->refcnt
, 1);
307 atomic_dec(&tbl
->entries
);
311 static void neigh_get_hash_rnd(u32
*x
)
313 get_random_bytes(x
, sizeof(*x
));
317 static struct neigh_hash_table
*neigh_hash_alloc(unsigned int shift
)
319 size_t size
= (1 << shift
) * sizeof(struct neighbour
*);
320 struct neigh_hash_table
*ret
;
321 struct neighbour __rcu
**buckets
;
324 ret
= kmalloc(sizeof(*ret
), GFP_ATOMIC
);
327 if (size
<= PAGE_SIZE
)
328 buckets
= kzalloc(size
, GFP_ATOMIC
);
330 buckets
= (struct neighbour __rcu
**)
331 __get_free_pages(GFP_ATOMIC
| __GFP_ZERO
,
337 ret
->hash_buckets
= buckets
;
338 ret
->hash_shift
= shift
;
339 for (i
= 0; i
< NEIGH_NUM_HASH_RND
; i
++)
340 neigh_get_hash_rnd(&ret
->hash_rnd
[i
]);
344 static void neigh_hash_free_rcu(struct rcu_head
*head
)
346 struct neigh_hash_table
*nht
= container_of(head
,
347 struct neigh_hash_table
,
349 size_t size
= (1 << nht
->hash_shift
) * sizeof(struct neighbour
*);
350 struct neighbour __rcu
**buckets
= nht
->hash_buckets
;
352 if (size
<= PAGE_SIZE
)
355 free_pages((unsigned long)buckets
, get_order(size
));
359 static struct neigh_hash_table
*neigh_hash_grow(struct neigh_table
*tbl
,
360 unsigned long new_shift
)
362 unsigned int i
, hash
;
363 struct neigh_hash_table
*new_nht
, *old_nht
;
365 NEIGH_CACHE_STAT_INC(tbl
, hash_grows
);
367 old_nht
= rcu_dereference_protected(tbl
->nht
,
368 lockdep_is_held(&tbl
->lock
));
369 new_nht
= neigh_hash_alloc(new_shift
);
373 for (i
= 0; i
< (1 << old_nht
->hash_shift
); i
++) {
374 struct neighbour
*n
, *next
;
376 for (n
= rcu_dereference_protected(old_nht
->hash_buckets
[i
],
377 lockdep_is_held(&tbl
->lock
));
380 hash
= tbl
->hash(n
->primary_key
, n
->dev
,
383 hash
>>= (32 - new_nht
->hash_shift
);
384 next
= rcu_dereference_protected(n
->next
,
385 lockdep_is_held(&tbl
->lock
));
387 rcu_assign_pointer(n
->next
,
388 rcu_dereference_protected(
389 new_nht
->hash_buckets
[hash
],
390 lockdep_is_held(&tbl
->lock
)));
391 rcu_assign_pointer(new_nht
->hash_buckets
[hash
], n
);
395 rcu_assign_pointer(tbl
->nht
, new_nht
);
396 call_rcu(&old_nht
->rcu
, neigh_hash_free_rcu
);
400 struct neighbour
*neigh_lookup(struct neigh_table
*tbl
, const void *pkey
,
401 struct net_device
*dev
)
405 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
408 n
= __neigh_lookup_noref(tbl
, pkey
, dev
);
410 if (!atomic_inc_not_zero(&n
->refcnt
))
412 NEIGH_CACHE_STAT_INC(tbl
, hits
);
415 rcu_read_unlock_bh();
418 EXPORT_SYMBOL(neigh_lookup
);
420 struct neighbour
*neigh_lookup_nodev(struct neigh_table
*tbl
, struct net
*net
,
424 int key_len
= tbl
->key_len
;
426 struct neigh_hash_table
*nht
;
428 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
431 nht
= rcu_dereference_bh(tbl
->nht
);
432 hash_val
= tbl
->hash(pkey
, NULL
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
434 for (n
= rcu_dereference_bh(nht
->hash_buckets
[hash_val
]);
436 n
= rcu_dereference_bh(n
->next
)) {
437 if (!memcmp(n
->primary_key
, pkey
, key_len
) &&
438 net_eq(dev_net(n
->dev
), net
)) {
439 if (!atomic_inc_not_zero(&n
->refcnt
))
441 NEIGH_CACHE_STAT_INC(tbl
, hits
);
446 rcu_read_unlock_bh();
449 EXPORT_SYMBOL(neigh_lookup_nodev
);
451 struct neighbour
*__neigh_create(struct neigh_table
*tbl
, const void *pkey
,
452 struct net_device
*dev
, bool want_ref
)
455 int key_len
= tbl
->key_len
;
457 struct neighbour
*n1
, *rc
, *n
= neigh_alloc(tbl
, dev
);
458 struct neigh_hash_table
*nht
;
461 rc
= ERR_PTR(-ENOBUFS
);
465 memcpy(n
->primary_key
, pkey
, key_len
);
469 /* Protocol specific setup. */
470 if (tbl
->constructor
&& (error
= tbl
->constructor(n
)) < 0) {
472 goto out_neigh_release
;
475 if (dev
->netdev_ops
->ndo_neigh_construct
) {
476 error
= dev
->netdev_ops
->ndo_neigh_construct(dev
, n
);
479 goto out_neigh_release
;
483 /* Device specific setup. */
484 if (n
->parms
->neigh_setup
&&
485 (error
= n
->parms
->neigh_setup(n
)) < 0) {
487 goto out_neigh_release
;
490 n
->confirmed
= jiffies
- (NEIGH_VAR(n
->parms
, BASE_REACHABLE_TIME
) << 1);
492 write_lock_bh(&tbl
->lock
);
493 nht
= rcu_dereference_protected(tbl
->nht
,
494 lockdep_is_held(&tbl
->lock
));
496 if (atomic_read(&tbl
->entries
) > (1 << nht
->hash_shift
))
497 nht
= neigh_hash_grow(tbl
, nht
->hash_shift
+ 1);
499 hash_val
= tbl
->hash(pkey
, dev
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
501 if (n
->parms
->dead
) {
502 rc
= ERR_PTR(-EINVAL
);
506 for (n1
= rcu_dereference_protected(nht
->hash_buckets
[hash_val
],
507 lockdep_is_held(&tbl
->lock
));
509 n1
= rcu_dereference_protected(n1
->next
,
510 lockdep_is_held(&tbl
->lock
))) {
511 if (dev
== n1
->dev
&& !memcmp(n1
->primary_key
, pkey
, key_len
)) {
522 rcu_assign_pointer(n
->next
,
523 rcu_dereference_protected(nht
->hash_buckets
[hash_val
],
524 lockdep_is_held(&tbl
->lock
)));
525 rcu_assign_pointer(nht
->hash_buckets
[hash_val
], n
);
526 write_unlock_bh(&tbl
->lock
);
527 neigh_dbg(2, "neigh %p is created\n", n
);
532 write_unlock_bh(&tbl
->lock
);
537 EXPORT_SYMBOL(__neigh_create
);
539 static u32
pneigh_hash(const void *pkey
, int key_len
)
541 u32 hash_val
= *(u32
*)(pkey
+ key_len
- 4);
542 hash_val
^= (hash_val
>> 16);
543 hash_val
^= hash_val
>> 8;
544 hash_val
^= hash_val
>> 4;
545 hash_val
&= PNEIGH_HASHMASK
;
549 static struct pneigh_entry
*__pneigh_lookup_1(struct pneigh_entry
*n
,
553 struct net_device
*dev
)
556 if (!memcmp(n
->key
, pkey
, key_len
) &&
557 net_eq(pneigh_net(n
), net
) &&
558 (n
->dev
== dev
|| !n
->dev
))
565 struct pneigh_entry
*__pneigh_lookup(struct neigh_table
*tbl
,
566 struct net
*net
, const void *pkey
, struct net_device
*dev
)
568 int key_len
= tbl
->key_len
;
569 u32 hash_val
= pneigh_hash(pkey
, key_len
);
571 return __pneigh_lookup_1(tbl
->phash_buckets
[hash_val
],
572 net
, pkey
, key_len
, dev
);
574 EXPORT_SYMBOL_GPL(__pneigh_lookup
);
576 struct pneigh_entry
* pneigh_lookup(struct neigh_table
*tbl
,
577 struct net
*net
, const void *pkey
,
578 struct net_device
*dev
, int creat
)
580 struct pneigh_entry
*n
;
581 int key_len
= tbl
->key_len
;
582 u32 hash_val
= pneigh_hash(pkey
, key_len
);
584 read_lock_bh(&tbl
->lock
);
585 n
= __pneigh_lookup_1(tbl
->phash_buckets
[hash_val
],
586 net
, pkey
, key_len
, dev
);
587 read_unlock_bh(&tbl
->lock
);
594 n
= kmalloc(sizeof(*n
) + key_len
, GFP_KERNEL
);
598 write_pnet(&n
->net
, net
);
599 memcpy(n
->key
, pkey
, key_len
);
604 if (tbl
->pconstructor
&& tbl
->pconstructor(n
)) {
612 write_lock_bh(&tbl
->lock
);
613 n
->next
= tbl
->phash_buckets
[hash_val
];
614 tbl
->phash_buckets
[hash_val
] = n
;
615 write_unlock_bh(&tbl
->lock
);
619 EXPORT_SYMBOL(pneigh_lookup
);
622 int pneigh_delete(struct neigh_table
*tbl
, struct net
*net
, const void *pkey
,
623 struct net_device
*dev
)
625 struct pneigh_entry
*n
, **np
;
626 int key_len
= tbl
->key_len
;
627 u32 hash_val
= pneigh_hash(pkey
, key_len
);
629 write_lock_bh(&tbl
->lock
);
630 for (np
= &tbl
->phash_buckets
[hash_val
]; (n
= *np
) != NULL
;
632 if (!memcmp(n
->key
, pkey
, key_len
) && n
->dev
== dev
&&
633 net_eq(pneigh_net(n
), net
)) {
635 write_unlock_bh(&tbl
->lock
);
636 if (tbl
->pdestructor
)
644 write_unlock_bh(&tbl
->lock
);
648 static int pneigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
)
650 struct pneigh_entry
*n
, **np
;
653 for (h
= 0; h
<= PNEIGH_HASHMASK
; h
++) {
654 np
= &tbl
->phash_buckets
[h
];
655 while ((n
= *np
) != NULL
) {
656 if (!dev
|| n
->dev
== dev
) {
658 if (tbl
->pdestructor
)
671 static void neigh_parms_destroy(struct neigh_parms
*parms
);
673 static inline void neigh_parms_put(struct neigh_parms
*parms
)
675 if (atomic_dec_and_test(&parms
->refcnt
))
676 neigh_parms_destroy(parms
);
680 * neighbour must already be out of the table;
683 void neigh_destroy(struct neighbour
*neigh
)
685 struct net_device
*dev
= neigh
->dev
;
687 NEIGH_CACHE_STAT_INC(neigh
->tbl
, destroys
);
690 pr_warn("Destroying alive neighbour %p\n", neigh
);
695 if (neigh_del_timer(neigh
))
696 pr_warn("Impossible event\n");
698 write_lock_bh(&neigh
->lock
);
699 __skb_queue_purge(&neigh
->arp_queue
);
700 write_unlock_bh(&neigh
->lock
);
701 neigh
->arp_queue_len_bytes
= 0;
703 if (dev
->netdev_ops
->ndo_neigh_destroy
)
704 dev
->netdev_ops
->ndo_neigh_destroy(dev
, neigh
);
707 neigh_parms_put(neigh
->parms
);
709 neigh_dbg(2, "neigh %p is destroyed\n", neigh
);
711 atomic_dec(&neigh
->tbl
->entries
);
712 kfree_rcu(neigh
, rcu
);
714 EXPORT_SYMBOL(neigh_destroy
);
716 /* Neighbour state is suspicious;
719 Called with write_locked neigh.
721 static void neigh_suspect(struct neighbour
*neigh
)
723 neigh_dbg(2, "neigh %p is suspected\n", neigh
);
725 neigh
->output
= neigh
->ops
->output
;
728 /* Neighbour state is OK;
731 Called with write_locked neigh.
733 static void neigh_connect(struct neighbour
*neigh
)
735 neigh_dbg(2, "neigh %p is connected\n", neigh
);
737 neigh
->output
= neigh
->ops
->connected_output
;
740 static void neigh_periodic_work(struct work_struct
*work
)
742 struct neigh_table
*tbl
= container_of(work
, struct neigh_table
, gc_work
.work
);
744 struct neighbour __rcu
**np
;
746 struct neigh_hash_table
*nht
;
748 NEIGH_CACHE_STAT_INC(tbl
, periodic_gc_runs
);
750 write_lock_bh(&tbl
->lock
);
751 nht
= rcu_dereference_protected(tbl
->nht
,
752 lockdep_is_held(&tbl
->lock
));
755 * periodically recompute ReachableTime from random function
758 if (time_after(jiffies
, tbl
->last_rand
+ 300 * HZ
)) {
759 struct neigh_parms
*p
;
760 tbl
->last_rand
= jiffies
;
761 list_for_each_entry(p
, &tbl
->parms_list
, list
)
763 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
766 if (atomic_read(&tbl
->entries
) < tbl
->gc_thresh1
)
769 for (i
= 0 ; i
< (1 << nht
->hash_shift
); i
++) {
770 np
= &nht
->hash_buckets
[i
];
772 while ((n
= rcu_dereference_protected(*np
,
773 lockdep_is_held(&tbl
->lock
))) != NULL
) {
776 write_lock(&n
->lock
);
778 state
= n
->nud_state
;
779 if (state
& (NUD_PERMANENT
| NUD_IN_TIMER
)) {
780 write_unlock(&n
->lock
);
784 if (time_before(n
->used
, n
->confirmed
))
785 n
->used
= n
->confirmed
;
787 if (atomic_read(&n
->refcnt
) == 1 &&
788 (state
== NUD_FAILED
||
789 time_after(jiffies
, n
->used
+ NEIGH_VAR(n
->parms
, GC_STALETIME
)))) {
792 write_unlock(&n
->lock
);
793 neigh_cleanup_and_release(n
);
796 write_unlock(&n
->lock
);
802 * It's fine to release lock here, even if hash table
803 * grows while we are preempted.
805 write_unlock_bh(&tbl
->lock
);
807 write_lock_bh(&tbl
->lock
);
808 nht
= rcu_dereference_protected(tbl
->nht
,
809 lockdep_is_held(&tbl
->lock
));
812 /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks.
813 * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2
814 * BASE_REACHABLE_TIME.
816 queue_delayed_work(system_power_efficient_wq
, &tbl
->gc_work
,
817 NEIGH_VAR(&tbl
->parms
, BASE_REACHABLE_TIME
) >> 1);
818 write_unlock_bh(&tbl
->lock
);
821 static __inline__
int neigh_max_probes(struct neighbour
*n
)
823 struct neigh_parms
*p
= n
->parms
;
824 return NEIGH_VAR(p
, UCAST_PROBES
) + NEIGH_VAR(p
, APP_PROBES
) +
825 (n
->nud_state
& NUD_PROBE
? NEIGH_VAR(p
, MCAST_REPROBES
) :
826 NEIGH_VAR(p
, MCAST_PROBES
));
829 static void neigh_invalidate(struct neighbour
*neigh
)
830 __releases(neigh
->lock
)
831 __acquires(neigh
->lock
)
835 NEIGH_CACHE_STAT_INC(neigh
->tbl
, res_failed
);
836 neigh_dbg(2, "neigh %p is failed\n", neigh
);
837 neigh
->updated
= jiffies
;
839 /* It is very thin place. report_unreachable is very complicated
840 routine. Particularly, it can hit the same neighbour entry!
842 So that, we try to be accurate and avoid dead loop. --ANK
844 while (neigh
->nud_state
== NUD_FAILED
&&
845 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
846 write_unlock(&neigh
->lock
);
847 neigh
->ops
->error_report(neigh
, skb
);
848 write_lock(&neigh
->lock
);
850 __skb_queue_purge(&neigh
->arp_queue
);
851 neigh
->arp_queue_len_bytes
= 0;
854 static void neigh_probe(struct neighbour
*neigh
)
855 __releases(neigh
->lock
)
857 struct sk_buff
*skb
= skb_peek_tail(&neigh
->arp_queue
);
858 /* keep skb alive even if arp_queue overflows */
860 skb
= skb_clone(skb
, GFP_ATOMIC
);
861 write_unlock(&neigh
->lock
);
862 neigh
->ops
->solicit(neigh
, skb
);
863 atomic_inc(&neigh
->probes
);
867 /* Called when a timer expires for a neighbour entry. */
869 static void neigh_timer_handler(unsigned long arg
)
871 unsigned long now
, next
;
872 struct neighbour
*neigh
= (struct neighbour
*)arg
;
876 write_lock(&neigh
->lock
);
878 state
= neigh
->nud_state
;
882 if (!(state
& NUD_IN_TIMER
))
885 if (state
& NUD_REACHABLE
) {
886 if (time_before_eq(now
,
887 neigh
->confirmed
+ neigh
->parms
->reachable_time
)) {
888 neigh_dbg(2, "neigh %p is still alive\n", neigh
);
889 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
890 } else if (time_before_eq(now
,
892 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
))) {
893 neigh_dbg(2, "neigh %p is delayed\n", neigh
);
894 neigh
->nud_state
= NUD_DELAY
;
895 neigh
->updated
= jiffies
;
896 neigh_suspect(neigh
);
897 next
= now
+ NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
);
899 neigh_dbg(2, "neigh %p is suspected\n", neigh
);
900 neigh
->nud_state
= NUD_STALE
;
901 neigh
->updated
= jiffies
;
902 neigh_suspect(neigh
);
905 } else if (state
& NUD_DELAY
) {
906 if (time_before_eq(now
,
908 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
))) {
909 neigh_dbg(2, "neigh %p is now reachable\n", neigh
);
910 neigh
->nud_state
= NUD_REACHABLE
;
911 neigh
->updated
= jiffies
;
912 neigh_connect(neigh
);
914 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
916 neigh_dbg(2, "neigh %p is probed\n", neigh
);
917 neigh
->nud_state
= NUD_PROBE
;
918 neigh
->updated
= jiffies
;
919 atomic_set(&neigh
->probes
, 0);
921 next
= now
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
);
924 /* NUD_PROBE|NUD_INCOMPLETE */
925 next
= now
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
);
928 if ((neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
929 atomic_read(&neigh
->probes
) >= neigh_max_probes(neigh
)) {
930 neigh
->nud_state
= NUD_FAILED
;
932 neigh_invalidate(neigh
);
936 if (neigh
->nud_state
& NUD_IN_TIMER
) {
937 if (time_before(next
, jiffies
+ HZ
/2))
938 next
= jiffies
+ HZ
/2;
939 if (!mod_timer(&neigh
->timer
, next
))
942 if (neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) {
946 write_unlock(&neigh
->lock
);
950 neigh_update_notify(neigh
);
952 neigh_release(neigh
);
955 int __neigh_event_send(struct neighbour
*neigh
, struct sk_buff
*skb
)
958 bool immediate_probe
= false;
960 write_lock_bh(&neigh
->lock
);
963 if (neigh
->nud_state
& (NUD_CONNECTED
| NUD_DELAY
| NUD_PROBE
))
968 if (!(neigh
->nud_state
& (NUD_STALE
| NUD_INCOMPLETE
))) {
969 if (NEIGH_VAR(neigh
->parms
, MCAST_PROBES
) +
970 NEIGH_VAR(neigh
->parms
, APP_PROBES
)) {
971 unsigned long next
, now
= jiffies
;
973 atomic_set(&neigh
->probes
,
974 NEIGH_VAR(neigh
->parms
, UCAST_PROBES
));
975 neigh
->nud_state
= NUD_INCOMPLETE
;
976 neigh
->updated
= now
;
977 next
= now
+ max(NEIGH_VAR(neigh
->parms
, RETRANS_TIME
),
979 neigh_add_timer(neigh
, next
);
980 immediate_probe
= true;
982 neigh
->nud_state
= NUD_FAILED
;
983 neigh
->updated
= jiffies
;
984 write_unlock_bh(&neigh
->lock
);
989 } else if (neigh
->nud_state
& NUD_STALE
) {
990 neigh_dbg(2, "neigh %p is delayed\n", neigh
);
991 neigh
->nud_state
= NUD_DELAY
;
992 neigh
->updated
= jiffies
;
993 neigh_add_timer(neigh
, jiffies
+
994 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
));
997 if (neigh
->nud_state
== NUD_INCOMPLETE
) {
999 while (neigh
->arp_queue_len_bytes
+ skb
->truesize
>
1000 NEIGH_VAR(neigh
->parms
, QUEUE_LEN_BYTES
)) {
1001 struct sk_buff
*buff
;
1003 buff
= __skb_dequeue(&neigh
->arp_queue
);
1006 neigh
->arp_queue_len_bytes
-= buff
->truesize
;
1008 NEIGH_CACHE_STAT_INC(neigh
->tbl
, unres_discards
);
1011 __skb_queue_tail(&neigh
->arp_queue
, skb
);
1012 neigh
->arp_queue_len_bytes
+= skb
->truesize
;
1017 if (immediate_probe
)
1020 write_unlock(&neigh
->lock
);
1025 if (neigh
->nud_state
& NUD_STALE
)
1027 write_unlock_bh(&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 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
1065 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
1067 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1070 Caller MUST hold reference count on the entry.
1073 int neigh_update(struct neighbour
*neigh
, const u8
*lladdr
, u8
new,
1079 struct net_device
*dev
;
1080 int update_isrouter
= 0;
1082 write_lock_bh(&neigh
->lock
);
1085 old
= neigh
->nud_state
;
1088 if (!(flags
& NEIGH_UPDATE_F_ADMIN
) &&
1089 (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
)
1157 neigh_del_timer(neigh
);
1158 if (new & NUD_PROBE
)
1159 atomic_set(&neigh
->probes
, 0);
1160 if (new & NUD_IN_TIMER
)
1161 neigh_add_timer(neigh
, (jiffies
+
1162 ((new & NUD_REACHABLE
) ?
1163 neigh
->parms
->reachable_time
:
1165 neigh
->nud_state
= new;
1169 if (lladdr
!= neigh
->ha
) {
1170 write_seqlock(&neigh
->ha_lock
);
1171 memcpy(&neigh
->ha
, lladdr
, dev
->addr_len
);
1172 write_sequnlock(&neigh
->ha_lock
);
1173 neigh_update_hhs(neigh
);
1174 if (!(new & NUD_CONNECTED
))
1175 neigh
->confirmed
= jiffies
-
1176 (NEIGH_VAR(neigh
->parms
, BASE_REACHABLE_TIME
) << 1);
1181 if (new & NUD_CONNECTED
)
1182 neigh_connect(neigh
);
1184 neigh_suspect(neigh
);
1185 if (!(old
& NUD_VALID
)) {
1186 struct sk_buff
*skb
;
1188 /* Again: avoid dead loop if something went wrong */
1190 while (neigh
->nud_state
& NUD_VALID
&&
1191 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
1192 struct dst_entry
*dst
= skb_dst(skb
);
1193 struct neighbour
*n2
, *n1
= neigh
;
1194 write_unlock_bh(&neigh
->lock
);
1198 /* Why not just use 'neigh' as-is? The problem is that
1199 * things such as shaper, eql, and sch_teql can end up
1200 * using alternative, different, neigh objects to output
1201 * the packet in the output path. So what we need to do
1202 * here is re-lookup the top-level neigh in the path so
1203 * we can reinject the packet there.
1207 n2
= dst_neigh_lookup_skb(dst
, skb
);
1211 n1
->output(n1
, skb
);
1216 write_lock_bh(&neigh
->lock
);
1218 __skb_queue_purge(&neigh
->arp_queue
);
1219 neigh
->arp_queue_len_bytes
= 0;
1222 if (update_isrouter
) {
1223 neigh
->flags
= (flags
& NEIGH_UPDATE_F_ISROUTER
) ?
1224 (neigh
->flags
| NTF_ROUTER
) :
1225 (neigh
->flags
& ~NTF_ROUTER
);
1227 write_unlock_bh(&neigh
->lock
);
1230 neigh_update_notify(neigh
);
1234 EXPORT_SYMBOL(neigh_update
);
1236 /* Update the neigh to listen temporarily for probe responses, even if it is
1237 * in a NUD_FAILED state. The caller has to hold neigh->lock for writing.
1239 void __neigh_set_probe_once(struct neighbour
*neigh
)
1243 neigh
->updated
= jiffies
;
1244 if (!(neigh
->nud_state
& NUD_FAILED
))
1246 neigh
->nud_state
= NUD_INCOMPLETE
;
1247 atomic_set(&neigh
->probes
, neigh_max_probes(neigh
));
1248 neigh_add_timer(neigh
,
1249 jiffies
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
));
1251 EXPORT_SYMBOL(__neigh_set_probe_once
);
1253 struct neighbour
*neigh_event_ns(struct neigh_table
*tbl
,
1254 u8
*lladdr
, void *saddr
,
1255 struct net_device
*dev
)
1257 struct neighbour
*neigh
= __neigh_lookup(tbl
, saddr
, dev
,
1258 lladdr
|| !dev
->addr_len
);
1260 neigh_update(neigh
, lladdr
, NUD_STALE
,
1261 NEIGH_UPDATE_F_OVERRIDE
);
1264 EXPORT_SYMBOL(neigh_event_ns
);
1266 /* called with read_lock_bh(&n->lock); */
1267 static void neigh_hh_init(struct neighbour
*n
)
1269 struct net_device
*dev
= n
->dev
;
1270 __be16 prot
= n
->tbl
->protocol
;
1271 struct hh_cache
*hh
= &n
->hh
;
1273 write_lock_bh(&n
->lock
);
1275 /* Only one thread can come in here and initialize the
1279 dev
->header_ops
->cache(n
, hh
, prot
);
1281 write_unlock_bh(&n
->lock
);
1284 /* Slow and careful. */
1286 int neigh_resolve_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1290 if (!neigh_event_send(neigh
, skb
)) {
1292 struct net_device
*dev
= neigh
->dev
;
1295 if (dev
->header_ops
->cache
&& !neigh
->hh
.hh_len
)
1296 neigh_hh_init(neigh
);
1299 __skb_pull(skb
, skb_network_offset(skb
));
1300 seq
= read_seqbegin(&neigh
->ha_lock
);
1301 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1302 neigh
->ha
, NULL
, skb
->len
);
1303 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1306 rc
= dev_queue_xmit(skb
);
1317 EXPORT_SYMBOL(neigh_resolve_output
);
1319 /* As fast as possible without hh cache */
1321 int neigh_connected_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1323 struct net_device
*dev
= neigh
->dev
;
1328 __skb_pull(skb
, skb_network_offset(skb
));
1329 seq
= read_seqbegin(&neigh
->ha_lock
);
1330 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1331 neigh
->ha
, NULL
, skb
->len
);
1332 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1335 err
= dev_queue_xmit(skb
);
1342 EXPORT_SYMBOL(neigh_connected_output
);
1344 int neigh_direct_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1346 return dev_queue_xmit(skb
);
1348 EXPORT_SYMBOL(neigh_direct_output
);
1350 static void neigh_proxy_process(unsigned long arg
)
1352 struct neigh_table
*tbl
= (struct neigh_table
*)arg
;
1353 long sched_next
= 0;
1354 unsigned long now
= jiffies
;
1355 struct sk_buff
*skb
, *n
;
1357 spin_lock(&tbl
->proxy_queue
.lock
);
1359 skb_queue_walk_safe(&tbl
->proxy_queue
, skb
, n
) {
1360 long tdif
= NEIGH_CB(skb
)->sched_next
- now
;
1363 struct net_device
*dev
= skb
->dev
;
1365 __skb_unlink(skb
, &tbl
->proxy_queue
);
1366 if (tbl
->proxy_redo
&& netif_running(dev
)) {
1368 tbl
->proxy_redo(skb
);
1375 } else if (!sched_next
|| tdif
< sched_next
)
1378 del_timer(&tbl
->proxy_timer
);
1380 mod_timer(&tbl
->proxy_timer
, jiffies
+ sched_next
);
1381 spin_unlock(&tbl
->proxy_queue
.lock
);
1384 void pneigh_enqueue(struct neigh_table
*tbl
, struct neigh_parms
*p
,
1385 struct sk_buff
*skb
)
1387 unsigned long now
= jiffies
;
1389 unsigned long sched_next
= now
+ (prandom_u32() %
1390 NEIGH_VAR(p
, PROXY_DELAY
));
1392 if (tbl
->proxy_queue
.qlen
> NEIGH_VAR(p
, PROXY_QLEN
)) {
1397 NEIGH_CB(skb
)->sched_next
= sched_next
;
1398 NEIGH_CB(skb
)->flags
|= LOCALLY_ENQUEUED
;
1400 spin_lock(&tbl
->proxy_queue
.lock
);
1401 if (del_timer(&tbl
->proxy_timer
)) {
1402 if (time_before(tbl
->proxy_timer
.expires
, sched_next
))
1403 sched_next
= tbl
->proxy_timer
.expires
;
1407 __skb_queue_tail(&tbl
->proxy_queue
, skb
);
1408 mod_timer(&tbl
->proxy_timer
, sched_next
);
1409 spin_unlock(&tbl
->proxy_queue
.lock
);
1411 EXPORT_SYMBOL(pneigh_enqueue
);
1413 static inline struct neigh_parms
*lookup_neigh_parms(struct neigh_table
*tbl
,
1414 struct net
*net
, int ifindex
)
1416 struct neigh_parms
*p
;
1418 list_for_each_entry(p
, &tbl
->parms_list
, list
) {
1419 if ((p
->dev
&& p
->dev
->ifindex
== ifindex
&& net_eq(neigh_parms_net(p
), net
)) ||
1420 (!p
->dev
&& !ifindex
&& net_eq(net
, &init_net
)))
1427 struct neigh_parms
*neigh_parms_alloc(struct net_device
*dev
,
1428 struct neigh_table
*tbl
)
1430 struct neigh_parms
*p
;
1431 struct net
*net
= dev_net(dev
);
1432 const struct net_device_ops
*ops
= dev
->netdev_ops
;
1434 p
= kmemdup(&tbl
->parms
, sizeof(*p
), GFP_KERNEL
);
1437 atomic_set(&p
->refcnt
, 1);
1439 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
1442 write_pnet(&p
->net
, net
);
1443 p
->sysctl_table
= NULL
;
1445 if (ops
->ndo_neigh_setup
&& ops
->ndo_neigh_setup(dev
, p
)) {
1451 write_lock_bh(&tbl
->lock
);
1452 list_add(&p
->list
, &tbl
->parms
.list
);
1453 write_unlock_bh(&tbl
->lock
);
1455 neigh_parms_data_state_cleanall(p
);
1459 EXPORT_SYMBOL(neigh_parms_alloc
);
1461 static void neigh_rcu_free_parms(struct rcu_head
*head
)
1463 struct neigh_parms
*parms
=
1464 container_of(head
, struct neigh_parms
, rcu_head
);
1466 neigh_parms_put(parms
);
1469 void neigh_parms_release(struct neigh_table
*tbl
, struct neigh_parms
*parms
)
1471 if (!parms
|| parms
== &tbl
->parms
)
1473 write_lock_bh(&tbl
->lock
);
1474 list_del(&parms
->list
);
1476 write_unlock_bh(&tbl
->lock
);
1478 dev_put(parms
->dev
);
1479 call_rcu(&parms
->rcu_head
, neigh_rcu_free_parms
);
1481 EXPORT_SYMBOL(neigh_parms_release
);
1483 static void neigh_parms_destroy(struct neigh_parms
*parms
)
1488 static struct lock_class_key neigh_table_proxy_queue_class
;
1490 static struct neigh_table
*neigh_tables
[NEIGH_NR_TABLES
] __read_mostly
;
1492 void neigh_table_init(int index
, struct neigh_table
*tbl
)
1494 unsigned long now
= jiffies
;
1495 unsigned long phsize
;
1497 INIT_LIST_HEAD(&tbl
->parms_list
);
1498 list_add(&tbl
->parms
.list
, &tbl
->parms_list
);
1499 write_pnet(&tbl
->parms
.net
, &init_net
);
1500 atomic_set(&tbl
->parms
.refcnt
, 1);
1501 tbl
->parms
.reachable_time
=
1502 neigh_rand_reach_time(NEIGH_VAR(&tbl
->parms
, BASE_REACHABLE_TIME
));
1504 tbl
->stats
= alloc_percpu(struct neigh_statistics
);
1506 panic("cannot create neighbour cache statistics");
1508 #ifdef CONFIG_PROC_FS
1509 if (!proc_create_data(tbl
->id
, 0, init_net
.proc_net_stat
,
1510 &neigh_stat_seq_fops
, tbl
))
1511 panic("cannot create neighbour proc dir entry");
1514 RCU_INIT_POINTER(tbl
->nht
, neigh_hash_alloc(3));
1516 phsize
= (PNEIGH_HASHMASK
+ 1) * sizeof(struct pneigh_entry
*);
1517 tbl
->phash_buckets
= kzalloc(phsize
, GFP_KERNEL
);
1519 if (!tbl
->nht
|| !tbl
->phash_buckets
)
1520 panic("cannot allocate neighbour cache hashes");
1522 if (!tbl
->entry_size
)
1523 tbl
->entry_size
= ALIGN(offsetof(struct neighbour
, primary_key
) +
1524 tbl
->key_len
, NEIGH_PRIV_ALIGN
);
1526 WARN_ON(tbl
->entry_size
% NEIGH_PRIV_ALIGN
);
1528 rwlock_init(&tbl
->lock
);
1529 INIT_DEFERRABLE_WORK(&tbl
->gc_work
, neigh_periodic_work
);
1530 queue_delayed_work(system_power_efficient_wq
, &tbl
->gc_work
,
1531 tbl
->parms
.reachable_time
);
1532 setup_timer(&tbl
->proxy_timer
, neigh_proxy_process
, (unsigned long)tbl
);
1533 skb_queue_head_init_class(&tbl
->proxy_queue
,
1534 &neigh_table_proxy_queue_class
);
1536 tbl
->last_flush
= now
;
1537 tbl
->last_rand
= now
+ tbl
->parms
.reachable_time
* 20;
1539 neigh_tables
[index
] = tbl
;
1541 EXPORT_SYMBOL(neigh_table_init
);
1543 int neigh_table_clear(int index
, struct neigh_table
*tbl
)
1545 neigh_tables
[index
] = NULL
;
1546 /* It is not clean... Fix it to unload IPv6 module safely */
1547 cancel_delayed_work_sync(&tbl
->gc_work
);
1548 del_timer_sync(&tbl
->proxy_timer
);
1549 pneigh_queue_purge(&tbl
->proxy_queue
);
1550 neigh_ifdown(tbl
, NULL
);
1551 if (atomic_read(&tbl
->entries
))
1552 pr_crit("neighbour leakage\n");
1554 call_rcu(&rcu_dereference_protected(tbl
->nht
, 1)->rcu
,
1555 neigh_hash_free_rcu
);
1558 kfree(tbl
->phash_buckets
);
1559 tbl
->phash_buckets
= NULL
;
1561 remove_proc_entry(tbl
->id
, init_net
.proc_net_stat
);
1563 free_percpu(tbl
->stats
);
1568 EXPORT_SYMBOL(neigh_table_clear
);
1570 static struct neigh_table
*neigh_find_table(int family
)
1572 struct neigh_table
*tbl
= NULL
;
1576 tbl
= neigh_tables
[NEIGH_ARP_TABLE
];
1579 tbl
= neigh_tables
[NEIGH_ND_TABLE
];
1582 tbl
= neigh_tables
[NEIGH_DN_TABLE
];
1589 static int neigh_delete(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1591 struct net
*net
= sock_net(skb
->sk
);
1593 struct nlattr
*dst_attr
;
1594 struct neigh_table
*tbl
;
1595 struct neighbour
*neigh
;
1596 struct net_device
*dev
= NULL
;
1600 if (nlmsg_len(nlh
) < sizeof(*ndm
))
1603 dst_attr
= nlmsg_find_attr(nlh
, sizeof(*ndm
), NDA_DST
);
1604 if (dst_attr
== NULL
)
1607 ndm
= nlmsg_data(nlh
);
1608 if (ndm
->ndm_ifindex
) {
1609 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1616 tbl
= neigh_find_table(ndm
->ndm_family
);
1618 return -EAFNOSUPPORT
;
1620 if (nla_len(dst_attr
) < tbl
->key_len
)
1623 if (ndm
->ndm_flags
& NTF_PROXY
) {
1624 err
= pneigh_delete(tbl
, net
, nla_data(dst_attr
), dev
);
1631 neigh
= neigh_lookup(tbl
, nla_data(dst_attr
), dev
);
1632 if (neigh
== NULL
) {
1637 err
= neigh_update(neigh
, NULL
, NUD_FAILED
,
1638 NEIGH_UPDATE_F_OVERRIDE
|
1639 NEIGH_UPDATE_F_ADMIN
);
1640 neigh_release(neigh
);
1646 static int neigh_add(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1648 int flags
= NEIGH_UPDATE_F_ADMIN
| NEIGH_UPDATE_F_OVERRIDE
;
1649 struct net
*net
= sock_net(skb
->sk
);
1651 struct nlattr
*tb
[NDA_MAX
+1];
1652 struct neigh_table
*tbl
;
1653 struct net_device
*dev
= NULL
;
1654 struct neighbour
*neigh
;
1659 err
= nlmsg_parse(nlh
, sizeof(*ndm
), tb
, NDA_MAX
, NULL
);
1664 if (tb
[NDA_DST
] == NULL
)
1667 ndm
= nlmsg_data(nlh
);
1668 if (ndm
->ndm_ifindex
) {
1669 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1675 if (tb
[NDA_LLADDR
] && nla_len(tb
[NDA_LLADDR
]) < dev
->addr_len
)
1679 tbl
= neigh_find_table(ndm
->ndm_family
);
1681 return -EAFNOSUPPORT
;
1683 if (nla_len(tb
[NDA_DST
]) < tbl
->key_len
)
1685 dst
= nla_data(tb
[NDA_DST
]);
1686 lladdr
= tb
[NDA_LLADDR
] ? nla_data(tb
[NDA_LLADDR
]) : NULL
;
1688 if (ndm
->ndm_flags
& NTF_PROXY
) {
1689 struct pneigh_entry
*pn
;
1692 pn
= pneigh_lookup(tbl
, net
, dst
, dev
, 1);
1694 pn
->flags
= ndm
->ndm_flags
;
1703 neigh
= neigh_lookup(tbl
, dst
, dev
);
1704 if (neigh
== NULL
) {
1705 if (!(nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
1710 neigh
= __neigh_lookup_errno(tbl
, dst
, dev
);
1711 if (IS_ERR(neigh
)) {
1712 err
= PTR_ERR(neigh
);
1716 if (nlh
->nlmsg_flags
& NLM_F_EXCL
) {
1718 neigh_release(neigh
);
1722 if (!(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
1723 flags
&= ~NEIGH_UPDATE_F_OVERRIDE
;
1726 if (ndm
->ndm_flags
& NTF_USE
) {
1727 neigh_event_send(neigh
, NULL
);
1730 err
= neigh_update(neigh
, lladdr
, ndm
->ndm_state
, flags
);
1731 neigh_release(neigh
);
1737 static int neightbl_fill_parms(struct sk_buff
*skb
, struct neigh_parms
*parms
)
1739 struct nlattr
*nest
;
1741 nest
= nla_nest_start(skb
, NDTA_PARMS
);
1746 nla_put_u32(skb
, NDTPA_IFINDEX
, parms
->dev
->ifindex
)) ||
1747 nla_put_u32(skb
, NDTPA_REFCNT
, atomic_read(&parms
->refcnt
)) ||
1748 nla_put_u32(skb
, NDTPA_QUEUE_LENBYTES
,
1749 NEIGH_VAR(parms
, QUEUE_LEN_BYTES
)) ||
1750 /* approximative value for deprecated QUEUE_LEN (in packets) */
1751 nla_put_u32(skb
, NDTPA_QUEUE_LEN
,
1752 NEIGH_VAR(parms
, QUEUE_LEN_BYTES
) / SKB_TRUESIZE(ETH_FRAME_LEN
)) ||
1753 nla_put_u32(skb
, NDTPA_PROXY_QLEN
, NEIGH_VAR(parms
, PROXY_QLEN
)) ||
1754 nla_put_u32(skb
, NDTPA_APP_PROBES
, NEIGH_VAR(parms
, APP_PROBES
)) ||
1755 nla_put_u32(skb
, NDTPA_UCAST_PROBES
,
1756 NEIGH_VAR(parms
, UCAST_PROBES
)) ||
1757 nla_put_u32(skb
, NDTPA_MCAST_PROBES
,
1758 NEIGH_VAR(parms
, MCAST_PROBES
)) ||
1759 nla_put_u32(skb
, NDTPA_MCAST_REPROBES
,
1760 NEIGH_VAR(parms
, MCAST_REPROBES
)) ||
1761 nla_put_msecs(skb
, NDTPA_REACHABLE_TIME
, parms
->reachable_time
,
1763 nla_put_msecs(skb
, NDTPA_BASE_REACHABLE_TIME
,
1764 NEIGH_VAR(parms
, BASE_REACHABLE_TIME
), NDTPA_PAD
) ||
1765 nla_put_msecs(skb
, NDTPA_GC_STALETIME
,
1766 NEIGH_VAR(parms
, GC_STALETIME
), NDTPA_PAD
) ||
1767 nla_put_msecs(skb
, NDTPA_DELAY_PROBE_TIME
,
1768 NEIGH_VAR(parms
, DELAY_PROBE_TIME
), NDTPA_PAD
) ||
1769 nla_put_msecs(skb
, NDTPA_RETRANS_TIME
,
1770 NEIGH_VAR(parms
, RETRANS_TIME
), NDTPA_PAD
) ||
1771 nla_put_msecs(skb
, NDTPA_ANYCAST_DELAY
,
1772 NEIGH_VAR(parms
, ANYCAST_DELAY
), NDTPA_PAD
) ||
1773 nla_put_msecs(skb
, NDTPA_PROXY_DELAY
,
1774 NEIGH_VAR(parms
, PROXY_DELAY
), NDTPA_PAD
) ||
1775 nla_put_msecs(skb
, NDTPA_LOCKTIME
,
1776 NEIGH_VAR(parms
, LOCKTIME
), NDTPA_PAD
))
1777 goto nla_put_failure
;
1778 return nla_nest_end(skb
, nest
);
1781 nla_nest_cancel(skb
, nest
);
1785 static int neightbl_fill_info(struct sk_buff
*skb
, struct neigh_table
*tbl
,
1786 u32 pid
, u32 seq
, int type
, int flags
)
1788 struct nlmsghdr
*nlh
;
1789 struct ndtmsg
*ndtmsg
;
1791 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1795 ndtmsg
= nlmsg_data(nlh
);
1797 read_lock_bh(&tbl
->lock
);
1798 ndtmsg
->ndtm_family
= tbl
->family
;
1799 ndtmsg
->ndtm_pad1
= 0;
1800 ndtmsg
->ndtm_pad2
= 0;
1802 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) ||
1803 nla_put_msecs(skb
, NDTA_GC_INTERVAL
, tbl
->gc_interval
, NDTA_PAD
) ||
1804 nla_put_u32(skb
, NDTA_THRESH1
, tbl
->gc_thresh1
) ||
1805 nla_put_u32(skb
, NDTA_THRESH2
, tbl
->gc_thresh2
) ||
1806 nla_put_u32(skb
, NDTA_THRESH3
, tbl
->gc_thresh3
))
1807 goto nla_put_failure
;
1809 unsigned long now
= jiffies
;
1810 unsigned int flush_delta
= now
- tbl
->last_flush
;
1811 unsigned int rand_delta
= now
- tbl
->last_rand
;
1812 struct neigh_hash_table
*nht
;
1813 struct ndt_config ndc
= {
1814 .ndtc_key_len
= tbl
->key_len
,
1815 .ndtc_entry_size
= tbl
->entry_size
,
1816 .ndtc_entries
= atomic_read(&tbl
->entries
),
1817 .ndtc_last_flush
= jiffies_to_msecs(flush_delta
),
1818 .ndtc_last_rand
= jiffies_to_msecs(rand_delta
),
1819 .ndtc_proxy_qlen
= tbl
->proxy_queue
.qlen
,
1823 nht
= rcu_dereference_bh(tbl
->nht
);
1824 ndc
.ndtc_hash_rnd
= nht
->hash_rnd
[0];
1825 ndc
.ndtc_hash_mask
= ((1 << nht
->hash_shift
) - 1);
1826 rcu_read_unlock_bh();
1828 if (nla_put(skb
, NDTA_CONFIG
, sizeof(ndc
), &ndc
))
1829 goto nla_put_failure
;
1834 struct ndt_stats ndst
;
1836 memset(&ndst
, 0, sizeof(ndst
));
1838 for_each_possible_cpu(cpu
) {
1839 struct neigh_statistics
*st
;
1841 st
= per_cpu_ptr(tbl
->stats
, cpu
);
1842 ndst
.ndts_allocs
+= st
->allocs
;
1843 ndst
.ndts_destroys
+= st
->destroys
;
1844 ndst
.ndts_hash_grows
+= st
->hash_grows
;
1845 ndst
.ndts_res_failed
+= st
->res_failed
;
1846 ndst
.ndts_lookups
+= st
->lookups
;
1847 ndst
.ndts_hits
+= st
->hits
;
1848 ndst
.ndts_rcv_probes_mcast
+= st
->rcv_probes_mcast
;
1849 ndst
.ndts_rcv_probes_ucast
+= st
->rcv_probes_ucast
;
1850 ndst
.ndts_periodic_gc_runs
+= st
->periodic_gc_runs
;
1851 ndst
.ndts_forced_gc_runs
+= st
->forced_gc_runs
;
1852 ndst
.ndts_table_fulls
+= st
->table_fulls
;
1855 if (nla_put_64bit(skb
, NDTA_STATS
, sizeof(ndst
), &ndst
,
1857 goto nla_put_failure
;
1860 BUG_ON(tbl
->parms
.dev
);
1861 if (neightbl_fill_parms(skb
, &tbl
->parms
) < 0)
1862 goto nla_put_failure
;
1864 read_unlock_bh(&tbl
->lock
);
1865 nlmsg_end(skb
, nlh
);
1869 read_unlock_bh(&tbl
->lock
);
1870 nlmsg_cancel(skb
, nlh
);
1874 static int neightbl_fill_param_info(struct sk_buff
*skb
,
1875 struct neigh_table
*tbl
,
1876 struct neigh_parms
*parms
,
1877 u32 pid
, u32 seq
, int type
,
1880 struct ndtmsg
*ndtmsg
;
1881 struct nlmsghdr
*nlh
;
1883 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1887 ndtmsg
= nlmsg_data(nlh
);
1889 read_lock_bh(&tbl
->lock
);
1890 ndtmsg
->ndtm_family
= tbl
->family
;
1891 ndtmsg
->ndtm_pad1
= 0;
1892 ndtmsg
->ndtm_pad2
= 0;
1894 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) < 0 ||
1895 neightbl_fill_parms(skb
, parms
) < 0)
1898 read_unlock_bh(&tbl
->lock
);
1899 nlmsg_end(skb
, nlh
);
1902 read_unlock_bh(&tbl
->lock
);
1903 nlmsg_cancel(skb
, nlh
);
1907 static const struct nla_policy nl_neightbl_policy
[NDTA_MAX
+1] = {
1908 [NDTA_NAME
] = { .type
= NLA_STRING
},
1909 [NDTA_THRESH1
] = { .type
= NLA_U32
},
1910 [NDTA_THRESH2
] = { .type
= NLA_U32
},
1911 [NDTA_THRESH3
] = { .type
= NLA_U32
},
1912 [NDTA_GC_INTERVAL
] = { .type
= NLA_U64
},
1913 [NDTA_PARMS
] = { .type
= NLA_NESTED
},
1916 static const struct nla_policy nl_ntbl_parm_policy
[NDTPA_MAX
+1] = {
1917 [NDTPA_IFINDEX
] = { .type
= NLA_U32
},
1918 [NDTPA_QUEUE_LEN
] = { .type
= NLA_U32
},
1919 [NDTPA_PROXY_QLEN
] = { .type
= NLA_U32
},
1920 [NDTPA_APP_PROBES
] = { .type
= NLA_U32
},
1921 [NDTPA_UCAST_PROBES
] = { .type
= NLA_U32
},
1922 [NDTPA_MCAST_PROBES
] = { .type
= NLA_U32
},
1923 [NDTPA_MCAST_REPROBES
] = { .type
= NLA_U32
},
1924 [NDTPA_BASE_REACHABLE_TIME
] = { .type
= NLA_U64
},
1925 [NDTPA_GC_STALETIME
] = { .type
= NLA_U64
},
1926 [NDTPA_DELAY_PROBE_TIME
] = { .type
= NLA_U64
},
1927 [NDTPA_RETRANS_TIME
] = { .type
= NLA_U64
},
1928 [NDTPA_ANYCAST_DELAY
] = { .type
= NLA_U64
},
1929 [NDTPA_PROXY_DELAY
] = { .type
= NLA_U64
},
1930 [NDTPA_LOCKTIME
] = { .type
= NLA_U64
},
1933 static int neightbl_set(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1935 struct net
*net
= sock_net(skb
->sk
);
1936 struct neigh_table
*tbl
;
1937 struct ndtmsg
*ndtmsg
;
1938 struct nlattr
*tb
[NDTA_MAX
+1];
1942 err
= nlmsg_parse(nlh
, sizeof(*ndtmsg
), tb
, NDTA_MAX
,
1943 nl_neightbl_policy
);
1947 if (tb
[NDTA_NAME
] == NULL
) {
1952 ndtmsg
= nlmsg_data(nlh
);
1954 for (tidx
= 0; tidx
< NEIGH_NR_TABLES
; tidx
++) {
1955 tbl
= neigh_tables
[tidx
];
1958 if (ndtmsg
->ndtm_family
&& tbl
->family
!= ndtmsg
->ndtm_family
)
1960 if (nla_strcmp(tb
[NDTA_NAME
], tbl
->id
) == 0) {
1970 * We acquire tbl->lock to be nice to the periodic timers and
1971 * make sure they always see a consistent set of values.
1973 write_lock_bh(&tbl
->lock
);
1975 if (tb
[NDTA_PARMS
]) {
1976 struct nlattr
*tbp
[NDTPA_MAX
+1];
1977 struct neigh_parms
*p
;
1980 err
= nla_parse_nested(tbp
, NDTPA_MAX
, tb
[NDTA_PARMS
],
1981 nl_ntbl_parm_policy
);
1983 goto errout_tbl_lock
;
1985 if (tbp
[NDTPA_IFINDEX
])
1986 ifindex
= nla_get_u32(tbp
[NDTPA_IFINDEX
]);
1988 p
= lookup_neigh_parms(tbl
, net
, ifindex
);
1991 goto errout_tbl_lock
;
1994 for (i
= 1; i
<= NDTPA_MAX
; i
++) {
1999 case NDTPA_QUEUE_LEN
:
2000 NEIGH_VAR_SET(p
, QUEUE_LEN_BYTES
,
2001 nla_get_u32(tbp
[i
]) *
2002 SKB_TRUESIZE(ETH_FRAME_LEN
));
2004 case NDTPA_QUEUE_LENBYTES
:
2005 NEIGH_VAR_SET(p
, QUEUE_LEN_BYTES
,
2006 nla_get_u32(tbp
[i
]));
2008 case NDTPA_PROXY_QLEN
:
2009 NEIGH_VAR_SET(p
, PROXY_QLEN
,
2010 nla_get_u32(tbp
[i
]));
2012 case NDTPA_APP_PROBES
:
2013 NEIGH_VAR_SET(p
, APP_PROBES
,
2014 nla_get_u32(tbp
[i
]));
2016 case NDTPA_UCAST_PROBES
:
2017 NEIGH_VAR_SET(p
, UCAST_PROBES
,
2018 nla_get_u32(tbp
[i
]));
2020 case NDTPA_MCAST_PROBES
:
2021 NEIGH_VAR_SET(p
, MCAST_PROBES
,
2022 nla_get_u32(tbp
[i
]));
2024 case NDTPA_MCAST_REPROBES
:
2025 NEIGH_VAR_SET(p
, MCAST_REPROBES
,
2026 nla_get_u32(tbp
[i
]));
2028 case NDTPA_BASE_REACHABLE_TIME
:
2029 NEIGH_VAR_SET(p
, BASE_REACHABLE_TIME
,
2030 nla_get_msecs(tbp
[i
]));
2031 /* update reachable_time as well, otherwise, the change will
2032 * only be effective after the next time neigh_periodic_work
2033 * decides to recompute it (can be multiple minutes)
2036 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
2038 case NDTPA_GC_STALETIME
:
2039 NEIGH_VAR_SET(p
, GC_STALETIME
,
2040 nla_get_msecs(tbp
[i
]));
2042 case NDTPA_DELAY_PROBE_TIME
:
2043 NEIGH_VAR_SET(p
, DELAY_PROBE_TIME
,
2044 nla_get_msecs(tbp
[i
]));
2045 call_netevent_notifiers(NETEVENT_DELAY_PROBE_TIME_UPDATE
, p
);
2047 case NDTPA_RETRANS_TIME
:
2048 NEIGH_VAR_SET(p
, RETRANS_TIME
,
2049 nla_get_msecs(tbp
[i
]));
2051 case NDTPA_ANYCAST_DELAY
:
2052 NEIGH_VAR_SET(p
, ANYCAST_DELAY
,
2053 nla_get_msecs(tbp
[i
]));
2055 case NDTPA_PROXY_DELAY
:
2056 NEIGH_VAR_SET(p
, PROXY_DELAY
,
2057 nla_get_msecs(tbp
[i
]));
2059 case NDTPA_LOCKTIME
:
2060 NEIGH_VAR_SET(p
, LOCKTIME
,
2061 nla_get_msecs(tbp
[i
]));
2068 if ((tb
[NDTA_THRESH1
] || tb
[NDTA_THRESH2
] ||
2069 tb
[NDTA_THRESH3
] || tb
[NDTA_GC_INTERVAL
]) &&
2070 !net_eq(net
, &init_net
))
2071 goto errout_tbl_lock
;
2073 if (tb
[NDTA_THRESH1
])
2074 tbl
->gc_thresh1
= nla_get_u32(tb
[NDTA_THRESH1
]);
2076 if (tb
[NDTA_THRESH2
])
2077 tbl
->gc_thresh2
= nla_get_u32(tb
[NDTA_THRESH2
]);
2079 if (tb
[NDTA_THRESH3
])
2080 tbl
->gc_thresh3
= nla_get_u32(tb
[NDTA_THRESH3
]);
2082 if (tb
[NDTA_GC_INTERVAL
])
2083 tbl
->gc_interval
= nla_get_msecs(tb
[NDTA_GC_INTERVAL
]);
2088 write_unlock_bh(&tbl
->lock
);
2093 static int neightbl_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2095 struct net
*net
= sock_net(skb
->sk
);
2096 int family
, tidx
, nidx
= 0;
2097 int tbl_skip
= cb
->args
[0];
2098 int neigh_skip
= cb
->args
[1];
2099 struct neigh_table
*tbl
;
2101 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2103 for (tidx
= 0; tidx
< NEIGH_NR_TABLES
; tidx
++) {
2104 struct neigh_parms
*p
;
2106 tbl
= neigh_tables
[tidx
];
2110 if (tidx
< tbl_skip
|| (family
&& tbl
->family
!= family
))
2113 if (neightbl_fill_info(skb
, tbl
, NETLINK_CB(cb
->skb
).portid
,
2114 cb
->nlh
->nlmsg_seq
, RTM_NEWNEIGHTBL
,
2119 p
= list_next_entry(&tbl
->parms
, list
);
2120 list_for_each_entry_from(p
, &tbl
->parms_list
, list
) {
2121 if (!net_eq(neigh_parms_net(p
), net
))
2124 if (nidx
< neigh_skip
)
2127 if (neightbl_fill_param_info(skb
, tbl
, p
,
2128 NETLINK_CB(cb
->skb
).portid
,
2146 static int neigh_fill_info(struct sk_buff
*skb
, struct neighbour
*neigh
,
2147 u32 pid
, u32 seq
, int type
, unsigned int flags
)
2149 unsigned long now
= jiffies
;
2150 struct nda_cacheinfo ci
;
2151 struct nlmsghdr
*nlh
;
2154 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2158 ndm
= nlmsg_data(nlh
);
2159 ndm
->ndm_family
= neigh
->ops
->family
;
2162 ndm
->ndm_flags
= neigh
->flags
;
2163 ndm
->ndm_type
= neigh
->type
;
2164 ndm
->ndm_ifindex
= neigh
->dev
->ifindex
;
2166 if (nla_put(skb
, NDA_DST
, neigh
->tbl
->key_len
, neigh
->primary_key
))
2167 goto nla_put_failure
;
2169 read_lock_bh(&neigh
->lock
);
2170 ndm
->ndm_state
= neigh
->nud_state
;
2171 if (neigh
->nud_state
& NUD_VALID
) {
2172 char haddr
[MAX_ADDR_LEN
];
2174 neigh_ha_snapshot(haddr
, neigh
, neigh
->dev
);
2175 if (nla_put(skb
, NDA_LLADDR
, neigh
->dev
->addr_len
, haddr
) < 0) {
2176 read_unlock_bh(&neigh
->lock
);
2177 goto nla_put_failure
;
2181 ci
.ndm_used
= jiffies_to_clock_t(now
- neigh
->used
);
2182 ci
.ndm_confirmed
= jiffies_to_clock_t(now
- neigh
->confirmed
);
2183 ci
.ndm_updated
= jiffies_to_clock_t(now
- neigh
->updated
);
2184 ci
.ndm_refcnt
= atomic_read(&neigh
->refcnt
) - 1;
2185 read_unlock_bh(&neigh
->lock
);
2187 if (nla_put_u32(skb
, NDA_PROBES
, atomic_read(&neigh
->probes
)) ||
2188 nla_put(skb
, NDA_CACHEINFO
, sizeof(ci
), &ci
))
2189 goto nla_put_failure
;
2191 nlmsg_end(skb
, nlh
);
2195 nlmsg_cancel(skb
, nlh
);
2199 static int pneigh_fill_info(struct sk_buff
*skb
, struct pneigh_entry
*pn
,
2200 u32 pid
, u32 seq
, int type
, unsigned int flags
,
2201 struct neigh_table
*tbl
)
2203 struct nlmsghdr
*nlh
;
2206 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2210 ndm
= nlmsg_data(nlh
);
2211 ndm
->ndm_family
= tbl
->family
;
2214 ndm
->ndm_flags
= pn
->flags
| NTF_PROXY
;
2215 ndm
->ndm_type
= RTN_UNICAST
;
2216 ndm
->ndm_ifindex
= pn
->dev
? pn
->dev
->ifindex
: 0;
2217 ndm
->ndm_state
= NUD_NONE
;
2219 if (nla_put(skb
, NDA_DST
, tbl
->key_len
, pn
->key
))
2220 goto nla_put_failure
;
2222 nlmsg_end(skb
, nlh
);
2226 nlmsg_cancel(skb
, nlh
);
2230 static void neigh_update_notify(struct neighbour
*neigh
)
2232 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
2233 __neigh_notify(neigh
, RTM_NEWNEIGH
, 0);
2236 static bool neigh_master_filtered(struct net_device
*dev
, int master_idx
)
2238 struct net_device
*master
;
2243 master
= netdev_master_upper_dev_get(dev
);
2244 if (!master
|| master
->ifindex
!= master_idx
)
2250 static bool neigh_ifindex_filtered(struct net_device
*dev
, int filter_idx
)
2252 if (filter_idx
&& dev
->ifindex
!= filter_idx
)
2258 static int neigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2259 struct netlink_callback
*cb
)
2261 struct net
*net
= sock_net(skb
->sk
);
2262 const struct nlmsghdr
*nlh
= cb
->nlh
;
2263 struct nlattr
*tb
[NDA_MAX
+ 1];
2264 struct neighbour
*n
;
2265 int rc
, h
, s_h
= cb
->args
[1];
2266 int idx
, s_idx
= idx
= cb
->args
[2];
2267 struct neigh_hash_table
*nht
;
2268 int filter_master_idx
= 0, filter_idx
= 0;
2269 unsigned int flags
= NLM_F_MULTI
;
2272 err
= nlmsg_parse(nlh
, sizeof(struct ndmsg
), tb
, NDA_MAX
, NULL
);
2274 if (tb
[NDA_IFINDEX
])
2275 filter_idx
= nla_get_u32(tb
[NDA_IFINDEX
]);
2278 filter_master_idx
= nla_get_u32(tb
[NDA_MASTER
]);
2280 if (filter_idx
|| filter_master_idx
)
2281 flags
|= NLM_F_DUMP_FILTERED
;
2285 nht
= rcu_dereference_bh(tbl
->nht
);
2287 for (h
= s_h
; h
< (1 << nht
->hash_shift
); h
++) {
2290 for (n
= rcu_dereference_bh(nht
->hash_buckets
[h
]), idx
= 0;
2292 n
= rcu_dereference_bh(n
->next
)) {
2293 if (!net_eq(dev_net(n
->dev
), net
))
2295 if (neigh_ifindex_filtered(n
->dev
, filter_idx
))
2297 if (neigh_master_filtered(n
->dev
, filter_master_idx
))
2301 if (neigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).portid
,
2314 rcu_read_unlock_bh();
2320 static int pneigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2321 struct netlink_callback
*cb
)
2323 struct pneigh_entry
*n
;
2324 struct net
*net
= sock_net(skb
->sk
);
2325 int rc
, h
, s_h
= cb
->args
[3];
2326 int idx
, s_idx
= idx
= cb
->args
[4];
2328 read_lock_bh(&tbl
->lock
);
2330 for (h
= s_h
; h
<= PNEIGH_HASHMASK
; h
++) {
2333 for (n
= tbl
->phash_buckets
[h
], idx
= 0; n
; n
= n
->next
) {
2334 if (pneigh_net(n
) != net
)
2338 if (pneigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).portid
,
2341 NLM_F_MULTI
, tbl
) < 0) {
2342 read_unlock_bh(&tbl
->lock
);
2351 read_unlock_bh(&tbl
->lock
);
2360 static int neigh_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2362 struct neigh_table
*tbl
;
2367 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2369 /* check for full ndmsg structure presence, family member is
2370 * the same for both structures
2372 if (nlmsg_len(cb
->nlh
) >= sizeof(struct ndmsg
) &&
2373 ((struct ndmsg
*) nlmsg_data(cb
->nlh
))->ndm_flags
== NTF_PROXY
)
2378 for (t
= 0; t
< NEIGH_NR_TABLES
; t
++) {
2379 tbl
= neigh_tables
[t
];
2383 if (t
< s_t
|| (family
&& tbl
->family
!= family
))
2386 memset(&cb
->args
[1], 0, sizeof(cb
->args
) -
2387 sizeof(cb
->args
[0]));
2389 err
= pneigh_dump_table(tbl
, skb
, cb
);
2391 err
= neigh_dump_table(tbl
, skb
, cb
);
2400 void neigh_for_each(struct neigh_table
*tbl
, void (*cb
)(struct neighbour
*, void *), void *cookie
)
2403 struct neigh_hash_table
*nht
;
2406 nht
= rcu_dereference_bh(tbl
->nht
);
2408 read_lock(&tbl
->lock
); /* avoid resizes */
2409 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2410 struct neighbour
*n
;
2412 for (n
= rcu_dereference_bh(nht
->hash_buckets
[chain
]);
2414 n
= rcu_dereference_bh(n
->next
))
2417 read_unlock(&tbl
->lock
);
2418 rcu_read_unlock_bh();
2420 EXPORT_SYMBOL(neigh_for_each
);
2422 /* The tbl->lock must be held as a writer and BH disabled. */
2423 void __neigh_for_each_release(struct neigh_table
*tbl
,
2424 int (*cb
)(struct neighbour
*))
2427 struct neigh_hash_table
*nht
;
2429 nht
= rcu_dereference_protected(tbl
->nht
,
2430 lockdep_is_held(&tbl
->lock
));
2431 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2432 struct neighbour
*n
;
2433 struct neighbour __rcu
**np
;
2435 np
= &nht
->hash_buckets
[chain
];
2436 while ((n
= rcu_dereference_protected(*np
,
2437 lockdep_is_held(&tbl
->lock
))) != NULL
) {
2440 write_lock(&n
->lock
);
2443 rcu_assign_pointer(*np
,
2444 rcu_dereference_protected(n
->next
,
2445 lockdep_is_held(&tbl
->lock
)));
2449 write_unlock(&n
->lock
);
2451 neigh_cleanup_and_release(n
);
2455 EXPORT_SYMBOL(__neigh_for_each_release
);
2457 int neigh_xmit(int index
, struct net_device
*dev
,
2458 const void *addr
, struct sk_buff
*skb
)
2460 int err
= -EAFNOSUPPORT
;
2461 if (likely(index
< NEIGH_NR_TABLES
)) {
2462 struct neigh_table
*tbl
;
2463 struct neighbour
*neigh
;
2465 tbl
= neigh_tables
[index
];
2469 neigh
= __neigh_lookup_noref(tbl
, addr
, dev
);
2471 neigh
= __neigh_create(tbl
, addr
, dev
, false);
2472 err
= PTR_ERR(neigh
);
2473 if (IS_ERR(neigh
)) {
2474 rcu_read_unlock_bh();
2477 err
= neigh
->output(neigh
, skb
);
2478 rcu_read_unlock_bh();
2480 else if (index
== NEIGH_LINK_TABLE
) {
2481 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
2482 addr
, NULL
, skb
->len
);
2485 err
= dev_queue_xmit(skb
);
2493 EXPORT_SYMBOL(neigh_xmit
);
2495 #ifdef CONFIG_PROC_FS
2497 static struct neighbour
*neigh_get_first(struct seq_file
*seq
)
2499 struct neigh_seq_state
*state
= seq
->private;
2500 struct net
*net
= seq_file_net(seq
);
2501 struct neigh_hash_table
*nht
= state
->nht
;
2502 struct neighbour
*n
= NULL
;
2503 int bucket
= state
->bucket
;
2505 state
->flags
&= ~NEIGH_SEQ_IS_PNEIGH
;
2506 for (bucket
= 0; bucket
< (1 << nht
->hash_shift
); bucket
++) {
2507 n
= rcu_dereference_bh(nht
->hash_buckets
[bucket
]);
2510 if (!net_eq(dev_net(n
->dev
), net
))
2512 if (state
->neigh_sub_iter
) {
2516 v
= state
->neigh_sub_iter(state
, n
, &fakep
);
2520 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2522 if (n
->nud_state
& ~NUD_NOARP
)
2525 n
= rcu_dereference_bh(n
->next
);
2531 state
->bucket
= bucket
;
2536 static struct neighbour
*neigh_get_next(struct seq_file
*seq
,
2537 struct neighbour
*n
,
2540 struct neigh_seq_state
*state
= seq
->private;
2541 struct net
*net
= seq_file_net(seq
);
2542 struct neigh_hash_table
*nht
= state
->nht
;
2544 if (state
->neigh_sub_iter
) {
2545 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2549 n
= rcu_dereference_bh(n
->next
);
2553 if (!net_eq(dev_net(n
->dev
), net
))
2555 if (state
->neigh_sub_iter
) {
2556 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2561 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2564 if (n
->nud_state
& ~NUD_NOARP
)
2567 n
= rcu_dereference_bh(n
->next
);
2573 if (++state
->bucket
>= (1 << nht
->hash_shift
))
2576 n
= rcu_dereference_bh(nht
->hash_buckets
[state
->bucket
]);
2584 static struct neighbour
*neigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2586 struct neighbour
*n
= neigh_get_first(seq
);
2591 n
= neigh_get_next(seq
, n
, pos
);
2596 return *pos
? NULL
: n
;
2599 static struct pneigh_entry
*pneigh_get_first(struct seq_file
*seq
)
2601 struct neigh_seq_state
*state
= seq
->private;
2602 struct net
*net
= seq_file_net(seq
);
2603 struct neigh_table
*tbl
= state
->tbl
;
2604 struct pneigh_entry
*pn
= NULL
;
2605 int bucket
= state
->bucket
;
2607 state
->flags
|= NEIGH_SEQ_IS_PNEIGH
;
2608 for (bucket
= 0; bucket
<= PNEIGH_HASHMASK
; bucket
++) {
2609 pn
= tbl
->phash_buckets
[bucket
];
2610 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2615 state
->bucket
= bucket
;
2620 static struct pneigh_entry
*pneigh_get_next(struct seq_file
*seq
,
2621 struct pneigh_entry
*pn
,
2624 struct neigh_seq_state
*state
= seq
->private;
2625 struct net
*net
= seq_file_net(seq
);
2626 struct neigh_table
*tbl
= state
->tbl
;
2630 } while (pn
&& !net_eq(pneigh_net(pn
), net
));
2633 if (++state
->bucket
> PNEIGH_HASHMASK
)
2635 pn
= tbl
->phash_buckets
[state
->bucket
];
2636 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2648 static struct pneigh_entry
*pneigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2650 struct pneigh_entry
*pn
= pneigh_get_first(seq
);
2655 pn
= pneigh_get_next(seq
, pn
, pos
);
2660 return *pos
? NULL
: pn
;
2663 static void *neigh_get_idx_any(struct seq_file
*seq
, loff_t
*pos
)
2665 struct neigh_seq_state
*state
= seq
->private;
2667 loff_t idxpos
= *pos
;
2669 rc
= neigh_get_idx(seq
, &idxpos
);
2670 if (!rc
&& !(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2671 rc
= pneigh_get_idx(seq
, &idxpos
);
2676 void *neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
, struct neigh_table
*tbl
, unsigned int neigh_seq_flags
)
2679 struct neigh_seq_state
*state
= seq
->private;
2683 state
->flags
= (neigh_seq_flags
& ~NEIGH_SEQ_IS_PNEIGH
);
2686 state
->nht
= rcu_dereference_bh(tbl
->nht
);
2688 return *pos
? neigh_get_idx_any(seq
, pos
) : SEQ_START_TOKEN
;
2690 EXPORT_SYMBOL(neigh_seq_start
);
2692 void *neigh_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2694 struct neigh_seq_state
*state
;
2697 if (v
== SEQ_START_TOKEN
) {
2698 rc
= neigh_get_first(seq
);
2702 state
= seq
->private;
2703 if (!(state
->flags
& NEIGH_SEQ_IS_PNEIGH
)) {
2704 rc
= neigh_get_next(seq
, v
, NULL
);
2707 if (!(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2708 rc
= pneigh_get_first(seq
);
2710 BUG_ON(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
);
2711 rc
= pneigh_get_next(seq
, v
, NULL
);
2717 EXPORT_SYMBOL(neigh_seq_next
);
2719 void neigh_seq_stop(struct seq_file
*seq
, void *v
)
2722 rcu_read_unlock_bh();
2724 EXPORT_SYMBOL(neigh_seq_stop
);
2726 /* statistics via seq_file */
2728 static void *neigh_stat_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2730 struct neigh_table
*tbl
= seq
->private;
2734 return SEQ_START_TOKEN
;
2736 for (cpu
= *pos
-1; cpu
< nr_cpu_ids
; ++cpu
) {
2737 if (!cpu_possible(cpu
))
2740 return per_cpu_ptr(tbl
->stats
, cpu
);
2745 static void *neigh_stat_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2747 struct neigh_table
*tbl
= seq
->private;
2750 for (cpu
= *pos
; cpu
< nr_cpu_ids
; ++cpu
) {
2751 if (!cpu_possible(cpu
))
2754 return per_cpu_ptr(tbl
->stats
, cpu
);
2759 static void neigh_stat_seq_stop(struct seq_file
*seq
, void *v
)
2764 static int neigh_stat_seq_show(struct seq_file
*seq
, void *v
)
2766 struct neigh_table
*tbl
= seq
->private;
2767 struct neigh_statistics
*st
= v
;
2769 if (v
== SEQ_START_TOKEN
) {
2770 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");
2774 seq_printf(seq
, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2775 "%08lx %08lx %08lx %08lx %08lx %08lx\n",
2776 atomic_read(&tbl
->entries
),
2787 st
->rcv_probes_mcast
,
2788 st
->rcv_probes_ucast
,
2790 st
->periodic_gc_runs
,
2799 static const struct seq_operations neigh_stat_seq_ops
= {
2800 .start
= neigh_stat_seq_start
,
2801 .next
= neigh_stat_seq_next
,
2802 .stop
= neigh_stat_seq_stop
,
2803 .show
= neigh_stat_seq_show
,
2806 static int neigh_stat_seq_open(struct inode
*inode
, struct file
*file
)
2808 int ret
= seq_open(file
, &neigh_stat_seq_ops
);
2811 struct seq_file
*sf
= file
->private_data
;
2812 sf
->private = PDE_DATA(inode
);
2817 static const struct file_operations neigh_stat_seq_fops
= {
2818 .owner
= THIS_MODULE
,
2819 .open
= neigh_stat_seq_open
,
2821 .llseek
= seq_lseek
,
2822 .release
= seq_release
,
2825 #endif /* CONFIG_PROC_FS */
2827 static inline size_t neigh_nlmsg_size(void)
2829 return NLMSG_ALIGN(sizeof(struct ndmsg
))
2830 + nla_total_size(MAX_ADDR_LEN
) /* NDA_DST */
2831 + nla_total_size(MAX_ADDR_LEN
) /* NDA_LLADDR */
2832 + nla_total_size(sizeof(struct nda_cacheinfo
))
2833 + nla_total_size(4); /* NDA_PROBES */
2836 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
)
2838 struct net
*net
= dev_net(n
->dev
);
2839 struct sk_buff
*skb
;
2842 skb
= nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC
);
2846 err
= neigh_fill_info(skb
, n
, 0, 0, type
, flags
);
2848 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2849 WARN_ON(err
== -EMSGSIZE
);
2853 rtnl_notify(skb
, net
, 0, RTNLGRP_NEIGH
, NULL
, GFP_ATOMIC
);
2857 rtnl_set_sk_err(net
, RTNLGRP_NEIGH
, err
);
2860 void neigh_app_ns(struct neighbour
*n
)
2862 __neigh_notify(n
, RTM_GETNEIGH
, NLM_F_REQUEST
);
2864 EXPORT_SYMBOL(neigh_app_ns
);
2866 #ifdef CONFIG_SYSCTL
2868 static int int_max
= INT_MAX
;
2869 static int unres_qlen_max
= INT_MAX
/ SKB_TRUESIZE(ETH_FRAME_LEN
);
2871 static int proc_unres_qlen(struct ctl_table
*ctl
, int write
,
2872 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2875 struct ctl_table tmp
= *ctl
;
2878 tmp
.extra2
= &unres_qlen_max
;
2881 size
= *(int *)ctl
->data
/ SKB_TRUESIZE(ETH_FRAME_LEN
);
2882 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
2885 *(int *)ctl
->data
= size
* SKB_TRUESIZE(ETH_FRAME_LEN
);
2889 static struct neigh_parms
*neigh_get_dev_parms_rcu(struct net_device
*dev
,
2894 return __in_dev_arp_parms_get_rcu(dev
);
2896 return __in6_dev_nd_parms_get_rcu(dev
);
2901 static void neigh_copy_dflt_parms(struct net
*net
, struct neigh_parms
*p
,
2904 struct net_device
*dev
;
2905 int family
= neigh_parms_family(p
);
2908 for_each_netdev_rcu(net
, dev
) {
2909 struct neigh_parms
*dst_p
=
2910 neigh_get_dev_parms_rcu(dev
, family
);
2912 if (dst_p
&& !test_bit(index
, dst_p
->data_state
))
2913 dst_p
->data
[index
] = p
->data
[index
];
2918 static void neigh_proc_update(struct ctl_table
*ctl
, int write
)
2920 struct net_device
*dev
= ctl
->extra1
;
2921 struct neigh_parms
*p
= ctl
->extra2
;
2922 struct net
*net
= neigh_parms_net(p
);
2923 int index
= (int *) ctl
->data
- p
->data
;
2928 set_bit(index
, p
->data_state
);
2929 call_netevent_notifiers(NETEVENT_DELAY_PROBE_TIME_UPDATE
, p
);
2930 if (!dev
) /* NULL dev means this is default value */
2931 neigh_copy_dflt_parms(net
, p
, index
);
2934 static int neigh_proc_dointvec_zero_intmax(struct ctl_table
*ctl
, int write
,
2935 void __user
*buffer
,
2936 size_t *lenp
, loff_t
*ppos
)
2938 struct ctl_table tmp
= *ctl
;
2942 tmp
.extra2
= &int_max
;
2944 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
2945 neigh_proc_update(ctl
, write
);
2949 int neigh_proc_dointvec(struct ctl_table
*ctl
, int write
,
2950 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2952 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2954 neigh_proc_update(ctl
, write
);
2957 EXPORT_SYMBOL(neigh_proc_dointvec
);
2959 int neigh_proc_dointvec_jiffies(struct ctl_table
*ctl
, int write
,
2960 void __user
*buffer
,
2961 size_t *lenp
, loff_t
*ppos
)
2963 int ret
= proc_dointvec_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2965 neigh_proc_update(ctl
, write
);
2968 EXPORT_SYMBOL(neigh_proc_dointvec_jiffies
);
2970 static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table
*ctl
, int write
,
2971 void __user
*buffer
,
2972 size_t *lenp
, loff_t
*ppos
)
2974 int ret
= proc_dointvec_userhz_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2976 neigh_proc_update(ctl
, write
);
2980 int neigh_proc_dointvec_ms_jiffies(struct ctl_table
*ctl
, int write
,
2981 void __user
*buffer
,
2982 size_t *lenp
, loff_t
*ppos
)
2984 int ret
= proc_dointvec_ms_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2986 neigh_proc_update(ctl
, write
);
2989 EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies
);
2991 static int neigh_proc_dointvec_unres_qlen(struct ctl_table
*ctl
, int write
,
2992 void __user
*buffer
,
2993 size_t *lenp
, loff_t
*ppos
)
2995 int ret
= proc_unres_qlen(ctl
, write
, buffer
, lenp
, ppos
);
2997 neigh_proc_update(ctl
, write
);
3001 static int neigh_proc_base_reachable_time(struct ctl_table
*ctl
, int write
,
3002 void __user
*buffer
,
3003 size_t *lenp
, loff_t
*ppos
)
3005 struct neigh_parms
*p
= ctl
->extra2
;
3008 if (strcmp(ctl
->procname
, "base_reachable_time") == 0)
3009 ret
= neigh_proc_dointvec_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
3010 else if (strcmp(ctl
->procname
, "base_reachable_time_ms") == 0)
3011 ret
= neigh_proc_dointvec_ms_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
3015 if (write
&& ret
== 0) {
3016 /* update reachable_time as well, otherwise, the change will
3017 * only be effective after the next time neigh_periodic_work
3018 * decides to recompute it
3021 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
3026 #define NEIGH_PARMS_DATA_OFFSET(index) \
3027 (&((struct neigh_parms *) 0)->data[index])
3029 #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \
3030 [NEIGH_VAR_ ## attr] = { \
3032 .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \
3033 .maxlen = sizeof(int), \
3035 .proc_handler = proc, \
3038 #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \
3039 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax)
3041 #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \
3042 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies)
3044 #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \
3045 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies)
3047 #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \
3048 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
3050 #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \
3051 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
3053 #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \
3054 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen)
3056 static struct neigh_sysctl_table
{
3057 struct ctl_table_header
*sysctl_header
;
3058 struct ctl_table neigh_vars
[NEIGH_VAR_MAX
+ 1];
3059 } neigh_sysctl_template __read_mostly
= {
3061 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES
, "mcast_solicit"),
3062 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES
, "ucast_solicit"),
3063 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES
, "app_solicit"),
3064 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_REPROBES
, "mcast_resolicit"),
3065 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME
, "retrans_time"),
3066 NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME
, "base_reachable_time"),
3067 NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME
, "delay_first_probe_time"),
3068 NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME
, "gc_stale_time"),
3069 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES
, "unres_qlen_bytes"),
3070 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN
, "proxy_qlen"),
3071 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY
, "anycast_delay"),
3072 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY
, "proxy_delay"),
3073 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME
, "locktime"),
3074 NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN
, QUEUE_LEN_BYTES
, "unres_qlen"),
3075 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS
, RETRANS_TIME
, "retrans_time_ms"),
3076 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS
, BASE_REACHABLE_TIME
, "base_reachable_time_ms"),
3077 [NEIGH_VAR_GC_INTERVAL
] = {
3078 .procname
= "gc_interval",
3079 .maxlen
= sizeof(int),
3081 .proc_handler
= proc_dointvec_jiffies
,
3083 [NEIGH_VAR_GC_THRESH1
] = {
3084 .procname
= "gc_thresh1",
3085 .maxlen
= sizeof(int),
3089 .proc_handler
= proc_dointvec_minmax
,
3091 [NEIGH_VAR_GC_THRESH2
] = {
3092 .procname
= "gc_thresh2",
3093 .maxlen
= sizeof(int),
3097 .proc_handler
= proc_dointvec_minmax
,
3099 [NEIGH_VAR_GC_THRESH3
] = {
3100 .procname
= "gc_thresh3",
3101 .maxlen
= sizeof(int),
3105 .proc_handler
= proc_dointvec_minmax
,
3111 int neigh_sysctl_register(struct net_device
*dev
, struct neigh_parms
*p
,
3112 proc_handler
*handler
)
3115 struct neigh_sysctl_table
*t
;
3116 const char *dev_name_source
;
3117 char neigh_path
[ sizeof("net//neigh/") + IFNAMSIZ
+ IFNAMSIZ
];
3120 t
= kmemdup(&neigh_sysctl_template
, sizeof(*t
), GFP_KERNEL
);
3124 for (i
= 0; i
< NEIGH_VAR_GC_INTERVAL
; i
++) {
3125 t
->neigh_vars
[i
].data
+= (long) p
;
3126 t
->neigh_vars
[i
].extra1
= dev
;
3127 t
->neigh_vars
[i
].extra2
= p
;
3131 dev_name_source
= dev
->name
;
3132 /* Terminate the table early */
3133 memset(&t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
], 0,
3134 sizeof(t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
]));
3136 struct neigh_table
*tbl
= p
->tbl
;
3137 dev_name_source
= "default";
3138 t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
].data
= &tbl
->gc_interval
;
3139 t
->neigh_vars
[NEIGH_VAR_GC_THRESH1
].data
= &tbl
->gc_thresh1
;
3140 t
->neigh_vars
[NEIGH_VAR_GC_THRESH2
].data
= &tbl
->gc_thresh2
;
3141 t
->neigh_vars
[NEIGH_VAR_GC_THRESH3
].data
= &tbl
->gc_thresh3
;
3146 t
->neigh_vars
[NEIGH_VAR_RETRANS_TIME
].proc_handler
= handler
;
3148 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME
].proc_handler
= handler
;
3149 /* RetransTime (in milliseconds)*/
3150 t
->neigh_vars
[NEIGH_VAR_RETRANS_TIME_MS
].proc_handler
= handler
;
3151 /* ReachableTime (in milliseconds) */
3152 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME_MS
].proc_handler
= handler
;
3154 /* Those handlers will update p->reachable_time after
3155 * base_reachable_time(_ms) is set to ensure the new timer starts being
3156 * applied after the next neighbour update instead of waiting for
3157 * neigh_periodic_work to update its value (can be multiple minutes)
3158 * So any handler that replaces them should do this as well
3161 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME
].proc_handler
=
3162 neigh_proc_base_reachable_time
;
3163 /* ReachableTime (in milliseconds) */
3164 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME_MS
].proc_handler
=
3165 neigh_proc_base_reachable_time
;
3168 /* Don't export sysctls to unprivileged users */
3169 if (neigh_parms_net(p
)->user_ns
!= &init_user_ns
)
3170 t
->neigh_vars
[0].procname
= NULL
;
3172 switch (neigh_parms_family(p
)) {
3183 snprintf(neigh_path
, sizeof(neigh_path
), "net/%s/neigh/%s",
3184 p_name
, dev_name_source
);
3186 register_net_sysctl(neigh_parms_net(p
), neigh_path
, t
->neigh_vars
);
3187 if (!t
->sysctl_header
)
3190 p
->sysctl_table
= t
;
3198 EXPORT_SYMBOL(neigh_sysctl_register
);
3200 void neigh_sysctl_unregister(struct neigh_parms
*p
)
3202 if (p
->sysctl_table
) {
3203 struct neigh_sysctl_table
*t
= p
->sysctl_table
;
3204 p
->sysctl_table
= NULL
;
3205 unregister_net_sysctl_table(t
->sysctl_header
);
3209 EXPORT_SYMBOL(neigh_sysctl_unregister
);
3211 #endif /* CONFIG_SYSCTL */
3213 static int __init
neigh_init(void)
3215 rtnl_register(PF_UNSPEC
, RTM_NEWNEIGH
, neigh_add
, NULL
, NULL
);
3216 rtnl_register(PF_UNSPEC
, RTM_DELNEIGH
, neigh_delete
, NULL
, NULL
);
3217 rtnl_register(PF_UNSPEC
, RTM_GETNEIGH
, NULL
, neigh_dump_info
, NULL
);
3219 rtnl_register(PF_UNSPEC
, RTM_GETNEIGHTBL
, NULL
, neightbl_dump_info
,
3221 rtnl_register(PF_UNSPEC
, RTM_SETNEIGHTBL
, neightbl_set
, NULL
, NULL
);
3226 subsys_initcall(neigh_init
);