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/sched.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/neighbour.h>
32 #include <net/netevent.h>
33 #include <net/netlink.h>
34 #include <linux/rtnetlink.h>
35 #include <linux/random.h>
36 #include <linux/string.h>
40 #define NEIGH_PRINTK(x...) printk(x)
41 #define NEIGH_NOPRINTK(x...) do { ; } while(0)
42 #define NEIGH_PRINTK0 NEIGH_PRINTK
43 #define NEIGH_PRINTK1 NEIGH_NOPRINTK
44 #define NEIGH_PRINTK2 NEIGH_NOPRINTK
48 #define NEIGH_PRINTK1 NEIGH_PRINTK
52 #define NEIGH_PRINTK2 NEIGH_PRINTK
55 #define PNEIGH_HASHMASK 0xF
57 static void neigh_timer_handler(unsigned long arg
);
59 static void neigh_app_notify(struct neighbour
*n
);
61 static int pneigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
);
62 void neigh_changeaddr(struct neigh_table
*tbl
, struct net_device
*dev
);
64 static struct neigh_table
*neigh_tables
;
66 static struct file_operations neigh_stat_seq_fops
;
70 Neighbour hash table buckets are protected with rwlock tbl->lock.
72 - All the scans/updates to hash buckets MUST be made under this lock.
73 - NOTHING clever should be made under this lock: no callbacks
74 to protocol backends, no attempts to send something to network.
75 It will result in deadlocks, if backend/driver wants to use neighbour
77 - If the entry requires some non-trivial actions, increase
78 its reference count and release table lock.
80 Neighbour entries are protected:
81 - with reference count.
82 - with rwlock neigh->lock
84 Reference count prevents destruction.
86 neigh->lock mainly serializes ll address data and its validity state.
87 However, the same lock is used to protect another entry fields:
91 Again, nothing clever shall be made under neigh->lock,
92 the most complicated procedure, which we allow is dev->hard_header.
93 It is supposed, that dev->hard_header is simplistic and does
94 not make callbacks to neighbour tables.
96 The last lock is neigh_tbl_lock. It is pure SMP lock, protecting
97 list of neighbour tables. This list is used only in process context,
100 static DEFINE_RWLOCK(neigh_tbl_lock
);
102 static int neigh_blackhole(struct sk_buff
*skb
)
109 * It is random distribution in the interval (1/2)*base...(3/2)*base.
110 * It corresponds to default IPv6 settings and is not overridable,
111 * because it is really reasonable choice.
114 unsigned long neigh_rand_reach_time(unsigned long base
)
116 return (base
? (net_random() % base
) + (base
>> 1) : 0);
120 static int neigh_forced_gc(struct neigh_table
*tbl
)
125 NEIGH_CACHE_STAT_INC(tbl
, forced_gc_runs
);
127 write_lock_bh(&tbl
->lock
);
128 for (i
= 0; i
<= tbl
->hash_mask
; i
++) {
129 struct neighbour
*n
, **np
;
131 np
= &tbl
->hash_buckets
[i
];
132 while ((n
= *np
) != NULL
) {
133 /* Neighbour record may be discarded if:
134 * - nobody refers to it.
135 * - it is not permanent
137 write_lock(&n
->lock
);
138 if (atomic_read(&n
->refcnt
) == 1 &&
139 !(n
->nud_state
& NUD_PERMANENT
)) {
143 write_unlock(&n
->lock
);
147 write_unlock(&n
->lock
);
152 tbl
->last_flush
= jiffies
;
154 write_unlock_bh(&tbl
->lock
);
159 static int neigh_del_timer(struct neighbour
*n
)
161 if ((n
->nud_state
& NUD_IN_TIMER
) &&
162 del_timer(&n
->timer
)) {
169 static void pneigh_queue_purge(struct sk_buff_head
*list
)
173 while ((skb
= skb_dequeue(list
)) != NULL
) {
179 static void neigh_flush_dev(struct neigh_table
*tbl
, struct net_device
*dev
)
183 for (i
= 0; i
<= tbl
->hash_mask
; i
++) {
184 struct neighbour
*n
, **np
= &tbl
->hash_buckets
[i
];
186 while ((n
= *np
) != NULL
) {
187 if (dev
&& n
->dev
!= dev
) {
192 write_lock(&n
->lock
);
196 if (atomic_read(&n
->refcnt
) != 1) {
197 /* The most unpleasant situation.
198 We must destroy neighbour entry,
199 but someone still uses it.
201 The destroy will be delayed until
202 the last user releases us, but
203 we must kill timers etc. and move
206 skb_queue_purge(&n
->arp_queue
);
207 n
->output
= neigh_blackhole
;
208 if (n
->nud_state
& NUD_VALID
)
209 n
->nud_state
= NUD_NOARP
;
211 n
->nud_state
= NUD_NONE
;
212 NEIGH_PRINTK2("neigh %p is stray.\n", n
);
214 write_unlock(&n
->lock
);
220 void neigh_changeaddr(struct neigh_table
*tbl
, struct net_device
*dev
)
222 write_lock_bh(&tbl
->lock
);
223 neigh_flush_dev(tbl
, dev
);
224 write_unlock_bh(&tbl
->lock
);
227 int neigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
)
229 write_lock_bh(&tbl
->lock
);
230 neigh_flush_dev(tbl
, dev
);
231 pneigh_ifdown(tbl
, dev
);
232 write_unlock_bh(&tbl
->lock
);
234 del_timer_sync(&tbl
->proxy_timer
);
235 pneigh_queue_purge(&tbl
->proxy_queue
);
239 static struct neighbour
*neigh_alloc(struct neigh_table
*tbl
)
241 struct neighbour
*n
= NULL
;
242 unsigned long now
= jiffies
;
245 entries
= atomic_inc_return(&tbl
->entries
) - 1;
246 if (entries
>= tbl
->gc_thresh3
||
247 (entries
>= tbl
->gc_thresh2
&&
248 time_after(now
, tbl
->last_flush
+ 5 * HZ
))) {
249 if (!neigh_forced_gc(tbl
) &&
250 entries
>= tbl
->gc_thresh3
)
254 n
= kmem_cache_alloc(tbl
->kmem_cachep
, SLAB_ATOMIC
);
258 memset(n
, 0, tbl
->entry_size
);
260 skb_queue_head_init(&n
->arp_queue
);
261 rwlock_init(&n
->lock
);
262 n
->updated
= n
->used
= now
;
263 n
->nud_state
= NUD_NONE
;
264 n
->output
= neigh_blackhole
;
265 n
->parms
= neigh_parms_clone(&tbl
->parms
);
266 init_timer(&n
->timer
);
267 n
->timer
.function
= neigh_timer_handler
;
268 n
->timer
.data
= (unsigned long)n
;
270 NEIGH_CACHE_STAT_INC(tbl
, allocs
);
272 atomic_set(&n
->refcnt
, 1);
278 atomic_dec(&tbl
->entries
);
282 static struct neighbour
**neigh_hash_alloc(unsigned int entries
)
284 unsigned long size
= entries
* sizeof(struct neighbour
*);
285 struct neighbour
**ret
;
287 if (size
<= PAGE_SIZE
) {
288 ret
= kzalloc(size
, GFP_ATOMIC
);
290 ret
= (struct neighbour
**)
291 __get_free_pages(GFP_ATOMIC
|__GFP_ZERO
, get_order(size
));
296 static void neigh_hash_free(struct neighbour
**hash
, unsigned int entries
)
298 unsigned long size
= entries
* sizeof(struct neighbour
*);
300 if (size
<= PAGE_SIZE
)
303 free_pages((unsigned long)hash
, get_order(size
));
306 static void neigh_hash_grow(struct neigh_table
*tbl
, unsigned long new_entries
)
308 struct neighbour
**new_hash
, **old_hash
;
309 unsigned int i
, new_hash_mask
, old_entries
;
311 NEIGH_CACHE_STAT_INC(tbl
, hash_grows
);
313 BUG_ON(new_entries
& (new_entries
- 1));
314 new_hash
= neigh_hash_alloc(new_entries
);
318 old_entries
= tbl
->hash_mask
+ 1;
319 new_hash_mask
= new_entries
- 1;
320 old_hash
= tbl
->hash_buckets
;
322 get_random_bytes(&tbl
->hash_rnd
, sizeof(tbl
->hash_rnd
));
323 for (i
= 0; i
< old_entries
; i
++) {
324 struct neighbour
*n
, *next
;
326 for (n
= old_hash
[i
]; n
; n
= next
) {
327 unsigned int hash_val
= tbl
->hash(n
->primary_key
, n
->dev
);
329 hash_val
&= new_hash_mask
;
332 n
->next
= new_hash
[hash_val
];
333 new_hash
[hash_val
] = n
;
336 tbl
->hash_buckets
= new_hash
;
337 tbl
->hash_mask
= new_hash_mask
;
339 neigh_hash_free(old_hash
, old_entries
);
342 struct neighbour
*neigh_lookup(struct neigh_table
*tbl
, const void *pkey
,
343 struct net_device
*dev
)
346 int key_len
= tbl
->key_len
;
347 u32 hash_val
= tbl
->hash(pkey
, dev
) & tbl
->hash_mask
;
349 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
351 read_lock_bh(&tbl
->lock
);
352 for (n
= tbl
->hash_buckets
[hash_val
]; n
; n
= n
->next
) {
353 if (dev
== n
->dev
&& !memcmp(n
->primary_key
, pkey
, key_len
)) {
355 NEIGH_CACHE_STAT_INC(tbl
, hits
);
359 read_unlock_bh(&tbl
->lock
);
363 struct neighbour
*neigh_lookup_nodev(struct neigh_table
*tbl
, const void *pkey
)
366 int key_len
= tbl
->key_len
;
367 u32 hash_val
= tbl
->hash(pkey
, NULL
) & tbl
->hash_mask
;
369 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
371 read_lock_bh(&tbl
->lock
);
372 for (n
= tbl
->hash_buckets
[hash_val
]; n
; n
= n
->next
) {
373 if (!memcmp(n
->primary_key
, pkey
, key_len
)) {
375 NEIGH_CACHE_STAT_INC(tbl
, hits
);
379 read_unlock_bh(&tbl
->lock
);
383 struct neighbour
*neigh_create(struct neigh_table
*tbl
, const void *pkey
,
384 struct net_device
*dev
)
387 int key_len
= tbl
->key_len
;
389 struct neighbour
*n1
, *rc
, *n
= neigh_alloc(tbl
);
392 rc
= ERR_PTR(-ENOBUFS
);
396 memcpy(n
->primary_key
, pkey
, key_len
);
400 /* Protocol specific setup. */
401 if (tbl
->constructor
&& (error
= tbl
->constructor(n
)) < 0) {
403 goto out_neigh_release
;
406 /* Device specific setup. */
407 if (n
->parms
->neigh_setup
&&
408 (error
= n
->parms
->neigh_setup(n
)) < 0) {
410 goto out_neigh_release
;
413 n
->confirmed
= jiffies
- (n
->parms
->base_reachable_time
<< 1);
415 write_lock_bh(&tbl
->lock
);
417 if (atomic_read(&tbl
->entries
) > (tbl
->hash_mask
+ 1))
418 neigh_hash_grow(tbl
, (tbl
->hash_mask
+ 1) << 1);
420 hash_val
= tbl
->hash(pkey
, dev
) & tbl
->hash_mask
;
422 if (n
->parms
->dead
) {
423 rc
= ERR_PTR(-EINVAL
);
427 for (n1
= tbl
->hash_buckets
[hash_val
]; n1
; n1
= n1
->next
) {
428 if (dev
== n1
->dev
&& !memcmp(n1
->primary_key
, pkey
, key_len
)) {
435 n
->next
= tbl
->hash_buckets
[hash_val
];
436 tbl
->hash_buckets
[hash_val
] = n
;
439 write_unlock_bh(&tbl
->lock
);
440 NEIGH_PRINTK2("neigh %p is created.\n", n
);
445 write_unlock_bh(&tbl
->lock
);
451 struct pneigh_entry
* pneigh_lookup(struct neigh_table
*tbl
, const void *pkey
,
452 struct net_device
*dev
, int creat
)
454 struct pneigh_entry
*n
;
455 int key_len
= tbl
->key_len
;
456 u32 hash_val
= *(u32
*)(pkey
+ key_len
- 4);
458 hash_val
^= (hash_val
>> 16);
459 hash_val
^= hash_val
>> 8;
460 hash_val
^= hash_val
>> 4;
461 hash_val
&= PNEIGH_HASHMASK
;
463 read_lock_bh(&tbl
->lock
);
465 for (n
= tbl
->phash_buckets
[hash_val
]; n
; n
= n
->next
) {
466 if (!memcmp(n
->key
, pkey
, key_len
) &&
467 (n
->dev
== dev
|| !n
->dev
)) {
468 read_unlock_bh(&tbl
->lock
);
472 read_unlock_bh(&tbl
->lock
);
477 n
= kmalloc(sizeof(*n
) + key_len
, GFP_KERNEL
);
481 memcpy(n
->key
, pkey
, key_len
);
486 if (tbl
->pconstructor
&& tbl
->pconstructor(n
)) {
494 write_lock_bh(&tbl
->lock
);
495 n
->next
= tbl
->phash_buckets
[hash_val
];
496 tbl
->phash_buckets
[hash_val
] = n
;
497 write_unlock_bh(&tbl
->lock
);
503 int pneigh_delete(struct neigh_table
*tbl
, const void *pkey
,
504 struct net_device
*dev
)
506 struct pneigh_entry
*n
, **np
;
507 int key_len
= tbl
->key_len
;
508 u32 hash_val
= *(u32
*)(pkey
+ key_len
- 4);
510 hash_val
^= (hash_val
>> 16);
511 hash_val
^= hash_val
>> 8;
512 hash_val
^= hash_val
>> 4;
513 hash_val
&= PNEIGH_HASHMASK
;
515 write_lock_bh(&tbl
->lock
);
516 for (np
= &tbl
->phash_buckets
[hash_val
]; (n
= *np
) != NULL
;
518 if (!memcmp(n
->key
, pkey
, key_len
) && n
->dev
== dev
) {
520 write_unlock_bh(&tbl
->lock
);
521 if (tbl
->pdestructor
)
529 write_unlock_bh(&tbl
->lock
);
533 static int pneigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
)
535 struct pneigh_entry
*n
, **np
;
538 for (h
= 0; h
<= PNEIGH_HASHMASK
; h
++) {
539 np
= &tbl
->phash_buckets
[h
];
540 while ((n
= *np
) != NULL
) {
541 if (!dev
|| n
->dev
== dev
) {
543 if (tbl
->pdestructor
)
558 * neighbour must already be out of the table;
561 void neigh_destroy(struct neighbour
*neigh
)
565 NEIGH_CACHE_STAT_INC(neigh
->tbl
, destroys
);
569 "Destroying alive neighbour %p\n", neigh
);
574 if (neigh_del_timer(neigh
))
575 printk(KERN_WARNING
"Impossible event.\n");
577 while ((hh
= neigh
->hh
) != NULL
) {
578 neigh
->hh
= hh
->hh_next
;
580 write_lock_bh(&hh
->hh_lock
);
581 hh
->hh_output
= neigh_blackhole
;
582 write_unlock_bh(&hh
->hh_lock
);
583 if (atomic_dec_and_test(&hh
->hh_refcnt
))
587 if (neigh
->parms
->neigh_destructor
)
588 (neigh
->parms
->neigh_destructor
)(neigh
);
590 skb_queue_purge(&neigh
->arp_queue
);
593 neigh_parms_put(neigh
->parms
);
595 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh
);
597 atomic_dec(&neigh
->tbl
->entries
);
598 kmem_cache_free(neigh
->tbl
->kmem_cachep
, neigh
);
601 /* Neighbour state is suspicious;
604 Called with write_locked neigh.
606 static void neigh_suspect(struct neighbour
*neigh
)
610 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh
);
612 neigh
->output
= neigh
->ops
->output
;
614 for (hh
= neigh
->hh
; hh
; hh
= hh
->hh_next
)
615 hh
->hh_output
= neigh
->ops
->output
;
618 /* Neighbour state is OK;
621 Called with write_locked neigh.
623 static void neigh_connect(struct neighbour
*neigh
)
627 NEIGH_PRINTK2("neigh %p is connected.\n", neigh
);
629 neigh
->output
= neigh
->ops
->connected_output
;
631 for (hh
= neigh
->hh
; hh
; hh
= hh
->hh_next
)
632 hh
->hh_output
= neigh
->ops
->hh_output
;
635 static void neigh_periodic_timer(unsigned long arg
)
637 struct neigh_table
*tbl
= (struct neigh_table
*)arg
;
638 struct neighbour
*n
, **np
;
639 unsigned long expire
, now
= jiffies
;
641 NEIGH_CACHE_STAT_INC(tbl
, periodic_gc_runs
);
643 write_lock(&tbl
->lock
);
646 * periodically recompute ReachableTime from random function
649 if (time_after(now
, tbl
->last_rand
+ 300 * HZ
)) {
650 struct neigh_parms
*p
;
651 tbl
->last_rand
= now
;
652 for (p
= &tbl
->parms
; p
; p
= p
->next
)
654 neigh_rand_reach_time(p
->base_reachable_time
);
657 np
= &tbl
->hash_buckets
[tbl
->hash_chain_gc
];
658 tbl
->hash_chain_gc
= ((tbl
->hash_chain_gc
+ 1) & tbl
->hash_mask
);
660 while ((n
= *np
) != NULL
) {
663 write_lock(&n
->lock
);
665 state
= n
->nud_state
;
666 if (state
& (NUD_PERMANENT
| NUD_IN_TIMER
)) {
667 write_unlock(&n
->lock
);
671 if (time_before(n
->used
, n
->confirmed
))
672 n
->used
= n
->confirmed
;
674 if (atomic_read(&n
->refcnt
) == 1 &&
675 (state
== NUD_FAILED
||
676 time_after(now
, n
->used
+ n
->parms
->gc_staletime
))) {
679 write_unlock(&n
->lock
);
683 write_unlock(&n
->lock
);
689 /* Cycle through all hash buckets every base_reachable_time/2 ticks.
690 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
691 * base_reachable_time.
693 expire
= tbl
->parms
.base_reachable_time
>> 1;
694 expire
/= (tbl
->hash_mask
+ 1);
698 mod_timer(&tbl
->gc_timer
, now
+ expire
);
700 write_unlock(&tbl
->lock
);
703 static __inline__
int neigh_max_probes(struct neighbour
*n
)
705 struct neigh_parms
*p
= n
->parms
;
706 return (n
->nud_state
& NUD_PROBE
?
708 p
->ucast_probes
+ p
->app_probes
+ p
->mcast_probes
);
711 static inline void neigh_add_timer(struct neighbour
*n
, unsigned long when
)
713 if (unlikely(mod_timer(&n
->timer
, when
))) {
714 printk("NEIGH: BUG, double timer add, state is %x\n",
720 /* Called when a timer expires for a neighbour entry. */
722 static void neigh_timer_handler(unsigned long arg
)
724 unsigned long now
, next
;
725 struct neighbour
*neigh
= (struct neighbour
*)arg
;
729 write_lock(&neigh
->lock
);
731 state
= neigh
->nud_state
;
735 if (!(state
& NUD_IN_TIMER
)) {
737 printk(KERN_WARNING
"neigh: timer & !nud_in_timer\n");
742 if (state
& NUD_REACHABLE
) {
743 if (time_before_eq(now
,
744 neigh
->confirmed
+ neigh
->parms
->reachable_time
)) {
745 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh
);
746 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
747 } else if (time_before_eq(now
,
748 neigh
->used
+ neigh
->parms
->delay_probe_time
)) {
749 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh
);
750 neigh
->nud_state
= NUD_DELAY
;
751 neigh
->updated
= jiffies
;
752 neigh_suspect(neigh
);
753 next
= now
+ neigh
->parms
->delay_probe_time
;
755 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh
);
756 neigh
->nud_state
= NUD_STALE
;
757 neigh
->updated
= jiffies
;
758 neigh_suspect(neigh
);
761 } else if (state
& NUD_DELAY
) {
762 if (time_before_eq(now
,
763 neigh
->confirmed
+ neigh
->parms
->delay_probe_time
)) {
764 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh
);
765 neigh
->nud_state
= NUD_REACHABLE
;
766 neigh
->updated
= jiffies
;
767 neigh_connect(neigh
);
769 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
771 NEIGH_PRINTK2("neigh %p is probed.\n", neigh
);
772 neigh
->nud_state
= NUD_PROBE
;
773 neigh
->updated
= jiffies
;
774 atomic_set(&neigh
->probes
, 0);
775 next
= now
+ neigh
->parms
->retrans_time
;
778 /* NUD_PROBE|NUD_INCOMPLETE */
779 next
= now
+ neigh
->parms
->retrans_time
;
782 if ((neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
783 atomic_read(&neigh
->probes
) >= neigh_max_probes(neigh
)) {
786 neigh
->nud_state
= NUD_FAILED
;
787 neigh
->updated
= jiffies
;
789 NEIGH_CACHE_STAT_INC(neigh
->tbl
, res_failed
);
790 NEIGH_PRINTK2("neigh %p is failed.\n", neigh
);
792 /* It is very thin place. report_unreachable is very complicated
793 routine. Particularly, it can hit the same neighbour entry!
795 So that, we try to be accurate and avoid dead loop. --ANK
797 while (neigh
->nud_state
== NUD_FAILED
&&
798 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
799 write_unlock(&neigh
->lock
);
800 neigh
->ops
->error_report(neigh
, skb
);
801 write_lock(&neigh
->lock
);
803 skb_queue_purge(&neigh
->arp_queue
);
806 if (neigh
->nud_state
& NUD_IN_TIMER
) {
807 if (time_before(next
, jiffies
+ HZ
/2))
808 next
= jiffies
+ HZ
/2;
809 if (!mod_timer(&neigh
->timer
, next
))
812 if (neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) {
813 struct sk_buff
*skb
= skb_peek(&neigh
->arp_queue
);
814 /* keep skb alive even if arp_queue overflows */
817 write_unlock(&neigh
->lock
);
818 neigh
->ops
->solicit(neigh
, skb
);
819 atomic_inc(&neigh
->probes
);
824 write_unlock(&neigh
->lock
);
827 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
830 if (notify
&& neigh
->parms
->app_probes
)
831 neigh_app_notify(neigh
);
833 neigh_release(neigh
);
836 int __neigh_event_send(struct neighbour
*neigh
, struct sk_buff
*skb
)
841 write_lock_bh(&neigh
->lock
);
844 if (neigh
->nud_state
& (NUD_CONNECTED
| NUD_DELAY
| NUD_PROBE
))
849 if (!(neigh
->nud_state
& (NUD_STALE
| NUD_INCOMPLETE
))) {
850 if (neigh
->parms
->mcast_probes
+ neigh
->parms
->app_probes
) {
851 atomic_set(&neigh
->probes
, neigh
->parms
->ucast_probes
);
852 neigh
->nud_state
= NUD_INCOMPLETE
;
853 neigh
->updated
= jiffies
;
855 neigh_add_timer(neigh
, now
+ 1);
857 neigh
->nud_state
= NUD_FAILED
;
858 neigh
->updated
= jiffies
;
859 write_unlock_bh(&neigh
->lock
);
865 } else if (neigh
->nud_state
& NUD_STALE
) {
866 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh
);
868 neigh
->nud_state
= NUD_DELAY
;
869 neigh
->updated
= jiffies
;
870 neigh_add_timer(neigh
,
871 jiffies
+ neigh
->parms
->delay_probe_time
);
874 if (neigh
->nud_state
== NUD_INCOMPLETE
) {
876 if (skb_queue_len(&neigh
->arp_queue
) >=
877 neigh
->parms
->queue_len
) {
878 struct sk_buff
*buff
;
879 buff
= neigh
->arp_queue
.next
;
880 __skb_unlink(buff
, &neigh
->arp_queue
);
883 __skb_queue_tail(&neigh
->arp_queue
, skb
);
888 write_unlock_bh(&neigh
->lock
);
892 static __inline__
void neigh_update_hhs(struct neighbour
*neigh
)
895 void (*update
)(struct hh_cache
*, struct net_device
*, unsigned char *) =
896 neigh
->dev
->header_cache_update
;
899 for (hh
= neigh
->hh
; hh
; hh
= hh
->hh_next
) {
900 write_lock_bh(&hh
->hh_lock
);
901 update(hh
, neigh
->dev
, neigh
->ha
);
902 write_unlock_bh(&hh
->hh_lock
);
909 /* Generic update routine.
910 -- lladdr is new lladdr or NULL, if it is not supplied.
913 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
915 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
916 lladdr instead of overriding it
918 It also allows to retain current state
919 if lladdr is unchanged.
920 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
922 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
924 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
927 Caller MUST hold reference count on the entry.
930 int neigh_update(struct neighbour
*neigh
, const u8
*lladdr
, u8
new,
936 struct net_device
*dev
;
937 int update_isrouter
= 0;
939 write_lock_bh(&neigh
->lock
);
942 old
= neigh
->nud_state
;
945 if (!(flags
& NEIGH_UPDATE_F_ADMIN
) &&
946 (old
& (NUD_NOARP
| NUD_PERMANENT
)))
949 if (!(new & NUD_VALID
)) {
950 neigh_del_timer(neigh
);
951 if (old
& NUD_CONNECTED
)
952 neigh_suspect(neigh
);
953 neigh
->nud_state
= new;
955 notify
= old
& NUD_VALID
;
959 /* Compare new lladdr with cached one */
960 if (!dev
->addr_len
) {
961 /* First case: device needs no address. */
964 /* The second case: if something is already cached
965 and a new address is proposed:
967 - if they are different, check override flag
969 if ((old
& NUD_VALID
) &&
970 !memcmp(lladdr
, neigh
->ha
, dev
->addr_len
))
973 /* No address is supplied; if we know something,
974 use it, otherwise discard the request.
977 if (!(old
& NUD_VALID
))
982 if (new & NUD_CONNECTED
)
983 neigh
->confirmed
= jiffies
;
984 neigh
->updated
= jiffies
;
986 /* If entry was valid and address is not changed,
987 do not change entry state, if new one is STALE.
990 update_isrouter
= flags
& NEIGH_UPDATE_F_OVERRIDE_ISROUTER
;
991 if (old
& NUD_VALID
) {
992 if (lladdr
!= neigh
->ha
&& !(flags
& NEIGH_UPDATE_F_OVERRIDE
)) {
994 if ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) &&
995 (old
& NUD_CONNECTED
)) {
1001 if (lladdr
== neigh
->ha
&& new == NUD_STALE
&&
1002 ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) ||
1003 (old
& NUD_CONNECTED
))
1010 neigh_del_timer(neigh
);
1011 if (new & NUD_IN_TIMER
) {
1013 neigh_add_timer(neigh
, (jiffies
+
1014 ((new & NUD_REACHABLE
) ?
1015 neigh
->parms
->reachable_time
:
1018 neigh
->nud_state
= new;
1021 if (lladdr
!= neigh
->ha
) {
1022 memcpy(&neigh
->ha
, lladdr
, dev
->addr_len
);
1023 neigh_update_hhs(neigh
);
1024 if (!(new & NUD_CONNECTED
))
1025 neigh
->confirmed
= jiffies
-
1026 (neigh
->parms
->base_reachable_time
<< 1);
1031 if (new & NUD_CONNECTED
)
1032 neigh_connect(neigh
);
1034 neigh_suspect(neigh
);
1035 if (!(old
& NUD_VALID
)) {
1036 struct sk_buff
*skb
;
1038 /* Again: avoid dead loop if something went wrong */
1040 while (neigh
->nud_state
& NUD_VALID
&&
1041 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
1042 struct neighbour
*n1
= neigh
;
1043 write_unlock_bh(&neigh
->lock
);
1044 /* On shaper/eql skb->dst->neighbour != neigh :( */
1045 if (skb
->dst
&& skb
->dst
->neighbour
)
1046 n1
= skb
->dst
->neighbour
;
1048 write_lock_bh(&neigh
->lock
);
1050 skb_queue_purge(&neigh
->arp_queue
);
1053 if (update_isrouter
) {
1054 neigh
->flags
= (flags
& NEIGH_UPDATE_F_ISROUTER
) ?
1055 (neigh
->flags
| NTF_ROUTER
) :
1056 (neigh
->flags
& ~NTF_ROUTER
);
1058 write_unlock_bh(&neigh
->lock
);
1061 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
1063 if (notify
&& neigh
->parms
->app_probes
)
1064 neigh_app_notify(neigh
);
1069 struct neighbour
*neigh_event_ns(struct neigh_table
*tbl
,
1070 u8
*lladdr
, void *saddr
,
1071 struct net_device
*dev
)
1073 struct neighbour
*neigh
= __neigh_lookup(tbl
, saddr
, dev
,
1074 lladdr
|| !dev
->addr_len
);
1076 neigh_update(neigh
, lladdr
, NUD_STALE
,
1077 NEIGH_UPDATE_F_OVERRIDE
);
1081 static void neigh_hh_init(struct neighbour
*n
, struct dst_entry
*dst
,
1084 struct hh_cache
*hh
;
1085 struct net_device
*dev
= dst
->dev
;
1087 for (hh
= n
->hh
; hh
; hh
= hh
->hh_next
)
1088 if (hh
->hh_type
== protocol
)
1091 if (!hh
&& (hh
= kzalloc(sizeof(*hh
), GFP_ATOMIC
)) != NULL
) {
1092 rwlock_init(&hh
->hh_lock
);
1093 hh
->hh_type
= protocol
;
1094 atomic_set(&hh
->hh_refcnt
, 0);
1096 if (dev
->hard_header_cache(n
, hh
)) {
1100 atomic_inc(&hh
->hh_refcnt
);
1101 hh
->hh_next
= n
->hh
;
1103 if (n
->nud_state
& NUD_CONNECTED
)
1104 hh
->hh_output
= n
->ops
->hh_output
;
1106 hh
->hh_output
= n
->ops
->output
;
1110 atomic_inc(&hh
->hh_refcnt
);
1115 /* This function can be used in contexts, where only old dev_queue_xmit
1116 worked, f.e. if you want to override normal output path (eql, shaper),
1117 but resolution is not made yet.
1120 int neigh_compat_output(struct sk_buff
*skb
)
1122 struct net_device
*dev
= skb
->dev
;
1124 __skb_pull(skb
, skb
->nh
.raw
- skb
->data
);
1126 if (dev
->hard_header
&&
1127 dev
->hard_header(skb
, dev
, ntohs(skb
->protocol
), NULL
, NULL
,
1129 dev
->rebuild_header(skb
))
1132 return dev_queue_xmit(skb
);
1135 /* Slow and careful. */
1137 int neigh_resolve_output(struct sk_buff
*skb
)
1139 struct dst_entry
*dst
= skb
->dst
;
1140 struct neighbour
*neigh
;
1143 if (!dst
|| !(neigh
= dst
->neighbour
))
1146 __skb_pull(skb
, skb
->nh
.raw
- skb
->data
);
1148 if (!neigh_event_send(neigh
, skb
)) {
1150 struct net_device
*dev
= neigh
->dev
;
1151 if (dev
->hard_header_cache
&& !dst
->hh
) {
1152 write_lock_bh(&neigh
->lock
);
1154 neigh_hh_init(neigh
, dst
, dst
->ops
->protocol
);
1155 err
= dev
->hard_header(skb
, dev
, ntohs(skb
->protocol
),
1156 neigh
->ha
, NULL
, skb
->len
);
1157 write_unlock_bh(&neigh
->lock
);
1159 read_lock_bh(&neigh
->lock
);
1160 err
= dev
->hard_header(skb
, dev
, ntohs(skb
->protocol
),
1161 neigh
->ha
, NULL
, skb
->len
);
1162 read_unlock_bh(&neigh
->lock
);
1165 rc
= neigh
->ops
->queue_xmit(skb
);
1172 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1173 dst
, dst
? dst
->neighbour
: NULL
);
1180 /* As fast as possible without hh cache */
1182 int neigh_connected_output(struct sk_buff
*skb
)
1185 struct dst_entry
*dst
= skb
->dst
;
1186 struct neighbour
*neigh
= dst
->neighbour
;
1187 struct net_device
*dev
= neigh
->dev
;
1189 __skb_pull(skb
, skb
->nh
.raw
- skb
->data
);
1191 read_lock_bh(&neigh
->lock
);
1192 err
= dev
->hard_header(skb
, dev
, ntohs(skb
->protocol
),
1193 neigh
->ha
, NULL
, skb
->len
);
1194 read_unlock_bh(&neigh
->lock
);
1196 err
= neigh
->ops
->queue_xmit(skb
);
1204 static void neigh_proxy_process(unsigned long arg
)
1206 struct neigh_table
*tbl
= (struct neigh_table
*)arg
;
1207 long sched_next
= 0;
1208 unsigned long now
= jiffies
;
1209 struct sk_buff
*skb
;
1211 spin_lock(&tbl
->proxy_queue
.lock
);
1213 skb
= tbl
->proxy_queue
.next
;
1215 while (skb
!= (struct sk_buff
*)&tbl
->proxy_queue
) {
1216 struct sk_buff
*back
= skb
;
1217 long tdif
= NEIGH_CB(back
)->sched_next
- now
;
1221 struct net_device
*dev
= back
->dev
;
1222 __skb_unlink(back
, &tbl
->proxy_queue
);
1223 if (tbl
->proxy_redo
&& netif_running(dev
))
1224 tbl
->proxy_redo(back
);
1229 } else if (!sched_next
|| tdif
< sched_next
)
1232 del_timer(&tbl
->proxy_timer
);
1234 mod_timer(&tbl
->proxy_timer
, jiffies
+ sched_next
);
1235 spin_unlock(&tbl
->proxy_queue
.lock
);
1238 void pneigh_enqueue(struct neigh_table
*tbl
, struct neigh_parms
*p
,
1239 struct sk_buff
*skb
)
1241 unsigned long now
= jiffies
;
1242 unsigned long sched_next
= now
+ (net_random() % p
->proxy_delay
);
1244 if (tbl
->proxy_queue
.qlen
> p
->proxy_qlen
) {
1249 NEIGH_CB(skb
)->sched_next
= sched_next
;
1250 NEIGH_CB(skb
)->flags
|= LOCALLY_ENQUEUED
;
1252 spin_lock(&tbl
->proxy_queue
.lock
);
1253 if (del_timer(&tbl
->proxy_timer
)) {
1254 if (time_before(tbl
->proxy_timer
.expires
, sched_next
))
1255 sched_next
= tbl
->proxy_timer
.expires
;
1257 dst_release(skb
->dst
);
1260 __skb_queue_tail(&tbl
->proxy_queue
, skb
);
1261 mod_timer(&tbl
->proxy_timer
, sched_next
);
1262 spin_unlock(&tbl
->proxy_queue
.lock
);
1266 struct neigh_parms
*neigh_parms_alloc(struct net_device
*dev
,
1267 struct neigh_table
*tbl
)
1269 struct neigh_parms
*p
= kmalloc(sizeof(*p
), GFP_KERNEL
);
1272 memcpy(p
, &tbl
->parms
, sizeof(*p
));
1274 atomic_set(&p
->refcnt
, 1);
1275 INIT_RCU_HEAD(&p
->rcu_head
);
1277 neigh_rand_reach_time(p
->base_reachable_time
);
1279 if (dev
->neigh_setup
&& dev
->neigh_setup(dev
, p
)) {
1287 p
->sysctl_table
= NULL
;
1288 write_lock_bh(&tbl
->lock
);
1289 p
->next
= tbl
->parms
.next
;
1290 tbl
->parms
.next
= p
;
1291 write_unlock_bh(&tbl
->lock
);
1296 static void neigh_rcu_free_parms(struct rcu_head
*head
)
1298 struct neigh_parms
*parms
=
1299 container_of(head
, struct neigh_parms
, rcu_head
);
1301 neigh_parms_put(parms
);
1304 void neigh_parms_release(struct neigh_table
*tbl
, struct neigh_parms
*parms
)
1306 struct neigh_parms
**p
;
1308 if (!parms
|| parms
== &tbl
->parms
)
1310 write_lock_bh(&tbl
->lock
);
1311 for (p
= &tbl
->parms
.next
; *p
; p
= &(*p
)->next
) {
1315 write_unlock_bh(&tbl
->lock
);
1317 dev_put(parms
->dev
);
1318 call_rcu(&parms
->rcu_head
, neigh_rcu_free_parms
);
1322 write_unlock_bh(&tbl
->lock
);
1323 NEIGH_PRINTK1("neigh_parms_release: not found\n");
1326 void neigh_parms_destroy(struct neigh_parms
*parms
)
1331 void neigh_table_init_no_netlink(struct neigh_table
*tbl
)
1333 unsigned long now
= jiffies
;
1334 unsigned long phsize
;
1336 atomic_set(&tbl
->parms
.refcnt
, 1);
1337 INIT_RCU_HEAD(&tbl
->parms
.rcu_head
);
1338 tbl
->parms
.reachable_time
=
1339 neigh_rand_reach_time(tbl
->parms
.base_reachable_time
);
1341 if (!tbl
->kmem_cachep
)
1342 tbl
->kmem_cachep
= kmem_cache_create(tbl
->id
,
1344 0, SLAB_HWCACHE_ALIGN
,
1347 if (!tbl
->kmem_cachep
)
1348 panic("cannot create neighbour cache");
1350 tbl
->stats
= alloc_percpu(struct neigh_statistics
);
1352 panic("cannot create neighbour cache statistics");
1354 #ifdef CONFIG_PROC_FS
1355 tbl
->pde
= create_proc_entry(tbl
->id
, 0, proc_net_stat
);
1357 panic("cannot create neighbour proc dir entry");
1358 tbl
->pde
->proc_fops
= &neigh_stat_seq_fops
;
1359 tbl
->pde
->data
= tbl
;
1363 tbl
->hash_buckets
= neigh_hash_alloc(tbl
->hash_mask
+ 1);
1365 phsize
= (PNEIGH_HASHMASK
+ 1) * sizeof(struct pneigh_entry
*);
1366 tbl
->phash_buckets
= kzalloc(phsize
, GFP_KERNEL
);
1368 if (!tbl
->hash_buckets
|| !tbl
->phash_buckets
)
1369 panic("cannot allocate neighbour cache hashes");
1371 get_random_bytes(&tbl
->hash_rnd
, sizeof(tbl
->hash_rnd
));
1373 rwlock_init(&tbl
->lock
);
1374 init_timer(&tbl
->gc_timer
);
1375 tbl
->gc_timer
.data
= (unsigned long)tbl
;
1376 tbl
->gc_timer
.function
= neigh_periodic_timer
;
1377 tbl
->gc_timer
.expires
= now
+ 1;
1378 add_timer(&tbl
->gc_timer
);
1380 init_timer(&tbl
->proxy_timer
);
1381 tbl
->proxy_timer
.data
= (unsigned long)tbl
;
1382 tbl
->proxy_timer
.function
= neigh_proxy_process
;
1383 skb_queue_head_init(&tbl
->proxy_queue
);
1385 tbl
->last_flush
= now
;
1386 tbl
->last_rand
= now
+ tbl
->parms
.reachable_time
* 20;
1389 void neigh_table_init(struct neigh_table
*tbl
)
1391 struct neigh_table
*tmp
;
1393 neigh_table_init_no_netlink(tbl
);
1394 write_lock(&neigh_tbl_lock
);
1395 for (tmp
= neigh_tables
; tmp
; tmp
= tmp
->next
) {
1396 if (tmp
->family
== tbl
->family
)
1399 tbl
->next
= neigh_tables
;
1401 write_unlock(&neigh_tbl_lock
);
1403 if (unlikely(tmp
)) {
1404 printk(KERN_ERR
"NEIGH: Registering multiple tables for "
1405 "family %d\n", tbl
->family
);
1410 int neigh_table_clear(struct neigh_table
*tbl
)
1412 struct neigh_table
**tp
;
1414 /* It is not clean... Fix it to unload IPv6 module safely */
1415 del_timer_sync(&tbl
->gc_timer
);
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 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 int neigh_add(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
1509 struct ndmsg
*ndm
= NLMSG_DATA(nlh
);
1510 struct rtattr
**nda
= arg
;
1511 struct neigh_table
*tbl
;
1512 struct net_device
*dev
= NULL
;
1515 if (ndm
->ndm_ifindex
&&
1516 (dev
= dev_get_by_index(ndm
->ndm_ifindex
)) == NULL
)
1519 read_lock(&neigh_tbl_lock
);
1520 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1521 struct rtattr
*lladdr_attr
= nda
[NDA_LLADDR
- 1];
1522 struct rtattr
*dst_attr
= nda
[NDA_DST
- 1];
1524 struct neighbour
*n
;
1526 if (tbl
->family
!= ndm
->ndm_family
)
1528 read_unlock(&neigh_tbl_lock
);
1531 if (!dst_attr
|| RTA_PAYLOAD(dst_attr
) < tbl
->key_len
)
1534 if (ndm
->ndm_flags
& NTF_PROXY
) {
1536 if (pneigh_lookup(tbl
, RTA_DATA(dst_attr
), dev
, 1))
1544 if (lladdr_attr
&& RTA_PAYLOAD(lladdr_attr
) < dev
->addr_len
)
1547 n
= neigh_lookup(tbl
, RTA_DATA(dst_attr
), dev
);
1549 if (nlh
->nlmsg_flags
& NLM_F_EXCL
) {
1555 override
= nlh
->nlmsg_flags
& NLM_F_REPLACE
;
1556 } else if (!(nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
1560 n
= __neigh_lookup_errno(tbl
, RTA_DATA(dst_attr
), dev
);
1567 err
= neigh_update(n
,
1568 lladdr_attr
? RTA_DATA(lladdr_attr
) : NULL
,
1570 (override
? NEIGH_UPDATE_F_OVERRIDE
: 0) |
1571 NEIGH_UPDATE_F_ADMIN
);
1577 read_unlock(&neigh_tbl_lock
);
1578 err
= -EADDRNOTAVAIL
;
1586 static int neightbl_fill_parms(struct sk_buff
*skb
, struct neigh_parms
*parms
)
1588 struct rtattr
*nest
= NULL
;
1590 nest
= RTA_NEST(skb
, NDTA_PARMS
);
1593 RTA_PUT_U32(skb
, NDTPA_IFINDEX
, parms
->dev
->ifindex
);
1595 RTA_PUT_U32(skb
, NDTPA_REFCNT
, atomic_read(&parms
->refcnt
));
1596 RTA_PUT_U32(skb
, NDTPA_QUEUE_LEN
, parms
->queue_len
);
1597 RTA_PUT_U32(skb
, NDTPA_PROXY_QLEN
, parms
->proxy_qlen
);
1598 RTA_PUT_U32(skb
, NDTPA_APP_PROBES
, parms
->app_probes
);
1599 RTA_PUT_U32(skb
, NDTPA_UCAST_PROBES
, parms
->ucast_probes
);
1600 RTA_PUT_U32(skb
, NDTPA_MCAST_PROBES
, parms
->mcast_probes
);
1601 RTA_PUT_MSECS(skb
, NDTPA_REACHABLE_TIME
, parms
->reachable_time
);
1602 RTA_PUT_MSECS(skb
, NDTPA_BASE_REACHABLE_TIME
,
1603 parms
->base_reachable_time
);
1604 RTA_PUT_MSECS(skb
, NDTPA_GC_STALETIME
, parms
->gc_staletime
);
1605 RTA_PUT_MSECS(skb
, NDTPA_DELAY_PROBE_TIME
, parms
->delay_probe_time
);
1606 RTA_PUT_MSECS(skb
, NDTPA_RETRANS_TIME
, parms
->retrans_time
);
1607 RTA_PUT_MSECS(skb
, NDTPA_ANYCAST_DELAY
, parms
->anycast_delay
);
1608 RTA_PUT_MSECS(skb
, NDTPA_PROXY_DELAY
, parms
->proxy_delay
);
1609 RTA_PUT_MSECS(skb
, NDTPA_LOCKTIME
, parms
->locktime
);
1611 return RTA_NEST_END(skb
, nest
);
1614 return RTA_NEST_CANCEL(skb
, nest
);
1617 static int neightbl_fill_info(struct neigh_table
*tbl
, struct sk_buff
*skb
,
1618 struct netlink_callback
*cb
)
1620 struct nlmsghdr
*nlh
;
1621 struct ndtmsg
*ndtmsg
;
1623 nlh
= NLMSG_NEW_ANSWER(skb
, cb
, RTM_NEWNEIGHTBL
, sizeof(struct ndtmsg
),
1626 ndtmsg
= NLMSG_DATA(nlh
);
1628 read_lock_bh(&tbl
->lock
);
1629 ndtmsg
->ndtm_family
= tbl
->family
;
1630 ndtmsg
->ndtm_pad1
= 0;
1631 ndtmsg
->ndtm_pad2
= 0;
1633 RTA_PUT_STRING(skb
, NDTA_NAME
, tbl
->id
);
1634 RTA_PUT_MSECS(skb
, NDTA_GC_INTERVAL
, tbl
->gc_interval
);
1635 RTA_PUT_U32(skb
, NDTA_THRESH1
, tbl
->gc_thresh1
);
1636 RTA_PUT_U32(skb
, NDTA_THRESH2
, tbl
->gc_thresh2
);
1637 RTA_PUT_U32(skb
, NDTA_THRESH3
, tbl
->gc_thresh3
);
1640 unsigned long now
= jiffies
;
1641 unsigned int flush_delta
= now
- tbl
->last_flush
;
1642 unsigned int rand_delta
= now
- tbl
->last_rand
;
1644 struct ndt_config ndc
= {
1645 .ndtc_key_len
= tbl
->key_len
,
1646 .ndtc_entry_size
= tbl
->entry_size
,
1647 .ndtc_entries
= atomic_read(&tbl
->entries
),
1648 .ndtc_last_flush
= jiffies_to_msecs(flush_delta
),
1649 .ndtc_last_rand
= jiffies_to_msecs(rand_delta
),
1650 .ndtc_hash_rnd
= tbl
->hash_rnd
,
1651 .ndtc_hash_mask
= tbl
->hash_mask
,
1652 .ndtc_hash_chain_gc
= tbl
->hash_chain_gc
,
1653 .ndtc_proxy_qlen
= tbl
->proxy_queue
.qlen
,
1656 RTA_PUT(skb
, NDTA_CONFIG
, sizeof(ndc
), &ndc
);
1661 struct ndt_stats ndst
;
1663 memset(&ndst
, 0, sizeof(ndst
));
1665 for_each_possible_cpu(cpu
) {
1666 struct neigh_statistics
*st
;
1668 st
= per_cpu_ptr(tbl
->stats
, cpu
);
1669 ndst
.ndts_allocs
+= st
->allocs
;
1670 ndst
.ndts_destroys
+= st
->destroys
;
1671 ndst
.ndts_hash_grows
+= st
->hash_grows
;
1672 ndst
.ndts_res_failed
+= st
->res_failed
;
1673 ndst
.ndts_lookups
+= st
->lookups
;
1674 ndst
.ndts_hits
+= st
->hits
;
1675 ndst
.ndts_rcv_probes_mcast
+= st
->rcv_probes_mcast
;
1676 ndst
.ndts_rcv_probes_ucast
+= st
->rcv_probes_ucast
;
1677 ndst
.ndts_periodic_gc_runs
+= st
->periodic_gc_runs
;
1678 ndst
.ndts_forced_gc_runs
+= st
->forced_gc_runs
;
1681 RTA_PUT(skb
, NDTA_STATS
, sizeof(ndst
), &ndst
);
1684 BUG_ON(tbl
->parms
.dev
);
1685 if (neightbl_fill_parms(skb
, &tbl
->parms
) < 0)
1686 goto rtattr_failure
;
1688 read_unlock_bh(&tbl
->lock
);
1689 return NLMSG_END(skb
, nlh
);
1692 read_unlock_bh(&tbl
->lock
);
1693 return NLMSG_CANCEL(skb
, nlh
);
1699 static int neightbl_fill_param_info(struct neigh_table
*tbl
,
1700 struct neigh_parms
*parms
,
1701 struct sk_buff
*skb
,
1702 struct netlink_callback
*cb
)
1704 struct ndtmsg
*ndtmsg
;
1705 struct nlmsghdr
*nlh
;
1707 nlh
= NLMSG_NEW_ANSWER(skb
, cb
, RTM_NEWNEIGHTBL
, sizeof(struct ndtmsg
),
1710 ndtmsg
= NLMSG_DATA(nlh
);
1712 read_lock_bh(&tbl
->lock
);
1713 ndtmsg
->ndtm_family
= tbl
->family
;
1714 ndtmsg
->ndtm_pad1
= 0;
1715 ndtmsg
->ndtm_pad2
= 0;
1716 RTA_PUT_STRING(skb
, NDTA_NAME
, tbl
->id
);
1718 if (neightbl_fill_parms(skb
, parms
) < 0)
1719 goto rtattr_failure
;
1721 read_unlock_bh(&tbl
->lock
);
1722 return NLMSG_END(skb
, nlh
);
1725 read_unlock_bh(&tbl
->lock
);
1726 return NLMSG_CANCEL(skb
, nlh
);
1732 static inline struct neigh_parms
*lookup_neigh_params(struct neigh_table
*tbl
,
1735 struct neigh_parms
*p
;
1737 for (p
= &tbl
->parms
; p
; p
= p
->next
)
1738 if ((p
->dev
&& p
->dev
->ifindex
== ifindex
) ||
1739 (!p
->dev
&& !ifindex
))
1745 int neightbl_set(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
1747 struct neigh_table
*tbl
;
1748 struct ndtmsg
*ndtmsg
= NLMSG_DATA(nlh
);
1749 struct rtattr
**tb
= arg
;
1752 if (!tb
[NDTA_NAME
- 1] || !RTA_PAYLOAD(tb
[NDTA_NAME
- 1]))
1755 read_lock(&neigh_tbl_lock
);
1756 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1757 if (ndtmsg
->ndtm_family
&& tbl
->family
!= ndtmsg
->ndtm_family
)
1760 if (!rtattr_strcmp(tb
[NDTA_NAME
- 1], tbl
->id
))
1770 * We acquire tbl->lock to be nice to the periodic timers and
1771 * make sure they always see a consistent set of values.
1773 write_lock_bh(&tbl
->lock
);
1775 if (tb
[NDTA_THRESH1
- 1])
1776 tbl
->gc_thresh1
= RTA_GET_U32(tb
[NDTA_THRESH1
- 1]);
1778 if (tb
[NDTA_THRESH2
- 1])
1779 tbl
->gc_thresh2
= RTA_GET_U32(tb
[NDTA_THRESH2
- 1]);
1781 if (tb
[NDTA_THRESH3
- 1])
1782 tbl
->gc_thresh3
= RTA_GET_U32(tb
[NDTA_THRESH3
- 1]);
1784 if (tb
[NDTA_GC_INTERVAL
- 1])
1785 tbl
->gc_interval
= RTA_GET_MSECS(tb
[NDTA_GC_INTERVAL
- 1]);
1787 if (tb
[NDTA_PARMS
- 1]) {
1788 struct rtattr
*tbp
[NDTPA_MAX
];
1789 struct neigh_parms
*p
;
1792 if (rtattr_parse_nested(tbp
, NDTPA_MAX
, tb
[NDTA_PARMS
- 1]) < 0)
1793 goto rtattr_failure
;
1795 if (tbp
[NDTPA_IFINDEX
- 1])
1796 ifindex
= RTA_GET_U32(tbp
[NDTPA_IFINDEX
- 1]);
1798 p
= lookup_neigh_params(tbl
, ifindex
);
1801 goto rtattr_failure
;
1804 if (tbp
[NDTPA_QUEUE_LEN
- 1])
1805 p
->queue_len
= RTA_GET_U32(tbp
[NDTPA_QUEUE_LEN
- 1]);
1807 if (tbp
[NDTPA_PROXY_QLEN
- 1])
1808 p
->proxy_qlen
= RTA_GET_U32(tbp
[NDTPA_PROXY_QLEN
- 1]);
1810 if (tbp
[NDTPA_APP_PROBES
- 1])
1811 p
->app_probes
= RTA_GET_U32(tbp
[NDTPA_APP_PROBES
- 1]);
1813 if (tbp
[NDTPA_UCAST_PROBES
- 1])
1815 RTA_GET_U32(tbp
[NDTPA_UCAST_PROBES
- 1]);
1817 if (tbp
[NDTPA_MCAST_PROBES
- 1])
1819 RTA_GET_U32(tbp
[NDTPA_MCAST_PROBES
- 1]);
1821 if (tbp
[NDTPA_BASE_REACHABLE_TIME
- 1])
1822 p
->base_reachable_time
=
1823 RTA_GET_MSECS(tbp
[NDTPA_BASE_REACHABLE_TIME
- 1]);
1825 if (tbp
[NDTPA_GC_STALETIME
- 1])
1827 RTA_GET_MSECS(tbp
[NDTPA_GC_STALETIME
- 1]);
1829 if (tbp
[NDTPA_DELAY_PROBE_TIME
- 1])
1830 p
->delay_probe_time
=
1831 RTA_GET_MSECS(tbp
[NDTPA_DELAY_PROBE_TIME
- 1]);
1833 if (tbp
[NDTPA_RETRANS_TIME
- 1])
1835 RTA_GET_MSECS(tbp
[NDTPA_RETRANS_TIME
- 1]);
1837 if (tbp
[NDTPA_ANYCAST_DELAY
- 1])
1839 RTA_GET_MSECS(tbp
[NDTPA_ANYCAST_DELAY
- 1]);
1841 if (tbp
[NDTPA_PROXY_DELAY
- 1])
1843 RTA_GET_MSECS(tbp
[NDTPA_PROXY_DELAY
- 1]);
1845 if (tbp
[NDTPA_LOCKTIME
- 1])
1846 p
->locktime
= RTA_GET_MSECS(tbp
[NDTPA_LOCKTIME
- 1]);
1852 write_unlock_bh(&tbl
->lock
);
1854 read_unlock(&neigh_tbl_lock
);
1858 int neightbl_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1861 int s_idx
= cb
->args
[0];
1862 struct neigh_table
*tbl
;
1864 family
= ((struct rtgenmsg
*)NLMSG_DATA(cb
->nlh
))->rtgen_family
;
1866 read_lock(&neigh_tbl_lock
);
1867 for (tbl
= neigh_tables
, idx
= 0; tbl
; tbl
= tbl
->next
) {
1868 struct neigh_parms
*p
;
1870 if (idx
< s_idx
|| (family
&& tbl
->family
!= family
))
1873 if (neightbl_fill_info(tbl
, skb
, cb
) <= 0)
1876 for (++idx
, p
= tbl
->parms
.next
; p
; p
= p
->next
, idx
++) {
1880 if (neightbl_fill_param_info(tbl
, p
, skb
, cb
) <= 0)
1886 read_unlock(&neigh_tbl_lock
);
1892 static int neigh_fill_info(struct sk_buff
*skb
, struct neighbour
*n
,
1893 u32 pid
, u32 seq
, int event
, unsigned int flags
)
1895 unsigned long now
= jiffies
;
1896 unsigned char *b
= skb
->tail
;
1897 struct nda_cacheinfo ci
;
1900 struct nlmsghdr
*nlh
= NLMSG_NEW(skb
, pid
, seq
, event
,
1901 sizeof(struct ndmsg
), flags
);
1902 struct ndmsg
*ndm
= NLMSG_DATA(nlh
);
1904 ndm
->ndm_family
= n
->ops
->family
;
1907 ndm
->ndm_flags
= n
->flags
;
1908 ndm
->ndm_type
= n
->type
;
1909 ndm
->ndm_ifindex
= n
->dev
->ifindex
;
1910 RTA_PUT(skb
, NDA_DST
, n
->tbl
->key_len
, n
->primary_key
);
1911 read_lock_bh(&n
->lock
);
1913 ndm
->ndm_state
= n
->nud_state
;
1914 if (n
->nud_state
& NUD_VALID
)
1915 RTA_PUT(skb
, NDA_LLADDR
, n
->dev
->addr_len
, n
->ha
);
1916 ci
.ndm_used
= now
- n
->used
;
1917 ci
.ndm_confirmed
= now
- n
->confirmed
;
1918 ci
.ndm_updated
= now
- n
->updated
;
1919 ci
.ndm_refcnt
= atomic_read(&n
->refcnt
) - 1;
1920 probes
= atomic_read(&n
->probes
);
1921 read_unlock_bh(&n
->lock
);
1923 RTA_PUT(skb
, NDA_CACHEINFO
, sizeof(ci
), &ci
);
1924 RTA_PUT(skb
, NDA_PROBES
, sizeof(probes
), &probes
);
1925 nlh
->nlmsg_len
= skb
->tail
- b
;
1931 read_unlock_bh(&n
->lock
);
1932 skb_trim(skb
, b
- skb
->data
);
1937 static int neigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
1938 struct netlink_callback
*cb
)
1940 struct neighbour
*n
;
1941 int rc
, h
, s_h
= cb
->args
[1];
1942 int idx
, s_idx
= idx
= cb
->args
[2];
1944 for (h
= 0; h
<= tbl
->hash_mask
; h
++) {
1949 read_lock_bh(&tbl
->lock
);
1950 for (n
= tbl
->hash_buckets
[h
], idx
= 0; n
; n
= n
->next
, idx
++) {
1953 if (neigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).pid
,
1956 NLM_F_MULTI
) <= 0) {
1957 read_unlock_bh(&tbl
->lock
);
1962 read_unlock_bh(&tbl
->lock
);
1971 int neigh_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1973 struct neigh_table
*tbl
;
1976 read_lock(&neigh_tbl_lock
);
1977 family
= ((struct rtgenmsg
*)NLMSG_DATA(cb
->nlh
))->rtgen_family
;
1980 for (tbl
= neigh_tables
, t
= 0; tbl
; tbl
= tbl
->next
, t
++) {
1981 if (t
< s_t
|| (family
&& tbl
->family
!= family
))
1984 memset(&cb
->args
[1], 0, sizeof(cb
->args
) -
1985 sizeof(cb
->args
[0]));
1986 if (neigh_dump_table(tbl
, skb
, cb
) < 0)
1989 read_unlock(&neigh_tbl_lock
);
1995 void neigh_for_each(struct neigh_table
*tbl
, void (*cb
)(struct neighbour
*, void *), void *cookie
)
1999 read_lock_bh(&tbl
->lock
);
2000 for (chain
= 0; chain
<= tbl
->hash_mask
; chain
++) {
2001 struct neighbour
*n
;
2003 for (n
= tbl
->hash_buckets
[chain
]; n
; n
= n
->next
)
2006 read_unlock_bh(&tbl
->lock
);
2008 EXPORT_SYMBOL(neigh_for_each
);
2010 /* The tbl->lock must be held as a writer and BH disabled. */
2011 void __neigh_for_each_release(struct neigh_table
*tbl
,
2012 int (*cb
)(struct neighbour
*))
2016 for (chain
= 0; chain
<= tbl
->hash_mask
; chain
++) {
2017 struct neighbour
*n
, **np
;
2019 np
= &tbl
->hash_buckets
[chain
];
2020 while ((n
= *np
) != NULL
) {
2023 write_lock(&n
->lock
);
2030 write_unlock(&n
->lock
);
2036 EXPORT_SYMBOL(__neigh_for_each_release
);
2038 #ifdef CONFIG_PROC_FS
2040 static struct neighbour
*neigh_get_first(struct seq_file
*seq
)
2042 struct neigh_seq_state
*state
= seq
->private;
2043 struct neigh_table
*tbl
= state
->tbl
;
2044 struct neighbour
*n
= NULL
;
2045 int bucket
= state
->bucket
;
2047 state
->flags
&= ~NEIGH_SEQ_IS_PNEIGH
;
2048 for (bucket
= 0; bucket
<= tbl
->hash_mask
; bucket
++) {
2049 n
= tbl
->hash_buckets
[bucket
];
2052 if (state
->neigh_sub_iter
) {
2056 v
= state
->neigh_sub_iter(state
, n
, &fakep
);
2060 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2062 if (n
->nud_state
& ~NUD_NOARP
)
2071 state
->bucket
= bucket
;
2076 static struct neighbour
*neigh_get_next(struct seq_file
*seq
,
2077 struct neighbour
*n
,
2080 struct neigh_seq_state
*state
= seq
->private;
2081 struct neigh_table
*tbl
= state
->tbl
;
2083 if (state
->neigh_sub_iter
) {
2084 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2092 if (state
->neigh_sub_iter
) {
2093 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2098 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2101 if (n
->nud_state
& ~NUD_NOARP
)
2110 if (++state
->bucket
> tbl
->hash_mask
)
2113 n
= tbl
->hash_buckets
[state
->bucket
];
2121 static struct neighbour
*neigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2123 struct neighbour
*n
= neigh_get_first(seq
);
2127 n
= neigh_get_next(seq
, n
, pos
);
2132 return *pos
? NULL
: n
;
2135 static struct pneigh_entry
*pneigh_get_first(struct seq_file
*seq
)
2137 struct neigh_seq_state
*state
= seq
->private;
2138 struct neigh_table
*tbl
= state
->tbl
;
2139 struct pneigh_entry
*pn
= NULL
;
2140 int bucket
= state
->bucket
;
2142 state
->flags
|= NEIGH_SEQ_IS_PNEIGH
;
2143 for (bucket
= 0; bucket
<= PNEIGH_HASHMASK
; bucket
++) {
2144 pn
= tbl
->phash_buckets
[bucket
];
2148 state
->bucket
= bucket
;
2153 static struct pneigh_entry
*pneigh_get_next(struct seq_file
*seq
,
2154 struct pneigh_entry
*pn
,
2157 struct neigh_seq_state
*state
= seq
->private;
2158 struct neigh_table
*tbl
= state
->tbl
;
2162 if (++state
->bucket
> PNEIGH_HASHMASK
)
2164 pn
= tbl
->phash_buckets
[state
->bucket
];
2175 static struct pneigh_entry
*pneigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2177 struct pneigh_entry
*pn
= pneigh_get_first(seq
);
2181 pn
= pneigh_get_next(seq
, pn
, pos
);
2186 return *pos
? NULL
: pn
;
2189 static void *neigh_get_idx_any(struct seq_file
*seq
, loff_t
*pos
)
2191 struct neigh_seq_state
*state
= seq
->private;
2194 rc
= neigh_get_idx(seq
, pos
);
2195 if (!rc
&& !(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2196 rc
= pneigh_get_idx(seq
, pos
);
2201 void *neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
, struct neigh_table
*tbl
, unsigned int neigh_seq_flags
)
2203 struct neigh_seq_state
*state
= seq
->private;
2204 loff_t pos_minus_one
;
2208 state
->flags
= (neigh_seq_flags
& ~NEIGH_SEQ_IS_PNEIGH
);
2210 read_lock_bh(&tbl
->lock
);
2212 pos_minus_one
= *pos
- 1;
2213 return *pos
? neigh_get_idx_any(seq
, &pos_minus_one
) : SEQ_START_TOKEN
;
2215 EXPORT_SYMBOL(neigh_seq_start
);
2217 void *neigh_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2219 struct neigh_seq_state
*state
;
2222 if (v
== SEQ_START_TOKEN
) {
2223 rc
= neigh_get_idx(seq
, pos
);
2227 state
= seq
->private;
2228 if (!(state
->flags
& NEIGH_SEQ_IS_PNEIGH
)) {
2229 rc
= neigh_get_next(seq
, v
, NULL
);
2232 if (!(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2233 rc
= pneigh_get_first(seq
);
2235 BUG_ON(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
);
2236 rc
= pneigh_get_next(seq
, v
, NULL
);
2242 EXPORT_SYMBOL(neigh_seq_next
);
2244 void neigh_seq_stop(struct seq_file
*seq
, void *v
)
2246 struct neigh_seq_state
*state
= seq
->private;
2247 struct neigh_table
*tbl
= state
->tbl
;
2249 read_unlock_bh(&tbl
->lock
);
2251 EXPORT_SYMBOL(neigh_seq_stop
);
2253 /* statistics via seq_file */
2255 static void *neigh_stat_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2257 struct proc_dir_entry
*pde
= seq
->private;
2258 struct neigh_table
*tbl
= pde
->data
;
2262 return SEQ_START_TOKEN
;
2264 for (cpu
= *pos
-1; cpu
< NR_CPUS
; ++cpu
) {
2265 if (!cpu_possible(cpu
))
2268 return per_cpu_ptr(tbl
->stats
, cpu
);
2273 static void *neigh_stat_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2275 struct proc_dir_entry
*pde
= seq
->private;
2276 struct neigh_table
*tbl
= pde
->data
;
2279 for (cpu
= *pos
; cpu
< NR_CPUS
; ++cpu
) {
2280 if (!cpu_possible(cpu
))
2283 return per_cpu_ptr(tbl
->stats
, cpu
);
2288 static void neigh_stat_seq_stop(struct seq_file
*seq
, void *v
)
2293 static int neigh_stat_seq_show(struct seq_file
*seq
, void *v
)
2295 struct proc_dir_entry
*pde
= seq
->private;
2296 struct neigh_table
*tbl
= pde
->data
;
2297 struct neigh_statistics
*st
= v
;
2299 if (v
== SEQ_START_TOKEN
) {
2300 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");
2304 seq_printf(seq
, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2305 "%08lx %08lx %08lx %08lx\n",
2306 atomic_read(&tbl
->entries
),
2317 st
->rcv_probes_mcast
,
2318 st
->rcv_probes_ucast
,
2320 st
->periodic_gc_runs
,
2327 static struct seq_operations neigh_stat_seq_ops
= {
2328 .start
= neigh_stat_seq_start
,
2329 .next
= neigh_stat_seq_next
,
2330 .stop
= neigh_stat_seq_stop
,
2331 .show
= neigh_stat_seq_show
,
2334 static int neigh_stat_seq_open(struct inode
*inode
, struct file
*file
)
2336 int ret
= seq_open(file
, &neigh_stat_seq_ops
);
2339 struct seq_file
*sf
= file
->private_data
;
2340 sf
->private = PDE(inode
);
2345 static struct file_operations neigh_stat_seq_fops
= {
2346 .owner
= THIS_MODULE
,
2347 .open
= neigh_stat_seq_open
,
2349 .llseek
= seq_lseek
,
2350 .release
= seq_release
,
2353 #endif /* CONFIG_PROC_FS */
2356 void neigh_app_ns(struct neighbour
*n
)
2358 struct nlmsghdr
*nlh
;
2359 int size
= NLMSG_SPACE(sizeof(struct ndmsg
) + 256);
2360 struct sk_buff
*skb
= alloc_skb(size
, GFP_ATOMIC
);
2365 if (neigh_fill_info(skb
, n
, 0, 0, RTM_GETNEIGH
, 0) < 0) {
2369 nlh
= (struct nlmsghdr
*)skb
->data
;
2370 nlh
->nlmsg_flags
= NLM_F_REQUEST
;
2371 NETLINK_CB(skb
).dst_group
= RTNLGRP_NEIGH
;
2372 netlink_broadcast(rtnl
, skb
, 0, RTNLGRP_NEIGH
, GFP_ATOMIC
);
2375 static void neigh_app_notify(struct neighbour
*n
)
2377 struct nlmsghdr
*nlh
;
2378 int size
= NLMSG_SPACE(sizeof(struct ndmsg
) + 256);
2379 struct sk_buff
*skb
= alloc_skb(size
, GFP_ATOMIC
);
2384 if (neigh_fill_info(skb
, n
, 0, 0, RTM_NEWNEIGH
, 0) < 0) {
2388 nlh
= (struct nlmsghdr
*)skb
->data
;
2389 NETLINK_CB(skb
).dst_group
= RTNLGRP_NEIGH
;
2390 netlink_broadcast(rtnl
, skb
, 0, RTNLGRP_NEIGH
, GFP_ATOMIC
);
2393 #endif /* CONFIG_ARPD */
2395 #ifdef CONFIG_SYSCTL
2397 static struct neigh_sysctl_table
{
2398 struct ctl_table_header
*sysctl_header
;
2399 ctl_table neigh_vars
[__NET_NEIGH_MAX
];
2400 ctl_table neigh_dev
[2];
2401 ctl_table neigh_neigh_dir
[2];
2402 ctl_table neigh_proto_dir
[2];
2403 ctl_table neigh_root_dir
[2];
2404 } neigh_sysctl_template
= {
2407 .ctl_name
= NET_NEIGH_MCAST_SOLICIT
,
2408 .procname
= "mcast_solicit",
2409 .maxlen
= sizeof(int),
2411 .proc_handler
= &proc_dointvec
,
2414 .ctl_name
= NET_NEIGH_UCAST_SOLICIT
,
2415 .procname
= "ucast_solicit",
2416 .maxlen
= sizeof(int),
2418 .proc_handler
= &proc_dointvec
,
2421 .ctl_name
= NET_NEIGH_APP_SOLICIT
,
2422 .procname
= "app_solicit",
2423 .maxlen
= sizeof(int),
2425 .proc_handler
= &proc_dointvec
,
2428 .ctl_name
= NET_NEIGH_RETRANS_TIME
,
2429 .procname
= "retrans_time",
2430 .maxlen
= sizeof(int),
2432 .proc_handler
= &proc_dointvec_userhz_jiffies
,
2435 .ctl_name
= NET_NEIGH_REACHABLE_TIME
,
2436 .procname
= "base_reachable_time",
2437 .maxlen
= sizeof(int),
2439 .proc_handler
= &proc_dointvec_jiffies
,
2440 .strategy
= &sysctl_jiffies
,
2443 .ctl_name
= NET_NEIGH_DELAY_PROBE_TIME
,
2444 .procname
= "delay_first_probe_time",
2445 .maxlen
= sizeof(int),
2447 .proc_handler
= &proc_dointvec_jiffies
,
2448 .strategy
= &sysctl_jiffies
,
2451 .ctl_name
= NET_NEIGH_GC_STALE_TIME
,
2452 .procname
= "gc_stale_time",
2453 .maxlen
= sizeof(int),
2455 .proc_handler
= &proc_dointvec_jiffies
,
2456 .strategy
= &sysctl_jiffies
,
2459 .ctl_name
= NET_NEIGH_UNRES_QLEN
,
2460 .procname
= "unres_qlen",
2461 .maxlen
= sizeof(int),
2463 .proc_handler
= &proc_dointvec
,
2466 .ctl_name
= NET_NEIGH_PROXY_QLEN
,
2467 .procname
= "proxy_qlen",
2468 .maxlen
= sizeof(int),
2470 .proc_handler
= &proc_dointvec
,
2473 .ctl_name
= NET_NEIGH_ANYCAST_DELAY
,
2474 .procname
= "anycast_delay",
2475 .maxlen
= sizeof(int),
2477 .proc_handler
= &proc_dointvec_userhz_jiffies
,
2480 .ctl_name
= NET_NEIGH_PROXY_DELAY
,
2481 .procname
= "proxy_delay",
2482 .maxlen
= sizeof(int),
2484 .proc_handler
= &proc_dointvec_userhz_jiffies
,
2487 .ctl_name
= NET_NEIGH_LOCKTIME
,
2488 .procname
= "locktime",
2489 .maxlen
= sizeof(int),
2491 .proc_handler
= &proc_dointvec_userhz_jiffies
,
2494 .ctl_name
= NET_NEIGH_GC_INTERVAL
,
2495 .procname
= "gc_interval",
2496 .maxlen
= sizeof(int),
2498 .proc_handler
= &proc_dointvec_jiffies
,
2499 .strategy
= &sysctl_jiffies
,
2502 .ctl_name
= NET_NEIGH_GC_THRESH1
,
2503 .procname
= "gc_thresh1",
2504 .maxlen
= sizeof(int),
2506 .proc_handler
= &proc_dointvec
,
2509 .ctl_name
= NET_NEIGH_GC_THRESH2
,
2510 .procname
= "gc_thresh2",
2511 .maxlen
= sizeof(int),
2513 .proc_handler
= &proc_dointvec
,
2516 .ctl_name
= NET_NEIGH_GC_THRESH3
,
2517 .procname
= "gc_thresh3",
2518 .maxlen
= sizeof(int),
2520 .proc_handler
= &proc_dointvec
,
2523 .ctl_name
= NET_NEIGH_RETRANS_TIME_MS
,
2524 .procname
= "retrans_time_ms",
2525 .maxlen
= sizeof(int),
2527 .proc_handler
= &proc_dointvec_ms_jiffies
,
2528 .strategy
= &sysctl_ms_jiffies
,
2531 .ctl_name
= NET_NEIGH_REACHABLE_TIME_MS
,
2532 .procname
= "base_reachable_time_ms",
2533 .maxlen
= sizeof(int),
2535 .proc_handler
= &proc_dointvec_ms_jiffies
,
2536 .strategy
= &sysctl_ms_jiffies
,
2541 .ctl_name
= NET_PROTO_CONF_DEFAULT
,
2542 .procname
= "default",
2546 .neigh_neigh_dir
= {
2548 .procname
= "neigh",
2552 .neigh_proto_dir
= {
2559 .ctl_name
= CTL_NET
,
2566 int neigh_sysctl_register(struct net_device
*dev
, struct neigh_parms
*p
,
2567 int p_id
, int pdev_id
, char *p_name
,
2568 proc_handler
*handler
, ctl_handler
*strategy
)
2570 struct neigh_sysctl_table
*t
= kmalloc(sizeof(*t
), GFP_KERNEL
);
2571 const char *dev_name_source
= NULL
;
2572 char *dev_name
= NULL
;
2577 memcpy(t
, &neigh_sysctl_template
, sizeof(*t
));
2578 t
->neigh_vars
[0].data
= &p
->mcast_probes
;
2579 t
->neigh_vars
[1].data
= &p
->ucast_probes
;
2580 t
->neigh_vars
[2].data
= &p
->app_probes
;
2581 t
->neigh_vars
[3].data
= &p
->retrans_time
;
2582 t
->neigh_vars
[4].data
= &p
->base_reachable_time
;
2583 t
->neigh_vars
[5].data
= &p
->delay_probe_time
;
2584 t
->neigh_vars
[6].data
= &p
->gc_staletime
;
2585 t
->neigh_vars
[7].data
= &p
->queue_len
;
2586 t
->neigh_vars
[8].data
= &p
->proxy_qlen
;
2587 t
->neigh_vars
[9].data
= &p
->anycast_delay
;
2588 t
->neigh_vars
[10].data
= &p
->proxy_delay
;
2589 t
->neigh_vars
[11].data
= &p
->locktime
;
2592 dev_name_source
= dev
->name
;
2593 t
->neigh_dev
[0].ctl_name
= dev
->ifindex
;
2594 t
->neigh_vars
[12].procname
= NULL
;
2595 t
->neigh_vars
[13].procname
= NULL
;
2596 t
->neigh_vars
[14].procname
= NULL
;
2597 t
->neigh_vars
[15].procname
= NULL
;
2599 dev_name_source
= t
->neigh_dev
[0].procname
;
2600 t
->neigh_vars
[12].data
= (int *)(p
+ 1);
2601 t
->neigh_vars
[13].data
= (int *)(p
+ 1) + 1;
2602 t
->neigh_vars
[14].data
= (int *)(p
+ 1) + 2;
2603 t
->neigh_vars
[15].data
= (int *)(p
+ 1) + 3;
2606 t
->neigh_vars
[16].data
= &p
->retrans_time
;
2607 t
->neigh_vars
[17].data
= &p
->base_reachable_time
;
2609 if (handler
|| strategy
) {
2611 t
->neigh_vars
[3].proc_handler
= handler
;
2612 t
->neigh_vars
[3].strategy
= strategy
;
2613 t
->neigh_vars
[3].extra1
= dev
;
2615 t
->neigh_vars
[4].proc_handler
= handler
;
2616 t
->neigh_vars
[4].strategy
= strategy
;
2617 t
->neigh_vars
[4].extra1
= dev
;
2618 /* RetransTime (in milliseconds)*/
2619 t
->neigh_vars
[16].proc_handler
= handler
;
2620 t
->neigh_vars
[16].strategy
= strategy
;
2621 t
->neigh_vars
[16].extra1
= dev
;
2622 /* ReachableTime (in milliseconds) */
2623 t
->neigh_vars
[17].proc_handler
= handler
;
2624 t
->neigh_vars
[17].strategy
= strategy
;
2625 t
->neigh_vars
[17].extra1
= dev
;
2628 dev_name
= kstrdup(dev_name_source
, GFP_KERNEL
);
2634 t
->neigh_dev
[0].procname
= dev_name
;
2636 t
->neigh_neigh_dir
[0].ctl_name
= pdev_id
;
2638 t
->neigh_proto_dir
[0].procname
= p_name
;
2639 t
->neigh_proto_dir
[0].ctl_name
= p_id
;
2641 t
->neigh_dev
[0].child
= t
->neigh_vars
;
2642 t
->neigh_neigh_dir
[0].child
= t
->neigh_dev
;
2643 t
->neigh_proto_dir
[0].child
= t
->neigh_neigh_dir
;
2644 t
->neigh_root_dir
[0].child
= t
->neigh_proto_dir
;
2646 t
->sysctl_header
= register_sysctl_table(t
->neigh_root_dir
, 0);
2647 if (!t
->sysctl_header
) {
2651 p
->sysctl_table
= t
;
2663 void neigh_sysctl_unregister(struct neigh_parms
*p
)
2665 if (p
->sysctl_table
) {
2666 struct neigh_sysctl_table
*t
= p
->sysctl_table
;
2667 p
->sysctl_table
= NULL
;
2668 unregister_sysctl_table(t
->sysctl_header
);
2669 kfree(t
->neigh_dev
[0].procname
);
2674 #endif /* CONFIG_SYSCTL */
2676 EXPORT_SYMBOL(__neigh_event_send
);
2677 EXPORT_SYMBOL(neigh_add
);
2678 EXPORT_SYMBOL(neigh_changeaddr
);
2679 EXPORT_SYMBOL(neigh_compat_output
);
2680 EXPORT_SYMBOL(neigh_connected_output
);
2681 EXPORT_SYMBOL(neigh_create
);
2682 EXPORT_SYMBOL(neigh_delete
);
2683 EXPORT_SYMBOL(neigh_destroy
);
2684 EXPORT_SYMBOL(neigh_dump_info
);
2685 EXPORT_SYMBOL(neigh_event_ns
);
2686 EXPORT_SYMBOL(neigh_ifdown
);
2687 EXPORT_SYMBOL(neigh_lookup
);
2688 EXPORT_SYMBOL(neigh_lookup_nodev
);
2689 EXPORT_SYMBOL(neigh_parms_alloc
);
2690 EXPORT_SYMBOL(neigh_parms_release
);
2691 EXPORT_SYMBOL(neigh_rand_reach_time
);
2692 EXPORT_SYMBOL(neigh_resolve_output
);
2693 EXPORT_SYMBOL(neigh_table_clear
);
2694 EXPORT_SYMBOL(neigh_table_init
);
2695 EXPORT_SYMBOL(neigh_table_init_no_netlink
);
2696 EXPORT_SYMBOL(neigh_update
);
2697 EXPORT_SYMBOL(neigh_update_hhs
);
2698 EXPORT_SYMBOL(pneigh_enqueue
);
2699 EXPORT_SYMBOL(pneigh_lookup
);
2700 EXPORT_SYMBOL(neightbl_dump_info
);
2701 EXPORT_SYMBOL(neightbl_set
);
2704 EXPORT_SYMBOL(neigh_app_ns
);
2706 #ifdef CONFIG_SYSCTL
2707 EXPORT_SYMBOL(neigh_sysctl_register
);
2708 EXPORT_SYMBOL(neigh_sysctl_unregister
);