2 * Generic address resolution entity
5 * Pedro Roque <roque@di.fc.ul.pt>
6 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
14 * Vitaly E. Lavrov releasing NULL neighbor in neigh_add.
15 * Harald Welte Add neighbour cache statistics like rtstat
18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <linux/slab.h>
21 #include <linux/types.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/socket.h>
25 #include <linux/netdevice.h>
26 #include <linux/proc_fs.h>
28 #include <linux/sysctl.h>
30 #include <linux/times.h>
31 #include <net/net_namespace.h>
32 #include <net/neighbour.h>
35 #include <net/netevent.h>
36 #include <net/netlink.h>
37 #include <linux/rtnetlink.h>
38 #include <linux/random.h>
39 #include <linux/string.h>
40 #include <linux/log2.h>
44 #define neigh_dbg(level, fmt, ...) \
46 if (level <= NEIGH_DEBUG) \
47 pr_debug(fmt, ##__VA_ARGS__); \
50 #define PNEIGH_HASHMASK 0xF
52 static void neigh_timer_handler(unsigned long arg
);
53 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
);
54 static void neigh_update_notify(struct neighbour
*neigh
);
55 static int pneigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
);
57 static struct neigh_table
*neigh_tables
;
59 static const struct file_operations neigh_stat_seq_fops
;
63 Neighbour hash table buckets are protected with rwlock tbl->lock.
65 - All the scans/updates to hash buckets MUST be made under this lock.
66 - NOTHING clever should be made under this lock: no callbacks
67 to protocol backends, no attempts to send something to network.
68 It will result in deadlocks, if backend/driver wants to use neighbour
70 - If the entry requires some non-trivial actions, increase
71 its reference count and release table lock.
73 Neighbour entries are protected:
74 - with reference count.
75 - with rwlock neigh->lock
77 Reference count prevents destruction.
79 neigh->lock mainly serializes ll address data and its validity state.
80 However, the same lock is used to protect another entry fields:
84 Again, nothing clever shall be made under neigh->lock,
85 the most complicated procedure, which we allow is dev->hard_header.
86 It is supposed, that dev->hard_header is simplistic and does
87 not make callbacks to neighbour tables.
89 The last lock is neigh_tbl_lock. It is pure SMP lock, protecting
90 list of neighbour tables. This list is used only in process context,
93 static DEFINE_RWLOCK(neigh_tbl_lock
);
95 static int neigh_blackhole(struct neighbour
*neigh
, struct sk_buff
*skb
)
101 static void neigh_cleanup_and_release(struct neighbour
*neigh
)
103 if (neigh
->parms
->neigh_cleanup
)
104 neigh
->parms
->neigh_cleanup(neigh
);
106 __neigh_notify(neigh
, RTM_DELNEIGH
, 0);
107 neigh_release(neigh
);
111 * It is random distribution in the interval (1/2)*base...(3/2)*base.
112 * It corresponds to default IPv6 settings and is not overridable,
113 * because it is really reasonable choice.
116 unsigned long neigh_rand_reach_time(unsigned long base
)
118 return base
? (net_random() % base
) + (base
>> 1) : 0;
120 EXPORT_SYMBOL(neigh_rand_reach_time
);
123 static int neigh_forced_gc(struct neigh_table
*tbl
)
127 struct neigh_hash_table
*nht
;
129 NEIGH_CACHE_STAT_INC(tbl
, forced_gc_runs
);
131 write_lock_bh(&tbl
->lock
);
132 nht
= rcu_dereference_protected(tbl
->nht
,
133 lockdep_is_held(&tbl
->lock
));
134 for (i
= 0; i
< (1 << nht
->hash_shift
); i
++) {
136 struct neighbour __rcu
**np
;
138 np
= &nht
->hash_buckets
[i
];
139 while ((n
= rcu_dereference_protected(*np
,
140 lockdep_is_held(&tbl
->lock
))) != NULL
) {
141 /* Neighbour record may be discarded if:
142 * - nobody refers to it.
143 * - it is not permanent
145 write_lock(&n
->lock
);
146 if (atomic_read(&n
->refcnt
) == 1 &&
147 !(n
->nud_state
& NUD_PERMANENT
)) {
148 rcu_assign_pointer(*np
,
149 rcu_dereference_protected(n
->next
,
150 lockdep_is_held(&tbl
->lock
)));
153 write_unlock(&n
->lock
);
154 neigh_cleanup_and_release(n
);
157 write_unlock(&n
->lock
);
162 tbl
->last_flush
= jiffies
;
164 write_unlock_bh(&tbl
->lock
);
169 static void neigh_add_timer(struct neighbour
*n
, unsigned long when
)
172 if (unlikely(mod_timer(&n
->timer
, when
))) {
173 printk("NEIGH: BUG, double timer add, state is %x\n",
179 static int neigh_del_timer(struct neighbour
*n
)
181 if ((n
->nud_state
& NUD_IN_TIMER
) &&
182 del_timer(&n
->timer
)) {
189 static void pneigh_queue_purge(struct sk_buff_head
*list
)
193 while ((skb
= skb_dequeue(list
)) != NULL
) {
199 static void neigh_flush_dev(struct neigh_table
*tbl
, struct net_device
*dev
)
202 struct neigh_hash_table
*nht
;
204 nht
= rcu_dereference_protected(tbl
->nht
,
205 lockdep_is_held(&tbl
->lock
));
207 for (i
= 0; i
< (1 << nht
->hash_shift
); i
++) {
209 struct neighbour __rcu
**np
= &nht
->hash_buckets
[i
];
211 while ((n
= rcu_dereference_protected(*np
,
212 lockdep_is_held(&tbl
->lock
))) != NULL
) {
213 if (dev
&& n
->dev
!= dev
) {
217 rcu_assign_pointer(*np
,
218 rcu_dereference_protected(n
->next
,
219 lockdep_is_held(&tbl
->lock
)));
220 write_lock(&n
->lock
);
224 if (atomic_read(&n
->refcnt
) != 1) {
225 /* The most unpleasant situation.
226 We must destroy neighbour entry,
227 but someone still uses it.
229 The destroy will be delayed until
230 the last user releases us, but
231 we must kill timers etc. and move
234 __skb_queue_purge(&n
->arp_queue
);
235 n
->arp_queue_len_bytes
= 0;
236 n
->output
= neigh_blackhole
;
237 if (n
->nud_state
& NUD_VALID
)
238 n
->nud_state
= NUD_NOARP
;
240 n
->nud_state
= NUD_NONE
;
241 neigh_dbg(2, "neigh %p is stray\n", n
);
243 write_unlock(&n
->lock
);
244 neigh_cleanup_and_release(n
);
249 void neigh_changeaddr(struct neigh_table
*tbl
, struct net_device
*dev
)
251 write_lock_bh(&tbl
->lock
);
252 neigh_flush_dev(tbl
, dev
);
253 write_unlock_bh(&tbl
->lock
);
255 EXPORT_SYMBOL(neigh_changeaddr
);
257 int neigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
)
259 write_lock_bh(&tbl
->lock
);
260 neigh_flush_dev(tbl
, dev
);
261 pneigh_ifdown(tbl
, dev
);
262 write_unlock_bh(&tbl
->lock
);
264 del_timer_sync(&tbl
->proxy_timer
);
265 pneigh_queue_purge(&tbl
->proxy_queue
);
268 EXPORT_SYMBOL(neigh_ifdown
);
270 static struct neighbour
*neigh_alloc(struct neigh_table
*tbl
, struct net_device
*dev
)
272 struct neighbour
*n
= NULL
;
273 unsigned long now
= jiffies
;
276 entries
= atomic_inc_return(&tbl
->entries
) - 1;
277 if (entries
>= tbl
->gc_thresh3
||
278 (entries
>= tbl
->gc_thresh2
&&
279 time_after(now
, tbl
->last_flush
+ 5 * HZ
))) {
280 if (!neigh_forced_gc(tbl
) &&
281 entries
>= tbl
->gc_thresh3
)
285 n
= kzalloc(tbl
->entry_size
+ dev
->neigh_priv_len
, GFP_ATOMIC
);
289 __skb_queue_head_init(&n
->arp_queue
);
290 rwlock_init(&n
->lock
);
291 seqlock_init(&n
->ha_lock
);
292 n
->updated
= n
->used
= now
;
293 n
->nud_state
= NUD_NONE
;
294 n
->output
= neigh_blackhole
;
295 seqlock_init(&n
->hh
.hh_lock
);
296 n
->parms
= neigh_parms_clone(&tbl
->parms
);
297 setup_timer(&n
->timer
, neigh_timer_handler
, (unsigned long)n
);
299 NEIGH_CACHE_STAT_INC(tbl
, allocs
);
301 atomic_set(&n
->refcnt
, 1);
307 atomic_dec(&tbl
->entries
);
311 static void neigh_get_hash_rnd(u32
*x
)
313 get_random_bytes(x
, sizeof(*x
));
317 static struct neigh_hash_table
*neigh_hash_alloc(unsigned int shift
)
319 size_t size
= (1 << shift
) * sizeof(struct neighbour
*);
320 struct neigh_hash_table
*ret
;
321 struct neighbour __rcu
**buckets
;
324 ret
= kmalloc(sizeof(*ret
), GFP_ATOMIC
);
327 if (size
<= PAGE_SIZE
)
328 buckets
= kzalloc(size
, GFP_ATOMIC
);
330 buckets
= (struct neighbour __rcu
**)
331 __get_free_pages(GFP_ATOMIC
| __GFP_ZERO
,
337 ret
->hash_buckets
= buckets
;
338 ret
->hash_shift
= shift
;
339 for (i
= 0; i
< NEIGH_NUM_HASH_RND
; i
++)
340 neigh_get_hash_rnd(&ret
->hash_rnd
[i
]);
344 static void neigh_hash_free_rcu(struct rcu_head
*head
)
346 struct neigh_hash_table
*nht
= container_of(head
,
347 struct neigh_hash_table
,
349 size_t size
= (1 << nht
->hash_shift
) * sizeof(struct neighbour
*);
350 struct neighbour __rcu
**buckets
= nht
->hash_buckets
;
352 if (size
<= PAGE_SIZE
)
355 free_pages((unsigned long)buckets
, get_order(size
));
359 static struct neigh_hash_table
*neigh_hash_grow(struct neigh_table
*tbl
,
360 unsigned long new_shift
)
362 unsigned int i
, hash
;
363 struct neigh_hash_table
*new_nht
, *old_nht
;
365 NEIGH_CACHE_STAT_INC(tbl
, hash_grows
);
367 old_nht
= rcu_dereference_protected(tbl
->nht
,
368 lockdep_is_held(&tbl
->lock
));
369 new_nht
= neigh_hash_alloc(new_shift
);
373 for (i
= 0; i
< (1 << old_nht
->hash_shift
); i
++) {
374 struct neighbour
*n
, *next
;
376 for (n
= rcu_dereference_protected(old_nht
->hash_buckets
[i
],
377 lockdep_is_held(&tbl
->lock
));
380 hash
= tbl
->hash(n
->primary_key
, n
->dev
,
383 hash
>>= (32 - new_nht
->hash_shift
);
384 next
= rcu_dereference_protected(n
->next
,
385 lockdep_is_held(&tbl
->lock
));
387 rcu_assign_pointer(n
->next
,
388 rcu_dereference_protected(
389 new_nht
->hash_buckets
[hash
],
390 lockdep_is_held(&tbl
->lock
)));
391 rcu_assign_pointer(new_nht
->hash_buckets
[hash
], n
);
395 rcu_assign_pointer(tbl
->nht
, new_nht
);
396 call_rcu(&old_nht
->rcu
, neigh_hash_free_rcu
);
400 struct neighbour
*neigh_lookup(struct neigh_table
*tbl
, const void *pkey
,
401 struct net_device
*dev
)
404 int key_len
= tbl
->key_len
;
406 struct neigh_hash_table
*nht
;
408 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
411 nht
= rcu_dereference_bh(tbl
->nht
);
412 hash_val
= tbl
->hash(pkey
, dev
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
414 for (n
= rcu_dereference_bh(nht
->hash_buckets
[hash_val
]);
416 n
= rcu_dereference_bh(n
->next
)) {
417 if (dev
== n
->dev
&& !memcmp(n
->primary_key
, pkey
, key_len
)) {
418 if (!atomic_inc_not_zero(&n
->refcnt
))
420 NEIGH_CACHE_STAT_INC(tbl
, hits
);
425 rcu_read_unlock_bh();
428 EXPORT_SYMBOL(neigh_lookup
);
430 struct neighbour
*neigh_lookup_nodev(struct neigh_table
*tbl
, struct net
*net
,
434 int key_len
= tbl
->key_len
;
436 struct neigh_hash_table
*nht
;
438 NEIGH_CACHE_STAT_INC(tbl
, lookups
);
441 nht
= rcu_dereference_bh(tbl
->nht
);
442 hash_val
= tbl
->hash(pkey
, NULL
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
444 for (n
= rcu_dereference_bh(nht
->hash_buckets
[hash_val
]);
446 n
= rcu_dereference_bh(n
->next
)) {
447 if (!memcmp(n
->primary_key
, pkey
, key_len
) &&
448 net_eq(dev_net(n
->dev
), net
)) {
449 if (!atomic_inc_not_zero(&n
->refcnt
))
451 NEIGH_CACHE_STAT_INC(tbl
, hits
);
456 rcu_read_unlock_bh();
459 EXPORT_SYMBOL(neigh_lookup_nodev
);
461 struct neighbour
*__neigh_create(struct neigh_table
*tbl
, const void *pkey
,
462 struct net_device
*dev
, bool want_ref
)
465 int key_len
= tbl
->key_len
;
467 struct neighbour
*n1
, *rc
, *n
= neigh_alloc(tbl
, dev
);
468 struct neigh_hash_table
*nht
;
471 rc
= ERR_PTR(-ENOBUFS
);
475 memcpy(n
->primary_key
, pkey
, key_len
);
479 /* Protocol specific setup. */
480 if (tbl
->constructor
&& (error
= tbl
->constructor(n
)) < 0) {
482 goto out_neigh_release
;
485 if (dev
->netdev_ops
->ndo_neigh_construct
) {
486 error
= dev
->netdev_ops
->ndo_neigh_construct(n
);
489 goto out_neigh_release
;
493 /* Device specific setup. */
494 if (n
->parms
->neigh_setup
&&
495 (error
= n
->parms
->neigh_setup(n
)) < 0) {
497 goto out_neigh_release
;
500 n
->confirmed
= jiffies
- (NEIGH_VAR(n
->parms
, BASE_REACHABLE_TIME
) << 1);
502 write_lock_bh(&tbl
->lock
);
503 nht
= rcu_dereference_protected(tbl
->nht
,
504 lockdep_is_held(&tbl
->lock
));
506 if (atomic_read(&tbl
->entries
) > (1 << nht
->hash_shift
))
507 nht
= neigh_hash_grow(tbl
, nht
->hash_shift
+ 1);
509 hash_val
= tbl
->hash(pkey
, dev
, nht
->hash_rnd
) >> (32 - nht
->hash_shift
);
511 if (n
->parms
->dead
) {
512 rc
= ERR_PTR(-EINVAL
);
516 for (n1
= rcu_dereference_protected(nht
->hash_buckets
[hash_val
],
517 lockdep_is_held(&tbl
->lock
));
519 n1
= rcu_dereference_protected(n1
->next
,
520 lockdep_is_held(&tbl
->lock
))) {
521 if (dev
== n1
->dev
&& !memcmp(n1
->primary_key
, pkey
, key_len
)) {
532 rcu_assign_pointer(n
->next
,
533 rcu_dereference_protected(nht
->hash_buckets
[hash_val
],
534 lockdep_is_held(&tbl
->lock
)));
535 rcu_assign_pointer(nht
->hash_buckets
[hash_val
], n
);
536 write_unlock_bh(&tbl
->lock
);
537 neigh_dbg(2, "neigh %p is created\n", n
);
542 write_unlock_bh(&tbl
->lock
);
547 EXPORT_SYMBOL(__neigh_create
);
549 static u32
pneigh_hash(const void *pkey
, int key_len
)
551 u32 hash_val
= *(u32
*)(pkey
+ key_len
- 4);
552 hash_val
^= (hash_val
>> 16);
553 hash_val
^= hash_val
>> 8;
554 hash_val
^= hash_val
>> 4;
555 hash_val
&= PNEIGH_HASHMASK
;
559 static struct pneigh_entry
*__pneigh_lookup_1(struct pneigh_entry
*n
,
563 struct net_device
*dev
)
566 if (!memcmp(n
->key
, pkey
, key_len
) &&
567 net_eq(pneigh_net(n
), net
) &&
568 (n
->dev
== dev
|| !n
->dev
))
575 struct pneigh_entry
*__pneigh_lookup(struct neigh_table
*tbl
,
576 struct net
*net
, const void *pkey
, struct net_device
*dev
)
578 int key_len
= tbl
->key_len
;
579 u32 hash_val
= pneigh_hash(pkey
, key_len
);
581 return __pneigh_lookup_1(tbl
->phash_buckets
[hash_val
],
582 net
, pkey
, key_len
, dev
);
584 EXPORT_SYMBOL_GPL(__pneigh_lookup
);
586 struct pneigh_entry
* pneigh_lookup(struct neigh_table
*tbl
,
587 struct net
*net
, const void *pkey
,
588 struct net_device
*dev
, int creat
)
590 struct pneigh_entry
*n
;
591 int key_len
= tbl
->key_len
;
592 u32 hash_val
= pneigh_hash(pkey
, key_len
);
594 read_lock_bh(&tbl
->lock
);
595 n
= __pneigh_lookup_1(tbl
->phash_buckets
[hash_val
],
596 net
, pkey
, key_len
, dev
);
597 read_unlock_bh(&tbl
->lock
);
604 n
= kmalloc(sizeof(*n
) + key_len
, GFP_KERNEL
);
608 write_pnet(&n
->net
, hold_net(net
));
609 memcpy(n
->key
, pkey
, key_len
);
614 if (tbl
->pconstructor
&& tbl
->pconstructor(n
)) {
623 write_lock_bh(&tbl
->lock
);
624 n
->next
= tbl
->phash_buckets
[hash_val
];
625 tbl
->phash_buckets
[hash_val
] = n
;
626 write_unlock_bh(&tbl
->lock
);
630 EXPORT_SYMBOL(pneigh_lookup
);
633 int pneigh_delete(struct neigh_table
*tbl
, struct net
*net
, const void *pkey
,
634 struct net_device
*dev
)
636 struct pneigh_entry
*n
, **np
;
637 int key_len
= tbl
->key_len
;
638 u32 hash_val
= pneigh_hash(pkey
, key_len
);
640 write_lock_bh(&tbl
->lock
);
641 for (np
= &tbl
->phash_buckets
[hash_val
]; (n
= *np
) != NULL
;
643 if (!memcmp(n
->key
, pkey
, key_len
) && n
->dev
== dev
&&
644 net_eq(pneigh_net(n
), net
)) {
646 write_unlock_bh(&tbl
->lock
);
647 if (tbl
->pdestructor
)
651 release_net(pneigh_net(n
));
656 write_unlock_bh(&tbl
->lock
);
660 static int pneigh_ifdown(struct neigh_table
*tbl
, struct net_device
*dev
)
662 struct pneigh_entry
*n
, **np
;
665 for (h
= 0; h
<= PNEIGH_HASHMASK
; h
++) {
666 np
= &tbl
->phash_buckets
[h
];
667 while ((n
= *np
) != NULL
) {
668 if (!dev
|| n
->dev
== dev
) {
670 if (tbl
->pdestructor
)
674 release_net(pneigh_net(n
));
684 static void neigh_parms_destroy(struct neigh_parms
*parms
);
686 static inline void neigh_parms_put(struct neigh_parms
*parms
)
688 if (atomic_dec_and_test(&parms
->refcnt
))
689 neigh_parms_destroy(parms
);
693 * neighbour must already be out of the table;
696 void neigh_destroy(struct neighbour
*neigh
)
698 struct net_device
*dev
= neigh
->dev
;
700 NEIGH_CACHE_STAT_INC(neigh
->tbl
, destroys
);
703 pr_warn("Destroying alive neighbour %p\n", neigh
);
708 if (neigh_del_timer(neigh
))
709 pr_warn("Impossible event\n");
711 write_lock_bh(&neigh
->lock
);
712 __skb_queue_purge(&neigh
->arp_queue
);
713 write_unlock_bh(&neigh
->lock
);
714 neigh
->arp_queue_len_bytes
= 0;
716 if (dev
->netdev_ops
->ndo_neigh_destroy
)
717 dev
->netdev_ops
->ndo_neigh_destroy(neigh
);
720 neigh_parms_put(neigh
->parms
);
722 neigh_dbg(2, "neigh %p is destroyed\n", neigh
);
724 atomic_dec(&neigh
->tbl
->entries
);
725 kfree_rcu(neigh
, rcu
);
727 EXPORT_SYMBOL(neigh_destroy
);
729 /* Neighbour state is suspicious;
732 Called with write_locked neigh.
734 static void neigh_suspect(struct neighbour
*neigh
)
736 neigh_dbg(2, "neigh %p is suspected\n", neigh
);
738 neigh
->output
= neigh
->ops
->output
;
741 /* Neighbour state is OK;
744 Called with write_locked neigh.
746 static void neigh_connect(struct neighbour
*neigh
)
748 neigh_dbg(2, "neigh %p is connected\n", neigh
);
750 neigh
->output
= neigh
->ops
->connected_output
;
753 static void neigh_periodic_work(struct work_struct
*work
)
755 struct neigh_table
*tbl
= container_of(work
, struct neigh_table
, gc_work
.work
);
757 struct neighbour __rcu
**np
;
759 struct neigh_hash_table
*nht
;
761 NEIGH_CACHE_STAT_INC(tbl
, periodic_gc_runs
);
763 write_lock_bh(&tbl
->lock
);
764 nht
= rcu_dereference_protected(tbl
->nht
,
765 lockdep_is_held(&tbl
->lock
));
767 if (atomic_read(&tbl
->entries
) < tbl
->gc_thresh1
)
771 * periodically recompute ReachableTime from random function
774 if (time_after(jiffies
, tbl
->last_rand
+ 300 * HZ
)) {
775 struct neigh_parms
*p
;
776 tbl
->last_rand
= jiffies
;
777 for (p
= &tbl
->parms
; p
; p
= p
->next
)
779 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
782 for (i
= 0 ; i
< (1 << nht
->hash_shift
); i
++) {
783 np
= &nht
->hash_buckets
[i
];
785 while ((n
= rcu_dereference_protected(*np
,
786 lockdep_is_held(&tbl
->lock
))) != NULL
) {
789 write_lock(&n
->lock
);
791 state
= n
->nud_state
;
792 if (state
& (NUD_PERMANENT
| NUD_IN_TIMER
)) {
793 write_unlock(&n
->lock
);
797 if (time_before(n
->used
, n
->confirmed
))
798 n
->used
= n
->confirmed
;
800 if (atomic_read(&n
->refcnt
) == 1 &&
801 (state
== NUD_FAILED
||
802 time_after(jiffies
, n
->used
+ NEIGH_VAR(n
->parms
, GC_STALETIME
)))) {
805 write_unlock(&n
->lock
);
806 neigh_cleanup_and_release(n
);
809 write_unlock(&n
->lock
);
815 * It's fine to release lock here, even if hash table
816 * grows while we are preempted.
818 write_unlock_bh(&tbl
->lock
);
820 write_lock_bh(&tbl
->lock
);
821 nht
= rcu_dereference_protected(tbl
->nht
,
822 lockdep_is_held(&tbl
->lock
));
825 /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks.
826 * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2
827 * BASE_REACHABLE_TIME.
829 schedule_delayed_work(&tbl
->gc_work
,
830 NEIGH_VAR(&tbl
->parms
, BASE_REACHABLE_TIME
) >> 1);
831 write_unlock_bh(&tbl
->lock
);
834 static __inline__
int neigh_max_probes(struct neighbour
*n
)
836 struct neigh_parms
*p
= n
->parms
;
837 return (n
->nud_state
& NUD_PROBE
) ?
838 NEIGH_VAR(p
, UCAST_PROBES
) :
839 NEIGH_VAR(p
, UCAST_PROBES
) + NEIGH_VAR(p
, APP_PROBES
) +
840 NEIGH_VAR(p
, MCAST_PROBES
);
843 static void neigh_invalidate(struct neighbour
*neigh
)
844 __releases(neigh
->lock
)
845 __acquires(neigh
->lock
)
849 NEIGH_CACHE_STAT_INC(neigh
->tbl
, res_failed
);
850 neigh_dbg(2, "neigh %p is failed\n", neigh
);
851 neigh
->updated
= jiffies
;
853 /* It is very thin place. report_unreachable is very complicated
854 routine. Particularly, it can hit the same neighbour entry!
856 So that, we try to be accurate and avoid dead loop. --ANK
858 while (neigh
->nud_state
== NUD_FAILED
&&
859 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
860 write_unlock(&neigh
->lock
);
861 neigh
->ops
->error_report(neigh
, skb
);
862 write_lock(&neigh
->lock
);
864 __skb_queue_purge(&neigh
->arp_queue
);
865 neigh
->arp_queue_len_bytes
= 0;
868 static void neigh_probe(struct neighbour
*neigh
)
869 __releases(neigh
->lock
)
871 struct sk_buff
*skb
= skb_peek_tail(&neigh
->arp_queue
);
872 /* keep skb alive even if arp_queue overflows */
874 skb
= skb_copy(skb
, GFP_ATOMIC
);
875 write_unlock(&neigh
->lock
);
876 neigh
->ops
->solicit(neigh
, skb
);
877 atomic_inc(&neigh
->probes
);
881 /* Called when a timer expires for a neighbour entry. */
883 static void neigh_timer_handler(unsigned long arg
)
885 unsigned long now
, next
;
886 struct neighbour
*neigh
= (struct neighbour
*)arg
;
890 write_lock(&neigh
->lock
);
892 state
= neigh
->nud_state
;
896 if (!(state
& NUD_IN_TIMER
))
899 if (state
& NUD_REACHABLE
) {
900 if (time_before_eq(now
,
901 neigh
->confirmed
+ neigh
->parms
->reachable_time
)) {
902 neigh_dbg(2, "neigh %p is still alive\n", neigh
);
903 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
904 } else if (time_before_eq(now
,
906 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
))) {
907 neigh_dbg(2, "neigh %p is delayed\n", neigh
);
908 neigh
->nud_state
= NUD_DELAY
;
909 neigh
->updated
= jiffies
;
910 neigh_suspect(neigh
);
911 next
= now
+ NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
);
913 neigh_dbg(2, "neigh %p is suspected\n", neigh
);
914 neigh
->nud_state
= NUD_STALE
;
915 neigh
->updated
= jiffies
;
916 neigh_suspect(neigh
);
919 } else if (state
& NUD_DELAY
) {
920 if (time_before_eq(now
,
922 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
))) {
923 neigh_dbg(2, "neigh %p is now reachable\n", neigh
);
924 neigh
->nud_state
= NUD_REACHABLE
;
925 neigh
->updated
= jiffies
;
926 neigh_connect(neigh
);
928 next
= neigh
->confirmed
+ neigh
->parms
->reachable_time
;
930 neigh_dbg(2, "neigh %p is probed\n", neigh
);
931 neigh
->nud_state
= NUD_PROBE
;
932 neigh
->updated
= jiffies
;
933 atomic_set(&neigh
->probes
, 0);
934 next
= now
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
);
937 /* NUD_PROBE|NUD_INCOMPLETE */
938 next
= now
+ NEIGH_VAR(neigh
->parms
, RETRANS_TIME
);
941 if ((neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
942 atomic_read(&neigh
->probes
) >= neigh_max_probes(neigh
)) {
943 neigh
->nud_state
= NUD_FAILED
;
945 neigh_invalidate(neigh
);
948 if (neigh
->nud_state
& NUD_IN_TIMER
) {
949 if (time_before(next
, jiffies
+ HZ
/2))
950 next
= jiffies
+ HZ
/2;
951 if (!mod_timer(&neigh
->timer
, next
))
954 if (neigh
->nud_state
& (NUD_INCOMPLETE
| NUD_PROBE
)) {
958 write_unlock(&neigh
->lock
);
962 neigh_update_notify(neigh
);
964 neigh_release(neigh
);
967 int __neigh_event_send(struct neighbour
*neigh
, struct sk_buff
*skb
)
970 bool immediate_probe
= false;
972 write_lock_bh(&neigh
->lock
);
975 if (neigh
->nud_state
& (NUD_CONNECTED
| NUD_DELAY
| NUD_PROBE
))
978 if (!(neigh
->nud_state
& (NUD_STALE
| NUD_INCOMPLETE
))) {
979 if (NEIGH_VAR(neigh
->parms
, MCAST_PROBES
) +
980 NEIGH_VAR(neigh
->parms
, APP_PROBES
)) {
981 unsigned long next
, now
= jiffies
;
983 atomic_set(&neigh
->probes
,
984 NEIGH_VAR(neigh
->parms
, UCAST_PROBES
));
985 neigh
->nud_state
= NUD_INCOMPLETE
;
986 neigh
->updated
= now
;
987 next
= now
+ max(NEIGH_VAR(neigh
->parms
, RETRANS_TIME
),
989 neigh_add_timer(neigh
, next
);
990 immediate_probe
= true;
992 neigh
->nud_state
= NUD_FAILED
;
993 neigh
->updated
= jiffies
;
994 write_unlock_bh(&neigh
->lock
);
999 } else if (neigh
->nud_state
& NUD_STALE
) {
1000 neigh_dbg(2, "neigh %p is delayed\n", neigh
);
1001 neigh
->nud_state
= NUD_DELAY
;
1002 neigh
->updated
= jiffies
;
1003 neigh_add_timer(neigh
, jiffies
+
1004 NEIGH_VAR(neigh
->parms
, DELAY_PROBE_TIME
));
1007 if (neigh
->nud_state
== NUD_INCOMPLETE
) {
1009 while (neigh
->arp_queue_len_bytes
+ skb
->truesize
>
1010 NEIGH_VAR(neigh
->parms
, QUEUE_LEN_BYTES
)) {
1011 struct sk_buff
*buff
;
1013 buff
= __skb_dequeue(&neigh
->arp_queue
);
1016 neigh
->arp_queue_len_bytes
-= buff
->truesize
;
1018 NEIGH_CACHE_STAT_INC(neigh
->tbl
, unres_discards
);
1021 __skb_queue_tail(&neigh
->arp_queue
, skb
);
1022 neigh
->arp_queue_len_bytes
+= skb
->truesize
;
1027 if (immediate_probe
)
1030 write_unlock(&neigh
->lock
);
1034 EXPORT_SYMBOL(__neigh_event_send
);
1036 static void neigh_update_hhs(struct neighbour
*neigh
)
1038 struct hh_cache
*hh
;
1039 void (*update
)(struct hh_cache
*, const struct net_device
*, const unsigned char *)
1042 if (neigh
->dev
->header_ops
)
1043 update
= neigh
->dev
->header_ops
->cache_update
;
1048 write_seqlock_bh(&hh
->hh_lock
);
1049 update(hh
, neigh
->dev
, neigh
->ha
);
1050 write_sequnlock_bh(&hh
->hh_lock
);
1057 /* Generic update routine.
1058 -- lladdr is new lladdr or NULL, if it is not supplied.
1059 -- new is new state.
1061 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
1063 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
1064 lladdr instead of overriding it
1066 It also allows to retain current state
1067 if lladdr is unchanged.
1068 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
1070 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
1072 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1075 Caller MUST hold reference count on the entry.
1078 int neigh_update(struct neighbour
*neigh
, const u8
*lladdr
, u8
new,
1084 struct net_device
*dev
;
1085 int update_isrouter
= 0;
1087 write_lock_bh(&neigh
->lock
);
1090 old
= neigh
->nud_state
;
1093 if (!(flags
& NEIGH_UPDATE_F_ADMIN
) &&
1094 (old
& (NUD_NOARP
| NUD_PERMANENT
)))
1097 if (!(new & NUD_VALID
)) {
1098 neigh_del_timer(neigh
);
1099 if (old
& NUD_CONNECTED
)
1100 neigh_suspect(neigh
);
1101 neigh
->nud_state
= new;
1103 notify
= old
& NUD_VALID
;
1104 if ((old
& (NUD_INCOMPLETE
| NUD_PROBE
)) &&
1105 (new & NUD_FAILED
)) {
1106 neigh_invalidate(neigh
);
1112 /* Compare new lladdr with cached one */
1113 if (!dev
->addr_len
) {
1114 /* First case: device needs no address. */
1116 } else if (lladdr
) {
1117 /* The second case: if something is already cached
1118 and a new address is proposed:
1120 - if they are different, check override flag
1122 if ((old
& NUD_VALID
) &&
1123 !memcmp(lladdr
, neigh
->ha
, dev
->addr_len
))
1126 /* No address is supplied; if we know something,
1127 use it, otherwise discard the request.
1130 if (!(old
& NUD_VALID
))
1135 if (new & NUD_CONNECTED
)
1136 neigh
->confirmed
= jiffies
;
1137 neigh
->updated
= jiffies
;
1139 /* If entry was valid and address is not changed,
1140 do not change entry state, if new one is STALE.
1143 update_isrouter
= flags
& NEIGH_UPDATE_F_OVERRIDE_ISROUTER
;
1144 if (old
& NUD_VALID
) {
1145 if (lladdr
!= neigh
->ha
&& !(flags
& NEIGH_UPDATE_F_OVERRIDE
)) {
1146 update_isrouter
= 0;
1147 if ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) &&
1148 (old
& NUD_CONNECTED
)) {
1154 if (lladdr
== neigh
->ha
&& new == NUD_STALE
&&
1155 ((flags
& NEIGH_UPDATE_F_WEAK_OVERRIDE
) ||
1156 (old
& NUD_CONNECTED
))
1163 neigh_del_timer(neigh
);
1164 if (new & NUD_IN_TIMER
)
1165 neigh_add_timer(neigh
, (jiffies
+
1166 ((new & NUD_REACHABLE
) ?
1167 neigh
->parms
->reachable_time
:
1169 neigh
->nud_state
= new;
1172 if (lladdr
!= neigh
->ha
) {
1173 write_seqlock(&neigh
->ha_lock
);
1174 memcpy(&neigh
->ha
, lladdr
, dev
->addr_len
);
1175 write_sequnlock(&neigh
->ha_lock
);
1176 neigh_update_hhs(neigh
);
1177 if (!(new & NUD_CONNECTED
))
1178 neigh
->confirmed
= jiffies
-
1179 (NEIGH_VAR(neigh
->parms
, BASE_REACHABLE_TIME
) << 1);
1184 if (new & NUD_CONNECTED
)
1185 neigh_connect(neigh
);
1187 neigh_suspect(neigh
);
1188 if (!(old
& NUD_VALID
)) {
1189 struct sk_buff
*skb
;
1191 /* Again: avoid dead loop if something went wrong */
1193 while (neigh
->nud_state
& NUD_VALID
&&
1194 (skb
= __skb_dequeue(&neigh
->arp_queue
)) != NULL
) {
1195 struct dst_entry
*dst
= skb_dst(skb
);
1196 struct neighbour
*n2
, *n1
= neigh
;
1197 write_unlock_bh(&neigh
->lock
);
1201 /* Why not just use 'neigh' as-is? The problem is that
1202 * things such as shaper, eql, and sch_teql can end up
1203 * using alternative, different, neigh objects to output
1204 * the packet in the output path. So what we need to do
1205 * here is re-lookup the top-level neigh in the path so
1206 * we can reinject the packet there.
1210 n2
= dst_neigh_lookup_skb(dst
, skb
);
1214 n1
->output(n1
, skb
);
1219 write_lock_bh(&neigh
->lock
);
1221 __skb_queue_purge(&neigh
->arp_queue
);
1222 neigh
->arp_queue_len_bytes
= 0;
1225 if (update_isrouter
) {
1226 neigh
->flags
= (flags
& NEIGH_UPDATE_F_ISROUTER
) ?
1227 (neigh
->flags
| NTF_ROUTER
) :
1228 (neigh
->flags
& ~NTF_ROUTER
);
1230 write_unlock_bh(&neigh
->lock
);
1233 neigh_update_notify(neigh
);
1237 EXPORT_SYMBOL(neigh_update
);
1239 struct neighbour
*neigh_event_ns(struct neigh_table
*tbl
,
1240 u8
*lladdr
, void *saddr
,
1241 struct net_device
*dev
)
1243 struct neighbour
*neigh
= __neigh_lookup(tbl
, saddr
, dev
,
1244 lladdr
|| !dev
->addr_len
);
1246 neigh_update(neigh
, lladdr
, NUD_STALE
,
1247 NEIGH_UPDATE_F_OVERRIDE
);
1250 EXPORT_SYMBOL(neigh_event_ns
);
1252 /* called with read_lock_bh(&n->lock); */
1253 static void neigh_hh_init(struct neighbour
*n
, struct dst_entry
*dst
)
1255 struct net_device
*dev
= dst
->dev
;
1256 __be16 prot
= dst
->ops
->protocol
;
1257 struct hh_cache
*hh
= &n
->hh
;
1259 write_lock_bh(&n
->lock
);
1261 /* Only one thread can come in here and initialize the
1265 dev
->header_ops
->cache(n
, hh
, prot
);
1267 write_unlock_bh(&n
->lock
);
1270 /* This function can be used in contexts, where only old dev_queue_xmit
1271 * worked, f.e. if you want to override normal output path (eql, shaper),
1272 * but resolution is not made yet.
1275 int neigh_compat_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1277 struct net_device
*dev
= skb
->dev
;
1279 __skb_pull(skb
, skb_network_offset(skb
));
1281 if (dev_hard_header(skb
, dev
, ntohs(skb
->protocol
), NULL
, NULL
,
1283 dev
->header_ops
->rebuild(skb
))
1286 return dev_queue_xmit(skb
);
1288 EXPORT_SYMBOL(neigh_compat_output
);
1290 /* Slow and careful. */
1292 int neigh_resolve_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1294 struct dst_entry
*dst
= skb_dst(skb
);
1300 if (!neigh_event_send(neigh
, skb
)) {
1302 struct net_device
*dev
= neigh
->dev
;
1305 if (dev
->header_ops
->cache
&& !neigh
->hh
.hh_len
)
1306 neigh_hh_init(neigh
, dst
);
1309 __skb_pull(skb
, skb_network_offset(skb
));
1310 seq
= read_seqbegin(&neigh
->ha_lock
);
1311 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1312 neigh
->ha
, NULL
, skb
->len
);
1313 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1316 rc
= dev_queue_xmit(skb
);
1323 neigh_dbg(1, "%s: dst=%p neigh=%p\n", __func__
, dst
, neigh
);
1329 EXPORT_SYMBOL(neigh_resolve_output
);
1331 /* As fast as possible without hh cache */
1333 int neigh_connected_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1335 struct net_device
*dev
= neigh
->dev
;
1340 __skb_pull(skb
, skb_network_offset(skb
));
1341 seq
= read_seqbegin(&neigh
->ha_lock
);
1342 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
1343 neigh
->ha
, NULL
, skb
->len
);
1344 } while (read_seqretry(&neigh
->ha_lock
, seq
));
1347 err
= dev_queue_xmit(skb
);
1354 EXPORT_SYMBOL(neigh_connected_output
);
1356 int neigh_direct_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
1358 return dev_queue_xmit(skb
);
1360 EXPORT_SYMBOL(neigh_direct_output
);
1362 static void neigh_proxy_process(unsigned long arg
)
1364 struct neigh_table
*tbl
= (struct neigh_table
*)arg
;
1365 long sched_next
= 0;
1366 unsigned long now
= jiffies
;
1367 struct sk_buff
*skb
, *n
;
1369 spin_lock(&tbl
->proxy_queue
.lock
);
1371 skb_queue_walk_safe(&tbl
->proxy_queue
, skb
, n
) {
1372 long tdif
= NEIGH_CB(skb
)->sched_next
- now
;
1375 struct net_device
*dev
= skb
->dev
;
1377 __skb_unlink(skb
, &tbl
->proxy_queue
);
1378 if (tbl
->proxy_redo
&& netif_running(dev
)) {
1380 tbl
->proxy_redo(skb
);
1387 } else if (!sched_next
|| tdif
< sched_next
)
1390 del_timer(&tbl
->proxy_timer
);
1392 mod_timer(&tbl
->proxy_timer
, jiffies
+ sched_next
);
1393 spin_unlock(&tbl
->proxy_queue
.lock
);
1396 void pneigh_enqueue(struct neigh_table
*tbl
, struct neigh_parms
*p
,
1397 struct sk_buff
*skb
)
1399 unsigned long now
= jiffies
;
1400 unsigned long sched_next
= now
+ (net_random() %
1401 NEIGH_VAR(p
, PROXY_DELAY
));
1403 if (tbl
->proxy_queue
.qlen
> NEIGH_VAR(p
, PROXY_QLEN
)) {
1408 NEIGH_CB(skb
)->sched_next
= sched_next
;
1409 NEIGH_CB(skb
)->flags
|= LOCALLY_ENQUEUED
;
1411 spin_lock(&tbl
->proxy_queue
.lock
);
1412 if (del_timer(&tbl
->proxy_timer
)) {
1413 if (time_before(tbl
->proxy_timer
.expires
, sched_next
))
1414 sched_next
= tbl
->proxy_timer
.expires
;
1418 __skb_queue_tail(&tbl
->proxy_queue
, skb
);
1419 mod_timer(&tbl
->proxy_timer
, sched_next
);
1420 spin_unlock(&tbl
->proxy_queue
.lock
);
1422 EXPORT_SYMBOL(pneigh_enqueue
);
1424 static inline struct neigh_parms
*lookup_neigh_parms(struct neigh_table
*tbl
,
1425 struct net
*net
, int ifindex
)
1427 struct neigh_parms
*p
;
1429 for (p
= &tbl
->parms
; p
; p
= p
->next
) {
1430 if ((p
->dev
&& p
->dev
->ifindex
== ifindex
&& net_eq(neigh_parms_net(p
), net
)) ||
1431 (!p
->dev
&& !ifindex
&& net_eq(net
, &init_net
)))
1438 struct neigh_parms
*neigh_parms_alloc(struct net_device
*dev
,
1439 struct neigh_table
*tbl
)
1441 struct neigh_parms
*p
;
1442 struct net
*net
= dev_net(dev
);
1443 const struct net_device_ops
*ops
= dev
->netdev_ops
;
1445 p
= kmemdup(&tbl
->parms
, sizeof(*p
), GFP_KERNEL
);
1448 atomic_set(&p
->refcnt
, 1);
1450 neigh_rand_reach_time(NEIGH_VAR(p
, BASE_REACHABLE_TIME
));
1453 write_pnet(&p
->net
, hold_net(net
));
1454 p
->sysctl_table
= NULL
;
1456 if (ops
->ndo_neigh_setup
&& ops
->ndo_neigh_setup(dev
, p
)) {
1463 write_lock_bh(&tbl
->lock
);
1464 p
->next
= tbl
->parms
.next
;
1465 tbl
->parms
.next
= p
;
1466 write_unlock_bh(&tbl
->lock
);
1470 EXPORT_SYMBOL(neigh_parms_alloc
);
1472 static void neigh_rcu_free_parms(struct rcu_head
*head
)
1474 struct neigh_parms
*parms
=
1475 container_of(head
, struct neigh_parms
, rcu_head
);
1477 neigh_parms_put(parms
);
1480 void neigh_parms_release(struct neigh_table
*tbl
, struct neigh_parms
*parms
)
1482 struct neigh_parms
**p
;
1484 if (!parms
|| parms
== &tbl
->parms
)
1486 write_lock_bh(&tbl
->lock
);
1487 for (p
= &tbl
->parms
.next
; *p
; p
= &(*p
)->next
) {
1491 write_unlock_bh(&tbl
->lock
);
1493 dev_put(parms
->dev
);
1494 call_rcu(&parms
->rcu_head
, neigh_rcu_free_parms
);
1498 write_unlock_bh(&tbl
->lock
);
1499 neigh_dbg(1, "%s: not found\n", __func__
);
1501 EXPORT_SYMBOL(neigh_parms_release
);
1503 static void neigh_parms_destroy(struct neigh_parms
*parms
)
1505 release_net(neigh_parms_net(parms
));
1509 static struct lock_class_key neigh_table_proxy_queue_class
;
1511 static void neigh_table_init_no_netlink(struct neigh_table
*tbl
)
1513 unsigned long now
= jiffies
;
1514 unsigned long phsize
;
1516 write_pnet(&tbl
->parms
.net
, &init_net
);
1517 atomic_set(&tbl
->parms
.refcnt
, 1);
1518 tbl
->parms
.reachable_time
=
1519 neigh_rand_reach_time(NEIGH_VAR(&tbl
->parms
, BASE_REACHABLE_TIME
));
1521 tbl
->stats
= alloc_percpu(struct neigh_statistics
);
1523 panic("cannot create neighbour cache statistics");
1525 #ifdef CONFIG_PROC_FS
1526 if (!proc_create_data(tbl
->id
, 0, init_net
.proc_net_stat
,
1527 &neigh_stat_seq_fops
, tbl
))
1528 panic("cannot create neighbour proc dir entry");
1531 RCU_INIT_POINTER(tbl
->nht
, neigh_hash_alloc(3));
1533 phsize
= (PNEIGH_HASHMASK
+ 1) * sizeof(struct pneigh_entry
*);
1534 tbl
->phash_buckets
= kzalloc(phsize
, GFP_KERNEL
);
1536 if (!tbl
->nht
|| !tbl
->phash_buckets
)
1537 panic("cannot allocate neighbour cache hashes");
1539 if (!tbl
->entry_size
)
1540 tbl
->entry_size
= ALIGN(offsetof(struct neighbour
, primary_key
) +
1541 tbl
->key_len
, NEIGH_PRIV_ALIGN
);
1543 WARN_ON(tbl
->entry_size
% NEIGH_PRIV_ALIGN
);
1545 rwlock_init(&tbl
->lock
);
1546 INIT_DEFERRABLE_WORK(&tbl
->gc_work
, neigh_periodic_work
);
1547 schedule_delayed_work(&tbl
->gc_work
, tbl
->parms
.reachable_time
);
1548 setup_timer(&tbl
->proxy_timer
, neigh_proxy_process
, (unsigned long)tbl
);
1549 skb_queue_head_init_class(&tbl
->proxy_queue
,
1550 &neigh_table_proxy_queue_class
);
1552 tbl
->last_flush
= now
;
1553 tbl
->last_rand
= now
+ tbl
->parms
.reachable_time
* 20;
1556 void neigh_table_init(struct neigh_table
*tbl
)
1558 struct neigh_table
*tmp
;
1560 neigh_table_init_no_netlink(tbl
);
1561 write_lock(&neigh_tbl_lock
);
1562 for (tmp
= neigh_tables
; tmp
; tmp
= tmp
->next
) {
1563 if (tmp
->family
== tbl
->family
)
1566 tbl
->next
= neigh_tables
;
1568 write_unlock(&neigh_tbl_lock
);
1570 if (unlikely(tmp
)) {
1571 pr_err("Registering multiple tables for family %d\n",
1576 EXPORT_SYMBOL(neigh_table_init
);
1578 int neigh_table_clear(struct neigh_table
*tbl
)
1580 struct neigh_table
**tp
;
1582 /* It is not clean... Fix it to unload IPv6 module safely */
1583 cancel_delayed_work_sync(&tbl
->gc_work
);
1584 del_timer_sync(&tbl
->proxy_timer
);
1585 pneigh_queue_purge(&tbl
->proxy_queue
);
1586 neigh_ifdown(tbl
, NULL
);
1587 if (atomic_read(&tbl
->entries
))
1588 pr_crit("neighbour leakage\n");
1589 write_lock(&neigh_tbl_lock
);
1590 for (tp
= &neigh_tables
; *tp
; tp
= &(*tp
)->next
) {
1596 write_unlock(&neigh_tbl_lock
);
1598 call_rcu(&rcu_dereference_protected(tbl
->nht
, 1)->rcu
,
1599 neigh_hash_free_rcu
);
1602 kfree(tbl
->phash_buckets
);
1603 tbl
->phash_buckets
= NULL
;
1605 remove_proc_entry(tbl
->id
, init_net
.proc_net_stat
);
1607 free_percpu(tbl
->stats
);
1612 EXPORT_SYMBOL(neigh_table_clear
);
1614 static int neigh_delete(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1616 struct net
*net
= sock_net(skb
->sk
);
1618 struct nlattr
*dst_attr
;
1619 struct neigh_table
*tbl
;
1620 struct net_device
*dev
= NULL
;
1624 if (nlmsg_len(nlh
) < sizeof(*ndm
))
1627 dst_attr
= nlmsg_find_attr(nlh
, sizeof(*ndm
), NDA_DST
);
1628 if (dst_attr
== NULL
)
1631 ndm
= nlmsg_data(nlh
);
1632 if (ndm
->ndm_ifindex
) {
1633 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1640 read_lock(&neigh_tbl_lock
);
1641 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1642 struct neighbour
*neigh
;
1644 if (tbl
->family
!= ndm
->ndm_family
)
1646 read_unlock(&neigh_tbl_lock
);
1648 if (nla_len(dst_attr
) < tbl
->key_len
)
1651 if (ndm
->ndm_flags
& NTF_PROXY
) {
1652 err
= pneigh_delete(tbl
, net
, nla_data(dst_attr
), dev
);
1659 neigh
= neigh_lookup(tbl
, nla_data(dst_attr
), dev
);
1660 if (neigh
== NULL
) {
1665 err
= neigh_update(neigh
, NULL
, NUD_FAILED
,
1666 NEIGH_UPDATE_F_OVERRIDE
|
1667 NEIGH_UPDATE_F_ADMIN
);
1668 neigh_release(neigh
);
1671 read_unlock(&neigh_tbl_lock
);
1672 err
= -EAFNOSUPPORT
;
1678 static int neigh_add(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1680 struct net
*net
= sock_net(skb
->sk
);
1682 struct nlattr
*tb
[NDA_MAX
+1];
1683 struct neigh_table
*tbl
;
1684 struct net_device
*dev
= NULL
;
1688 err
= nlmsg_parse(nlh
, sizeof(*ndm
), tb
, NDA_MAX
, NULL
);
1693 if (tb
[NDA_DST
] == NULL
)
1696 ndm
= nlmsg_data(nlh
);
1697 if (ndm
->ndm_ifindex
) {
1698 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
1704 if (tb
[NDA_LLADDR
] && nla_len(tb
[NDA_LLADDR
]) < dev
->addr_len
)
1708 read_lock(&neigh_tbl_lock
);
1709 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1710 int flags
= NEIGH_UPDATE_F_ADMIN
| NEIGH_UPDATE_F_OVERRIDE
;
1711 struct neighbour
*neigh
;
1714 if (tbl
->family
!= ndm
->ndm_family
)
1716 read_unlock(&neigh_tbl_lock
);
1718 if (nla_len(tb
[NDA_DST
]) < tbl
->key_len
)
1720 dst
= nla_data(tb
[NDA_DST
]);
1721 lladdr
= tb
[NDA_LLADDR
] ? nla_data(tb
[NDA_LLADDR
]) : NULL
;
1723 if (ndm
->ndm_flags
& NTF_PROXY
) {
1724 struct pneigh_entry
*pn
;
1727 pn
= pneigh_lookup(tbl
, net
, dst
, dev
, 1);
1729 pn
->flags
= ndm
->ndm_flags
;
1738 neigh
= neigh_lookup(tbl
, dst
, dev
);
1739 if (neigh
== NULL
) {
1740 if (!(nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
1745 neigh
= __neigh_lookup_errno(tbl
, dst
, dev
);
1746 if (IS_ERR(neigh
)) {
1747 err
= PTR_ERR(neigh
);
1751 if (nlh
->nlmsg_flags
& NLM_F_EXCL
) {
1753 neigh_release(neigh
);
1757 if (!(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
1758 flags
&= ~NEIGH_UPDATE_F_OVERRIDE
;
1761 if (ndm
->ndm_flags
& NTF_USE
) {
1762 neigh_event_send(neigh
, NULL
);
1765 err
= neigh_update(neigh
, lladdr
, ndm
->ndm_state
, flags
);
1766 neigh_release(neigh
);
1770 read_unlock(&neigh_tbl_lock
);
1771 err
= -EAFNOSUPPORT
;
1776 static int neightbl_fill_parms(struct sk_buff
*skb
, struct neigh_parms
*parms
)
1778 struct nlattr
*nest
;
1780 nest
= nla_nest_start(skb
, NDTA_PARMS
);
1785 nla_put_u32(skb
, NDTPA_IFINDEX
, parms
->dev
->ifindex
)) ||
1786 nla_put_u32(skb
, NDTPA_REFCNT
, atomic_read(&parms
->refcnt
)) ||
1787 nla_put_u32(skb
, NDTPA_QUEUE_LENBYTES
,
1788 NEIGH_VAR(parms
, QUEUE_LEN_BYTES
)) ||
1789 /* approximative value for deprecated QUEUE_LEN (in packets) */
1790 nla_put_u32(skb
, NDTPA_QUEUE_LEN
,
1791 NEIGH_VAR(parms
, QUEUE_LEN_BYTES
) / SKB_TRUESIZE(ETH_FRAME_LEN
)) ||
1792 nla_put_u32(skb
, NDTPA_PROXY_QLEN
, NEIGH_VAR(parms
, PROXY_QLEN
)) ||
1793 nla_put_u32(skb
, NDTPA_APP_PROBES
, NEIGH_VAR(parms
, APP_PROBES
)) ||
1794 nla_put_u32(skb
, NDTPA_UCAST_PROBES
,
1795 NEIGH_VAR(parms
, UCAST_PROBES
)) ||
1796 nla_put_u32(skb
, NDTPA_MCAST_PROBES
,
1797 NEIGH_VAR(parms
, MCAST_PROBES
)) ||
1798 nla_put_msecs(skb
, NDTPA_REACHABLE_TIME
, parms
->reachable_time
) ||
1799 nla_put_msecs(skb
, NDTPA_BASE_REACHABLE_TIME
,
1800 NEIGH_VAR(parms
, BASE_REACHABLE_TIME
)) ||
1801 nla_put_msecs(skb
, NDTPA_GC_STALETIME
,
1802 NEIGH_VAR(parms
, GC_STALETIME
)) ||
1803 nla_put_msecs(skb
, NDTPA_DELAY_PROBE_TIME
,
1804 NEIGH_VAR(parms
, DELAY_PROBE_TIME
)) ||
1805 nla_put_msecs(skb
, NDTPA_RETRANS_TIME
,
1806 NEIGH_VAR(parms
, RETRANS_TIME
)) ||
1807 nla_put_msecs(skb
, NDTPA_ANYCAST_DELAY
,
1808 NEIGH_VAR(parms
, ANYCAST_DELAY
)) ||
1809 nla_put_msecs(skb
, NDTPA_PROXY_DELAY
,
1810 NEIGH_VAR(parms
, PROXY_DELAY
)) ||
1811 nla_put_msecs(skb
, NDTPA_LOCKTIME
,
1812 NEIGH_VAR(parms
, LOCKTIME
)))
1813 goto nla_put_failure
;
1814 return nla_nest_end(skb
, nest
);
1817 nla_nest_cancel(skb
, nest
);
1821 static int neightbl_fill_info(struct sk_buff
*skb
, struct neigh_table
*tbl
,
1822 u32 pid
, u32 seq
, int type
, int flags
)
1824 struct nlmsghdr
*nlh
;
1825 struct ndtmsg
*ndtmsg
;
1827 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1831 ndtmsg
= nlmsg_data(nlh
);
1833 read_lock_bh(&tbl
->lock
);
1834 ndtmsg
->ndtm_family
= tbl
->family
;
1835 ndtmsg
->ndtm_pad1
= 0;
1836 ndtmsg
->ndtm_pad2
= 0;
1838 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) ||
1839 nla_put_msecs(skb
, NDTA_GC_INTERVAL
, tbl
->gc_interval
) ||
1840 nla_put_u32(skb
, NDTA_THRESH1
, tbl
->gc_thresh1
) ||
1841 nla_put_u32(skb
, NDTA_THRESH2
, tbl
->gc_thresh2
) ||
1842 nla_put_u32(skb
, NDTA_THRESH3
, tbl
->gc_thresh3
))
1843 goto nla_put_failure
;
1845 unsigned long now
= jiffies
;
1846 unsigned int flush_delta
= now
- tbl
->last_flush
;
1847 unsigned int rand_delta
= now
- tbl
->last_rand
;
1848 struct neigh_hash_table
*nht
;
1849 struct ndt_config ndc
= {
1850 .ndtc_key_len
= tbl
->key_len
,
1851 .ndtc_entry_size
= tbl
->entry_size
,
1852 .ndtc_entries
= atomic_read(&tbl
->entries
),
1853 .ndtc_last_flush
= jiffies_to_msecs(flush_delta
),
1854 .ndtc_last_rand
= jiffies_to_msecs(rand_delta
),
1855 .ndtc_proxy_qlen
= tbl
->proxy_queue
.qlen
,
1859 nht
= rcu_dereference_bh(tbl
->nht
);
1860 ndc
.ndtc_hash_rnd
= nht
->hash_rnd
[0];
1861 ndc
.ndtc_hash_mask
= ((1 << nht
->hash_shift
) - 1);
1862 rcu_read_unlock_bh();
1864 if (nla_put(skb
, NDTA_CONFIG
, sizeof(ndc
), &ndc
))
1865 goto nla_put_failure
;
1870 struct ndt_stats ndst
;
1872 memset(&ndst
, 0, sizeof(ndst
));
1874 for_each_possible_cpu(cpu
) {
1875 struct neigh_statistics
*st
;
1877 st
= per_cpu_ptr(tbl
->stats
, cpu
);
1878 ndst
.ndts_allocs
+= st
->allocs
;
1879 ndst
.ndts_destroys
+= st
->destroys
;
1880 ndst
.ndts_hash_grows
+= st
->hash_grows
;
1881 ndst
.ndts_res_failed
+= st
->res_failed
;
1882 ndst
.ndts_lookups
+= st
->lookups
;
1883 ndst
.ndts_hits
+= st
->hits
;
1884 ndst
.ndts_rcv_probes_mcast
+= st
->rcv_probes_mcast
;
1885 ndst
.ndts_rcv_probes_ucast
+= st
->rcv_probes_ucast
;
1886 ndst
.ndts_periodic_gc_runs
+= st
->periodic_gc_runs
;
1887 ndst
.ndts_forced_gc_runs
+= st
->forced_gc_runs
;
1890 if (nla_put(skb
, NDTA_STATS
, sizeof(ndst
), &ndst
))
1891 goto nla_put_failure
;
1894 BUG_ON(tbl
->parms
.dev
);
1895 if (neightbl_fill_parms(skb
, &tbl
->parms
) < 0)
1896 goto nla_put_failure
;
1898 read_unlock_bh(&tbl
->lock
);
1899 return nlmsg_end(skb
, nlh
);
1902 read_unlock_bh(&tbl
->lock
);
1903 nlmsg_cancel(skb
, nlh
);
1907 static int neightbl_fill_param_info(struct sk_buff
*skb
,
1908 struct neigh_table
*tbl
,
1909 struct neigh_parms
*parms
,
1910 u32 pid
, u32 seq
, int type
,
1913 struct ndtmsg
*ndtmsg
;
1914 struct nlmsghdr
*nlh
;
1916 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndtmsg
), flags
);
1920 ndtmsg
= nlmsg_data(nlh
);
1922 read_lock_bh(&tbl
->lock
);
1923 ndtmsg
->ndtm_family
= tbl
->family
;
1924 ndtmsg
->ndtm_pad1
= 0;
1925 ndtmsg
->ndtm_pad2
= 0;
1927 if (nla_put_string(skb
, NDTA_NAME
, tbl
->id
) < 0 ||
1928 neightbl_fill_parms(skb
, parms
) < 0)
1931 read_unlock_bh(&tbl
->lock
);
1932 return nlmsg_end(skb
, nlh
);
1934 read_unlock_bh(&tbl
->lock
);
1935 nlmsg_cancel(skb
, nlh
);
1939 static const struct nla_policy nl_neightbl_policy
[NDTA_MAX
+1] = {
1940 [NDTA_NAME
] = { .type
= NLA_STRING
},
1941 [NDTA_THRESH1
] = { .type
= NLA_U32
},
1942 [NDTA_THRESH2
] = { .type
= NLA_U32
},
1943 [NDTA_THRESH3
] = { .type
= NLA_U32
},
1944 [NDTA_GC_INTERVAL
] = { .type
= NLA_U64
},
1945 [NDTA_PARMS
] = { .type
= NLA_NESTED
},
1948 static const struct nla_policy nl_ntbl_parm_policy
[NDTPA_MAX
+1] = {
1949 [NDTPA_IFINDEX
] = { .type
= NLA_U32
},
1950 [NDTPA_QUEUE_LEN
] = { .type
= NLA_U32
},
1951 [NDTPA_PROXY_QLEN
] = { .type
= NLA_U32
},
1952 [NDTPA_APP_PROBES
] = { .type
= NLA_U32
},
1953 [NDTPA_UCAST_PROBES
] = { .type
= NLA_U32
},
1954 [NDTPA_MCAST_PROBES
] = { .type
= NLA_U32
},
1955 [NDTPA_BASE_REACHABLE_TIME
] = { .type
= NLA_U64
},
1956 [NDTPA_GC_STALETIME
] = { .type
= NLA_U64
},
1957 [NDTPA_DELAY_PROBE_TIME
] = { .type
= NLA_U64
},
1958 [NDTPA_RETRANS_TIME
] = { .type
= NLA_U64
},
1959 [NDTPA_ANYCAST_DELAY
] = { .type
= NLA_U64
},
1960 [NDTPA_PROXY_DELAY
] = { .type
= NLA_U64
},
1961 [NDTPA_LOCKTIME
] = { .type
= NLA_U64
},
1964 static int neightbl_set(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1966 struct net
*net
= sock_net(skb
->sk
);
1967 struct neigh_table
*tbl
;
1968 struct ndtmsg
*ndtmsg
;
1969 struct nlattr
*tb
[NDTA_MAX
+1];
1972 err
= nlmsg_parse(nlh
, sizeof(*ndtmsg
), tb
, NDTA_MAX
,
1973 nl_neightbl_policy
);
1977 if (tb
[NDTA_NAME
] == NULL
) {
1982 ndtmsg
= nlmsg_data(nlh
);
1983 read_lock(&neigh_tbl_lock
);
1984 for (tbl
= neigh_tables
; tbl
; tbl
= tbl
->next
) {
1985 if (ndtmsg
->ndtm_family
&& tbl
->family
!= ndtmsg
->ndtm_family
)
1988 if (nla_strcmp(tb
[NDTA_NAME
], tbl
->id
) == 0)
1998 * We acquire tbl->lock to be nice to the periodic timers and
1999 * make sure they always see a consistent set of values.
2001 write_lock_bh(&tbl
->lock
);
2003 if (tb
[NDTA_PARMS
]) {
2004 struct nlattr
*tbp
[NDTPA_MAX
+1];
2005 struct neigh_parms
*p
;
2008 err
= nla_parse_nested(tbp
, NDTPA_MAX
, tb
[NDTA_PARMS
],
2009 nl_ntbl_parm_policy
);
2011 goto errout_tbl_lock
;
2013 if (tbp
[NDTPA_IFINDEX
])
2014 ifindex
= nla_get_u32(tbp
[NDTPA_IFINDEX
]);
2016 p
= lookup_neigh_parms(tbl
, net
, ifindex
);
2019 goto errout_tbl_lock
;
2022 for (i
= 1; i
<= NDTPA_MAX
; i
++) {
2027 case NDTPA_QUEUE_LEN
:
2028 NEIGH_VAR_SET(p
, QUEUE_LEN_BYTES
,
2029 nla_get_u32(tbp
[i
]) *
2030 SKB_TRUESIZE(ETH_FRAME_LEN
));
2032 case NDTPA_QUEUE_LENBYTES
:
2033 NEIGH_VAR_SET(p
, QUEUE_LEN_BYTES
,
2034 nla_get_u32(tbp
[i
]));
2036 case NDTPA_PROXY_QLEN
:
2037 NEIGH_VAR_SET(p
, PROXY_QLEN
,
2038 nla_get_u32(tbp
[i
]));
2040 case NDTPA_APP_PROBES
:
2041 NEIGH_VAR_SET(p
, APP_PROBES
,
2042 nla_get_u32(tbp
[i
]));
2044 case NDTPA_UCAST_PROBES
:
2045 NEIGH_VAR_SET(p
, UCAST_PROBES
,
2046 nla_get_u32(tbp
[i
]));
2048 case NDTPA_MCAST_PROBES
:
2049 NEIGH_VAR_SET(p
, MCAST_PROBES
,
2050 nla_get_u32(tbp
[i
]));
2052 case NDTPA_BASE_REACHABLE_TIME
:
2053 NEIGH_VAR_SET(p
, BASE_REACHABLE_TIME
,
2054 nla_get_msecs(tbp
[i
]));
2056 case NDTPA_GC_STALETIME
:
2057 NEIGH_VAR_SET(p
, GC_STALETIME
,
2058 nla_get_msecs(tbp
[i
]));
2060 case NDTPA_DELAY_PROBE_TIME
:
2061 NEIGH_VAR_SET(p
, DELAY_PROBE_TIME
,
2062 nla_get_msecs(tbp
[i
]));
2064 case NDTPA_RETRANS_TIME
:
2065 NEIGH_VAR_SET(p
, RETRANS_TIME
,
2066 nla_get_msecs(tbp
[i
]));
2068 case NDTPA_ANYCAST_DELAY
:
2069 NEIGH_VAR_SET(p
, ANYCAST_DELAY
, nla_get_msecs(tbp
[i
]));
2071 case NDTPA_PROXY_DELAY
:
2072 NEIGH_VAR_SET(p
, PROXY_DELAY
, nla_get_msecs(tbp
[i
]));
2074 case NDTPA_LOCKTIME
:
2075 NEIGH_VAR_SET(p
, LOCKTIME
, nla_get_msecs(tbp
[i
]));
2082 if ((tb
[NDTA_THRESH1
] || tb
[NDTA_THRESH2
] ||
2083 tb
[NDTA_THRESH3
] || tb
[NDTA_GC_INTERVAL
]) &&
2084 !net_eq(net
, &init_net
))
2085 goto errout_tbl_lock
;
2087 if (tb
[NDTA_THRESH1
])
2088 tbl
->gc_thresh1
= nla_get_u32(tb
[NDTA_THRESH1
]);
2090 if (tb
[NDTA_THRESH2
])
2091 tbl
->gc_thresh2
= nla_get_u32(tb
[NDTA_THRESH2
]);
2093 if (tb
[NDTA_THRESH3
])
2094 tbl
->gc_thresh3
= nla_get_u32(tb
[NDTA_THRESH3
]);
2096 if (tb
[NDTA_GC_INTERVAL
])
2097 tbl
->gc_interval
= nla_get_msecs(tb
[NDTA_GC_INTERVAL
]);
2102 write_unlock_bh(&tbl
->lock
);
2104 read_unlock(&neigh_tbl_lock
);
2109 static int neightbl_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2111 struct net
*net
= sock_net(skb
->sk
);
2112 int family
, tidx
, nidx
= 0;
2113 int tbl_skip
= cb
->args
[0];
2114 int neigh_skip
= cb
->args
[1];
2115 struct neigh_table
*tbl
;
2117 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2119 read_lock(&neigh_tbl_lock
);
2120 for (tbl
= neigh_tables
, tidx
= 0; tbl
; tbl
= tbl
->next
, tidx
++) {
2121 struct neigh_parms
*p
;
2123 if (tidx
< tbl_skip
|| (family
&& tbl
->family
!= family
))
2126 if (neightbl_fill_info(skb
, tbl
, NETLINK_CB(cb
->skb
).portid
,
2127 cb
->nlh
->nlmsg_seq
, RTM_NEWNEIGHTBL
,
2131 for (nidx
= 0, p
= tbl
->parms
.next
; p
; p
= p
->next
) {
2132 if (!net_eq(neigh_parms_net(p
), net
))
2135 if (nidx
< neigh_skip
)
2138 if (neightbl_fill_param_info(skb
, tbl
, p
,
2139 NETLINK_CB(cb
->skb
).portid
,
2151 read_unlock(&neigh_tbl_lock
);
2158 static int neigh_fill_info(struct sk_buff
*skb
, struct neighbour
*neigh
,
2159 u32 pid
, u32 seq
, int type
, unsigned int flags
)
2161 unsigned long now
= jiffies
;
2162 struct nda_cacheinfo ci
;
2163 struct nlmsghdr
*nlh
;
2166 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2170 ndm
= nlmsg_data(nlh
);
2171 ndm
->ndm_family
= neigh
->ops
->family
;
2174 ndm
->ndm_flags
= neigh
->flags
;
2175 ndm
->ndm_type
= neigh
->type
;
2176 ndm
->ndm_ifindex
= neigh
->dev
->ifindex
;
2178 if (nla_put(skb
, NDA_DST
, neigh
->tbl
->key_len
, neigh
->primary_key
))
2179 goto nla_put_failure
;
2181 read_lock_bh(&neigh
->lock
);
2182 ndm
->ndm_state
= neigh
->nud_state
;
2183 if (neigh
->nud_state
& NUD_VALID
) {
2184 char haddr
[MAX_ADDR_LEN
];
2186 neigh_ha_snapshot(haddr
, neigh
, neigh
->dev
);
2187 if (nla_put(skb
, NDA_LLADDR
, neigh
->dev
->addr_len
, haddr
) < 0) {
2188 read_unlock_bh(&neigh
->lock
);
2189 goto nla_put_failure
;
2193 ci
.ndm_used
= jiffies_to_clock_t(now
- neigh
->used
);
2194 ci
.ndm_confirmed
= jiffies_to_clock_t(now
- neigh
->confirmed
);
2195 ci
.ndm_updated
= jiffies_to_clock_t(now
- neigh
->updated
);
2196 ci
.ndm_refcnt
= atomic_read(&neigh
->refcnt
) - 1;
2197 read_unlock_bh(&neigh
->lock
);
2199 if (nla_put_u32(skb
, NDA_PROBES
, atomic_read(&neigh
->probes
)) ||
2200 nla_put(skb
, NDA_CACHEINFO
, sizeof(ci
), &ci
))
2201 goto nla_put_failure
;
2203 return nlmsg_end(skb
, nlh
);
2206 nlmsg_cancel(skb
, nlh
);
2210 static int pneigh_fill_info(struct sk_buff
*skb
, struct pneigh_entry
*pn
,
2211 u32 pid
, u32 seq
, int type
, unsigned int flags
,
2212 struct neigh_table
*tbl
)
2214 struct nlmsghdr
*nlh
;
2217 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), flags
);
2221 ndm
= nlmsg_data(nlh
);
2222 ndm
->ndm_family
= tbl
->family
;
2225 ndm
->ndm_flags
= pn
->flags
| NTF_PROXY
;
2226 ndm
->ndm_type
= NDA_DST
;
2227 ndm
->ndm_ifindex
= pn
->dev
->ifindex
;
2228 ndm
->ndm_state
= NUD_NONE
;
2230 if (nla_put(skb
, NDA_DST
, tbl
->key_len
, pn
->key
))
2231 goto nla_put_failure
;
2233 return nlmsg_end(skb
, nlh
);
2236 nlmsg_cancel(skb
, nlh
);
2240 static void neigh_update_notify(struct neighbour
*neigh
)
2242 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, neigh
);
2243 __neigh_notify(neigh
, RTM_NEWNEIGH
, 0);
2246 static int neigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2247 struct netlink_callback
*cb
)
2249 struct net
*net
= sock_net(skb
->sk
);
2250 struct neighbour
*n
;
2251 int rc
, h
, s_h
= cb
->args
[1];
2252 int idx
, s_idx
= idx
= cb
->args
[2];
2253 struct neigh_hash_table
*nht
;
2256 nht
= rcu_dereference_bh(tbl
->nht
);
2258 for (h
= s_h
; h
< (1 << nht
->hash_shift
); h
++) {
2261 for (n
= rcu_dereference_bh(nht
->hash_buckets
[h
]), idx
= 0;
2263 n
= rcu_dereference_bh(n
->next
)) {
2264 if (!net_eq(dev_net(n
->dev
), net
))
2268 if (neigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).portid
,
2271 NLM_F_MULTI
) <= 0) {
2281 rcu_read_unlock_bh();
2287 static int pneigh_dump_table(struct neigh_table
*tbl
, struct sk_buff
*skb
,
2288 struct netlink_callback
*cb
)
2290 struct pneigh_entry
*n
;
2291 struct net
*net
= sock_net(skb
->sk
);
2292 int rc
, h
, s_h
= cb
->args
[3];
2293 int idx
, s_idx
= idx
= cb
->args
[4];
2295 read_lock_bh(&tbl
->lock
);
2297 for (h
= s_h
; h
<= PNEIGH_HASHMASK
; h
++) {
2300 for (n
= tbl
->phash_buckets
[h
], idx
= 0; n
; n
= n
->next
) {
2301 if (dev_net(n
->dev
) != net
)
2305 if (pneigh_fill_info(skb
, n
, NETLINK_CB(cb
->skb
).portid
,
2308 NLM_F_MULTI
, tbl
) <= 0) {
2309 read_unlock_bh(&tbl
->lock
);
2318 read_unlock_bh(&tbl
->lock
);
2327 static int neigh_dump_info(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2329 struct neigh_table
*tbl
;
2334 read_lock(&neigh_tbl_lock
);
2335 family
= ((struct rtgenmsg
*) nlmsg_data(cb
->nlh
))->rtgen_family
;
2337 /* check for full ndmsg structure presence, family member is
2338 * the same for both structures
2340 if (nlmsg_len(cb
->nlh
) >= sizeof(struct ndmsg
) &&
2341 ((struct ndmsg
*) nlmsg_data(cb
->nlh
))->ndm_flags
== NTF_PROXY
)
2346 for (tbl
= neigh_tables
, t
= 0; tbl
;
2347 tbl
= tbl
->next
, t
++) {
2348 if (t
< s_t
|| (family
&& tbl
->family
!= family
))
2351 memset(&cb
->args
[1], 0, sizeof(cb
->args
) -
2352 sizeof(cb
->args
[0]));
2354 err
= pneigh_dump_table(tbl
, skb
, cb
);
2356 err
= neigh_dump_table(tbl
, skb
, cb
);
2360 read_unlock(&neigh_tbl_lock
);
2366 void neigh_for_each(struct neigh_table
*tbl
, void (*cb
)(struct neighbour
*, void *), void *cookie
)
2369 struct neigh_hash_table
*nht
;
2372 nht
= rcu_dereference_bh(tbl
->nht
);
2374 read_lock(&tbl
->lock
); /* avoid resizes */
2375 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2376 struct neighbour
*n
;
2378 for (n
= rcu_dereference_bh(nht
->hash_buckets
[chain
]);
2380 n
= rcu_dereference_bh(n
->next
))
2383 read_unlock(&tbl
->lock
);
2384 rcu_read_unlock_bh();
2386 EXPORT_SYMBOL(neigh_for_each
);
2388 /* The tbl->lock must be held as a writer and BH disabled. */
2389 void __neigh_for_each_release(struct neigh_table
*tbl
,
2390 int (*cb
)(struct neighbour
*))
2393 struct neigh_hash_table
*nht
;
2395 nht
= rcu_dereference_protected(tbl
->nht
,
2396 lockdep_is_held(&tbl
->lock
));
2397 for (chain
= 0; chain
< (1 << nht
->hash_shift
); chain
++) {
2398 struct neighbour
*n
;
2399 struct neighbour __rcu
**np
;
2401 np
= &nht
->hash_buckets
[chain
];
2402 while ((n
= rcu_dereference_protected(*np
,
2403 lockdep_is_held(&tbl
->lock
))) != NULL
) {
2406 write_lock(&n
->lock
);
2409 rcu_assign_pointer(*np
,
2410 rcu_dereference_protected(n
->next
,
2411 lockdep_is_held(&tbl
->lock
)));
2415 write_unlock(&n
->lock
);
2417 neigh_cleanup_and_release(n
);
2421 EXPORT_SYMBOL(__neigh_for_each_release
);
2423 #ifdef CONFIG_PROC_FS
2425 static struct neighbour
*neigh_get_first(struct seq_file
*seq
)
2427 struct neigh_seq_state
*state
= seq
->private;
2428 struct net
*net
= seq_file_net(seq
);
2429 struct neigh_hash_table
*nht
= state
->nht
;
2430 struct neighbour
*n
= NULL
;
2431 int bucket
= state
->bucket
;
2433 state
->flags
&= ~NEIGH_SEQ_IS_PNEIGH
;
2434 for (bucket
= 0; bucket
< (1 << nht
->hash_shift
); bucket
++) {
2435 n
= rcu_dereference_bh(nht
->hash_buckets
[bucket
]);
2438 if (!net_eq(dev_net(n
->dev
), net
))
2440 if (state
->neigh_sub_iter
) {
2444 v
= state
->neigh_sub_iter(state
, n
, &fakep
);
2448 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2450 if (n
->nud_state
& ~NUD_NOARP
)
2453 n
= rcu_dereference_bh(n
->next
);
2459 state
->bucket
= bucket
;
2464 static struct neighbour
*neigh_get_next(struct seq_file
*seq
,
2465 struct neighbour
*n
,
2468 struct neigh_seq_state
*state
= seq
->private;
2469 struct net
*net
= seq_file_net(seq
);
2470 struct neigh_hash_table
*nht
= state
->nht
;
2472 if (state
->neigh_sub_iter
) {
2473 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2477 n
= rcu_dereference_bh(n
->next
);
2481 if (!net_eq(dev_net(n
->dev
), net
))
2483 if (state
->neigh_sub_iter
) {
2484 void *v
= state
->neigh_sub_iter(state
, n
, pos
);
2489 if (!(state
->flags
& NEIGH_SEQ_SKIP_NOARP
))
2492 if (n
->nud_state
& ~NUD_NOARP
)
2495 n
= rcu_dereference_bh(n
->next
);
2501 if (++state
->bucket
>= (1 << nht
->hash_shift
))
2504 n
= rcu_dereference_bh(nht
->hash_buckets
[state
->bucket
]);
2512 static struct neighbour
*neigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2514 struct neighbour
*n
= neigh_get_first(seq
);
2519 n
= neigh_get_next(seq
, n
, pos
);
2524 return *pos
? NULL
: n
;
2527 static struct pneigh_entry
*pneigh_get_first(struct seq_file
*seq
)
2529 struct neigh_seq_state
*state
= seq
->private;
2530 struct net
*net
= seq_file_net(seq
);
2531 struct neigh_table
*tbl
= state
->tbl
;
2532 struct pneigh_entry
*pn
= NULL
;
2533 int bucket
= state
->bucket
;
2535 state
->flags
|= NEIGH_SEQ_IS_PNEIGH
;
2536 for (bucket
= 0; bucket
<= PNEIGH_HASHMASK
; bucket
++) {
2537 pn
= tbl
->phash_buckets
[bucket
];
2538 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2543 state
->bucket
= bucket
;
2548 static struct pneigh_entry
*pneigh_get_next(struct seq_file
*seq
,
2549 struct pneigh_entry
*pn
,
2552 struct neigh_seq_state
*state
= seq
->private;
2553 struct net
*net
= seq_file_net(seq
);
2554 struct neigh_table
*tbl
= state
->tbl
;
2558 } while (pn
&& !net_eq(pneigh_net(pn
), net
));
2561 if (++state
->bucket
> PNEIGH_HASHMASK
)
2563 pn
= tbl
->phash_buckets
[state
->bucket
];
2564 while (pn
&& !net_eq(pneigh_net(pn
), net
))
2576 static struct pneigh_entry
*pneigh_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2578 struct pneigh_entry
*pn
= pneigh_get_first(seq
);
2583 pn
= pneigh_get_next(seq
, pn
, pos
);
2588 return *pos
? NULL
: pn
;
2591 static void *neigh_get_idx_any(struct seq_file
*seq
, loff_t
*pos
)
2593 struct neigh_seq_state
*state
= seq
->private;
2595 loff_t idxpos
= *pos
;
2597 rc
= neigh_get_idx(seq
, &idxpos
);
2598 if (!rc
&& !(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2599 rc
= pneigh_get_idx(seq
, &idxpos
);
2604 void *neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
, struct neigh_table
*tbl
, unsigned int neigh_seq_flags
)
2607 struct neigh_seq_state
*state
= seq
->private;
2611 state
->flags
= (neigh_seq_flags
& ~NEIGH_SEQ_IS_PNEIGH
);
2614 state
->nht
= rcu_dereference_bh(tbl
->nht
);
2616 return *pos
? neigh_get_idx_any(seq
, pos
) : SEQ_START_TOKEN
;
2618 EXPORT_SYMBOL(neigh_seq_start
);
2620 void *neigh_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2622 struct neigh_seq_state
*state
;
2625 if (v
== SEQ_START_TOKEN
) {
2626 rc
= neigh_get_first(seq
);
2630 state
= seq
->private;
2631 if (!(state
->flags
& NEIGH_SEQ_IS_PNEIGH
)) {
2632 rc
= neigh_get_next(seq
, v
, NULL
);
2635 if (!(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
))
2636 rc
= pneigh_get_first(seq
);
2638 BUG_ON(state
->flags
& NEIGH_SEQ_NEIGH_ONLY
);
2639 rc
= pneigh_get_next(seq
, v
, NULL
);
2645 EXPORT_SYMBOL(neigh_seq_next
);
2647 void neigh_seq_stop(struct seq_file
*seq
, void *v
)
2650 rcu_read_unlock_bh();
2652 EXPORT_SYMBOL(neigh_seq_stop
);
2654 /* statistics via seq_file */
2656 static void *neigh_stat_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2658 struct neigh_table
*tbl
= seq
->private;
2662 return SEQ_START_TOKEN
;
2664 for (cpu
= *pos
-1; cpu
< nr_cpu_ids
; ++cpu
) {
2665 if (!cpu_possible(cpu
))
2668 return per_cpu_ptr(tbl
->stats
, cpu
);
2673 static void *neigh_stat_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2675 struct neigh_table
*tbl
= seq
->private;
2678 for (cpu
= *pos
; cpu
< nr_cpu_ids
; ++cpu
) {
2679 if (!cpu_possible(cpu
))
2682 return per_cpu_ptr(tbl
->stats
, cpu
);
2687 static void neigh_stat_seq_stop(struct seq_file
*seq
, void *v
)
2692 static int neigh_stat_seq_show(struct seq_file
*seq
, void *v
)
2694 struct neigh_table
*tbl
= seq
->private;
2695 struct neigh_statistics
*st
= v
;
2697 if (v
== SEQ_START_TOKEN
) {
2698 seq_printf(seq
, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs unresolved_discards\n");
2702 seq_printf(seq
, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2703 "%08lx %08lx %08lx %08lx %08lx\n",
2704 atomic_read(&tbl
->entries
),
2715 st
->rcv_probes_mcast
,
2716 st
->rcv_probes_ucast
,
2718 st
->periodic_gc_runs
,
2726 static const struct seq_operations neigh_stat_seq_ops
= {
2727 .start
= neigh_stat_seq_start
,
2728 .next
= neigh_stat_seq_next
,
2729 .stop
= neigh_stat_seq_stop
,
2730 .show
= neigh_stat_seq_show
,
2733 static int neigh_stat_seq_open(struct inode
*inode
, struct file
*file
)
2735 int ret
= seq_open(file
, &neigh_stat_seq_ops
);
2738 struct seq_file
*sf
= file
->private_data
;
2739 sf
->private = PDE_DATA(inode
);
2744 static const struct file_operations neigh_stat_seq_fops
= {
2745 .owner
= THIS_MODULE
,
2746 .open
= neigh_stat_seq_open
,
2748 .llseek
= seq_lseek
,
2749 .release
= seq_release
,
2752 #endif /* CONFIG_PROC_FS */
2754 static inline size_t neigh_nlmsg_size(void)
2756 return NLMSG_ALIGN(sizeof(struct ndmsg
))
2757 + nla_total_size(MAX_ADDR_LEN
) /* NDA_DST */
2758 + nla_total_size(MAX_ADDR_LEN
) /* NDA_LLADDR */
2759 + nla_total_size(sizeof(struct nda_cacheinfo
))
2760 + nla_total_size(4); /* NDA_PROBES */
2763 static void __neigh_notify(struct neighbour
*n
, int type
, int flags
)
2765 struct net
*net
= dev_net(n
->dev
);
2766 struct sk_buff
*skb
;
2769 skb
= nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC
);
2773 err
= neigh_fill_info(skb
, n
, 0, 0, type
, flags
);
2775 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2776 WARN_ON(err
== -EMSGSIZE
);
2780 rtnl_notify(skb
, net
, 0, RTNLGRP_NEIGH
, NULL
, GFP_ATOMIC
);
2784 rtnl_set_sk_err(net
, RTNLGRP_NEIGH
, err
);
2787 void neigh_app_ns(struct neighbour
*n
)
2789 __neigh_notify(n
, RTM_GETNEIGH
, NLM_F_REQUEST
);
2791 EXPORT_SYMBOL(neigh_app_ns
);
2793 #ifdef CONFIG_SYSCTL
2795 static int int_max
= INT_MAX
;
2796 static int unres_qlen_max
= INT_MAX
/ SKB_TRUESIZE(ETH_FRAME_LEN
);
2798 static int proc_unres_qlen(struct ctl_table
*ctl
, int write
,
2799 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2802 struct ctl_table tmp
= *ctl
;
2805 tmp
.extra2
= &unres_qlen_max
;
2808 size
= *(int *)ctl
->data
/ SKB_TRUESIZE(ETH_FRAME_LEN
);
2809 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
2812 *(int *)ctl
->data
= size
* SKB_TRUESIZE(ETH_FRAME_LEN
);
2816 static int neigh_proc_dointvec_zero_intmax(struct ctl_table
*ctl
, int write
,
2817 void __user
*buffer
,
2818 size_t *lenp
, loff_t
*ppos
)
2820 struct ctl_table tmp
= *ctl
;
2823 tmp
.extra2
= &int_max
;
2825 return proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
2828 int neigh_proc_dointvec(struct ctl_table
*ctl
, int write
,
2829 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2831 return proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2833 EXPORT_SYMBOL(neigh_proc_dointvec
);
2835 int neigh_proc_dointvec_jiffies(struct ctl_table
*ctl
, int write
,
2836 void __user
*buffer
,
2837 size_t *lenp
, loff_t
*ppos
)
2839 return proc_dointvec_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2841 EXPORT_SYMBOL(neigh_proc_dointvec_jiffies
);
2843 static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table
*ctl
, int write
,
2844 void __user
*buffer
,
2845 size_t *lenp
, loff_t
*ppos
)
2847 return proc_dointvec_userhz_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2850 int neigh_proc_dointvec_ms_jiffies(struct ctl_table
*ctl
, int write
,
2851 void __user
*buffer
,
2852 size_t *lenp
, loff_t
*ppos
)
2854 return proc_dointvec_ms_jiffies(ctl
, write
, buffer
, lenp
, ppos
);
2856 EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies
);
2858 static int neigh_proc_dointvec_unres_qlen(struct ctl_table
*ctl
, int write
,
2859 void __user
*buffer
,
2860 size_t *lenp
, loff_t
*ppos
)
2862 return proc_unres_qlen(ctl
, write
, buffer
, lenp
, ppos
);
2865 #define NEIGH_PARMS_DATA_OFFSET(index) \
2866 (&((struct neigh_parms *) 0)->data[index])
2868 #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \
2869 [NEIGH_VAR_ ## attr] = { \
2871 .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \
2872 .maxlen = sizeof(int), \
2874 .proc_handler = proc, \
2877 #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \
2878 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax)
2880 #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \
2881 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies)
2883 #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \
2884 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies)
2886 #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \
2887 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
2889 #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \
2890 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
2892 #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \
2893 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen)
2895 static struct neigh_sysctl_table
{
2896 struct ctl_table_header
*sysctl_header
;
2897 struct ctl_table neigh_vars
[NEIGH_VAR_MAX
+ 1];
2898 } neigh_sysctl_template __read_mostly
= {
2900 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES
, "mcast_solicit"),
2901 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES
, "ucast_solicit"),
2902 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES
, "app_solicit"),
2903 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME
, "retrans_time"),
2904 NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME
, "base_reachable_time"),
2905 NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME
, "delay_first_probe_time"),
2906 NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME
, "gc_stale_time"),
2907 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES
, "unres_qlen_bytes"),
2908 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN
, "proxy_qlen"),
2909 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY
, "anycast_delay"),
2910 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY
, "proxy_delay"),
2911 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME
, "locktime"),
2912 NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN
, QUEUE_LEN_BYTES
, "unres_qlen"),
2913 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS
, RETRANS_TIME
, "retrans_time_ms"),
2914 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS
, BASE_REACHABLE_TIME
, "base_reachable_time_ms"),
2915 [NEIGH_VAR_GC_INTERVAL
] = {
2916 .procname
= "gc_interval",
2917 .maxlen
= sizeof(int),
2919 .proc_handler
= proc_dointvec_jiffies
,
2921 [NEIGH_VAR_GC_THRESH1
] = {
2922 .procname
= "gc_thresh1",
2923 .maxlen
= sizeof(int),
2927 .proc_handler
= proc_dointvec_minmax
,
2929 [NEIGH_VAR_GC_THRESH2
] = {
2930 .procname
= "gc_thresh2",
2931 .maxlen
= sizeof(int),
2935 .proc_handler
= proc_dointvec_minmax
,
2937 [NEIGH_VAR_GC_THRESH3
] = {
2938 .procname
= "gc_thresh3",
2939 .maxlen
= sizeof(int),
2943 .proc_handler
= proc_dointvec_minmax
,
2949 int neigh_sysctl_register(struct net_device
*dev
, struct neigh_parms
*p
,
2950 char *p_name
, proc_handler
*handler
)
2953 struct neigh_sysctl_table
*t
;
2954 const char *dev_name_source
;
2955 char neigh_path
[ sizeof("net//neigh/") + IFNAMSIZ
+ IFNAMSIZ
];
2957 t
= kmemdup(&neigh_sysctl_template
, sizeof(*t
), GFP_KERNEL
);
2961 for (i
= 0; i
< ARRAY_SIZE(t
->neigh_vars
); i
++) {
2962 t
->neigh_vars
[i
].data
+= (long) p
;
2963 t
->neigh_vars
[i
].extra1
= dev
;
2967 dev_name_source
= dev
->name
;
2968 /* Terminate the table early */
2969 memset(&t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
], 0,
2970 sizeof(t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
]));
2972 dev_name_source
= "default";
2973 t
->neigh_vars
[NEIGH_VAR_GC_INTERVAL
].data
= (int *)(p
+ 1);
2974 t
->neigh_vars
[NEIGH_VAR_GC_THRESH1
].data
= (int *)(p
+ 1) + 1;
2975 t
->neigh_vars
[NEIGH_VAR_GC_THRESH2
].data
= (int *)(p
+ 1) + 2;
2976 t
->neigh_vars
[NEIGH_VAR_GC_THRESH3
].data
= (int *)(p
+ 1) + 3;
2981 t
->neigh_vars
[NEIGH_VAR_RETRANS_TIME
].proc_handler
= handler
;
2983 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME
].proc_handler
= handler
;
2984 /* RetransTime (in milliseconds)*/
2985 t
->neigh_vars
[NEIGH_VAR_RETRANS_TIME_MS
].proc_handler
= handler
;
2986 /* ReachableTime (in milliseconds) */
2987 t
->neigh_vars
[NEIGH_VAR_BASE_REACHABLE_TIME_MS
].proc_handler
= handler
;
2990 /* Don't export sysctls to unprivileged users */
2991 if (neigh_parms_net(p
)->user_ns
!= &init_user_ns
)
2992 t
->neigh_vars
[0].procname
= NULL
;
2994 snprintf(neigh_path
, sizeof(neigh_path
), "net/%s/neigh/%s",
2995 p_name
, dev_name_source
);
2997 register_net_sysctl(neigh_parms_net(p
), neigh_path
, t
->neigh_vars
);
2998 if (!t
->sysctl_header
)
3001 p
->sysctl_table
= t
;
3009 EXPORT_SYMBOL(neigh_sysctl_register
);
3011 void neigh_sysctl_unregister(struct neigh_parms
*p
)
3013 if (p
->sysctl_table
) {
3014 struct neigh_sysctl_table
*t
= p
->sysctl_table
;
3015 p
->sysctl_table
= NULL
;
3016 unregister_net_sysctl_table(t
->sysctl_header
);
3020 EXPORT_SYMBOL(neigh_sysctl_unregister
);
3022 #endif /* CONFIG_SYSCTL */
3024 static int __init
neigh_init(void)
3026 rtnl_register(PF_UNSPEC
, RTM_NEWNEIGH
, neigh_add
, NULL
, NULL
);
3027 rtnl_register(PF_UNSPEC
, RTM_DELNEIGH
, neigh_delete
, NULL
, NULL
);
3028 rtnl_register(PF_UNSPEC
, RTM_GETNEIGH
, NULL
, neigh_dump_info
, NULL
);
3030 rtnl_register(PF_UNSPEC
, RTM_GETNEIGHTBL
, NULL
, neightbl_dump_info
,
3032 rtnl_register(PF_UNSPEC
, RTM_SETNEIGHTBL
, neightbl_set
, NULL
, NULL
);
3037 subsys_initcall(neigh_init
);