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/types.h>
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/socket.h>
22 #include <linux/netdevice.h>
23 #include <linux/proc_fs.h>
25 #include <linux/sysctl.h>
27 #include <linux/times.h>
28 #include <net/neighbour.h>
31 #include <net/netevent.h>
32 #include <net/netlink.h>
33 #include <linux/rtnetlink.h>
34 #include <linux/random.h>
35 #include <linux/string.h>
39 #define NEIGH_PRINTK(x...) printk(x)
40 #define NEIGH_NOPRINTK(x...) do { ; } while(0)
41 #define NEIGH_PRINTK0 NEIGH_PRINTK
42 #define NEIGH_PRINTK1 NEIGH_NOPRINTK
43 #define NEIGH_PRINTK2 NEIGH_NOPRINTK
47 #define NEIGH_PRINTK1 NEIGH_PRINTK
51 #define NEIGH_PRINTK2 NEIGH_PRINTK
54 #define PNEIGH_HASHMASK 0xF
56 static void neigh_timer_handler(unsigned long arg
);
58 static void neigh_app_notify(struct neighbour
*n
);
60 static int pneigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
);
61 void neigh_changeaddr(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_release(neigh
);
116 * It is random distribution in the interval (1/2)*base...(3/2)*base.
117 * It corresponds to default IPv6 settings and is not overridable,
118 * because it is really reasonable choice.
121 unsigned long neigh_rand_reach_time(unsigned long base
)
123 return (base
? (net_random() % base
) + (base
>> 1) : 0);
127 static int neigh_forced_gc(struct neigh_table
*tbl
)
132 NEIGH_CACHE_STAT_INC(tbl
, forced_gc_runs
);
134 write_lock_bh(&tbl
->lock
);
135 for (i
= 0; i
<= tbl
->hash_mask
; i
++) {
136 struct neighbour
*n
, **np
;
138 np
= &tbl
->hash_buckets
[i
];
139 while ((n
= *np
) != NULL
) {
140 /* Neighbour record may be discarded if:
141 * - nobody refers to it.
142 * - it is not permanent
144 write_lock(&n
->lock
);
145 if (atomic_read(&n
->refcnt
) == 1 &&
146 !(n
->nud_state
& NUD_PERMANENT
)) {
150 write_unlock(&n
->lock
);
151 neigh_cleanup_and_release(n
);
154 write_unlock(&n
->lock
);
159 tbl
->last_flush
= jiffies
;
161 write_unlock_bh(&tbl
->lock
);
166 static int neigh_del_timer(struct neighbour
*n
)
168 if ((n
->nud_state
& NUD_IN_TIMER
) &&
169 del_timer(&n
->timer
)) {
176 static void pneigh_queue_purge(struct sk_buff_head
*list
)
180 while ((skb
= skb_dequeue(list
)) != NULL
) {
186 static void neigh_flush_dev(struct neigh_table
*tbl
, struct net_device
*dev
)
190 for (i
= 0; i
<= tbl
->hash_mask
; i
++) {
191 struct neighbour
*n
, **np
= &tbl
->hash_buckets
[i
];
193 while ((n
= *np
) != NULL
) {
194 if (dev
&& n
->dev
!= dev
) {
199 write_lock(&n
->lock
);
203 if (atomic_read(&n
->refcnt
) != 1) {
204 /* The most unpleasant situation.
205 We must destroy neighbour entry,
206 but someone still uses it.
208 The destroy will be delayed until
209 the last user releases us, but
210 we must kill timers etc. and move
213 skb_queue_purge(&n
->arp_queue
);
214 n
->output
= neigh_blackhole
;
215 if (n
->nud_state
& NUD_VALID
)
216 n
->nud_state
= NUD_NOARP
;
218 n
->nud_state
= NUD_NONE
;
219 NEIGH_PRINTK2("neigh %p is stray.\n", n
);
221 write_unlock(&n
->lock
);
222 neigh_cleanup_and_release(n
);
227 void neigh_changeaddr(struct neigh_table
*tbl
, struct net_device
*dev
)
229 write_lock_bh(&tbl
->lock
);
230 neigh_flush_dev(tbl
, dev
);
231 write_unlock_bh(&tbl
->lock
);
234 int neigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
)
236 write_lock_bh(&tbl
->lock
);
237 neigh_flush_dev(tbl
, dev
);
238 pneigh_ifdown(tbl
, dev
);
239 write_unlock_bh(&tbl
->lock
);
241 del_timer_sync(&tbl
->proxy_timer
);
242 pneigh_queue_purge(&tbl
->proxy_queue
);
246 static struct neighbour
*neigh_alloc(struct neigh_table
*tbl
)
248 struct neighbour
*n
= NULL
;
249 unsigned long now
= jiffies
;
252 entries
= atomic_inc_return(&tbl
->entries
) - 1;
253 if (entries
>= tbl
->gc_thresh3
||
254 (entries
>= tbl
->gc_thresh2
&&
255 time_after(now
, tbl
->last_flush
+ 5 * HZ
))) {
256 if (!neigh_forced_gc(tbl
) &&
257 entries
>= tbl
->gc_thresh3
)
261 n
= kmem_cache_zalloc(tbl
->kmem_cachep
, GFP_ATOMIC
);
265 skb_queue_head_init(&n
->arp_queue
);
266 rwlock_init(&n
->lock
);
267 n
->updated
= n
->used
= now
;
268 n
->nud_state
= NUD_NONE
;
269 n
->output
= neigh_blackhole
;
270 n
->parms
= neigh_parms_clone(&tbl
->parms
);
271 init_timer(&n
->timer
);
272 n
->timer
.function
= neigh_timer_handler
;
273 n
->timer
.data
= (unsigned long)n
;
275 NEIGH_CACHE_STAT_INC(tbl
, allocs
);
277 atomic_set(&n
->refcnt
, 1);
283 atomic_dec(&tbl
->entries
);
287 static struct neighbour
**neigh_hash_alloc(unsigned int entries
)
289 unsigned long size
= entries
* sizeof(struct neighbour
*);
290 struct neighbour
**ret
;
292 if (size
<= PAGE_SIZE
) {
293 ret
= kzalloc(size
, GFP_ATOMIC
);
295 ret
= (struct neighbour
**)
296 __get_free_pages(GFP_ATOMIC
|__GFP_ZERO
, get_order(size
));
301 static void neigh_hash_free(struct neighbour
**hash
, unsigned int entries
)
303 unsigned long size
= entries
* sizeof(struct neighbour
*);
305 if (size
<= PAGE_SIZE
)
308 free_pages((unsigned long)hash
, get_order(size
));
311 static void neigh_hash_grow(struct neigh_table
*tbl
, unsigned long new_entries
)
313 struct neighbour
**new_hash
, **old_hash
;
314 unsigned int i
, new_hash_mask
, old_entries
;
316 NEIGH_CACHE_STAT_INC(tbl
, hash_grows
);
318 BUG_ON(new_entries
& (new_entries
- 1));
319 new_hash
= neigh_hash_alloc(new_entries
);
323 old_entries
= tbl
->hash_mask
+ 1;
324 new_hash_mask
= new_entries
- 1;
325 old_hash
= tbl
->hash_buckets
;
327 get_random_bytes(&tbl
->hash_rnd
, sizeof(tbl
->hash_rnd
));
328 for (i
= 0; i
< old_entries
; i
++) {
329 struct neighbour
*n
, *next
;
331 for (n
= old_hash
[i
]; n
; n
= next
) {
332 unsigned int hash_val
= tbl
->hash(n
->primary_key
, n
->dev
);
334 hash_val
&= new_hash_mask
;
337 n
->next
= new_hash
[hash_val
];
338 new_hash
[hash_val
] = n
;
341 tbl
->hash_buckets
= new_hash
;
342 tbl
->hash_mask
= new_hash_mask
;
344 neigh_hash_free(old_hash
, old_entries
);
347 struct neighbour
*neigh_lookup(struct neigh_table
*tbl
, const void *pkey
,
348 struct net_device
*dev
)
351 int key_len
= tbl
->key_len
;
352 u32 hash_val
= tbl
->hash(pkey
, dev
);
354 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
356 read_lock_bh(&tbl
->lock
);
357 for (n
= tbl
->hash_buckets
[hash_val
& tbl
->hash_mask
]; n
; n
= n
->next
) {
358 if (dev
== n
->dev
&& !memcmp(n
->primary_key
, pkey
, key_len
)) {
360 NEIGH_CACHE_STAT_INC(tbl
, hits
);
364 read_unlock_bh(&tbl
->lock
);
368 struct neighbour
*neigh_lookup_nodev(struct neigh_table
*tbl
, const void *pkey
)
371 int key_len
= tbl
->key_len
;
372 u32 hash_val
= tbl
->hash(pkey
, NULL
);
374 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
376 read_lock_bh(&tbl
->lock
);
377 for (n
= tbl
->hash_buckets
[hash_val
& tbl
->hash_mask
]; n
; n
= n
->next
) {
378 if (!memcmp(n
->primary_key
, pkey
, key_len
)) {
380 NEIGH_CACHE_STAT_INC(tbl
, hits
);
384 read_unlock_bh(&tbl
->lock
);
388 struct neighbour
*neigh_create(struct neigh_table
*tbl
, const void *pkey
,
389 struct net_device
*dev
)
392 int key_len
= tbl
->key_len
;
394 struct neighbour
*n1
, *rc
, *n
= neigh_alloc(tbl
);
397 rc
= ERR_PTR(-ENOBUFS
);
401 memcpy(n
->primary_key
, pkey
, key_len
);
405 /* Protocol specific setup. */
406 if (tbl
->constructor
&& (error
= tbl
->constructor(n
)) < 0) {
408 goto out_neigh_release
;
411 /* Device specific setup. */
412 if (n
->parms
->neigh_setup
&&
413 (error
= n
->parms
->neigh_setup(n
)) < 0) {
415 goto out_neigh_release
;
418 n
->confirmed
= jiffies
- (n
->parms
->base_reachable_time
<< 1);
420 write_lock_bh(&tbl
->lock
);
422 if (atomic_read(&tbl
->entries
) > (tbl
->hash_mask
+ 1))
423 neigh_hash_grow(tbl
, (tbl
->hash_mask
+ 1) << 1);
425 hash_val
= tbl
->hash(pkey
, dev
) & tbl
->hash_mask
;
427 if (n
->parms
->dead
) {
428 rc
= ERR_PTR(-EINVAL
);
432 for (n1
= tbl
->hash_buckets
[hash_val
]; n1
; n1
= n1
->next
) {
433 if (dev
== n1
->dev
&& !memcmp(n1
->primary_key
, pkey
, key_len
)) {
440 n
->next
= tbl
->hash_buckets
[hash_val
];
441 tbl
->hash_buckets
[hash_val
] = n
;
444 write_unlock_bh(&tbl
->lock
);
445 NEIGH_PRINTK2("neigh %p is created.\n", n
);
450 write_unlock_bh(&tbl
->lock
);
456 struct pneigh_entry
* pneigh_lookup(struct neigh_table
*tbl
, const void *pkey
,
457 struct net_device
*dev
, int creat
)
459 struct pneigh_entry
*n
;
460 int key_len
= tbl
->key_len
;
461 u32 hash_val
= *(u32
*)(pkey
+ key_len
- 4);
463 hash_val
^= (hash_val
>> 16);
464 hash_val
^= hash_val
>> 8;
465 hash_val
^= hash_val
>> 4;
466 hash_val
&= PNEIGH_HASHMASK
;
468 read_lock_bh(&tbl
->lock
);
470 for (n
= tbl
->phash_buckets
[hash_val
]; n
; n
= n
->next
) {
471 if (!memcmp(n
->key
, pkey
, key_len
) &&
472 (n
->dev
== dev
|| !n
->dev
)) {
473 read_unlock_bh(&tbl
->lock
);
477 read_unlock_bh(&tbl
->lock
);
482 n
= kmalloc(sizeof(*n
) + key_len
, GFP_KERNEL
);
486 memcpy(n
->key
, pkey
, key_len
);
491 if (tbl
->pconstructor
&& tbl
->pconstructor(n
)) {
499 write_lock_bh(&tbl
->lock
);
500 n
->next
= tbl
->phash_buckets
[hash_val
];
501 tbl
->phash_buckets
[hash_val
] = n
;
502 write_unlock_bh(&tbl
->lock
);
508 int pneigh_delete(struct neigh_table
*tbl
, const void *pkey
,
509 struct net_device
*dev
)
511 struct pneigh_entry
*n
, **np
;
512 int key_len
= tbl
->key_len
;
513 u32 hash_val
= *(u32
*)(pkey
+ key_len
- 4);
515 hash_val
^= (hash_val
>> 16);
516 hash_val
^= hash_val
>> 8;
517 hash_val
^= hash_val
>> 4;
518 hash_val
&= PNEIGH_HASHMASK
;
520 write_lock_bh(&tbl
->lock
);
521 for (np
= &tbl
->phash_buckets
[hash_val
]; (n
= *np
) != NULL
;
523 if (!memcmp(n
->key
, pkey
, key_len
) && n
->dev
== dev
) {
525 write_unlock_bh(&tbl
->lock
);
526 if (tbl
->pdestructor
)
534 write_unlock_bh(&tbl
->lock
);
538 static int pneigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
)
540 struct pneigh_entry
*n
, **np
;
543 for (h
= 0; h
<= PNEIGH_HASHMASK
; h
++) {
544 np
= &tbl
->phash_buckets
[h
];
545 while ((n
= *np
) != NULL
) {
546 if (!dev
|| n
->dev
== dev
) {
548 if (tbl
->pdestructor
)
563 * neighbour must already be out of the table;
566 void neigh_destroy(struct neighbour
*neigh
)
570 NEIGH_CACHE_STAT_INC(neigh
->tbl
, destroys
);
574 "Destroying alive neighbour %p\n", neigh
);
579 if (neigh_del_timer(neigh
))
580 printk(KERN_WARNING
"Impossible event.\n");
582 while ((hh
= neigh
->hh
) != NULL
) {
583 neigh
->hh
= hh
->hh_next
;
586 write_seqlock_bh(&hh
->hh_lock
);
587 hh
->hh_output
= neigh_blackhole
;
588 write_sequnlock_bh(&hh
->hh_lock
);
589 if (atomic_dec_and_test(&hh
->hh_refcnt
))
593 skb_queue_purge(&neigh
->arp_queue
);
596 neigh_parms_put(neigh
->parms
);
598 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh
);
600 atomic_dec(&neigh
->tbl
->entries
);
601 kmem_cache_free(neigh
->tbl
->kmem_cachep
, neigh
);
604 /* Neighbour state is suspicious;
607 Called with write_locked neigh.
609 static void neigh_suspect(struct neighbour
*neigh
)
613 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh
);
615 neigh
->output
= neigh
->ops
->output
;
617 for (hh
= neigh
->hh
; hh
; hh
= hh
->hh_next
)
618 hh
->hh_output
= neigh
->ops
->output
;
621 /* Neighbour state is OK;
624 Called with write_locked neigh.
626 static void neigh_connect(struct neighbour
*neigh
)
630 NEIGH_PRINTK2("neigh %p is connected.\n", neigh
);
632 neigh
->output
= neigh
->ops
->connected_output
;
634 for (hh
= neigh
->hh
; hh
; hh
= hh
->hh_next
)
635 hh
->hh_output
= neigh
->ops
->hh_output
;
638 static void neigh_periodic_work(struct work_struct
*work
)
640 struct neigh_table
*tbl
= container_of(work
, struct neigh_table
, gc_work
.work
);
641 struct neighbour
*n
, **np
;
644 NEIGH_CACHE_STAT_INC(tbl
, periodic_gc_runs
);
646 write_lock_bh(&tbl
->lock
);
649 * periodically recompute ReachableTime from random function
652 if (time_after(jiffies
, tbl
->last_rand
+ 300 * HZ
)) {
653 struct neigh_parms
*p
;
654 tbl
->last_rand
= jiffies
;
655 for (p
= &tbl
->parms
; p
; p
= p
->next
)
657 neigh_rand_reach_time(p
->base_reachable_time
);
660 for (i
= 0 ; i
<= tbl
->hash_mask
; i
++) {
661 np
= &tbl
->hash_buckets
[i
];
663 while ((n
= *np
) != NULL
) {
666 write_lock(&n
->lock
);
668 state
= n
->nud_state
;
669 if (state
& (NUD_PERMANENT
| NUD_IN_TIMER
)) {
670 write_unlock(&n
->lock
);
674 if (time_before(n
->used
, n
->confirmed
))
675 n
->used
= n
->confirmed
;
677 if (atomic_read(&n
->refcnt
) == 1 &&
678 (state
== NUD_FAILED
||
679 time_after(jiffies
, n
->used
+ n
->parms
->gc_staletime
))) {
682 write_unlock(&n
->lock
);
683 neigh_cleanup_and_release(n
);
686 write_unlock(&n
->lock
);
692 * It's fine to release lock here, even if hash table
693 * grows while we are preempted.
695 write_unlock_bh(&tbl
->lock
);
697 write_lock_bh(&tbl
->lock
);
699 /* Cycle through all hash buckets every base_reachable_time/2 ticks.
700 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
701 * base_reachable_time.
703 schedule_delayed_work(&tbl
->gc_work
,
704 tbl
->parms
.base_reachable_time
>> 1);
705 write_unlock_bh(&tbl
->lock
);
708 static __inline__
int neigh_max_probes(struct neighbour
*n
)
710 struct neigh_parms
*p
= n
->parms
;
711 return (n
->nud_state
& NUD_PROBE
?
713 p
->ucast_probes
+ p
->app_probes
+ p
->mcast_probes
);
716 static inline void neigh_add_timer(struct neighbour
*n
, unsigned long when
)
718 if (unlikely(mod_timer(&n
->timer
, when
))) {
719 printk("NEIGH: BUG, double timer add, state is %x\n",
725 /* Called when a timer expires for a neighbour entry. */
727 static void neigh_timer_handler(unsigned long arg
)
729 unsigned long now
, next
;
730 struct neighbour
*neigh
= (struct neighbour
*)arg
;
734 write_lock(&neigh
->lock
);
736 state
= neigh
->nud_state
;
740 if (!(state
& NUD_IN_TIMER
)) {
742 printk(KERN_WARNING
"neigh: timer & !nud_in_timer\n");
747 if (state
& NUD_REACHABLE
) {
748 if (time_before_eq(now
,
749 neigh
->confirmed
+ neigh
->parms
->reachable_time
)) {
750 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh
);
751 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
752 } else if (time_before_eq(now
,
753 neigh
->used
+ neigh
->parms
->delay_probe_time
)) {
754 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh
);
755 neigh
->nud_state
= NUD_DELAY
;
756 neigh
->updated
= jiffies
;
757 neigh_suspect(neigh
);
758 next
= now
+ neigh
->parms
->delay_probe_time
;
760 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh
);
761 neigh
->nud_state
= NUD_STALE
;
762 neigh
->updated
= jiffies
;
763 neigh_suspect(neigh
);
766 } else if (state
& NUD_DELAY
) {
767 if (time_before_eq(now
,
768 neigh
->confirmed
+ neigh
->parms
->delay_probe_time
)) {
769 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh
);
770 neigh
->nud_state
= NUD_REACHABLE
;
771 neigh
->updated
= jiffies
;
772 neigh_connect(neigh
);
774 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
776 NEIGH_PRINTK2("neigh %p is probed.\n", neigh
);
777 neigh
->nud_state
= NUD_PROBE
;
778 neigh
->updated
= jiffies
;
779 atomic_set(&neigh
->probes
, 0);
780 next
= now
+ neigh
->parms
->retrans_time
;
783 /* NUD_PROBE|NUD_INCOMPLETE */
784 next
= now
+ neigh
->parms
->retrans_time
;
787 if ((neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
788 atomic_read(&neigh
->probes
) >= neigh_max_probes(neigh
)) {
791 neigh
->nud_state
= NUD_FAILED
;
792 neigh
->updated
= jiffies
;
794 NEIGH_CACHE_STAT_INC(neigh
->tbl
, res_failed
);
795 NEIGH_PRINTK2("neigh %p is failed.\n", neigh
);
797 /* It is very thin place. report_unreachable is very complicated
798 routine. Particularly, it can hit the same neighbour entry!
800 So that, we try to be accurate and avoid dead loop. --ANK
802 while (neigh
->nud_state
== NUD_FAILED
&&
803 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
804 write_unlock(&neigh
->lock
);
805 neigh
->ops
->error_report(neigh
, skb
);
806 write_lock(&neigh
->lock
);
808 skb_queue_purge(&neigh
->arp_queue
);
811 if (neigh
->nud_state
& NUD_IN_TIMER
) {
812 if (time_before(next
, jiffies
+ HZ
/2))
813 next
= jiffies
+ HZ
/2;
814 if (!mod_timer(&neigh
->timer
, next
))
817 if (neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) {
818 struct sk_buff
*skb
= skb_peek(&neigh
->arp_queue
);
819 /* keep skb alive even if arp_queue overflows */
822 write_unlock(&neigh
->lock
);
823 neigh
->ops
->solicit(neigh
, skb
);
824 atomic_inc(&neigh
->probes
);
829 write_unlock(&neigh
->lock
);
832 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
835 if (notify
&& neigh
->parms
->app_probes
)
836 neigh_app_notify(neigh
);
838 neigh_release(neigh
);
841 int __neigh_event_send(struct neighbour
*neigh
, struct sk_buff
*skb
)
846 write_lock_bh(&neigh
->lock
);
849 if (neigh
->nud_state
& (NUD_CONNECTED
| NUD_DELAY
| NUD_PROBE
))
854 if (!(neigh
->nud_state
& (NUD_STALE
| NUD_INCOMPLETE
))) {
855 if (neigh
->parms
->mcast_probes
+ neigh
->parms
->app_probes
) {
856 atomic_set(&neigh
->probes
, neigh
->parms
->ucast_probes
);
857 neigh
->nud_state
= NUD_INCOMPLETE
;
858 neigh
->updated
= jiffies
;
860 neigh_add_timer(neigh
, now
+ 1);
862 neigh
->nud_state
= NUD_FAILED
;
863 neigh
->updated
= jiffies
;
864 write_unlock_bh(&neigh
->lock
);
870 } else if (neigh
->nud_state
& NUD_STALE
) {
871 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh
);
873 neigh
->nud_state
= NUD_DELAY
;
874 neigh
->updated
= jiffies
;
875 neigh_add_timer(neigh
,
876 jiffies
+ neigh
->parms
->delay_probe_time
);
879 if (neigh
->nud_state
== NUD_INCOMPLETE
) {
881 if (skb_queue_len(&neigh
->arp_queue
) >=
882 neigh
->parms
->queue_len
) {
883 struct sk_buff
*buff
;
884 buff
= neigh
->arp_queue
.next
;
885 __skb_unlink(buff
, &neigh
->arp_queue
);
888 __skb_queue_tail(&neigh
->arp_queue
, skb
);
893 write_unlock_bh(&neigh
->lock
);
897 static void neigh_update_hhs(struct neighbour
*neigh
)
900 void (*update
)(struct hh_cache
*, struct net_device
*, unsigned char *) =
901 neigh
->dev
->header_cache_update
;
904 for (hh
= neigh
->hh
; hh
; hh
= hh
->hh_next
) {
905 write_seqlock_bh(&hh
->hh_lock
);
906 update(hh
, neigh
->dev
, neigh
->ha
);
907 write_sequnlock_bh(&hh
->hh_lock
);
914 /* Generic update routine.
915 -- lladdr is new lladdr or NULL, if it is not supplied.
918 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
920 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
921 lladdr instead of overriding it
923 It also allows to retain current state
924 if lladdr is unchanged.
925 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
927 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
929 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
932 Caller MUST hold reference count on the entry.
935 int neigh_update(struct neighbour
*neigh
, const u8
*lladdr
, u8
new,
941 struct net_device
*dev
;
942 int update_isrouter
= 0;
944 write_lock_bh(&neigh
->lock
);
947 old
= neigh
->nud_state
;
950 if (!(flags
& NEIGH_UPDATE_F_ADMIN
) &&
951 (old
& (NUD_NOARP
| NUD_PERMANENT
)))
954 if (!(new & NUD_VALID
)) {
955 neigh_del_timer(neigh
);
956 if (old
& NUD_CONNECTED
)
957 neigh_suspect(neigh
);
958 neigh
->nud_state
= new;
960 notify
= old
& NUD_VALID
;
964 /* Compare new lladdr with cached one */
965 if (!dev
->addr_len
) {
966 /* First case: device needs no address. */
969 /* The second case: if something is already cached
970 and a new address is proposed:
972 - if they are different, check override flag
974 if ((old
& NUD_VALID
) &&
975 !memcmp(lladdr
, neigh
->ha
, dev
->addr_len
))
978 /* No address is supplied; if we know something,
979 use it, otherwise discard the request.
982 if (!(old
& NUD_VALID
))
987 if (new & NUD_CONNECTED
)
988 neigh
->confirmed
= jiffies
;
989 neigh
->updated
= jiffies
;
991 /* If entry was valid and address is not changed,
992 do not change entry state, if new one is STALE.
995 update_isrouter
= flags
& NEIGH_UPDATE_F_OVERRIDE_ISROUTER
;
996 if (old
& NUD_VALID
) {
997 if (lladdr
!= neigh
->ha
&& !(flags
& NEIGH_UPDATE_F_OVERRIDE
)) {
999 if ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) &&
1000 (old
& NUD_CONNECTED
)) {
1006 if (lladdr
== neigh
->ha
&& new == NUD_STALE
&&
1007 ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) ||
1008 (old
& NUD_CONNECTED
))
1015 neigh_del_timer(neigh
);
1016 if (new & NUD_IN_TIMER
) {
1018 neigh_add_timer(neigh
, (jiffies
+
1019 ((new & NUD_REACHABLE
) ?
1020 neigh
->parms
->reachable_time
:
1023 neigh
->nud_state
= new;
1026 if (lladdr
!= neigh
->ha
) {
1027 memcpy(&neigh
->ha
, lladdr
, dev
->addr_len
);
1028 neigh_update_hhs(neigh
);
1029 if (!(new & NUD_CONNECTED
))
1030 neigh
->confirmed
= jiffies
-
1031 (neigh
->parms
->base_reachable_time
<< 1);
1036 if (new & NUD_CONNECTED
)
1037 neigh_connect(neigh
);
1039 neigh_suspect(neigh
);
1040 if (!(old
& NUD_VALID
)) {
1041 struct sk_buff
*skb
;
1043 /* Again: avoid dead loop if something went wrong */
1045 while (neigh
->nud_state
& NUD_VALID
&&
1046 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
1047 struct neighbour
*n1
= neigh
;
1048 write_unlock_bh(&neigh
->lock
);
1049 /* On shaper/eql skb->dst->neighbour != neigh :( */
1050 if (skb
->dst
&& skb
->dst
->neighbour
)
1051 n1
= skb
->dst
->neighbour
;
1053 write_lock_bh(&neigh
->lock
);
1055 skb_queue_purge(&neigh
->arp_queue
);
1058 if (update_isrouter
) {
1059 neigh
->flags
= (flags
& NEIGH_UPDATE_F_ISROUTER
) ?
1060 (neigh
->flags
| NTF_ROUTER
) :
1061 (neigh
->flags
& ~NTF_ROUTER
);
1063 write_unlock_bh(&neigh
->lock
);
1066 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
1068 if (notify
&& neigh
->parms
->app_probes
)
1069 neigh_app_notify(neigh
);
1074 struct neighbour
*neigh_event_ns(struct neigh_table
*tbl
,
1075 u8
*lladdr
, void *saddr
,
1076 struct net_device
*dev
)
1078 struct neighbour
*neigh
= __neigh_lookup(tbl
, saddr
, dev
,
1079 lladdr
|| !dev
->addr_len
);
1081 neigh_update(neigh
, lladdr
, NUD_STALE
,
1082 NEIGH_UPDATE_F_OVERRIDE
);
1086 static void neigh_hh_init(struct neighbour
*n
, struct dst_entry
*dst
,
1089 struct hh_cache
*hh
;
1090 struct net_device
*dev
= dst
->dev
;
1092 for (hh
= n
->hh
; hh
; hh
= hh
->hh_next
)
1093 if (hh
->hh_type
== protocol
)
1096 if (!hh
&& (hh
= kzalloc(sizeof(*hh
), GFP_ATOMIC
)) != NULL
) {
1097 seqlock_init(&hh
->hh_lock
);
1098 hh
->hh_type
= protocol
;
1099 atomic_set(&hh
->hh_refcnt
, 0);
1101 if (dev
->hard_header_cache(n
, hh
)) {
1105 atomic_inc(&hh
->hh_refcnt
);
1106 hh
->hh_next
= n
->hh
;
1108 if (n
->nud_state
& NUD_CONNECTED
)
1109 hh
->hh_output
= n
->ops
->hh_output
;
1111 hh
->hh_output
= n
->ops
->output
;
1115 atomic_inc(&hh
->hh_refcnt
);
1120 /* This function can be used in contexts, where only old dev_queue_xmit
1121 worked, f.e. if you want to override normal output path (eql, shaper),
1122 but resolution is not made yet.
1125 int neigh_compat_output(struct sk_buff
*skb
)
1127 struct net_device
*dev
= skb
->dev
;
1129 __skb_pull(skb
, skb_network_offset(skb
));
1131 if (dev
->hard_header
&&
1132 dev
->hard_header(skb
, dev
, ntohs(skb
->protocol
), NULL
, NULL
,
1134 dev
->rebuild_header(skb
))
1137 return dev_queue_xmit(skb
);
1140 /* Slow and careful. */
1142 int neigh_resolve_output(struct sk_buff
*skb
)
1144 struct dst_entry
*dst
= skb
->dst
;
1145 struct neighbour
*neigh
;
1148 if (!dst
|| !(neigh
= dst
->neighbour
))
1151 __skb_pull(skb
, skb_network_offset(skb
));
1153 if (!neigh_event_send(neigh
, skb
)) {
1155 struct net_device
*dev
= neigh
->dev
;
1156 if (dev
->hard_header_cache
&& !dst
->hh
) {
1157 write_lock_bh(&neigh
->lock
);
1159 neigh_hh_init(neigh
, dst
, dst
->ops
->protocol
);
1160 err
= dev
->hard_header(skb
, dev
, ntohs(skb
->protocol
),
1161 neigh
->ha
, NULL
, skb
->len
);
1162 write_unlock_bh(&neigh
->lock
);
1164 read_lock_bh(&neigh
->lock
);
1165 err
= dev
->hard_header(skb
, dev
, ntohs(skb
->protocol
),
1166 neigh
->ha
, NULL
, skb
->len
);
1167 read_unlock_bh(&neigh
->lock
);
1170 rc
= neigh
->ops
->queue_xmit(skb
);
1177 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1178 dst
, dst
? dst
->neighbour
: NULL
);
1185 /* As fast as possible without hh cache */
1187 int neigh_connected_output(struct sk_buff
*skb
)
1190 struct dst_entry
*dst
= skb
->dst
;
1191 struct neighbour
*neigh
= dst
->neighbour
;
1192 struct net_device
*dev
= neigh
->dev
;
1194 __skb_pull(skb
, skb_network_offset(skb
));
1196 read_lock_bh(&neigh
->lock
);
1197 err
= dev
->hard_header(skb
, dev
, ntohs(skb
->protocol
),
1198 neigh
->ha
, NULL
, skb
->len
);
1199 read_unlock_bh(&neigh
->lock
);
1201 err
= neigh
->ops
->queue_xmit(skb
);
1209 static void neigh_proxy_process(unsigned long arg
)
1211 struct neigh_table
*tbl
= (struct neigh_table
*)arg
;
1212 long sched_next
= 0;
1213 unsigned long now
= jiffies
;
1214 struct sk_buff
*skb
;
1216 spin_lock(&tbl
->proxy_queue
.lock
);
1218 skb
= tbl
->proxy_queue
.next
;
1220 while (skb
!= (struct sk_buff
*)&tbl
->proxy_queue
) {
1221 struct sk_buff
*back
= skb
;
1222 long tdif
= NEIGH_CB(back
)->sched_next
- now
;
1226 struct net_device
*dev
= back
->dev
;
1227 __skb_unlink(back
, &tbl
->proxy_queue
);
1228 if (tbl
->proxy_redo
&& netif_running(dev
))
1229 tbl
->proxy_redo(back
);
1234 } else if (!sched_next
|| tdif
< sched_next
)
1237 del_timer(&tbl
->proxy_timer
);
1239 mod_timer(&tbl
->proxy_timer
, jiffies
+ sched_next
);
1240 spin_unlock(&tbl
->proxy_queue
.lock
);
1243 void pneigh_enqueue(struct neigh_table
*tbl
, struct neigh_parms
*p
,
1244 struct sk_buff
*skb
)
1246 unsigned long now
= jiffies
;
1247 unsigned long sched_next
= now
+ (net_random() % p
->proxy_delay
);
1249 if (tbl
->proxy_queue
.qlen
> p
->proxy_qlen
) {
1254 NEIGH_CB(skb
)->sched_next
= sched_next
;
1255 NEIGH_CB(skb
)->flags
|= LOCALLY_ENQUEUED
;
1257 spin_lock(&tbl
->proxy_queue
.lock
);
1258 if (del_timer(&tbl
->proxy_timer
)) {
1259 if (time_before(tbl
->proxy_timer
.expires
, sched_next
))
1260 sched_next
= tbl
->proxy_timer
.expires
;
1262 dst_release(skb
->dst
);
1265 __skb_queue_tail(&tbl
->proxy_queue
, skb
);
1266 mod_timer(&tbl
->proxy_timer
, sched_next
);
1267 spin_unlock(&tbl
->proxy_queue
.lock
);
1271 struct neigh_parms
*neigh_parms_alloc(struct net_device
*dev
,
1272 struct neigh_table
*tbl
)
1274 struct neigh_parms
*p
= kmemdup(&tbl
->parms
, sizeof(*p
), GFP_KERNEL
);
1278 atomic_set(&p
->refcnt
, 1);
1279 INIT_RCU_HEAD(&p
->rcu_head
);
1281 neigh_rand_reach_time(p
->base_reachable_time
);
1283 if (dev
->neigh_setup
&& dev
->neigh_setup(dev
, p
)) {
1291 p
->sysctl_table
= NULL
;
1292 write_lock_bh(&tbl
->lock
);
1293 p
->next
= tbl
->parms
.next
;
1294 tbl
->parms
.next
= p
;
1295 write_unlock_bh(&tbl
->lock
);
1300 static void neigh_rcu_free_parms(struct rcu_head
*head
)
1302 struct neigh_parms
*parms
=
1303 container_of(head
, struct neigh_parms
, rcu_head
);
1305 neigh_parms_put(parms
);
1308 void neigh_parms_release(struct neigh_table
*tbl
, struct neigh_parms
*parms
)
1310 struct neigh_parms
**p
;
1312 if (!parms
|| parms
== &tbl
->parms
)
1314 write_lock_bh(&tbl
->lock
);
1315 for (p
= &tbl
->parms
.next
; *p
; p
= &(*p
)->next
) {
1319 write_unlock_bh(&tbl
->lock
);
1321 dev_put(parms
->dev
);
1322 call_rcu(&parms
->rcu_head
, neigh_rcu_free_parms
);
1326 write_unlock_bh(&tbl
->lock
);
1327 NEIGH_PRINTK1("neigh_parms_release: not found\n");
1330 void neigh_parms_destroy(struct neigh_parms
*parms
)
1335 static struct lock_class_key neigh_table_proxy_queue_class
;
1337 void neigh_table_init_no_netlink(struct neigh_table
*tbl
)
1339 unsigned long now
= jiffies
;
1340 unsigned long phsize
;
1342 atomic_set(&tbl
->parms
.refcnt
, 1);
1343 INIT_RCU_HEAD(&tbl
->parms
.rcu_head
);
1344 tbl
->parms
.reachable_time
=
1345 neigh_rand_reach_time(tbl
->parms
.base_reachable_time
);
1347 if (!tbl
->kmem_cachep
)
1349 kmem_cache_create(tbl
->id
, tbl
->entry_size
, 0,
1350 SLAB_HWCACHE_ALIGN
|SLAB_PANIC
,
1352 tbl
->stats
= alloc_percpu(struct neigh_statistics
);
1354 panic("cannot create neighbour cache statistics");
1356 #ifdef CONFIG_PROC_FS
1357 tbl
->pde
= create_proc_entry(tbl
->id
, 0, proc_net_stat
);
1359 panic("cannot create neighbour proc dir entry");
1360 tbl
->pde
->proc_fops
= &neigh_stat_seq_fops
;
1361 tbl
->pde
->data
= tbl
;
1365 tbl
->hash_buckets
= neigh_hash_alloc(tbl
->hash_mask
+ 1);
1367 phsize
= (PNEIGH_HASHMASK
+ 1) * sizeof(struct pneigh_entry
*);
1368 tbl
->phash_buckets
= kzalloc(phsize
, GFP_KERNEL
);
1370 if (!tbl
->hash_buckets
|| !tbl
->phash_buckets
)
1371 panic("cannot allocate neighbour cache hashes");
1373 get_random_bytes(&tbl
->hash_rnd
, sizeof(tbl
->hash_rnd
));
1375 rwlock_init(&tbl
->lock
);
1376 INIT_DELAYED_WORK_DEFERRABLE(&tbl
->gc_work
, neigh_periodic_work
);
1377 schedule_delayed_work(&tbl
->gc_work
, tbl
->parms
.reachable_time
);
1378 init_timer(&tbl
->proxy_timer
);
1379 tbl
->proxy_timer
.data
= (unsigned long)tbl
;
1380 tbl
->proxy_timer
.function
= neigh_proxy_process
;
1381 skb_queue_head_init_class(&tbl
->proxy_queue
,
1382 &neigh_table_proxy_queue_class
);
1384 tbl
->last_flush
= now
;
1385 tbl
->last_rand
= now
+ tbl
->parms
.reachable_time
* 20;
1388 void neigh_table_init(struct neigh_table
*tbl
)
1390 struct neigh_table
*tmp
;
1392 neigh_table_init_no_netlink(tbl
);
1393 write_lock(&neigh_tbl_lock
);
1394 for (tmp
= neigh_tables
; tmp
; tmp
= tmp
->next
) {
1395 if (tmp
->family
== tbl
->family
)
1398 tbl
->next
= neigh_tables
;
1400 write_unlock(&neigh_tbl_lock
);
1402 if (unlikely(tmp
)) {
1403 printk(KERN_ERR
"NEIGH: Registering multiple tables for "
1404 "family %d\n", tbl
->family
);
1409 int neigh_table_clear(struct neigh_table
*tbl
)
1411 struct neigh_table
**tp
;
1413 /* It is not clean... Fix it to unload IPv6 module safely */
1414 cancel_delayed_work(&tbl
->gc_work
);
1415 flush_scheduled_work();
1416 del_timer_sync(&tbl
->proxy_timer
);
1417 pneigh_queue_purge(&tbl
->proxy_queue
);
1418 neigh_ifdown(tbl
, NULL
);
1419 if (atomic_read(&tbl
->entries
))
1420 printk(KERN_CRIT
"neighbour leakage\n");
1421 write_lock(&neigh_tbl_lock
);
1422 for (tp
= &neigh_tables
; *tp
; tp
= &(*tp
)->next
) {
1428 write_unlock(&neigh_tbl_lock
);
1430 neigh_hash_free(tbl
->hash_buckets
, tbl
->hash_mask
+ 1);
1431 tbl
->hash_buckets
= NULL
;
1433 kfree(tbl
->phash_buckets
);
1434 tbl
->phash_buckets
= NULL
;
1436 free_percpu(tbl
->stats
);
1442 static int neigh_delete(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
1445 struct nlattr
*dst_attr
;
1446 struct neigh_table
*tbl
;
1447 struct net_device
*dev
= NULL
;
1450 if (nlmsg_len(nlh
) < sizeof(*ndm
))
1453 dst_attr
= nlmsg_find_attr(nlh
, sizeof(*ndm
), NDA_DST
);
1454 if (dst_attr
== NULL
)
1457 ndm
= nlmsg_data(nlh
);
1458 if (ndm
->ndm_ifindex
) {
1459 dev
= dev_get_by_index(ndm
->ndm_ifindex
);
1466 read_lock(&neigh_tbl_lock
);
1467 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1468 struct neighbour
*neigh
;
1470 if (tbl
->family
!= ndm
->ndm_family
)
1472 read_unlock(&neigh_tbl_lock
);
1474 if (nla_len(dst_attr
) < tbl
->key_len
)
1477 if (ndm
->ndm_flags
& NTF_PROXY
) {
1478 err
= pneigh_delete(tbl
, nla_data(dst_attr
), dev
);
1485 neigh
= neigh_lookup(tbl
, nla_data(dst_attr
), dev
);
1486 if (neigh
== NULL
) {
1491 err
= neigh_update(neigh
, NULL
, NUD_FAILED
,
1492 NEIGH_UPDATE_F_OVERRIDE
|
1493 NEIGH_UPDATE_F_ADMIN
);
1494 neigh_release(neigh
);
1497 read_unlock(&neigh_tbl_lock
);
1498 err
= -EAFNOSUPPORT
;
1507 static int neigh_add(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
1510 struct nlattr
*tb
[NDA_MAX
+1];
1511 struct neigh_table
*tbl
;
1512 struct net_device
*dev
= NULL
;
1515 err
= nlmsg_parse(nlh
, sizeof(*ndm
), tb
, NDA_MAX
, NULL
);
1520 if (tb
[NDA_DST
] == NULL
)
1523 ndm
= nlmsg_data(nlh
);
1524 if (ndm
->ndm_ifindex
) {
1525 dev
= dev_get_by_index(ndm
->ndm_ifindex
);
1531 if (tb
[NDA_LLADDR
] && nla_len(tb
[NDA_LLADDR
]) < dev
->addr_len
)
1535 read_lock(&neigh_tbl_lock
);
1536 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1537 int flags
= NEIGH_UPDATE_F_ADMIN
| NEIGH_UPDATE_F_OVERRIDE
;
1538 struct neighbour
*neigh
;
1541 if (tbl
->family
!= ndm
->ndm_family
)
1543 read_unlock(&neigh_tbl_lock
);
1545 if (nla_len(tb
[NDA_DST
]) < tbl
->key_len
)
1547 dst
= nla_data(tb
[NDA_DST
]);
1548 lladdr
= tb
[NDA_LLADDR
] ? nla_data(tb
[NDA_LLADDR
]) : NULL
;
1550 if (ndm
->ndm_flags
& NTF_PROXY
) {
1551 struct pneigh_entry
*pn
;
1554 pn
= pneigh_lookup(tbl
, dst
, dev
, 1);
1556 pn
->flags
= ndm
->ndm_flags
;
1565 neigh
= neigh_lookup(tbl
, dst
, dev
);
1566 if (neigh
== NULL
) {
1567 if (!(nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
1572 neigh
= __neigh_lookup_errno(tbl
, dst
, dev
);
1573 if (IS_ERR(neigh
)) {
1574 err
= PTR_ERR(neigh
);
1578 if (nlh
->nlmsg_flags
& NLM_F_EXCL
) {
1580 neigh_release(neigh
);
1584 if (!(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
1585 flags
&= ~NEIGH_UPDATE_F_OVERRIDE
;
1588 err
= neigh_update(neigh
, lladdr
, ndm
->ndm_state
, flags
);
1589 neigh_release(neigh
);
1593 read_unlock(&neigh_tbl_lock
);
1594 err
= -EAFNOSUPPORT
;
1603 static int neightbl_fill_parms(struct sk_buff
*skb
, struct neigh_parms
*parms
)
1605 struct nlattr
*nest
;
1607 nest
= nla_nest_start(skb
, NDTA_PARMS
);
1612 NLA_PUT_U32(skb
, NDTPA_IFINDEX
, parms
->dev
->ifindex
);
1614 NLA_PUT_U32(skb
, NDTPA_REFCNT
, atomic_read(&parms
->refcnt
));
1615 NLA_PUT_U32(skb
, NDTPA_QUEUE_LEN
, parms
->queue_len
);
1616 NLA_PUT_U32(skb
, NDTPA_PROXY_QLEN
, parms
->proxy_qlen
);
1617 NLA_PUT_U32(skb
, NDTPA_APP_PROBES
, parms
->app_probes
);
1618 NLA_PUT_U32(skb
, NDTPA_UCAST_PROBES
, parms
->ucast_probes
);
1619 NLA_PUT_U32(skb
, NDTPA_MCAST_PROBES
, parms
->mcast_probes
);
1620 NLA_PUT_MSECS(skb
, NDTPA_REACHABLE_TIME
, parms
->reachable_time
);
1621 NLA_PUT_MSECS(skb
, NDTPA_BASE_REACHABLE_TIME
,
1622 parms
->base_reachable_time
);
1623 NLA_PUT_MSECS(skb
, NDTPA_GC_STALETIME
, parms
->gc_staletime
);
1624 NLA_PUT_MSECS(skb
, NDTPA_DELAY_PROBE_TIME
, parms
->delay_probe_time
);
1625 NLA_PUT_MSECS(skb
, NDTPA_RETRANS_TIME
, parms
->retrans_time
);
1626 NLA_PUT_MSECS(skb
, NDTPA_ANYCAST_DELAY
, parms
->anycast_delay
);
1627 NLA_PUT_MSECS(skb
, NDTPA_PROXY_DELAY
, parms
->proxy_delay
);
1628 NLA_PUT_MSECS(skb
, NDTPA_LOCKTIME
, parms
->locktime
);
1630 return nla_nest_end(skb
, nest
);
1633 return nla_nest_cancel(skb
, nest
);
1636 static int neightbl_fill_info(struct sk_buff
*skb
, struct neigh_table
*tbl
,
1637 u32 pid
, u32 seq
, int type
, int flags
)
1639 struct nlmsghdr
*nlh
;
1640 struct ndtmsg
*ndtmsg
;
1642 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1646 ndtmsg
= nlmsg_data(nlh
);
1648 read_lock_bh(&tbl
->lock
);
1649 ndtmsg
->ndtm_family
= tbl
->family
;
1650 ndtmsg
->ndtm_pad1
= 0;
1651 ndtmsg
->ndtm_pad2
= 0;
1653 NLA_PUT_STRING(skb
, NDTA_NAME
, tbl
->id
);
1654 NLA_PUT_MSECS(skb
, NDTA_GC_INTERVAL
, tbl
->gc_interval
);
1655 NLA_PUT_U32(skb
, NDTA_THRESH1
, tbl
->gc_thresh1
);
1656 NLA_PUT_U32(skb
, NDTA_THRESH2
, tbl
->gc_thresh2
);
1657 NLA_PUT_U32(skb
, NDTA_THRESH3
, tbl
->gc_thresh3
);
1660 unsigned long now
= jiffies
;
1661 unsigned int flush_delta
= now
- tbl
->last_flush
;
1662 unsigned int rand_delta
= now
- tbl
->last_rand
;
1664 struct ndt_config ndc
= {
1665 .ndtc_key_len
= tbl
->key_len
,
1666 .ndtc_entry_size
= tbl
->entry_size
,
1667 .ndtc_entries
= atomic_read(&tbl
->entries
),
1668 .ndtc_last_flush
= jiffies_to_msecs(flush_delta
),
1669 .ndtc_last_rand
= jiffies_to_msecs(rand_delta
),
1670 .ndtc_hash_rnd
= tbl
->hash_rnd
,
1671 .ndtc_hash_mask
= tbl
->hash_mask
,
1672 .ndtc_proxy_qlen
= tbl
->proxy_queue
.qlen
,
1675 NLA_PUT(skb
, NDTA_CONFIG
, sizeof(ndc
), &ndc
);
1680 struct ndt_stats ndst
;
1682 memset(&ndst
, 0, sizeof(ndst
));
1684 for_each_possible_cpu(cpu
) {
1685 struct neigh_statistics
*st
;
1687 st
= per_cpu_ptr(tbl
->stats
, cpu
);
1688 ndst
.ndts_allocs
+= st
->allocs
;
1689 ndst
.ndts_destroys
+= st
->destroys
;
1690 ndst
.ndts_hash_grows
+= st
->hash_grows
;
1691 ndst
.ndts_res_failed
+= st
->res_failed
;
1692 ndst
.ndts_lookups
+= st
->lookups
;
1693 ndst
.ndts_hits
+= st
->hits
;
1694 ndst
.ndts_rcv_probes_mcast
+= st
->rcv_probes_mcast
;
1695 ndst
.ndts_rcv_probes_ucast
+= st
->rcv_probes_ucast
;
1696 ndst
.ndts_periodic_gc_runs
+= st
->periodic_gc_runs
;
1697 ndst
.ndts_forced_gc_runs
+= st
->forced_gc_runs
;
1700 NLA_PUT(skb
, NDTA_STATS
, sizeof(ndst
), &ndst
);
1703 BUG_ON(tbl
->parms
.dev
);
1704 if (neightbl_fill_parms(skb
, &tbl
->parms
) < 0)
1705 goto nla_put_failure
;
1707 read_unlock_bh(&tbl
->lock
);
1708 return nlmsg_end(skb
, nlh
);
1711 read_unlock_bh(&tbl
->lock
);
1712 nlmsg_cancel(skb
, nlh
);
1716 static int neightbl_fill_param_info(struct sk_buff
*skb
,
1717 struct neigh_table
*tbl
,
1718 struct neigh_parms
*parms
,
1719 u32 pid
, u32 seq
, int type
,
1722 struct ndtmsg
*ndtmsg
;
1723 struct nlmsghdr
*nlh
;
1725 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1729 ndtmsg
= nlmsg_data(nlh
);
1731 read_lock_bh(&tbl
->lock
);
1732 ndtmsg
->ndtm_family
= tbl
->family
;
1733 ndtmsg
->ndtm_pad1
= 0;
1734 ndtmsg
->ndtm_pad2
= 0;
1736 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) < 0 ||
1737 neightbl_fill_parms(skb
, parms
) < 0)
1740 read_unlock_bh(&tbl
->lock
);
1741 return nlmsg_end(skb
, nlh
);
1743 read_unlock_bh(&tbl
->lock
);
1744 nlmsg_cancel(skb
, nlh
);
1748 static inline struct neigh_parms
*lookup_neigh_params(struct neigh_table
*tbl
,
1751 struct neigh_parms
*p
;
1753 for (p
= &tbl
->parms
; p
; p
= p
->next
)
1754 if ((p
->dev
&& p
->dev
->ifindex
== ifindex
) ||
1755 (!p
->dev
&& !ifindex
))
1761 static const struct nla_policy nl_neightbl_policy
[NDTA_MAX
+1] = {
1762 [NDTA_NAME
] = { .type
= NLA_STRING
},
1763 [NDTA_THRESH1
] = { .type
= NLA_U32
},
1764 [NDTA_THRESH2
] = { .type
= NLA_U32
},
1765 [NDTA_THRESH3
] = { .type
= NLA_U32
},
1766 [NDTA_GC_INTERVAL
] = { .type
= NLA_U64
},
1767 [NDTA_PARMS
] = { .type
= NLA_NESTED
},
1770 static const struct nla_policy nl_ntbl_parm_policy
[NDTPA_MAX
+1] = {
1771 [NDTPA_IFINDEX
] = { .type
= NLA_U32
},
1772 [NDTPA_QUEUE_LEN
] = { .type
= NLA_U32
},
1773 [NDTPA_PROXY_QLEN
] = { .type
= NLA_U32
},
1774 [NDTPA_APP_PROBES
] = { .type
= NLA_U32
},
1775 [NDTPA_UCAST_PROBES
] = { .type
= NLA_U32
},
1776 [NDTPA_MCAST_PROBES
] = { .type
= NLA_U32
},
1777 [NDTPA_BASE_REACHABLE_TIME
] = { .type
= NLA_U64
},
1778 [NDTPA_GC_STALETIME
] = { .type
= NLA_U64
},
1779 [NDTPA_DELAY_PROBE_TIME
] = { .type
= NLA_U64
},
1780 [NDTPA_RETRANS_TIME
] = { .type
= NLA_U64
},
1781 [NDTPA_ANYCAST_DELAY
] = { .type
= NLA_U64
},
1782 [NDTPA_PROXY_DELAY
] = { .type
= NLA_U64
},
1783 [NDTPA_LOCKTIME
] = { .type
= NLA_U64
},
1786 static int neightbl_set(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
1788 struct neigh_table
*tbl
;
1789 struct ndtmsg
*ndtmsg
;
1790 struct nlattr
*tb
[NDTA_MAX
+1];
1793 err
= nlmsg_parse(nlh
, sizeof(*ndtmsg
), tb
, NDTA_MAX
,
1794 nl_neightbl_policy
);
1798 if (tb
[NDTA_NAME
] == NULL
) {
1803 ndtmsg
= nlmsg_data(nlh
);
1804 read_lock(&neigh_tbl_lock
);
1805 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1806 if (ndtmsg
->ndtm_family
&& tbl
->family
!= ndtmsg
->ndtm_family
)
1809 if (nla_strcmp(tb
[NDTA_NAME
], tbl
->id
) == 0)
1819 * We acquire tbl->lock to be nice to the periodic timers and
1820 * make sure they always see a consistent set of values.
1822 write_lock_bh(&tbl
->lock
);
1824 if (tb
[NDTA_PARMS
]) {
1825 struct nlattr
*tbp
[NDTPA_MAX
+1];
1826 struct neigh_parms
*p
;
1829 err
= nla_parse_nested(tbp
, NDTPA_MAX
, tb
[NDTA_PARMS
],
1830 nl_ntbl_parm_policy
);
1832 goto errout_tbl_lock
;
1834 if (tbp
[NDTPA_IFINDEX
])
1835 ifindex
= nla_get_u32(tbp
[NDTPA_IFINDEX
]);
1837 p
= lookup_neigh_params(tbl
, ifindex
);
1840 goto errout_tbl_lock
;
1843 for (i
= 1; i
<= NDTPA_MAX
; i
++) {
1848 case NDTPA_QUEUE_LEN
:
1849 p
->queue_len
= nla_get_u32(tbp
[i
]);
1851 case NDTPA_PROXY_QLEN
:
1852 p
->proxy_qlen
= nla_get_u32(tbp
[i
]);
1854 case NDTPA_APP_PROBES
:
1855 p
->app_probes
= nla_get_u32(tbp
[i
]);
1857 case NDTPA_UCAST_PROBES
:
1858 p
->ucast_probes
= nla_get_u32(tbp
[i
]);
1860 case NDTPA_MCAST_PROBES
:
1861 p
->mcast_probes
= nla_get_u32(tbp
[i
]);
1863 case NDTPA_BASE_REACHABLE_TIME
:
1864 p
->base_reachable_time
= nla_get_msecs(tbp
[i
]);
1866 case NDTPA_GC_STALETIME
:
1867 p
->gc_staletime
= nla_get_msecs(tbp
[i
]);
1869 case NDTPA_DELAY_PROBE_TIME
:
1870 p
->delay_probe_time
= nla_get_msecs(tbp
[i
]);
1872 case NDTPA_RETRANS_TIME
:
1873 p
->retrans_time
= nla_get_msecs(tbp
[i
]);
1875 case NDTPA_ANYCAST_DELAY
:
1876 p
->anycast_delay
= nla_get_msecs(tbp
[i
]);
1878 case NDTPA_PROXY_DELAY
:
1879 p
->proxy_delay
= nla_get_msecs(tbp
[i
]);
1881 case NDTPA_LOCKTIME
:
1882 p
->locktime
= nla_get_msecs(tbp
[i
]);
1888 if (tb
[NDTA_THRESH1
])
1889 tbl
->gc_thresh1
= nla_get_u32(tb
[NDTA_THRESH1
]);
1891 if (tb
[NDTA_THRESH2
])
1892 tbl
->gc_thresh2
= nla_get_u32(tb
[NDTA_THRESH2
]);
1894 if (tb
[NDTA_THRESH3
])
1895 tbl
->gc_thresh3
= nla_get_u32(tb
[NDTA_THRESH3
]);
1897 if (tb
[NDTA_GC_INTERVAL
])
1898 tbl
->gc_interval
= nla_get_msecs(tb
[NDTA_GC_INTERVAL
]);
1903 write_unlock_bh(&tbl
->lock
);
1905 read_unlock(&neigh_tbl_lock
);
1910 static int neightbl_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1912 int family
, tidx
, nidx
= 0;
1913 int tbl_skip
= cb
->args
[0];
1914 int neigh_skip
= cb
->args
[1];
1915 struct neigh_table
*tbl
;
1917 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
1919 read_lock(&neigh_tbl_lock
);
1920 for (tbl
= neigh_tables
, tidx
= 0; tbl
; tbl
= tbl
->next
, tidx
++) {
1921 struct neigh_parms
*p
;
1923 if (tidx
< tbl_skip
|| (family
&& tbl
->family
!= family
))
1926 if (neightbl_fill_info(skb
, tbl
, NETLINK_CB(cb
->skb
).pid
,
1927 cb
->nlh
->nlmsg_seq
, RTM_NEWNEIGHTBL
,
1931 for (nidx
= 0, p
= tbl
->parms
.next
; p
; p
= p
->next
, nidx
++) {
1932 if (nidx
< neigh_skip
)
1935 if (neightbl_fill_param_info(skb
, tbl
, p
,
1936 NETLINK_CB(cb
->skb
).pid
,
1946 read_unlock(&neigh_tbl_lock
);
1953 static int neigh_fill_info(struct sk_buff
*skb
, struct neighbour
*neigh
,
1954 u32 pid
, u32 seq
, int type
, unsigned int flags
)
1956 unsigned long now
= jiffies
;
1957 struct nda_cacheinfo ci
;
1958 struct nlmsghdr
*nlh
;
1961 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
1965 ndm
= nlmsg_data(nlh
);
1966 ndm
->ndm_family
= neigh
->ops
->family
;
1969 ndm
->ndm_flags
= neigh
->flags
;
1970 ndm
->ndm_type
= neigh
->type
;
1971 ndm
->ndm_ifindex
= neigh
->dev
->ifindex
;
1973 NLA_PUT(skb
, NDA_DST
, neigh
->tbl
->key_len
, neigh
->primary_key
);
1975 read_lock_bh(&neigh
->lock
);
1976 ndm
->ndm_state
= neigh
->nud_state
;
1977 if ((neigh
->nud_state
& NUD_VALID
) &&
1978 nla_put(skb
, NDA_LLADDR
, neigh
->dev
->addr_len
, neigh
->ha
) < 0) {
1979 read_unlock_bh(&neigh
->lock
);
1980 goto nla_put_failure
;
1983 ci
.ndm_used
= now
- neigh
->used
;
1984 ci
.ndm_confirmed
= now
- neigh
->confirmed
;
1985 ci
.ndm_updated
= now
- neigh
->updated
;
1986 ci
.ndm_refcnt
= atomic_read(&neigh
->refcnt
) - 1;
1987 read_unlock_bh(&neigh
->lock
);
1989 NLA_PUT_U32(skb
, NDA_PROBES
, atomic_read(&neigh
->probes
));
1990 NLA_PUT(skb
, NDA_CACHEINFO
, sizeof(ci
), &ci
);
1992 return nlmsg_end(skb
, nlh
);
1995 nlmsg_cancel(skb
, nlh
);
2000 static int neigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2001 struct netlink_callback
*cb
)
2003 struct neighbour
*n
;
2004 int rc
, h
, s_h
= cb
->args
[1];
2005 int idx
, s_idx
= idx
= cb
->args
[2];
2007 read_lock_bh(&tbl
->lock
);
2008 for (h
= 0; h
<= tbl
->hash_mask
; h
++) {
2013 for (n
= tbl
->hash_buckets
[h
], idx
= 0; n
; n
= n
->next
, idx
++) {
2016 if (neigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).pid
,
2019 NLM_F_MULTI
) <= 0) {
2020 read_unlock_bh(&tbl
->lock
);
2026 read_unlock_bh(&tbl
->lock
);
2034 static int neigh_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2036 struct neigh_table
*tbl
;
2039 read_lock(&neigh_tbl_lock
);
2040 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2043 for (tbl
= neigh_tables
, t
= 0; tbl
; tbl
= tbl
->next
, t
++) {
2044 if (t
< s_t
|| (family
&& tbl
->family
!= family
))
2047 memset(&cb
->args
[1], 0, sizeof(cb
->args
) -
2048 sizeof(cb
->args
[0]));
2049 if (neigh_dump_table(tbl
, skb
, cb
) < 0)
2052 read_unlock(&neigh_tbl_lock
);
2058 void neigh_for_each(struct neigh_table
*tbl
, void (*cb
)(struct neighbour
*, void *), void *cookie
)
2062 read_lock_bh(&tbl
->lock
);
2063 for (chain
= 0; chain
<= tbl
->hash_mask
; chain
++) {
2064 struct neighbour
*n
;
2066 for (n
= tbl
->hash_buckets
[chain
]; n
; n
= n
->next
)
2069 read_unlock_bh(&tbl
->lock
);
2071 EXPORT_SYMBOL(neigh_for_each
);
2073 /* The tbl->lock must be held as a writer and BH disabled. */
2074 void __neigh_for_each_release(struct neigh_table
*tbl
,
2075 int (*cb
)(struct neighbour
*))
2079 for (chain
= 0; chain
<= tbl
->hash_mask
; chain
++) {
2080 struct neighbour
*n
, **np
;
2082 np
= &tbl
->hash_buckets
[chain
];
2083 while ((n
= *np
) != NULL
) {
2086 write_lock(&n
->lock
);
2093 write_unlock(&n
->lock
);
2095 neigh_cleanup_and_release(n
);
2100 EXPORT_SYMBOL(__neigh_for_each_release
);
2102 #ifdef CONFIG_PROC_FS
2104 static struct neighbour
*neigh_get_first(struct seq_file
*seq
)
2106 struct neigh_seq_state
*state
= seq
->private;
2107 struct neigh_table
*tbl
= state
->tbl
;
2108 struct neighbour
*n
= NULL
;
2109 int bucket
= state
->bucket
;
2111 state
->flags
&= ~NEIGH_SEQ_IS_PNEIGH
;
2112 for (bucket
= 0; bucket
<= tbl
->hash_mask
; bucket
++) {
2113 n
= tbl
->hash_buckets
[bucket
];
2116 if (state
->neigh_sub_iter
) {
2120 v
= state
->neigh_sub_iter(state
, n
, &fakep
);
2124 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2126 if (n
->nud_state
& ~NUD_NOARP
)
2135 state
->bucket
= bucket
;
2140 static struct neighbour
*neigh_get_next(struct seq_file
*seq
,
2141 struct neighbour
*n
,
2144 struct neigh_seq_state
*state
= seq
->private;
2145 struct neigh_table
*tbl
= state
->tbl
;
2147 if (state
->neigh_sub_iter
) {
2148 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2156 if (state
->neigh_sub_iter
) {
2157 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2162 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2165 if (n
->nud_state
& ~NUD_NOARP
)
2174 if (++state
->bucket
> tbl
->hash_mask
)
2177 n
= tbl
->hash_buckets
[state
->bucket
];
2185 static struct neighbour
*neigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2187 struct neighbour
*n
= neigh_get_first(seq
);
2191 n
= neigh_get_next(seq
, n
, pos
);
2196 return *pos
? NULL
: n
;
2199 static struct pneigh_entry
*pneigh_get_first(struct seq_file
*seq
)
2201 struct neigh_seq_state
*state
= seq
->private;
2202 struct neigh_table
*tbl
= state
->tbl
;
2203 struct pneigh_entry
*pn
= NULL
;
2204 int bucket
= state
->bucket
;
2206 state
->flags
|= NEIGH_SEQ_IS_PNEIGH
;
2207 for (bucket
= 0; bucket
<= PNEIGH_HASHMASK
; bucket
++) {
2208 pn
= tbl
->phash_buckets
[bucket
];
2212 state
->bucket
= bucket
;
2217 static struct pneigh_entry
*pneigh_get_next(struct seq_file
*seq
,
2218 struct pneigh_entry
*pn
,
2221 struct neigh_seq_state
*state
= seq
->private;
2222 struct neigh_table
*tbl
= state
->tbl
;
2226 if (++state
->bucket
> PNEIGH_HASHMASK
)
2228 pn
= tbl
->phash_buckets
[state
->bucket
];
2239 static struct pneigh_entry
*pneigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2241 struct pneigh_entry
*pn
= pneigh_get_first(seq
);
2245 pn
= pneigh_get_next(seq
, pn
, pos
);
2250 return *pos
? NULL
: pn
;
2253 static void *neigh_get_idx_any(struct seq_file
*seq
, loff_t
*pos
)
2255 struct neigh_seq_state
*state
= seq
->private;
2258 rc
= neigh_get_idx(seq
, pos
);
2259 if (!rc
&& !(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2260 rc
= pneigh_get_idx(seq
, pos
);
2265 void *neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
, struct neigh_table
*tbl
, unsigned int neigh_seq_flags
)
2267 struct neigh_seq_state
*state
= seq
->private;
2268 loff_t pos_minus_one
;
2272 state
->flags
= (neigh_seq_flags
& ~NEIGH_SEQ_IS_PNEIGH
);
2274 read_lock_bh(&tbl
->lock
);
2276 pos_minus_one
= *pos
- 1;
2277 return *pos
? neigh_get_idx_any(seq
, &pos_minus_one
) : SEQ_START_TOKEN
;
2279 EXPORT_SYMBOL(neigh_seq_start
);
2281 void *neigh_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2283 struct neigh_seq_state
*state
;
2286 if (v
== SEQ_START_TOKEN
) {
2287 rc
= neigh_get_idx(seq
, pos
);
2291 state
= seq
->private;
2292 if (!(state
->flags
& NEIGH_SEQ_IS_PNEIGH
)) {
2293 rc
= neigh_get_next(seq
, v
, NULL
);
2296 if (!(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2297 rc
= pneigh_get_first(seq
);
2299 BUG_ON(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
);
2300 rc
= pneigh_get_next(seq
, v
, NULL
);
2306 EXPORT_SYMBOL(neigh_seq_next
);
2308 void neigh_seq_stop(struct seq_file
*seq
, void *v
)
2310 struct neigh_seq_state
*state
= seq
->private;
2311 struct neigh_table
*tbl
= state
->tbl
;
2313 read_unlock_bh(&tbl
->lock
);
2315 EXPORT_SYMBOL(neigh_seq_stop
);
2317 /* statistics via seq_file */
2319 static void *neigh_stat_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2321 struct proc_dir_entry
*pde
= seq
->private;
2322 struct neigh_table
*tbl
= pde
->data
;
2326 return SEQ_START_TOKEN
;
2328 for (cpu
= *pos
-1; cpu
< NR_CPUS
; ++cpu
) {
2329 if (!cpu_possible(cpu
))
2332 return per_cpu_ptr(tbl
->stats
, cpu
);
2337 static void *neigh_stat_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2339 struct proc_dir_entry
*pde
= seq
->private;
2340 struct neigh_table
*tbl
= pde
->data
;
2343 for (cpu
= *pos
; cpu
< NR_CPUS
; ++cpu
) {
2344 if (!cpu_possible(cpu
))
2347 return per_cpu_ptr(tbl
->stats
, cpu
);
2352 static void neigh_stat_seq_stop(struct seq_file
*seq
, void *v
)
2357 static int neigh_stat_seq_show(struct seq_file
*seq
, void *v
)
2359 struct proc_dir_entry
*pde
= seq
->private;
2360 struct neigh_table
*tbl
= pde
->data
;
2361 struct neigh_statistics
*st
= v
;
2363 if (v
== SEQ_START_TOKEN
) {
2364 seq_printf(seq
, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs\n");
2368 seq_printf(seq
, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2369 "%08lx %08lx %08lx %08lx\n",
2370 atomic_read(&tbl
->entries
),
2381 st
->rcv_probes_mcast
,
2382 st
->rcv_probes_ucast
,
2384 st
->periodic_gc_runs
,
2391 static const struct seq_operations neigh_stat_seq_ops
= {
2392 .start
= neigh_stat_seq_start
,
2393 .next
= neigh_stat_seq_next
,
2394 .stop
= neigh_stat_seq_stop
,
2395 .show
= neigh_stat_seq_show
,
2398 static int neigh_stat_seq_open(struct inode
*inode
, struct file
*file
)
2400 int ret
= seq_open(file
, &neigh_stat_seq_ops
);
2403 struct seq_file
*sf
= file
->private_data
;
2404 sf
->private = PDE(inode
);
2409 static const struct file_operations neigh_stat_seq_fops
= {
2410 .owner
= THIS_MODULE
,
2411 .open
= neigh_stat_seq_open
,
2413 .llseek
= seq_lseek
,
2414 .release
= seq_release
,
2417 #endif /* CONFIG_PROC_FS */
2420 static inline size_t neigh_nlmsg_size(void)
2422 return NLMSG_ALIGN(sizeof(struct ndmsg
))
2423 + nla_total_size(MAX_ADDR_LEN
) /* NDA_DST */
2424 + nla_total_size(MAX_ADDR_LEN
) /* NDA_LLADDR */
2425 + nla_total_size(sizeof(struct nda_cacheinfo
))
2426 + nla_total_size(4); /* NDA_PROBES */
2429 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
)
2431 struct sk_buff
*skb
;
2434 skb
= nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC
);
2438 err
= neigh_fill_info(skb
, n
, 0, 0, type
, flags
);
2440 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2441 WARN_ON(err
== -EMSGSIZE
);
2445 err
= rtnl_notify(skb
, 0, RTNLGRP_NEIGH
, NULL
, GFP_ATOMIC
);
2448 rtnl_set_sk_err(RTNLGRP_NEIGH
, err
);
2451 void neigh_app_ns(struct neighbour
*n
)
2453 __neigh_notify(n
, RTM_GETNEIGH
, NLM_F_REQUEST
);
2456 static void neigh_app_notify(struct neighbour
*n
)
2458 __neigh_notify(n
, RTM_NEWNEIGH
, 0);
2461 #endif /* CONFIG_ARPD */
2463 #ifdef CONFIG_SYSCTL
2465 static struct neigh_sysctl_table
{
2466 struct ctl_table_header
*sysctl_header
;
2467 ctl_table neigh_vars
[__NET_NEIGH_MAX
];
2468 ctl_table neigh_dev
[2];
2469 ctl_table neigh_neigh_dir
[2];
2470 ctl_table neigh_proto_dir
[2];
2471 ctl_table neigh_root_dir
[2];
2472 } neigh_sysctl_template __read_mostly
= {
2475 .ctl_name
= NET_NEIGH_MCAST_SOLICIT
,
2476 .procname
= "mcast_solicit",
2477 .maxlen
= sizeof(int),
2479 .proc_handler
= &proc_dointvec
,
2482 .ctl_name
= NET_NEIGH_UCAST_SOLICIT
,
2483 .procname
= "ucast_solicit",
2484 .maxlen
= sizeof(int),
2486 .proc_handler
= &proc_dointvec
,
2489 .ctl_name
= NET_NEIGH_APP_SOLICIT
,
2490 .procname
= "app_solicit",
2491 .maxlen
= sizeof(int),
2493 .proc_handler
= &proc_dointvec
,
2496 .ctl_name
= NET_NEIGH_RETRANS_TIME
,
2497 .procname
= "retrans_time",
2498 .maxlen
= sizeof(int),
2500 .proc_handler
= &proc_dointvec_userhz_jiffies
,
2503 .ctl_name
= NET_NEIGH_REACHABLE_TIME
,
2504 .procname
= "base_reachable_time",
2505 .maxlen
= sizeof(int),
2507 .proc_handler
= &proc_dointvec_jiffies
,
2508 .strategy
= &sysctl_jiffies
,
2511 .ctl_name
= NET_NEIGH_DELAY_PROBE_TIME
,
2512 .procname
= "delay_first_probe_time",
2513 .maxlen
= sizeof(int),
2515 .proc_handler
= &proc_dointvec_jiffies
,
2516 .strategy
= &sysctl_jiffies
,
2519 .ctl_name
= NET_NEIGH_GC_STALE_TIME
,
2520 .procname
= "gc_stale_time",
2521 .maxlen
= sizeof(int),
2523 .proc_handler
= &proc_dointvec_jiffies
,
2524 .strategy
= &sysctl_jiffies
,
2527 .ctl_name
= NET_NEIGH_UNRES_QLEN
,
2528 .procname
= "unres_qlen",
2529 .maxlen
= sizeof(int),
2531 .proc_handler
= &proc_dointvec
,
2534 .ctl_name
= NET_NEIGH_PROXY_QLEN
,
2535 .procname
= "proxy_qlen",
2536 .maxlen
= sizeof(int),
2538 .proc_handler
= &proc_dointvec
,
2541 .ctl_name
= NET_NEIGH_ANYCAST_DELAY
,
2542 .procname
= "anycast_delay",
2543 .maxlen
= sizeof(int),
2545 .proc_handler
= &proc_dointvec_userhz_jiffies
,
2548 .ctl_name
= NET_NEIGH_PROXY_DELAY
,
2549 .procname
= "proxy_delay",
2550 .maxlen
= sizeof(int),
2552 .proc_handler
= &proc_dointvec_userhz_jiffies
,
2555 .ctl_name
= NET_NEIGH_LOCKTIME
,
2556 .procname
= "locktime",
2557 .maxlen
= sizeof(int),
2559 .proc_handler
= &proc_dointvec_userhz_jiffies
,
2562 .ctl_name
= NET_NEIGH_GC_INTERVAL
,
2563 .procname
= "gc_interval",
2564 .maxlen
= sizeof(int),
2566 .proc_handler
= &proc_dointvec_jiffies
,
2567 .strategy
= &sysctl_jiffies
,
2570 .ctl_name
= NET_NEIGH_GC_THRESH1
,
2571 .procname
= "gc_thresh1",
2572 .maxlen
= sizeof(int),
2574 .proc_handler
= &proc_dointvec
,
2577 .ctl_name
= NET_NEIGH_GC_THRESH2
,
2578 .procname
= "gc_thresh2",
2579 .maxlen
= sizeof(int),
2581 .proc_handler
= &proc_dointvec
,
2584 .ctl_name
= NET_NEIGH_GC_THRESH3
,
2585 .procname
= "gc_thresh3",
2586 .maxlen
= sizeof(int),
2588 .proc_handler
= &proc_dointvec
,
2591 .ctl_name
= NET_NEIGH_RETRANS_TIME_MS
,
2592 .procname
= "retrans_time_ms",
2593 .maxlen
= sizeof(int),
2595 .proc_handler
= &proc_dointvec_ms_jiffies
,
2596 .strategy
= &sysctl_ms_jiffies
,
2599 .ctl_name
= NET_NEIGH_REACHABLE_TIME_MS
,
2600 .procname
= "base_reachable_time_ms",
2601 .maxlen
= sizeof(int),
2603 .proc_handler
= &proc_dointvec_ms_jiffies
,
2604 .strategy
= &sysctl_ms_jiffies
,
2609 .ctl_name
= NET_PROTO_CONF_DEFAULT
,
2610 .procname
= "default",
2614 .neigh_neigh_dir
= {
2616 .procname
= "neigh",
2620 .neigh_proto_dir
= {
2627 .ctl_name
= CTL_NET
,
2634 int neigh_sysctl_register(struct net_device
*dev
, struct neigh_parms
*p
,
2635 int p_id
, int pdev_id
, char *p_name
,
2636 proc_handler
*handler
, ctl_handler
*strategy
)
2638 struct neigh_sysctl_table
*t
= kmemdup(&neigh_sysctl_template
,
2639 sizeof(*t
), GFP_KERNEL
);
2640 const char *dev_name_source
= NULL
;
2641 char *dev_name
= NULL
;
2646 t
->neigh_vars
[0].data
= &p
->mcast_probes
;
2647 t
->neigh_vars
[1].data
= &p
->ucast_probes
;
2648 t
->neigh_vars
[2].data
= &p
->app_probes
;
2649 t
->neigh_vars
[3].data
= &p
->retrans_time
;
2650 t
->neigh_vars
[4].data
= &p
->base_reachable_time
;
2651 t
->neigh_vars
[5].data
= &p
->delay_probe_time
;
2652 t
->neigh_vars
[6].data
= &p
->gc_staletime
;
2653 t
->neigh_vars
[7].data
= &p
->queue_len
;
2654 t
->neigh_vars
[8].data
= &p
->proxy_qlen
;
2655 t
->neigh_vars
[9].data
= &p
->anycast_delay
;
2656 t
->neigh_vars
[10].data
= &p
->proxy_delay
;
2657 t
->neigh_vars
[11].data
= &p
->locktime
;
2660 dev_name_source
= dev
->name
;
2661 t
->neigh_dev
[0].ctl_name
= dev
->ifindex
;
2662 t
->neigh_vars
[12].procname
= NULL
;
2663 t
->neigh_vars
[13].procname
= NULL
;
2664 t
->neigh_vars
[14].procname
= NULL
;
2665 t
->neigh_vars
[15].procname
= NULL
;
2667 dev_name_source
= t
->neigh_dev
[0].procname
;
2668 t
->neigh_vars
[12].data
= (int *)(p
+ 1);
2669 t
->neigh_vars
[13].data
= (int *)(p
+ 1) + 1;
2670 t
->neigh_vars
[14].data
= (int *)(p
+ 1) + 2;
2671 t
->neigh_vars
[15].data
= (int *)(p
+ 1) + 3;
2674 t
->neigh_vars
[16].data
= &p
->retrans_time
;
2675 t
->neigh_vars
[17].data
= &p
->base_reachable_time
;
2677 if (handler
|| strategy
) {
2679 t
->neigh_vars
[3].proc_handler
= handler
;
2680 t
->neigh_vars
[3].strategy
= strategy
;
2681 t
->neigh_vars
[3].extra1
= dev
;
2683 t
->neigh_vars
[4].proc_handler
= handler
;
2684 t
->neigh_vars
[4].strategy
= strategy
;
2685 t
->neigh_vars
[4].extra1
= dev
;
2686 /* RetransTime (in milliseconds)*/
2687 t
->neigh_vars
[16].proc_handler
= handler
;
2688 t
->neigh_vars
[16].strategy
= strategy
;
2689 t
->neigh_vars
[16].extra1
= dev
;
2690 /* ReachableTime (in milliseconds) */
2691 t
->neigh_vars
[17].proc_handler
= handler
;
2692 t
->neigh_vars
[17].strategy
= strategy
;
2693 t
->neigh_vars
[17].extra1
= dev
;
2696 dev_name
= kstrdup(dev_name_source
, GFP_KERNEL
);
2702 t
->neigh_dev
[0].procname
= dev_name
;
2704 t
->neigh_neigh_dir
[0].ctl_name
= pdev_id
;
2706 t
->neigh_proto_dir
[0].procname
= p_name
;
2707 t
->neigh_proto_dir
[0].ctl_name
= p_id
;
2709 t
->neigh_dev
[0].child
= t
->neigh_vars
;
2710 t
->neigh_neigh_dir
[0].child
= t
->neigh_dev
;
2711 t
->neigh_proto_dir
[0].child
= t
->neigh_neigh_dir
;
2712 t
->neigh_root_dir
[0].child
= t
->neigh_proto_dir
;
2714 t
->sysctl_header
= register_sysctl_table(t
->neigh_root_dir
);
2715 if (!t
->sysctl_header
) {
2719 p
->sysctl_table
= t
;
2731 void neigh_sysctl_unregister(struct neigh_parms
*p
)
2733 if (p
->sysctl_table
) {
2734 struct neigh_sysctl_table
*t
= p
->sysctl_table
;
2735 p
->sysctl_table
= NULL
;
2736 unregister_sysctl_table(t
->sysctl_header
);
2737 kfree(t
->neigh_dev
[0].procname
);
2742 #endif /* CONFIG_SYSCTL */
2744 static int __init
neigh_init(void)
2746 rtnl_register(PF_UNSPEC
, RTM_NEWNEIGH
, neigh_add
, NULL
);
2747 rtnl_register(PF_UNSPEC
, RTM_DELNEIGH
, neigh_delete
, NULL
);
2748 rtnl_register(PF_UNSPEC
, RTM_GETNEIGH
, NULL
, neigh_dump_info
);
2750 rtnl_register(PF_UNSPEC
, RTM_GETNEIGHTBL
, NULL
, neightbl_dump_info
);
2751 rtnl_register(PF_UNSPEC
, RTM_SETNEIGHTBL
, neightbl_set
, NULL
);
2756 subsys_initcall(neigh_init
);
2758 EXPORT_SYMBOL(__neigh_event_send
);
2759 EXPORT_SYMBOL(neigh_changeaddr
);
2760 EXPORT_SYMBOL(neigh_compat_output
);
2761 EXPORT_SYMBOL(neigh_connected_output
);
2762 EXPORT_SYMBOL(neigh_create
);
2763 EXPORT_SYMBOL(neigh_destroy
);
2764 EXPORT_SYMBOL(neigh_event_ns
);
2765 EXPORT_SYMBOL(neigh_ifdown
);
2766 EXPORT_SYMBOL(neigh_lookup
);
2767 EXPORT_SYMBOL(neigh_lookup_nodev
);
2768 EXPORT_SYMBOL(neigh_parms_alloc
);
2769 EXPORT_SYMBOL(neigh_parms_release
);
2770 EXPORT_SYMBOL(neigh_rand_reach_time
);
2771 EXPORT_SYMBOL(neigh_resolve_output
);
2772 EXPORT_SYMBOL(neigh_table_clear
);
2773 EXPORT_SYMBOL(neigh_table_init
);
2774 EXPORT_SYMBOL(neigh_table_init_no_netlink
);
2775 EXPORT_SYMBOL(neigh_update
);
2776 EXPORT_SYMBOL(pneigh_enqueue
);
2777 EXPORT_SYMBOL(pneigh_lookup
);
2780 EXPORT_SYMBOL(neigh_app_ns
);
2782 #ifdef CONFIG_SYSCTL
2783 EXPORT_SYMBOL(neigh_sysctl_register
);
2784 EXPORT_SYMBOL(neigh_sysctl_unregister
);