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 #include <linux/slab.h>
19 #include <linux/types.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/socket.h>
23 #include <linux/netdevice.h>
24 #include <linux/proc_fs.h>
26 #include <linux/sysctl.h>
28 #include <linux/times.h>
29 #include <net/net_namespace.h>
30 #include <net/neighbour.h>
33 #include <net/netevent.h>
34 #include <net/netlink.h>
35 #include <linux/rtnetlink.h>
36 #include <linux/random.h>
37 #include <linux/string.h>
38 #include <linux/log2.h>
42 #define NEIGH_PRINTK(x...) printk(x)
43 #define NEIGH_NOPRINTK(x...) do { ; } while(0)
44 #define NEIGH_PRINTK1 NEIGH_NOPRINTK
45 #define NEIGH_PRINTK2 NEIGH_NOPRINTK
49 #define NEIGH_PRINTK1 NEIGH_PRINTK
53 #define NEIGH_PRINTK2 NEIGH_PRINTK
56 #define PNEIGH_HASHMASK 0xF
58 static void neigh_timer_handler(unsigned long arg
);
59 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
);
60 static void neigh_update_notify(struct neighbour
*neigh
);
61 static int pneigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
);
63 static struct neigh_table
*neigh_tables
;
65 static const struct file_operations neigh_stat_seq_fops
;
69 Neighbour hash table buckets are protected with rwlock tbl->lock.
71 - All the scans/updates to hash buckets MUST be made under this lock.
72 - NOTHING clever should be made under this lock: no callbacks
73 to protocol backends, no attempts to send something to network.
74 It will result in deadlocks, if backend/driver wants to use neighbour
76 - If the entry requires some non-trivial actions, increase
77 its reference count and release table lock.
79 Neighbour entries are protected:
80 - with reference count.
81 - with rwlock neigh->lock
83 Reference count prevents destruction.
85 neigh->lock mainly serializes ll address data and its validity state.
86 However, the same lock is used to protect another entry fields:
90 Again, nothing clever shall be made under neigh->lock,
91 the most complicated procedure, which we allow is dev->hard_header.
92 It is supposed, that dev->hard_header is simplistic and does
93 not make callbacks to neighbour tables.
95 The last lock is neigh_tbl_lock. It is pure SMP lock, protecting
96 list of neighbour tables. This list is used only in process context,
99 static DEFINE_RWLOCK(neigh_tbl_lock
);
101 static int neigh_blackhole(struct sk_buff
*skb
)
107 static void neigh_cleanup_and_release(struct neighbour
*neigh
)
109 if (neigh
->parms
->neigh_cleanup
)
110 neigh
->parms
->neigh_cleanup(neigh
);
112 __neigh_notify(neigh
, RTM_DELNEIGH
, 0);
113 neigh_release(neigh
);
117 * It is random distribution in the interval (1/2)*base...(3/2)*base.
118 * It corresponds to default IPv6 settings and is not overridable,
119 * because it is really reasonable choice.
122 unsigned long neigh_rand_reach_time(unsigned long base
)
124 return base
? (net_random() % base
) + (base
>> 1) : 0;
126 EXPORT_SYMBOL(neigh_rand_reach_time
);
129 static int neigh_forced_gc(struct neigh_table
*tbl
)
133 struct neigh_hash_table
*nht
;
135 NEIGH_CACHE_STAT_INC(tbl
, forced_gc_runs
);
137 write_lock_bh(&tbl
->lock
);
138 nht
= rcu_dereference_protected(tbl
->nht
,
139 lockdep_is_held(&tbl
->lock
));
140 for (i
= 0; i
< (1 << nht
->hash_shift
); i
++) {
142 struct neighbour __rcu
**np
;
144 np
= &nht
->hash_buckets
[i
];
145 while ((n
= rcu_dereference_protected(*np
,
146 lockdep_is_held(&tbl
->lock
))) != NULL
) {
147 /* Neighbour record may be discarded if:
148 * - nobody refers to it.
149 * - it is not permanent
151 write_lock(&n
->lock
);
152 if (atomic_read(&n
->refcnt
) == 1 &&
153 !(n
->nud_state
& NUD_PERMANENT
)) {
154 rcu_assign_pointer(*np
,
155 rcu_dereference_protected(n
->next
,
156 lockdep_is_held(&tbl
->lock
)));
159 write_unlock(&n
->lock
);
160 neigh_cleanup_and_release(n
);
163 write_unlock(&n
->lock
);
168 tbl
->last_flush
= jiffies
;
170 write_unlock_bh(&tbl
->lock
);
175 static void neigh_add_timer(struct neighbour
*n
, unsigned long when
)
178 if (unlikely(mod_timer(&n
->timer
, when
))) {
179 printk("NEIGH: BUG, double timer add, state is %x\n",
185 static int neigh_del_timer(struct neighbour
*n
)
187 if ((n
->nud_state
& NUD_IN_TIMER
) &&
188 del_timer(&n
->timer
)) {
195 static void pneigh_queue_purge(struct sk_buff_head
*list
)
199 while ((skb
= skb_dequeue(list
)) != NULL
) {
205 static void neigh_flush_dev(struct neigh_table
*tbl
, struct net_device
*dev
)
208 struct neigh_hash_table
*nht
;
210 nht
= rcu_dereference_protected(tbl
->nht
,
211 lockdep_is_held(&tbl
->lock
));
213 for (i
= 0; i
< (1 << nht
->hash_shift
); i
++) {
215 struct neighbour __rcu
**np
= &nht
->hash_buckets
[i
];
217 while ((n
= rcu_dereference_protected(*np
,
218 lockdep_is_held(&tbl
->lock
))) != NULL
) {
219 if (dev
&& n
->dev
!= dev
) {
223 rcu_assign_pointer(*np
,
224 rcu_dereference_protected(n
->next
,
225 lockdep_is_held(&tbl
->lock
)));
226 write_lock(&n
->lock
);
230 if (atomic_read(&n
->refcnt
) != 1) {
231 /* The most unpleasant situation.
232 We must destroy neighbour entry,
233 but someone still uses it.
235 The destroy will be delayed until
236 the last user releases us, but
237 we must kill timers etc. and move
240 skb_queue_purge(&n
->arp_queue
);
241 n
->output
= neigh_blackhole
;
242 if (n
->nud_state
& NUD_VALID
)
243 n
->nud_state
= NUD_NOARP
;
245 n
->nud_state
= NUD_NONE
;
246 NEIGH_PRINTK2("neigh %p is stray.\n", n
);
248 write_unlock(&n
->lock
);
249 neigh_cleanup_and_release(n
);
254 void neigh_changeaddr(struct neigh_table
*tbl
, struct net_device
*dev
)
256 write_lock_bh(&tbl
->lock
);
257 neigh_flush_dev(tbl
, dev
);
258 write_unlock_bh(&tbl
->lock
);
260 EXPORT_SYMBOL(neigh_changeaddr
);
262 int neigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
)
264 write_lock_bh(&tbl
->lock
);
265 neigh_flush_dev(tbl
, dev
);
266 pneigh_ifdown(tbl
, dev
);
267 write_unlock_bh(&tbl
->lock
);
269 del_timer_sync(&tbl
->proxy_timer
);
270 pneigh_queue_purge(&tbl
->proxy_queue
);
273 EXPORT_SYMBOL(neigh_ifdown
);
275 static struct neighbour
*neigh_alloc(struct neigh_table
*tbl
)
277 struct neighbour
*n
= NULL
;
278 unsigned long now
= jiffies
;
281 entries
= atomic_inc_return(&tbl
->entries
) - 1;
282 if (entries
>= tbl
->gc_thresh3
||
283 (entries
>= tbl
->gc_thresh2
&&
284 time_after(now
, tbl
->last_flush
+ 5 * HZ
))) {
285 if (!neigh_forced_gc(tbl
) &&
286 entries
>= tbl
->gc_thresh3
)
290 n
= kmem_cache_zalloc(tbl
->kmem_cachep
, GFP_ATOMIC
);
294 skb_queue_head_init(&n
->arp_queue
);
295 rwlock_init(&n
->lock
);
296 seqlock_init(&n
->ha_lock
);
297 n
->updated
= n
->used
= now
;
298 n
->nud_state
= NUD_NONE
;
299 n
->output
= neigh_blackhole
;
300 seqlock_init(&n
->hh
.hh_lock
);
301 n
->parms
= neigh_parms_clone(&tbl
->parms
);
302 setup_timer(&n
->timer
, neigh_timer_handler
, (unsigned long)n
);
304 NEIGH_CACHE_STAT_INC(tbl
, allocs
);
306 atomic_set(&n
->refcnt
, 1);
312 atomic_dec(&tbl
->entries
);
316 static struct neigh_hash_table
*neigh_hash_alloc(unsigned int shift
)
318 size_t size
= (1 << shift
) * sizeof(struct neighbour
*);
319 struct neigh_hash_table
*ret
;
320 struct neighbour __rcu
**buckets
;
322 ret
= kmalloc(sizeof(*ret
), GFP_ATOMIC
);
325 if (size
<= PAGE_SIZE
)
326 buckets
= kzalloc(size
, GFP_ATOMIC
);
328 buckets
= (struct neighbour __rcu
**)
329 __get_free_pages(GFP_ATOMIC
| __GFP_ZERO
,
335 ret
->hash_buckets
= buckets
;
336 ret
->hash_shift
= shift
;
337 get_random_bytes(&ret
->hash_rnd
, sizeof(ret
->hash_rnd
));
342 static void neigh_hash_free_rcu(struct rcu_head
*head
)
344 struct neigh_hash_table
*nht
= container_of(head
,
345 struct neigh_hash_table
,
347 size_t size
= (1 << nht
->hash_shift
) * sizeof(struct neighbour
*);
348 struct neighbour __rcu
**buckets
= nht
->hash_buckets
;
350 if (size
<= PAGE_SIZE
)
353 free_pages((unsigned long)buckets
, get_order(size
));
357 static struct neigh_hash_table
*neigh_hash_grow(struct neigh_table
*tbl
,
358 unsigned long new_shift
)
360 unsigned int i
, hash
;
361 struct neigh_hash_table
*new_nht
, *old_nht
;
363 NEIGH_CACHE_STAT_INC(tbl
, hash_grows
);
365 old_nht
= rcu_dereference_protected(tbl
->nht
,
366 lockdep_is_held(&tbl
->lock
));
367 new_nht
= neigh_hash_alloc(new_shift
);
371 for (i
= 0; i
< (1 << old_nht
->hash_shift
); i
++) {
372 struct neighbour
*n
, *next
;
374 for (n
= rcu_dereference_protected(old_nht
->hash_buckets
[i
],
375 lockdep_is_held(&tbl
->lock
));
378 hash
= tbl
->hash(n
->primary_key
, n
->dev
,
381 hash
>>= (32 - new_nht
->hash_shift
);
382 next
= rcu_dereference_protected(n
->next
,
383 lockdep_is_held(&tbl
->lock
));
385 rcu_assign_pointer(n
->next
,
386 rcu_dereference_protected(
387 new_nht
->hash_buckets
[hash
],
388 lockdep_is_held(&tbl
->lock
)));
389 rcu_assign_pointer(new_nht
->hash_buckets
[hash
], n
);
393 rcu_assign_pointer(tbl
->nht
, new_nht
);
394 call_rcu(&old_nht
->rcu
, neigh_hash_free_rcu
);
398 struct neighbour
*neigh_lookup(struct neigh_table
*tbl
, const void *pkey
,
399 struct net_device
*dev
)
402 int key_len
= tbl
->key_len
;
404 struct neigh_hash_table
*nht
;
406 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
409 nht
= rcu_dereference_bh(tbl
->nht
);
410 hash_val
= tbl
->hash(pkey
, dev
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
412 for (n
= rcu_dereference_bh(nht
->hash_buckets
[hash_val
]);
414 n
= rcu_dereference_bh(n
->next
)) {
415 if (dev
== n
->dev
&& !memcmp(n
->primary_key
, pkey
, key_len
)) {
416 if (!atomic_inc_not_zero(&n
->refcnt
))
418 NEIGH_CACHE_STAT_INC(tbl
, hits
);
423 rcu_read_unlock_bh();
426 EXPORT_SYMBOL(neigh_lookup
);
428 struct neighbour
*neigh_lookup_nodev(struct neigh_table
*tbl
, struct net
*net
,
432 int key_len
= tbl
->key_len
;
434 struct neigh_hash_table
*nht
;
436 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
439 nht
= rcu_dereference_bh(tbl
->nht
);
440 hash_val
= tbl
->hash(pkey
, NULL
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
442 for (n
= rcu_dereference_bh(nht
->hash_buckets
[hash_val
]);
444 n
= rcu_dereference_bh(n
->next
)) {
445 if (!memcmp(n
->primary_key
, pkey
, key_len
) &&
446 net_eq(dev_net(n
->dev
), net
)) {
447 if (!atomic_inc_not_zero(&n
->refcnt
))
449 NEIGH_CACHE_STAT_INC(tbl
, hits
);
454 rcu_read_unlock_bh();
457 EXPORT_SYMBOL(neigh_lookup_nodev
);
459 struct neighbour
*neigh_create(struct neigh_table
*tbl
, const void *pkey
,
460 struct net_device
*dev
)
463 int key_len
= tbl
->key_len
;
465 struct neighbour
*n1
, *rc
, *n
= neigh_alloc(tbl
);
466 struct neigh_hash_table
*nht
;
469 rc
= ERR_PTR(-ENOBUFS
);
473 memcpy(n
->primary_key
, pkey
, key_len
);
477 /* Protocol specific setup. */
478 if (tbl
->constructor
&& (error
= tbl
->constructor(n
)) < 0) {
480 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
- (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
)) {
520 rcu_assign_pointer(n
->next
,
521 rcu_dereference_protected(nht
->hash_buckets
[hash_val
],
522 lockdep_is_held(&tbl
->lock
)));
523 rcu_assign_pointer(nht
->hash_buckets
[hash_val
], n
);
524 write_unlock_bh(&tbl
->lock
);
525 NEIGH_PRINTK2("neigh %p is created.\n", n
);
530 write_unlock_bh(&tbl
->lock
);
535 EXPORT_SYMBOL(neigh_create
);
537 static u32
pneigh_hash(const void *pkey
, int key_len
)
539 u32 hash_val
= *(u32
*)(pkey
+ key_len
- 4);
540 hash_val
^= (hash_val
>> 16);
541 hash_val
^= hash_val
>> 8;
542 hash_val
^= hash_val
>> 4;
543 hash_val
&= PNEIGH_HASHMASK
;
547 static struct pneigh_entry
*__pneigh_lookup_1(struct pneigh_entry
*n
,
551 struct net_device
*dev
)
554 if (!memcmp(n
->key
, pkey
, key_len
) &&
555 net_eq(pneigh_net(n
), net
) &&
556 (n
->dev
== dev
|| !n
->dev
))
563 struct pneigh_entry
*__pneigh_lookup(struct neigh_table
*tbl
,
564 struct net
*net
, const void *pkey
, struct net_device
*dev
)
566 int key_len
= tbl
->key_len
;
567 u32 hash_val
= pneigh_hash(pkey
, key_len
);
569 return __pneigh_lookup_1(tbl
->phash_buckets
[hash_val
],
570 net
, pkey
, key_len
, dev
);
572 EXPORT_SYMBOL_GPL(__pneigh_lookup
);
574 struct pneigh_entry
* pneigh_lookup(struct neigh_table
*tbl
,
575 struct net
*net
, const void *pkey
,
576 struct net_device
*dev
, int creat
)
578 struct pneigh_entry
*n
;
579 int key_len
= tbl
->key_len
;
580 u32 hash_val
= pneigh_hash(pkey
, key_len
);
582 read_lock_bh(&tbl
->lock
);
583 n
= __pneigh_lookup_1(tbl
->phash_buckets
[hash_val
],
584 net
, pkey
, key_len
, dev
);
585 read_unlock_bh(&tbl
->lock
);
592 n
= kmalloc(sizeof(*n
) + key_len
, GFP_KERNEL
);
596 write_pnet(&n
->net
, hold_net(net
));
597 memcpy(n
->key
, pkey
, key_len
);
602 if (tbl
->pconstructor
&& tbl
->pconstructor(n
)) {
611 write_lock_bh(&tbl
->lock
);
612 n
->next
= tbl
->phash_buckets
[hash_val
];
613 tbl
->phash_buckets
[hash_val
] = n
;
614 write_unlock_bh(&tbl
->lock
);
618 EXPORT_SYMBOL(pneigh_lookup
);
621 int pneigh_delete(struct neigh_table
*tbl
, struct net
*net
, const void *pkey
,
622 struct net_device
*dev
)
624 struct pneigh_entry
*n
, **np
;
625 int key_len
= tbl
->key_len
;
626 u32 hash_val
= pneigh_hash(pkey
, key_len
);
628 write_lock_bh(&tbl
->lock
);
629 for (np
= &tbl
->phash_buckets
[hash_val
]; (n
= *np
) != NULL
;
631 if (!memcmp(n
->key
, pkey
, key_len
) && n
->dev
== dev
&&
632 net_eq(pneigh_net(n
), net
)) {
634 write_unlock_bh(&tbl
->lock
);
635 if (tbl
->pdestructor
)
639 release_net(pneigh_net(n
));
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
)
662 release_net(pneigh_net(n
));
672 static void neigh_parms_destroy(struct neigh_parms
*parms
);
674 static inline void neigh_parms_put(struct neigh_parms
*parms
)
676 if (atomic_dec_and_test(&parms
->refcnt
))
677 neigh_parms_destroy(parms
);
680 static void neigh_destroy_rcu(struct rcu_head
*head
)
682 struct neighbour
*neigh
= container_of(head
, struct neighbour
, rcu
);
684 kmem_cache_free(neigh
->tbl
->kmem_cachep
, neigh
);
687 * neighbour must already be out of the table;
690 void neigh_destroy(struct neighbour
*neigh
)
692 NEIGH_CACHE_STAT_INC(neigh
->tbl
, destroys
);
696 "Destroying alive neighbour %p\n", neigh
);
701 if (neigh_del_timer(neigh
))
702 printk(KERN_WARNING
"Impossible event.\n");
704 skb_queue_purge(&neigh
->arp_queue
);
707 neigh_parms_put(neigh
->parms
);
709 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh
);
711 atomic_dec(&neigh
->tbl
->entries
);
712 call_rcu(&neigh
->rcu
, neigh_destroy_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_PRINTK2("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_PRINTK2("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 for (p
= &tbl
->parms
; p
; p
= p
->next
)
763 neigh_rand_reach_time(p
->base_reachable_time
);
766 for (i
= 0 ; i
< (1 << nht
->hash_shift
); i
++) {
767 np
= &nht
->hash_buckets
[i
];
769 while ((n
= rcu_dereference_protected(*np
,
770 lockdep_is_held(&tbl
->lock
))) != NULL
) {
773 write_lock(&n
->lock
);
775 state
= n
->nud_state
;
776 if (state
& (NUD_PERMANENT
| NUD_IN_TIMER
)) {
777 write_unlock(&n
->lock
);
781 if (time_before(n
->used
, n
->confirmed
))
782 n
->used
= n
->confirmed
;
784 if (atomic_read(&n
->refcnt
) == 1 &&
785 (state
== NUD_FAILED
||
786 time_after(jiffies
, n
->used
+ n
->parms
->gc_staletime
))) {
789 write_unlock(&n
->lock
);
790 neigh_cleanup_and_release(n
);
793 write_unlock(&n
->lock
);
799 * It's fine to release lock here, even if hash table
800 * grows while we are preempted.
802 write_unlock_bh(&tbl
->lock
);
804 write_lock_bh(&tbl
->lock
);
806 /* Cycle through all hash buckets every base_reachable_time/2 ticks.
807 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
808 * base_reachable_time.
810 schedule_delayed_work(&tbl
->gc_work
,
811 tbl
->parms
.base_reachable_time
>> 1);
812 write_unlock_bh(&tbl
->lock
);
815 static __inline__
int neigh_max_probes(struct neighbour
*n
)
817 struct neigh_parms
*p
= n
->parms
;
818 return (n
->nud_state
& NUD_PROBE
) ?
820 p
->ucast_probes
+ p
->app_probes
+ p
->mcast_probes
;
823 static void neigh_invalidate(struct neighbour
*neigh
)
824 __releases(neigh
->lock
)
825 __acquires(neigh
->lock
)
829 NEIGH_CACHE_STAT_INC(neigh
->tbl
, res_failed
);
830 NEIGH_PRINTK2("neigh %p is failed.\n", neigh
);
831 neigh
->updated
= jiffies
;
833 /* It is very thin place. report_unreachable is very complicated
834 routine. Particularly, it can hit the same neighbour entry!
836 So that, we try to be accurate and avoid dead loop. --ANK
838 while (neigh
->nud_state
== NUD_FAILED
&&
839 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
840 write_unlock(&neigh
->lock
);
841 neigh
->ops
->error_report(neigh
, skb
);
842 write_lock(&neigh
->lock
);
844 skb_queue_purge(&neigh
->arp_queue
);
847 /* Called when a timer expires for a neighbour entry. */
849 static void neigh_timer_handler(unsigned long arg
)
851 unsigned long now
, next
;
852 struct neighbour
*neigh
= (struct neighbour
*)arg
;
856 write_lock(&neigh
->lock
);
858 state
= neigh
->nud_state
;
862 if (!(state
& NUD_IN_TIMER
)) {
864 printk(KERN_WARNING
"neigh: timer & !nud_in_timer\n");
869 if (state
& NUD_REACHABLE
) {
870 if (time_before_eq(now
,
871 neigh
->confirmed
+ neigh
->parms
->reachable_time
)) {
872 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh
);
873 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
874 } else if (time_before_eq(now
,
875 neigh
->used
+ neigh
->parms
->delay_probe_time
)) {
876 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh
);
877 neigh
->nud_state
= NUD_DELAY
;
878 neigh
->updated
= jiffies
;
879 neigh_suspect(neigh
);
880 next
= now
+ neigh
->parms
->delay_probe_time
;
882 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh
);
883 neigh
->nud_state
= NUD_STALE
;
884 neigh
->updated
= jiffies
;
885 neigh_suspect(neigh
);
888 } else if (state
& NUD_DELAY
) {
889 if (time_before_eq(now
,
890 neigh
->confirmed
+ neigh
->parms
->delay_probe_time
)) {
891 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh
);
892 neigh
->nud_state
= NUD_REACHABLE
;
893 neigh
->updated
= jiffies
;
894 neigh_connect(neigh
);
896 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
898 NEIGH_PRINTK2("neigh %p is probed.\n", neigh
);
899 neigh
->nud_state
= NUD_PROBE
;
900 neigh
->updated
= jiffies
;
901 atomic_set(&neigh
->probes
, 0);
902 next
= now
+ neigh
->parms
->retrans_time
;
905 /* NUD_PROBE|NUD_INCOMPLETE */
906 next
= now
+ neigh
->parms
->retrans_time
;
909 if ((neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
910 atomic_read(&neigh
->probes
) >= neigh_max_probes(neigh
)) {
911 neigh
->nud_state
= NUD_FAILED
;
913 neigh_invalidate(neigh
);
916 if (neigh
->nud_state
& NUD_IN_TIMER
) {
917 if (time_before(next
, jiffies
+ HZ
/2))
918 next
= jiffies
+ HZ
/2;
919 if (!mod_timer(&neigh
->timer
, next
))
922 if (neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) {
923 struct sk_buff
*skb
= skb_peek(&neigh
->arp_queue
);
924 /* keep skb alive even if arp_queue overflows */
926 skb
= skb_copy(skb
, GFP_ATOMIC
);
927 write_unlock(&neigh
->lock
);
928 neigh
->ops
->solicit(neigh
, skb
);
929 atomic_inc(&neigh
->probes
);
933 write_unlock(&neigh
->lock
);
937 neigh_update_notify(neigh
);
939 neigh_release(neigh
);
942 int __neigh_event_send(struct neighbour
*neigh
, struct sk_buff
*skb
)
947 write_lock_bh(&neigh
->lock
);
950 if (neigh
->nud_state
& (NUD_CONNECTED
| NUD_DELAY
| NUD_PROBE
))
955 if (!(neigh
->nud_state
& (NUD_STALE
| NUD_INCOMPLETE
))) {
956 if (neigh
->parms
->mcast_probes
+ neigh
->parms
->app_probes
) {
957 atomic_set(&neigh
->probes
, neigh
->parms
->ucast_probes
);
958 neigh
->nud_state
= NUD_INCOMPLETE
;
959 neigh
->updated
= jiffies
;
960 neigh_add_timer(neigh
, now
+ 1);
962 neigh
->nud_state
= NUD_FAILED
;
963 neigh
->updated
= jiffies
;
964 write_unlock_bh(&neigh
->lock
);
969 } else if (neigh
->nud_state
& NUD_STALE
) {
970 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh
);
971 neigh
->nud_state
= NUD_DELAY
;
972 neigh
->updated
= jiffies
;
973 neigh_add_timer(neigh
,
974 jiffies
+ neigh
->parms
->delay_probe_time
);
977 if (neigh
->nud_state
== NUD_INCOMPLETE
) {
979 if (skb_queue_len(&neigh
->arp_queue
) >=
980 neigh
->parms
->queue_len
) {
981 struct sk_buff
*buff
;
982 buff
= __skb_dequeue(&neigh
->arp_queue
);
984 NEIGH_CACHE_STAT_INC(neigh
->tbl
, unres_discards
);
987 __skb_queue_tail(&neigh
->arp_queue
, skb
);
992 write_unlock_bh(&neigh
->lock
);
995 EXPORT_SYMBOL(__neigh_event_send
);
997 static void neigh_update_hhs(struct neighbour
*neigh
)
1000 void (*update
)(struct hh_cache
*, const struct net_device
*, const unsigned char *)
1003 if (neigh
->dev
->header_ops
)
1004 update
= neigh
->dev
->header_ops
->cache_update
;
1009 write_seqlock_bh(&hh
->hh_lock
);
1010 update(hh
, neigh
->dev
, neigh
->ha
);
1011 write_sequnlock_bh(&hh
->hh_lock
);
1018 /* Generic update routine.
1019 -- lladdr is new lladdr or NULL, if it is not supplied.
1020 -- new is new state.
1022 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
1024 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
1025 lladdr instead of overriding it
1027 It also allows to retain current state
1028 if lladdr is unchanged.
1029 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
1031 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
1033 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1036 Caller MUST hold reference count on the entry.
1039 int neigh_update(struct neighbour
*neigh
, const u8
*lladdr
, u8
new,
1045 struct net_device
*dev
;
1046 int update_isrouter
= 0;
1048 write_lock_bh(&neigh
->lock
);
1051 old
= neigh
->nud_state
;
1054 if (!(flags
& NEIGH_UPDATE_F_ADMIN
) &&
1055 (old
& (NUD_NOARP
| NUD_PERMANENT
)))
1058 if (!(new & NUD_VALID
)) {
1059 neigh_del_timer(neigh
);
1060 if (old
& NUD_CONNECTED
)
1061 neigh_suspect(neigh
);
1062 neigh
->nud_state
= new;
1064 notify
= old
& NUD_VALID
;
1065 if ((old
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
1066 (new & NUD_FAILED
)) {
1067 neigh_invalidate(neigh
);
1073 /* Compare new lladdr with cached one */
1074 if (!dev
->addr_len
) {
1075 /* First case: device needs no address. */
1077 } else if (lladdr
) {
1078 /* The second case: if something is already cached
1079 and a new address is proposed:
1081 - if they are different, check override flag
1083 if ((old
& NUD_VALID
) &&
1084 !memcmp(lladdr
, neigh
->ha
, dev
->addr_len
))
1087 /* No address is supplied; if we know something,
1088 use it, otherwise discard the request.
1091 if (!(old
& NUD_VALID
))
1096 if (new & NUD_CONNECTED
)
1097 neigh
->confirmed
= jiffies
;
1098 neigh
->updated
= jiffies
;
1100 /* If entry was valid and address is not changed,
1101 do not change entry state, if new one is STALE.
1104 update_isrouter
= flags
& NEIGH_UPDATE_F_OVERRIDE_ISROUTER
;
1105 if (old
& NUD_VALID
) {
1106 if (lladdr
!= neigh
->ha
&& !(flags
& NEIGH_UPDATE_F_OVERRIDE
)) {
1107 update_isrouter
= 0;
1108 if ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) &&
1109 (old
& NUD_CONNECTED
)) {
1115 if (lladdr
== neigh
->ha
&& new == NUD_STALE
&&
1116 ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) ||
1117 (old
& NUD_CONNECTED
))
1124 neigh_del_timer(neigh
);
1125 if (new & NUD_IN_TIMER
)
1126 neigh_add_timer(neigh
, (jiffies
+
1127 ((new & NUD_REACHABLE
) ?
1128 neigh
->parms
->reachable_time
:
1130 neigh
->nud_state
= new;
1133 if (lladdr
!= neigh
->ha
) {
1134 write_seqlock(&neigh
->ha_lock
);
1135 memcpy(&neigh
->ha
, lladdr
, dev
->addr_len
);
1136 write_sequnlock(&neigh
->ha_lock
);
1137 neigh_update_hhs(neigh
);
1138 if (!(new & NUD_CONNECTED
))
1139 neigh
->confirmed
= jiffies
-
1140 (neigh
->parms
->base_reachable_time
<< 1);
1145 if (new & NUD_CONNECTED
)
1146 neigh_connect(neigh
);
1148 neigh_suspect(neigh
);
1149 if (!(old
& NUD_VALID
)) {
1150 struct sk_buff
*skb
;
1152 /* Again: avoid dead loop if something went wrong */
1154 while (neigh
->nud_state
& NUD_VALID
&&
1155 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
1156 struct neighbour
*n1
= neigh
;
1157 write_unlock_bh(&neigh
->lock
);
1158 /* On shaper/eql skb->dst->neighbour != neigh :( */
1159 if (skb_dst(skb
) && skb_dst(skb
)->neighbour
)
1160 n1
= skb_dst(skb
)->neighbour
;
1162 write_lock_bh(&neigh
->lock
);
1164 skb_queue_purge(&neigh
->arp_queue
);
1167 if (update_isrouter
) {
1168 neigh
->flags
= (flags
& NEIGH_UPDATE_F_ISROUTER
) ?
1169 (neigh
->flags
| NTF_ROUTER
) :
1170 (neigh
->flags
& ~NTF_ROUTER
);
1172 write_unlock_bh(&neigh
->lock
);
1175 neigh_update_notify(neigh
);
1179 EXPORT_SYMBOL(neigh_update
);
1181 struct neighbour
*neigh_event_ns(struct neigh_table
*tbl
,
1182 u8
*lladdr
, void *saddr
,
1183 struct net_device
*dev
)
1185 struct neighbour
*neigh
= __neigh_lookup(tbl
, saddr
, dev
,
1186 lladdr
|| !dev
->addr_len
);
1188 neigh_update(neigh
, lladdr
, NUD_STALE
,
1189 NEIGH_UPDATE_F_OVERRIDE
);
1192 EXPORT_SYMBOL(neigh_event_ns
);
1194 /* called with read_lock_bh(&n->lock); */
1195 static void neigh_hh_init(struct neighbour
*n
, struct dst_entry
*dst
)
1197 struct net_device
*dev
= dst
->dev
;
1198 __be16 prot
= dst
->ops
->protocol
;
1199 struct hh_cache
*hh
= &n
->hh
;
1201 write_lock_bh(&n
->lock
);
1203 /* Only one thread can come in here and initialize the
1207 dev
->header_ops
->cache(n
, hh
, prot
);
1209 write_unlock_bh(&n
->lock
);
1212 /* This function can be used in contexts, where only old dev_queue_xmit
1213 * worked, f.e. if you want to override normal output path (eql, shaper),
1214 * but resolution is not made yet.
1217 int neigh_compat_output(struct sk_buff
*skb
)
1219 struct net_device
*dev
= skb
->dev
;
1221 __skb_pull(skb
, skb_network_offset(skb
));
1223 if (dev_hard_header(skb
, dev
, ntohs(skb
->protocol
), NULL
, NULL
,
1225 dev
->header_ops
->rebuild(skb
))
1228 return dev_queue_xmit(skb
);
1230 EXPORT_SYMBOL(neigh_compat_output
);
1232 /* Slow and careful. */
1234 int neigh_resolve_output(struct sk_buff
*skb
)
1236 struct dst_entry
*dst
= skb_dst(skb
);
1237 struct neighbour
*neigh
;
1240 if (!dst
|| !(neigh
= dst
->neighbour
))
1243 __skb_pull(skb
, skb_network_offset(skb
));
1245 if (!neigh_event_send(neigh
, skb
)) {
1247 struct net_device
*dev
= neigh
->dev
;
1250 if (dev
->header_ops
->cache
&& !neigh
->hh
.hh_len
)
1251 neigh_hh_init(neigh
, dst
);
1254 seq
= read_seqbegin(&neigh
->ha_lock
);
1255 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1256 neigh
->ha
, NULL
, skb
->len
);
1257 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1260 rc
= neigh
->ops
->queue_xmit(skb
);
1267 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1268 dst
, dst
? dst
->neighbour
: NULL
);
1274 EXPORT_SYMBOL(neigh_resolve_output
);
1276 /* As fast as possible without hh cache */
1278 int neigh_connected_output(struct sk_buff
*skb
)
1281 struct dst_entry
*dst
= skb_dst(skb
);
1282 struct neighbour
*neigh
= dst
->neighbour
;
1283 struct net_device
*dev
= neigh
->dev
;
1286 __skb_pull(skb
, skb_network_offset(skb
));
1289 seq
= read_seqbegin(&neigh
->ha_lock
);
1290 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1291 neigh
->ha
, NULL
, skb
->len
);
1292 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1295 err
= neigh
->ops
->queue_xmit(skb
);
1302 EXPORT_SYMBOL(neigh_connected_output
);
1304 static void neigh_proxy_process(unsigned long arg
)
1306 struct neigh_table
*tbl
= (struct neigh_table
*)arg
;
1307 long sched_next
= 0;
1308 unsigned long now
= jiffies
;
1309 struct sk_buff
*skb
, *n
;
1311 spin_lock(&tbl
->proxy_queue
.lock
);
1313 skb_queue_walk_safe(&tbl
->proxy_queue
, skb
, n
) {
1314 long tdif
= NEIGH_CB(skb
)->sched_next
- now
;
1317 struct net_device
*dev
= skb
->dev
;
1318 __skb_unlink(skb
, &tbl
->proxy_queue
);
1319 if (tbl
->proxy_redo
&& netif_running(dev
))
1320 tbl
->proxy_redo(skb
);
1325 } else if (!sched_next
|| tdif
< sched_next
)
1328 del_timer(&tbl
->proxy_timer
);
1330 mod_timer(&tbl
->proxy_timer
, jiffies
+ sched_next
);
1331 spin_unlock(&tbl
->proxy_queue
.lock
);
1334 void pneigh_enqueue(struct neigh_table
*tbl
, struct neigh_parms
*p
,
1335 struct sk_buff
*skb
)
1337 unsigned long now
= jiffies
;
1338 unsigned long sched_next
= now
+ (net_random() % p
->proxy_delay
);
1340 if (tbl
->proxy_queue
.qlen
> p
->proxy_qlen
) {
1345 NEIGH_CB(skb
)->sched_next
= sched_next
;
1346 NEIGH_CB(skb
)->flags
|= LOCALLY_ENQUEUED
;
1348 spin_lock(&tbl
->proxy_queue
.lock
);
1349 if (del_timer(&tbl
->proxy_timer
)) {
1350 if (time_before(tbl
->proxy_timer
.expires
, sched_next
))
1351 sched_next
= tbl
->proxy_timer
.expires
;
1355 __skb_queue_tail(&tbl
->proxy_queue
, skb
);
1356 mod_timer(&tbl
->proxy_timer
, sched_next
);
1357 spin_unlock(&tbl
->proxy_queue
.lock
);
1359 EXPORT_SYMBOL(pneigh_enqueue
);
1361 static inline struct neigh_parms
*lookup_neigh_parms(struct neigh_table
*tbl
,
1362 struct net
*net
, int ifindex
)
1364 struct neigh_parms
*p
;
1366 for (p
= &tbl
->parms
; p
; p
= p
->next
) {
1367 if ((p
->dev
&& p
->dev
->ifindex
== ifindex
&& net_eq(neigh_parms_net(p
), net
)) ||
1368 (!p
->dev
&& !ifindex
))
1375 struct neigh_parms
*neigh_parms_alloc(struct net_device
*dev
,
1376 struct neigh_table
*tbl
)
1378 struct neigh_parms
*p
, *ref
;
1379 struct net
*net
= dev_net(dev
);
1380 const struct net_device_ops
*ops
= dev
->netdev_ops
;
1382 ref
= lookup_neigh_parms(tbl
, net
, 0);
1386 p
= kmemdup(ref
, sizeof(*p
), GFP_KERNEL
);
1389 atomic_set(&p
->refcnt
, 1);
1391 neigh_rand_reach_time(p
->base_reachable_time
);
1393 if (ops
->ndo_neigh_setup
&& ops
->ndo_neigh_setup(dev
, p
)) {
1400 write_pnet(&p
->net
, hold_net(net
));
1401 p
->sysctl_table
= NULL
;
1402 write_lock_bh(&tbl
->lock
);
1403 p
->next
= tbl
->parms
.next
;
1404 tbl
->parms
.next
= p
;
1405 write_unlock_bh(&tbl
->lock
);
1409 EXPORT_SYMBOL(neigh_parms_alloc
);
1411 static void neigh_rcu_free_parms(struct rcu_head
*head
)
1413 struct neigh_parms
*parms
=
1414 container_of(head
, struct neigh_parms
, rcu_head
);
1416 neigh_parms_put(parms
);
1419 void neigh_parms_release(struct neigh_table
*tbl
, struct neigh_parms
*parms
)
1421 struct neigh_parms
**p
;
1423 if (!parms
|| parms
== &tbl
->parms
)
1425 write_lock_bh(&tbl
->lock
);
1426 for (p
= &tbl
->parms
.next
; *p
; p
= &(*p
)->next
) {
1430 write_unlock_bh(&tbl
->lock
);
1432 dev_put(parms
->dev
);
1433 call_rcu(&parms
->rcu_head
, neigh_rcu_free_parms
);
1437 write_unlock_bh(&tbl
->lock
);
1438 NEIGH_PRINTK1("neigh_parms_release: not found\n");
1440 EXPORT_SYMBOL(neigh_parms_release
);
1442 static void neigh_parms_destroy(struct neigh_parms
*parms
)
1444 release_net(neigh_parms_net(parms
));
1448 static struct lock_class_key neigh_table_proxy_queue_class
;
1450 void neigh_table_init_no_netlink(struct neigh_table
*tbl
)
1452 unsigned long now
= jiffies
;
1453 unsigned long phsize
;
1455 write_pnet(&tbl
->parms
.net
, &init_net
);
1456 atomic_set(&tbl
->parms
.refcnt
, 1);
1457 tbl
->parms
.reachable_time
=
1458 neigh_rand_reach_time(tbl
->parms
.base_reachable_time
);
1460 if (!tbl
->kmem_cachep
)
1462 kmem_cache_create(tbl
->id
, tbl
->entry_size
, 0,
1463 SLAB_HWCACHE_ALIGN
|SLAB_PANIC
,
1465 tbl
->stats
= alloc_percpu(struct neigh_statistics
);
1467 panic("cannot create neighbour cache statistics");
1469 #ifdef CONFIG_PROC_FS
1470 if (!proc_create_data(tbl
->id
, 0, init_net
.proc_net_stat
,
1471 &neigh_stat_seq_fops
, tbl
))
1472 panic("cannot create neighbour proc dir entry");
1475 RCU_INIT_POINTER(tbl
->nht
, neigh_hash_alloc(3));
1477 phsize
= (PNEIGH_HASHMASK
+ 1) * sizeof(struct pneigh_entry
*);
1478 tbl
->phash_buckets
= kzalloc(phsize
, GFP_KERNEL
);
1480 if (!tbl
->nht
|| !tbl
->phash_buckets
)
1481 panic("cannot allocate neighbour cache hashes");
1483 rwlock_init(&tbl
->lock
);
1484 INIT_DELAYED_WORK_DEFERRABLE(&tbl
->gc_work
, neigh_periodic_work
);
1485 schedule_delayed_work(&tbl
->gc_work
, tbl
->parms
.reachable_time
);
1486 setup_timer(&tbl
->proxy_timer
, neigh_proxy_process
, (unsigned long)tbl
);
1487 skb_queue_head_init_class(&tbl
->proxy_queue
,
1488 &neigh_table_proxy_queue_class
);
1490 tbl
->last_flush
= now
;
1491 tbl
->last_rand
= now
+ tbl
->parms
.reachable_time
* 20;
1493 EXPORT_SYMBOL(neigh_table_init_no_netlink
);
1495 void neigh_table_init(struct neigh_table
*tbl
)
1497 struct neigh_table
*tmp
;
1499 neigh_table_init_no_netlink(tbl
);
1500 write_lock(&neigh_tbl_lock
);
1501 for (tmp
= neigh_tables
; tmp
; tmp
= tmp
->next
) {
1502 if (tmp
->family
== tbl
->family
)
1505 tbl
->next
= neigh_tables
;
1507 write_unlock(&neigh_tbl_lock
);
1509 if (unlikely(tmp
)) {
1510 printk(KERN_ERR
"NEIGH: Registering multiple tables for "
1511 "family %d\n", tbl
->family
);
1515 EXPORT_SYMBOL(neigh_table_init
);
1517 int neigh_table_clear(struct neigh_table
*tbl
)
1519 struct neigh_table
**tp
;
1521 /* It is not clean... Fix it to unload IPv6 module safely */
1522 cancel_delayed_work_sync(&tbl
->gc_work
);
1523 del_timer_sync(&tbl
->proxy_timer
);
1524 pneigh_queue_purge(&tbl
->proxy_queue
);
1525 neigh_ifdown(tbl
, NULL
);
1526 if (atomic_read(&tbl
->entries
))
1527 printk(KERN_CRIT
"neighbour leakage\n");
1528 write_lock(&neigh_tbl_lock
);
1529 for (tp
= &neigh_tables
; *tp
; tp
= &(*tp
)->next
) {
1535 write_unlock(&neigh_tbl_lock
);
1537 call_rcu(&rcu_dereference_protected(tbl
->nht
, 1)->rcu
,
1538 neigh_hash_free_rcu
);
1541 kfree(tbl
->phash_buckets
);
1542 tbl
->phash_buckets
= NULL
;
1544 remove_proc_entry(tbl
->id
, init_net
.proc_net_stat
);
1546 free_percpu(tbl
->stats
);
1549 kmem_cache_destroy(tbl
->kmem_cachep
);
1550 tbl
->kmem_cachep
= NULL
;
1554 EXPORT_SYMBOL(neigh_table_clear
);
1556 static int neigh_delete(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
1558 struct net
*net
= sock_net(skb
->sk
);
1560 struct nlattr
*dst_attr
;
1561 struct neigh_table
*tbl
;
1562 struct net_device
*dev
= NULL
;
1566 if (nlmsg_len(nlh
) < sizeof(*ndm
))
1569 dst_attr
= nlmsg_find_attr(nlh
, sizeof(*ndm
), NDA_DST
);
1570 if (dst_attr
== NULL
)
1573 ndm
= nlmsg_data(nlh
);
1574 if (ndm
->ndm_ifindex
) {
1575 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1582 read_lock(&neigh_tbl_lock
);
1583 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1584 struct neighbour
*neigh
;
1586 if (tbl
->family
!= ndm
->ndm_family
)
1588 read_unlock(&neigh_tbl_lock
);
1590 if (nla_len(dst_attr
) < tbl
->key_len
)
1593 if (ndm
->ndm_flags
& NTF_PROXY
) {
1594 err
= pneigh_delete(tbl
, net
, nla_data(dst_attr
), dev
);
1601 neigh
= neigh_lookup(tbl
, nla_data(dst_attr
), dev
);
1602 if (neigh
== NULL
) {
1607 err
= neigh_update(neigh
, NULL
, NUD_FAILED
,
1608 NEIGH_UPDATE_F_OVERRIDE
|
1609 NEIGH_UPDATE_F_ADMIN
);
1610 neigh_release(neigh
);
1613 read_unlock(&neigh_tbl_lock
);
1614 err
= -EAFNOSUPPORT
;
1620 static int neigh_add(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
1622 struct net
*net
= sock_net(skb
->sk
);
1624 struct nlattr
*tb
[NDA_MAX
+1];
1625 struct neigh_table
*tbl
;
1626 struct net_device
*dev
= NULL
;
1630 err
= nlmsg_parse(nlh
, sizeof(*ndm
), tb
, NDA_MAX
, NULL
);
1635 if (tb
[NDA_DST
] == NULL
)
1638 ndm
= nlmsg_data(nlh
);
1639 if (ndm
->ndm_ifindex
) {
1640 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1646 if (tb
[NDA_LLADDR
] && nla_len(tb
[NDA_LLADDR
]) < dev
->addr_len
)
1650 read_lock(&neigh_tbl_lock
);
1651 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1652 int flags
= NEIGH_UPDATE_F_ADMIN
| NEIGH_UPDATE_F_OVERRIDE
;
1653 struct neighbour
*neigh
;
1656 if (tbl
->family
!= ndm
->ndm_family
)
1658 read_unlock(&neigh_tbl_lock
);
1660 if (nla_len(tb
[NDA_DST
]) < tbl
->key_len
)
1662 dst
= nla_data(tb
[NDA_DST
]);
1663 lladdr
= tb
[NDA_LLADDR
] ? nla_data(tb
[NDA_LLADDR
]) : NULL
;
1665 if (ndm
->ndm_flags
& NTF_PROXY
) {
1666 struct pneigh_entry
*pn
;
1669 pn
= pneigh_lookup(tbl
, net
, dst
, dev
, 1);
1671 pn
->flags
= ndm
->ndm_flags
;
1680 neigh
= neigh_lookup(tbl
, dst
, dev
);
1681 if (neigh
== NULL
) {
1682 if (!(nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
1687 neigh
= __neigh_lookup_errno(tbl
, dst
, dev
);
1688 if (IS_ERR(neigh
)) {
1689 err
= PTR_ERR(neigh
);
1693 if (nlh
->nlmsg_flags
& NLM_F_EXCL
) {
1695 neigh_release(neigh
);
1699 if (!(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
1700 flags
&= ~NEIGH_UPDATE_F_OVERRIDE
;
1703 if (ndm
->ndm_flags
& NTF_USE
) {
1704 neigh_event_send(neigh
, NULL
);
1707 err
= neigh_update(neigh
, lladdr
, ndm
->ndm_state
, flags
);
1708 neigh_release(neigh
);
1712 read_unlock(&neigh_tbl_lock
);
1713 err
= -EAFNOSUPPORT
;
1718 static int neightbl_fill_parms(struct sk_buff
*skb
, struct neigh_parms
*parms
)
1720 struct nlattr
*nest
;
1722 nest
= nla_nest_start(skb
, NDTA_PARMS
);
1727 NLA_PUT_U32(skb
, NDTPA_IFINDEX
, parms
->dev
->ifindex
);
1729 NLA_PUT_U32(skb
, NDTPA_REFCNT
, atomic_read(&parms
->refcnt
));
1730 NLA_PUT_U32(skb
, NDTPA_QUEUE_LEN
, parms
->queue_len
);
1731 NLA_PUT_U32(skb
, NDTPA_PROXY_QLEN
, parms
->proxy_qlen
);
1732 NLA_PUT_U32(skb
, NDTPA_APP_PROBES
, parms
->app_probes
);
1733 NLA_PUT_U32(skb
, NDTPA_UCAST_PROBES
, parms
->ucast_probes
);
1734 NLA_PUT_U32(skb
, NDTPA_MCAST_PROBES
, parms
->mcast_probes
);
1735 NLA_PUT_MSECS(skb
, NDTPA_REACHABLE_TIME
, parms
->reachable_time
);
1736 NLA_PUT_MSECS(skb
, NDTPA_BASE_REACHABLE_TIME
,
1737 parms
->base_reachable_time
);
1738 NLA_PUT_MSECS(skb
, NDTPA_GC_STALETIME
, parms
->gc_staletime
);
1739 NLA_PUT_MSECS(skb
, NDTPA_DELAY_PROBE_TIME
, parms
->delay_probe_time
);
1740 NLA_PUT_MSECS(skb
, NDTPA_RETRANS_TIME
, parms
->retrans_time
);
1741 NLA_PUT_MSECS(skb
, NDTPA_ANYCAST_DELAY
, parms
->anycast_delay
);
1742 NLA_PUT_MSECS(skb
, NDTPA_PROXY_DELAY
, parms
->proxy_delay
);
1743 NLA_PUT_MSECS(skb
, NDTPA_LOCKTIME
, parms
->locktime
);
1745 return nla_nest_end(skb
, nest
);
1748 nla_nest_cancel(skb
, nest
);
1752 static int neightbl_fill_info(struct sk_buff
*skb
, struct neigh_table
*tbl
,
1753 u32 pid
, u32 seq
, int type
, int flags
)
1755 struct nlmsghdr
*nlh
;
1756 struct ndtmsg
*ndtmsg
;
1758 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1762 ndtmsg
= nlmsg_data(nlh
);
1764 read_lock_bh(&tbl
->lock
);
1765 ndtmsg
->ndtm_family
= tbl
->family
;
1766 ndtmsg
->ndtm_pad1
= 0;
1767 ndtmsg
->ndtm_pad2
= 0;
1769 NLA_PUT_STRING(skb
, NDTA_NAME
, tbl
->id
);
1770 NLA_PUT_MSECS(skb
, NDTA_GC_INTERVAL
, tbl
->gc_interval
);
1771 NLA_PUT_U32(skb
, NDTA_THRESH1
, tbl
->gc_thresh1
);
1772 NLA_PUT_U32(skb
, NDTA_THRESH2
, tbl
->gc_thresh2
);
1773 NLA_PUT_U32(skb
, NDTA_THRESH3
, tbl
->gc_thresh3
);
1776 unsigned long now
= jiffies
;
1777 unsigned int flush_delta
= now
- tbl
->last_flush
;
1778 unsigned int rand_delta
= now
- tbl
->last_rand
;
1779 struct neigh_hash_table
*nht
;
1780 struct ndt_config ndc
= {
1781 .ndtc_key_len
= tbl
->key_len
,
1782 .ndtc_entry_size
= tbl
->entry_size
,
1783 .ndtc_entries
= atomic_read(&tbl
->entries
),
1784 .ndtc_last_flush
= jiffies_to_msecs(flush_delta
),
1785 .ndtc_last_rand
= jiffies_to_msecs(rand_delta
),
1786 .ndtc_proxy_qlen
= tbl
->proxy_queue
.qlen
,
1790 nht
= rcu_dereference_bh(tbl
->nht
);
1791 ndc
.ndtc_hash_rnd
= nht
->hash_rnd
;
1792 ndc
.ndtc_hash_mask
= ((1 << nht
->hash_shift
) - 1);
1793 rcu_read_unlock_bh();
1795 NLA_PUT(skb
, NDTA_CONFIG
, sizeof(ndc
), &ndc
);
1800 struct ndt_stats ndst
;
1802 memset(&ndst
, 0, sizeof(ndst
));
1804 for_each_possible_cpu(cpu
) {
1805 struct neigh_statistics
*st
;
1807 st
= per_cpu_ptr(tbl
->stats
, cpu
);
1808 ndst
.ndts_allocs
+= st
->allocs
;
1809 ndst
.ndts_destroys
+= st
->destroys
;
1810 ndst
.ndts_hash_grows
+= st
->hash_grows
;
1811 ndst
.ndts_res_failed
+= st
->res_failed
;
1812 ndst
.ndts_lookups
+= st
->lookups
;
1813 ndst
.ndts_hits
+= st
->hits
;
1814 ndst
.ndts_rcv_probes_mcast
+= st
->rcv_probes_mcast
;
1815 ndst
.ndts_rcv_probes_ucast
+= st
->rcv_probes_ucast
;
1816 ndst
.ndts_periodic_gc_runs
+= st
->periodic_gc_runs
;
1817 ndst
.ndts_forced_gc_runs
+= st
->forced_gc_runs
;
1820 NLA_PUT(skb
, NDTA_STATS
, sizeof(ndst
), &ndst
);
1823 BUG_ON(tbl
->parms
.dev
);
1824 if (neightbl_fill_parms(skb
, &tbl
->parms
) < 0)
1825 goto nla_put_failure
;
1827 read_unlock_bh(&tbl
->lock
);
1828 return nlmsg_end(skb
, nlh
);
1831 read_unlock_bh(&tbl
->lock
);
1832 nlmsg_cancel(skb
, nlh
);
1836 static int neightbl_fill_param_info(struct sk_buff
*skb
,
1837 struct neigh_table
*tbl
,
1838 struct neigh_parms
*parms
,
1839 u32 pid
, u32 seq
, int type
,
1842 struct ndtmsg
*ndtmsg
;
1843 struct nlmsghdr
*nlh
;
1845 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1849 ndtmsg
= nlmsg_data(nlh
);
1851 read_lock_bh(&tbl
->lock
);
1852 ndtmsg
->ndtm_family
= tbl
->family
;
1853 ndtmsg
->ndtm_pad1
= 0;
1854 ndtmsg
->ndtm_pad2
= 0;
1856 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) < 0 ||
1857 neightbl_fill_parms(skb
, parms
) < 0)
1860 read_unlock_bh(&tbl
->lock
);
1861 return nlmsg_end(skb
, nlh
);
1863 read_unlock_bh(&tbl
->lock
);
1864 nlmsg_cancel(skb
, nlh
);
1868 static const struct nla_policy nl_neightbl_policy
[NDTA_MAX
+1] = {
1869 [NDTA_NAME
] = { .type
= NLA_STRING
},
1870 [NDTA_THRESH1
] = { .type
= NLA_U32
},
1871 [NDTA_THRESH2
] = { .type
= NLA_U32
},
1872 [NDTA_THRESH3
] = { .type
= NLA_U32
},
1873 [NDTA_GC_INTERVAL
] = { .type
= NLA_U64
},
1874 [NDTA_PARMS
] = { .type
= NLA_NESTED
},
1877 static const struct nla_policy nl_ntbl_parm_policy
[NDTPA_MAX
+1] = {
1878 [NDTPA_IFINDEX
] = { .type
= NLA_U32
},
1879 [NDTPA_QUEUE_LEN
] = { .type
= NLA_U32
},
1880 [NDTPA_PROXY_QLEN
] = { .type
= NLA_U32
},
1881 [NDTPA_APP_PROBES
] = { .type
= NLA_U32
},
1882 [NDTPA_UCAST_PROBES
] = { .type
= NLA_U32
},
1883 [NDTPA_MCAST_PROBES
] = { .type
= NLA_U32
},
1884 [NDTPA_BASE_REACHABLE_TIME
] = { .type
= NLA_U64
},
1885 [NDTPA_GC_STALETIME
] = { .type
= NLA_U64
},
1886 [NDTPA_DELAY_PROBE_TIME
] = { .type
= NLA_U64
},
1887 [NDTPA_RETRANS_TIME
] = { .type
= NLA_U64
},
1888 [NDTPA_ANYCAST_DELAY
] = { .type
= NLA_U64
},
1889 [NDTPA_PROXY_DELAY
] = { .type
= NLA_U64
},
1890 [NDTPA_LOCKTIME
] = { .type
= NLA_U64
},
1893 static int neightbl_set(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
1895 struct net
*net
= sock_net(skb
->sk
);
1896 struct neigh_table
*tbl
;
1897 struct ndtmsg
*ndtmsg
;
1898 struct nlattr
*tb
[NDTA_MAX
+1];
1901 err
= nlmsg_parse(nlh
, sizeof(*ndtmsg
), tb
, NDTA_MAX
,
1902 nl_neightbl_policy
);
1906 if (tb
[NDTA_NAME
] == NULL
) {
1911 ndtmsg
= nlmsg_data(nlh
);
1912 read_lock(&neigh_tbl_lock
);
1913 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1914 if (ndtmsg
->ndtm_family
&& tbl
->family
!= ndtmsg
->ndtm_family
)
1917 if (nla_strcmp(tb
[NDTA_NAME
], tbl
->id
) == 0)
1927 * We acquire tbl->lock to be nice to the periodic timers and
1928 * make sure they always see a consistent set of values.
1930 write_lock_bh(&tbl
->lock
);
1932 if (tb
[NDTA_PARMS
]) {
1933 struct nlattr
*tbp
[NDTPA_MAX
+1];
1934 struct neigh_parms
*p
;
1937 err
= nla_parse_nested(tbp
, NDTPA_MAX
, tb
[NDTA_PARMS
],
1938 nl_ntbl_parm_policy
);
1940 goto errout_tbl_lock
;
1942 if (tbp
[NDTPA_IFINDEX
])
1943 ifindex
= nla_get_u32(tbp
[NDTPA_IFINDEX
]);
1945 p
= lookup_neigh_parms(tbl
, net
, ifindex
);
1948 goto errout_tbl_lock
;
1951 for (i
= 1; i
<= NDTPA_MAX
; i
++) {
1956 case NDTPA_QUEUE_LEN
:
1957 p
->queue_len
= nla_get_u32(tbp
[i
]);
1959 case NDTPA_PROXY_QLEN
:
1960 p
->proxy_qlen
= nla_get_u32(tbp
[i
]);
1962 case NDTPA_APP_PROBES
:
1963 p
->app_probes
= nla_get_u32(tbp
[i
]);
1965 case NDTPA_UCAST_PROBES
:
1966 p
->ucast_probes
= nla_get_u32(tbp
[i
]);
1968 case NDTPA_MCAST_PROBES
:
1969 p
->mcast_probes
= nla_get_u32(tbp
[i
]);
1971 case NDTPA_BASE_REACHABLE_TIME
:
1972 p
->base_reachable_time
= nla_get_msecs(tbp
[i
]);
1974 case NDTPA_GC_STALETIME
:
1975 p
->gc_staletime
= nla_get_msecs(tbp
[i
]);
1977 case NDTPA_DELAY_PROBE_TIME
:
1978 p
->delay_probe_time
= nla_get_msecs(tbp
[i
]);
1980 case NDTPA_RETRANS_TIME
:
1981 p
->retrans_time
= nla_get_msecs(tbp
[i
]);
1983 case NDTPA_ANYCAST_DELAY
:
1984 p
->anycast_delay
= nla_get_msecs(tbp
[i
]);
1986 case NDTPA_PROXY_DELAY
:
1987 p
->proxy_delay
= nla_get_msecs(tbp
[i
]);
1989 case NDTPA_LOCKTIME
:
1990 p
->locktime
= nla_get_msecs(tbp
[i
]);
1996 if (tb
[NDTA_THRESH1
])
1997 tbl
->gc_thresh1
= nla_get_u32(tb
[NDTA_THRESH1
]);
1999 if (tb
[NDTA_THRESH2
])
2000 tbl
->gc_thresh2
= nla_get_u32(tb
[NDTA_THRESH2
]);
2002 if (tb
[NDTA_THRESH3
])
2003 tbl
->gc_thresh3
= nla_get_u32(tb
[NDTA_THRESH3
]);
2005 if (tb
[NDTA_GC_INTERVAL
])
2006 tbl
->gc_interval
= nla_get_msecs(tb
[NDTA_GC_INTERVAL
]);
2011 write_unlock_bh(&tbl
->lock
);
2013 read_unlock(&neigh_tbl_lock
);
2018 static int neightbl_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2020 struct net
*net
= sock_net(skb
->sk
);
2021 int family
, tidx
, nidx
= 0;
2022 int tbl_skip
= cb
->args
[0];
2023 int neigh_skip
= cb
->args
[1];
2024 struct neigh_table
*tbl
;
2026 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2028 read_lock(&neigh_tbl_lock
);
2029 for (tbl
= neigh_tables
, tidx
= 0; tbl
; tbl
= tbl
->next
, tidx
++) {
2030 struct neigh_parms
*p
;
2032 if (tidx
< tbl_skip
|| (family
&& tbl
->family
!= family
))
2035 if (neightbl_fill_info(skb
, tbl
, NETLINK_CB(cb
->skb
).pid
,
2036 cb
->nlh
->nlmsg_seq
, RTM_NEWNEIGHTBL
,
2040 for (nidx
= 0, p
= tbl
->parms
.next
; p
; p
= p
->next
) {
2041 if (!net_eq(neigh_parms_net(p
), net
))
2044 if (nidx
< neigh_skip
)
2047 if (neightbl_fill_param_info(skb
, tbl
, p
,
2048 NETLINK_CB(cb
->skb
).pid
,
2060 read_unlock(&neigh_tbl_lock
);
2067 static int neigh_fill_info(struct sk_buff
*skb
, struct neighbour
*neigh
,
2068 u32 pid
, u32 seq
, int type
, unsigned int flags
)
2070 unsigned long now
= jiffies
;
2071 struct nda_cacheinfo ci
;
2072 struct nlmsghdr
*nlh
;
2075 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2079 ndm
= nlmsg_data(nlh
);
2080 ndm
->ndm_family
= neigh
->ops
->family
;
2083 ndm
->ndm_flags
= neigh
->flags
;
2084 ndm
->ndm_type
= neigh
->type
;
2085 ndm
->ndm_ifindex
= neigh
->dev
->ifindex
;
2087 NLA_PUT(skb
, NDA_DST
, neigh
->tbl
->key_len
, neigh
->primary_key
);
2089 read_lock_bh(&neigh
->lock
);
2090 ndm
->ndm_state
= neigh
->nud_state
;
2091 if (neigh
->nud_state
& NUD_VALID
) {
2092 char haddr
[MAX_ADDR_LEN
];
2094 neigh_ha_snapshot(haddr
, neigh
, neigh
->dev
);
2095 if (nla_put(skb
, NDA_LLADDR
, neigh
->dev
->addr_len
, haddr
) < 0) {
2096 read_unlock_bh(&neigh
->lock
);
2097 goto nla_put_failure
;
2101 ci
.ndm_used
= jiffies_to_clock_t(now
- neigh
->used
);
2102 ci
.ndm_confirmed
= jiffies_to_clock_t(now
- neigh
->confirmed
);
2103 ci
.ndm_updated
= jiffies_to_clock_t(now
- neigh
->updated
);
2104 ci
.ndm_refcnt
= atomic_read(&neigh
->refcnt
) - 1;
2105 read_unlock_bh(&neigh
->lock
);
2107 NLA_PUT_U32(skb
, NDA_PROBES
, atomic_read(&neigh
->probes
));
2108 NLA_PUT(skb
, NDA_CACHEINFO
, sizeof(ci
), &ci
);
2110 return nlmsg_end(skb
, nlh
);
2113 nlmsg_cancel(skb
, nlh
);
2117 static void neigh_update_notify(struct neighbour
*neigh
)
2119 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
2120 __neigh_notify(neigh
, RTM_NEWNEIGH
, 0);
2123 static int neigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2124 struct netlink_callback
*cb
)
2126 struct net
*net
= sock_net(skb
->sk
);
2127 struct neighbour
*n
;
2128 int rc
, h
, s_h
= cb
->args
[1];
2129 int idx
, s_idx
= idx
= cb
->args
[2];
2130 struct neigh_hash_table
*nht
;
2133 nht
= rcu_dereference_bh(tbl
->nht
);
2135 for (h
= 0; h
< (1 << nht
->hash_shift
); h
++) {
2140 for (n
= rcu_dereference_bh(nht
->hash_buckets
[h
]), idx
= 0;
2142 n
= rcu_dereference_bh(n
->next
)) {
2143 if (!net_eq(dev_net(n
->dev
), net
))
2147 if (neigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).pid
,
2150 NLM_F_MULTI
) <= 0) {
2160 rcu_read_unlock_bh();
2166 static int neigh_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2168 struct neigh_table
*tbl
;
2171 read_lock(&neigh_tbl_lock
);
2172 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2175 for (tbl
= neigh_tables
, t
= 0; tbl
; tbl
= tbl
->next
, t
++) {
2176 if (t
< s_t
|| (family
&& tbl
->family
!= family
))
2179 memset(&cb
->args
[1], 0, sizeof(cb
->args
) -
2180 sizeof(cb
->args
[0]));
2181 if (neigh_dump_table(tbl
, skb
, cb
) < 0)
2184 read_unlock(&neigh_tbl_lock
);
2190 void neigh_for_each(struct neigh_table
*tbl
, void (*cb
)(struct neighbour
*, void *), void *cookie
)
2193 struct neigh_hash_table
*nht
;
2196 nht
= rcu_dereference_bh(tbl
->nht
);
2198 read_lock(&tbl
->lock
); /* avoid resizes */
2199 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2200 struct neighbour
*n
;
2202 for (n
= rcu_dereference_bh(nht
->hash_buckets
[chain
]);
2204 n
= rcu_dereference_bh(n
->next
))
2207 read_unlock(&tbl
->lock
);
2208 rcu_read_unlock_bh();
2210 EXPORT_SYMBOL(neigh_for_each
);
2212 /* The tbl->lock must be held as a writer and BH disabled. */
2213 void __neigh_for_each_release(struct neigh_table
*tbl
,
2214 int (*cb
)(struct neighbour
*))
2217 struct neigh_hash_table
*nht
;
2219 nht
= rcu_dereference_protected(tbl
->nht
,
2220 lockdep_is_held(&tbl
->lock
));
2221 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2222 struct neighbour
*n
;
2223 struct neighbour __rcu
**np
;
2225 np
= &nht
->hash_buckets
[chain
];
2226 while ((n
= rcu_dereference_protected(*np
,
2227 lockdep_is_held(&tbl
->lock
))) != NULL
) {
2230 write_lock(&n
->lock
);
2233 rcu_assign_pointer(*np
,
2234 rcu_dereference_protected(n
->next
,
2235 lockdep_is_held(&tbl
->lock
)));
2239 write_unlock(&n
->lock
);
2241 neigh_cleanup_and_release(n
);
2245 EXPORT_SYMBOL(__neigh_for_each_release
);
2247 #ifdef CONFIG_PROC_FS
2249 static struct neighbour
*neigh_get_first(struct seq_file
*seq
)
2251 struct neigh_seq_state
*state
= seq
->private;
2252 struct net
*net
= seq_file_net(seq
);
2253 struct neigh_hash_table
*nht
= state
->nht
;
2254 struct neighbour
*n
= NULL
;
2255 int bucket
= state
->bucket
;
2257 state
->flags
&= ~NEIGH_SEQ_IS_PNEIGH
;
2258 for (bucket
= 0; bucket
< (1 << nht
->hash_shift
); bucket
++) {
2259 n
= rcu_dereference_bh(nht
->hash_buckets
[bucket
]);
2262 if (!net_eq(dev_net(n
->dev
), net
))
2264 if (state
->neigh_sub_iter
) {
2268 v
= state
->neigh_sub_iter(state
, n
, &fakep
);
2272 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2274 if (n
->nud_state
& ~NUD_NOARP
)
2277 n
= rcu_dereference_bh(n
->next
);
2283 state
->bucket
= bucket
;
2288 static struct neighbour
*neigh_get_next(struct seq_file
*seq
,
2289 struct neighbour
*n
,
2292 struct neigh_seq_state
*state
= seq
->private;
2293 struct net
*net
= seq_file_net(seq
);
2294 struct neigh_hash_table
*nht
= state
->nht
;
2296 if (state
->neigh_sub_iter
) {
2297 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2301 n
= rcu_dereference_bh(n
->next
);
2305 if (!net_eq(dev_net(n
->dev
), net
))
2307 if (state
->neigh_sub_iter
) {
2308 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2313 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2316 if (n
->nud_state
& ~NUD_NOARP
)
2319 n
= rcu_dereference_bh(n
->next
);
2325 if (++state
->bucket
>= (1 << nht
->hash_shift
))
2328 n
= rcu_dereference_bh(nht
->hash_buckets
[state
->bucket
]);
2336 static struct neighbour
*neigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2338 struct neighbour
*n
= neigh_get_first(seq
);
2343 n
= neigh_get_next(seq
, n
, pos
);
2348 return *pos
? NULL
: n
;
2351 static struct pneigh_entry
*pneigh_get_first(struct seq_file
*seq
)
2353 struct neigh_seq_state
*state
= seq
->private;
2354 struct net
*net
= seq_file_net(seq
);
2355 struct neigh_table
*tbl
= state
->tbl
;
2356 struct pneigh_entry
*pn
= NULL
;
2357 int bucket
= state
->bucket
;
2359 state
->flags
|= NEIGH_SEQ_IS_PNEIGH
;
2360 for (bucket
= 0; bucket
<= PNEIGH_HASHMASK
; bucket
++) {
2361 pn
= tbl
->phash_buckets
[bucket
];
2362 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2367 state
->bucket
= bucket
;
2372 static struct pneigh_entry
*pneigh_get_next(struct seq_file
*seq
,
2373 struct pneigh_entry
*pn
,
2376 struct neigh_seq_state
*state
= seq
->private;
2377 struct net
*net
= seq_file_net(seq
);
2378 struct neigh_table
*tbl
= state
->tbl
;
2382 if (++state
->bucket
> PNEIGH_HASHMASK
)
2384 pn
= tbl
->phash_buckets
[state
->bucket
];
2385 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2397 static struct pneigh_entry
*pneigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2399 struct pneigh_entry
*pn
= pneigh_get_first(seq
);
2404 pn
= pneigh_get_next(seq
, pn
, pos
);
2409 return *pos
? NULL
: pn
;
2412 static void *neigh_get_idx_any(struct seq_file
*seq
, loff_t
*pos
)
2414 struct neigh_seq_state
*state
= seq
->private;
2416 loff_t idxpos
= *pos
;
2418 rc
= neigh_get_idx(seq
, &idxpos
);
2419 if (!rc
&& !(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2420 rc
= pneigh_get_idx(seq
, &idxpos
);
2425 void *neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
, struct neigh_table
*tbl
, unsigned int neigh_seq_flags
)
2428 struct neigh_seq_state
*state
= seq
->private;
2432 state
->flags
= (neigh_seq_flags
& ~NEIGH_SEQ_IS_PNEIGH
);
2435 state
->nht
= rcu_dereference_bh(tbl
->nht
);
2437 return *pos
? neigh_get_idx_any(seq
, pos
) : SEQ_START_TOKEN
;
2439 EXPORT_SYMBOL(neigh_seq_start
);
2441 void *neigh_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2443 struct neigh_seq_state
*state
;
2446 if (v
== SEQ_START_TOKEN
) {
2447 rc
= neigh_get_first(seq
);
2451 state
= seq
->private;
2452 if (!(state
->flags
& NEIGH_SEQ_IS_PNEIGH
)) {
2453 rc
= neigh_get_next(seq
, v
, NULL
);
2456 if (!(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2457 rc
= pneigh_get_first(seq
);
2459 BUG_ON(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
);
2460 rc
= pneigh_get_next(seq
, v
, NULL
);
2466 EXPORT_SYMBOL(neigh_seq_next
);
2468 void neigh_seq_stop(struct seq_file
*seq
, void *v
)
2471 rcu_read_unlock_bh();
2473 EXPORT_SYMBOL(neigh_seq_stop
);
2475 /* statistics via seq_file */
2477 static void *neigh_stat_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2479 struct neigh_table
*tbl
= seq
->private;
2483 return SEQ_START_TOKEN
;
2485 for (cpu
= *pos
-1; cpu
< nr_cpu_ids
; ++cpu
) {
2486 if (!cpu_possible(cpu
))
2489 return per_cpu_ptr(tbl
->stats
, cpu
);
2494 static void *neigh_stat_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2496 struct neigh_table
*tbl
= seq
->private;
2499 for (cpu
= *pos
; cpu
< nr_cpu_ids
; ++cpu
) {
2500 if (!cpu_possible(cpu
))
2503 return per_cpu_ptr(tbl
->stats
, cpu
);
2508 static void neigh_stat_seq_stop(struct seq_file
*seq
, void *v
)
2513 static int neigh_stat_seq_show(struct seq_file
*seq
, void *v
)
2515 struct neigh_table
*tbl
= seq
->private;
2516 struct neigh_statistics
*st
= v
;
2518 if (v
== SEQ_START_TOKEN
) {
2519 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");
2523 seq_printf(seq
, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2524 "%08lx %08lx %08lx %08lx %08lx\n",
2525 atomic_read(&tbl
->entries
),
2536 st
->rcv_probes_mcast
,
2537 st
->rcv_probes_ucast
,
2539 st
->periodic_gc_runs
,
2547 static const struct seq_operations neigh_stat_seq_ops
= {
2548 .start
= neigh_stat_seq_start
,
2549 .next
= neigh_stat_seq_next
,
2550 .stop
= neigh_stat_seq_stop
,
2551 .show
= neigh_stat_seq_show
,
2554 static int neigh_stat_seq_open(struct inode
*inode
, struct file
*file
)
2556 int ret
= seq_open(file
, &neigh_stat_seq_ops
);
2559 struct seq_file
*sf
= file
->private_data
;
2560 sf
->private = PDE(inode
)->data
;
2565 static const struct file_operations neigh_stat_seq_fops
= {
2566 .owner
= THIS_MODULE
,
2567 .open
= neigh_stat_seq_open
,
2569 .llseek
= seq_lseek
,
2570 .release
= seq_release
,
2573 #endif /* CONFIG_PROC_FS */
2575 static inline size_t neigh_nlmsg_size(void)
2577 return NLMSG_ALIGN(sizeof(struct ndmsg
))
2578 + nla_total_size(MAX_ADDR_LEN
) /* NDA_DST */
2579 + nla_total_size(MAX_ADDR_LEN
) /* NDA_LLADDR */
2580 + nla_total_size(sizeof(struct nda_cacheinfo
))
2581 + nla_total_size(4); /* NDA_PROBES */
2584 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
)
2586 struct net
*net
= dev_net(n
->dev
);
2587 struct sk_buff
*skb
;
2590 skb
= nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC
);
2594 err
= neigh_fill_info(skb
, n
, 0, 0, type
, flags
);
2596 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2597 WARN_ON(err
== -EMSGSIZE
);
2601 rtnl_notify(skb
, net
, 0, RTNLGRP_NEIGH
, NULL
, GFP_ATOMIC
);
2605 rtnl_set_sk_err(net
, RTNLGRP_NEIGH
, err
);
2609 void neigh_app_ns(struct neighbour
*n
)
2611 __neigh_notify(n
, RTM_GETNEIGH
, NLM_F_REQUEST
);
2613 EXPORT_SYMBOL(neigh_app_ns
);
2614 #endif /* CONFIG_ARPD */
2616 #ifdef CONFIG_SYSCTL
2618 #define NEIGH_VARS_MAX 19
2620 static struct neigh_sysctl_table
{
2621 struct ctl_table_header
*sysctl_header
;
2622 struct ctl_table neigh_vars
[NEIGH_VARS_MAX
];
2624 } neigh_sysctl_template __read_mostly
= {
2627 .procname
= "mcast_solicit",
2628 .maxlen
= sizeof(int),
2630 .proc_handler
= proc_dointvec
,
2633 .procname
= "ucast_solicit",
2634 .maxlen
= sizeof(int),
2636 .proc_handler
= proc_dointvec
,
2639 .procname
= "app_solicit",
2640 .maxlen
= sizeof(int),
2642 .proc_handler
= proc_dointvec
,
2645 .procname
= "retrans_time",
2646 .maxlen
= sizeof(int),
2648 .proc_handler
= proc_dointvec_userhz_jiffies
,
2651 .procname
= "base_reachable_time",
2652 .maxlen
= sizeof(int),
2654 .proc_handler
= proc_dointvec_jiffies
,
2657 .procname
= "delay_first_probe_time",
2658 .maxlen
= sizeof(int),
2660 .proc_handler
= proc_dointvec_jiffies
,
2663 .procname
= "gc_stale_time",
2664 .maxlen
= sizeof(int),
2666 .proc_handler
= proc_dointvec_jiffies
,
2669 .procname
= "unres_qlen",
2670 .maxlen
= sizeof(int),
2672 .proc_handler
= proc_dointvec
,
2675 .procname
= "proxy_qlen",
2676 .maxlen
= sizeof(int),
2678 .proc_handler
= proc_dointvec
,
2681 .procname
= "anycast_delay",
2682 .maxlen
= sizeof(int),
2684 .proc_handler
= proc_dointvec_userhz_jiffies
,
2687 .procname
= "proxy_delay",
2688 .maxlen
= sizeof(int),
2690 .proc_handler
= proc_dointvec_userhz_jiffies
,
2693 .procname
= "locktime",
2694 .maxlen
= sizeof(int),
2696 .proc_handler
= proc_dointvec_userhz_jiffies
,
2699 .procname
= "retrans_time_ms",
2700 .maxlen
= sizeof(int),
2702 .proc_handler
= proc_dointvec_ms_jiffies
,
2705 .procname
= "base_reachable_time_ms",
2706 .maxlen
= sizeof(int),
2708 .proc_handler
= proc_dointvec_ms_jiffies
,
2711 .procname
= "gc_interval",
2712 .maxlen
= sizeof(int),
2714 .proc_handler
= proc_dointvec_jiffies
,
2717 .procname
= "gc_thresh1",
2718 .maxlen
= sizeof(int),
2720 .proc_handler
= proc_dointvec
,
2723 .procname
= "gc_thresh2",
2724 .maxlen
= sizeof(int),
2726 .proc_handler
= proc_dointvec
,
2729 .procname
= "gc_thresh3",
2730 .maxlen
= sizeof(int),
2732 .proc_handler
= proc_dointvec
,
2738 int neigh_sysctl_register(struct net_device
*dev
, struct neigh_parms
*p
,
2739 char *p_name
, proc_handler
*handler
)
2741 struct neigh_sysctl_table
*t
;
2742 const char *dev_name_source
= NULL
;
2744 #define NEIGH_CTL_PATH_ROOT 0
2745 #define NEIGH_CTL_PATH_PROTO 1
2746 #define NEIGH_CTL_PATH_NEIGH 2
2747 #define NEIGH_CTL_PATH_DEV 3
2749 struct ctl_path neigh_path
[] = {
2750 { .procname
= "net", },
2751 { .procname
= "proto", },
2752 { .procname
= "neigh", },
2753 { .procname
= "default", },
2757 t
= kmemdup(&neigh_sysctl_template
, sizeof(*t
), GFP_KERNEL
);
2761 t
->neigh_vars
[0].data
= &p
->mcast_probes
;
2762 t
->neigh_vars
[1].data
= &p
->ucast_probes
;
2763 t
->neigh_vars
[2].data
= &p
->app_probes
;
2764 t
->neigh_vars
[3].data
= &p
->retrans_time
;
2765 t
->neigh_vars
[4].data
= &p
->base_reachable_time
;
2766 t
->neigh_vars
[5].data
= &p
->delay_probe_time
;
2767 t
->neigh_vars
[6].data
= &p
->gc_staletime
;
2768 t
->neigh_vars
[7].data
= &p
->queue_len
;
2769 t
->neigh_vars
[8].data
= &p
->proxy_qlen
;
2770 t
->neigh_vars
[9].data
= &p
->anycast_delay
;
2771 t
->neigh_vars
[10].data
= &p
->proxy_delay
;
2772 t
->neigh_vars
[11].data
= &p
->locktime
;
2773 t
->neigh_vars
[12].data
= &p
->retrans_time
;
2774 t
->neigh_vars
[13].data
= &p
->base_reachable_time
;
2777 dev_name_source
= dev
->name
;
2778 /* Terminate the table early */
2779 memset(&t
->neigh_vars
[14], 0, sizeof(t
->neigh_vars
[14]));
2781 dev_name_source
= neigh_path
[NEIGH_CTL_PATH_DEV
].procname
;
2782 t
->neigh_vars
[14].data
= (int *)(p
+ 1);
2783 t
->neigh_vars
[15].data
= (int *)(p
+ 1) + 1;
2784 t
->neigh_vars
[16].data
= (int *)(p
+ 1) + 2;
2785 t
->neigh_vars
[17].data
= (int *)(p
+ 1) + 3;
2791 t
->neigh_vars
[3].proc_handler
= handler
;
2792 t
->neigh_vars
[3].extra1
= dev
;
2794 t
->neigh_vars
[4].proc_handler
= handler
;
2795 t
->neigh_vars
[4].extra1
= dev
;
2796 /* RetransTime (in milliseconds)*/
2797 t
->neigh_vars
[12].proc_handler
= handler
;
2798 t
->neigh_vars
[12].extra1
= dev
;
2799 /* ReachableTime (in milliseconds) */
2800 t
->neigh_vars
[13].proc_handler
= handler
;
2801 t
->neigh_vars
[13].extra1
= dev
;
2804 t
->dev_name
= kstrdup(dev_name_source
, GFP_KERNEL
);
2808 neigh_path
[NEIGH_CTL_PATH_DEV
].procname
= t
->dev_name
;
2809 neigh_path
[NEIGH_CTL_PATH_PROTO
].procname
= p_name
;
2812 register_net_sysctl_table(neigh_parms_net(p
), neigh_path
, t
->neigh_vars
);
2813 if (!t
->sysctl_header
)
2816 p
->sysctl_table
= t
;
2826 EXPORT_SYMBOL(neigh_sysctl_register
);
2828 void neigh_sysctl_unregister(struct neigh_parms
*p
)
2830 if (p
->sysctl_table
) {
2831 struct neigh_sysctl_table
*t
= p
->sysctl_table
;
2832 p
->sysctl_table
= NULL
;
2833 unregister_sysctl_table(t
->sysctl_header
);
2838 EXPORT_SYMBOL(neigh_sysctl_unregister
);
2840 #endif /* CONFIG_SYSCTL */
2842 static int __init
neigh_init(void)
2844 rtnl_register(PF_UNSPEC
, RTM_NEWNEIGH
, neigh_add
, NULL
, NULL
);
2845 rtnl_register(PF_UNSPEC
, RTM_DELNEIGH
, neigh_delete
, NULL
, NULL
);
2846 rtnl_register(PF_UNSPEC
, RTM_GETNEIGH
, NULL
, neigh_dump_info
, NULL
);
2848 rtnl_register(PF_UNSPEC
, RTM_GETNEIGHTBL
, NULL
, neightbl_dump_info
,
2850 rtnl_register(PF_UNSPEC
, RTM_SETNEIGHTBL
, neightbl_set
, NULL
, NULL
);
2855 subsys_initcall(neigh_init
);