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/config.h>
19 #include <linux/types.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/socket.h>
23 #include <linux/sched.h>
24 #include <linux/netdevice.h>
25 #include <linux/proc_fs.h>
27 #include <linux/sysctl.h>
29 #include <linux/times.h>
30 #include <net/neighbour.h>
33 #include <linux/rtnetlink.h>
34 #include <linux/random.h>
35 #include <linux/string.h>
39 #define NEIGH_PRINTK(x...) printk(x)
40 #define NEIGH_NOPRINTK(x...) do { ; } while(0)
41 #define NEIGH_PRINTK0 NEIGH_PRINTK
42 #define NEIGH_PRINTK1 NEIGH_NOPRINTK
43 #define NEIGH_PRINTK2 NEIGH_NOPRINTK
47 #define NEIGH_PRINTK1 NEIGH_PRINTK
51 #define NEIGH_PRINTK2 NEIGH_PRINTK
54 #define PNEIGH_HASHMASK 0xF
56 static void neigh_timer_handler(unsigned long arg);
58 static void neigh_app_notify(struct neighbour *n);
60 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
61 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
63 static struct neigh_table *neigh_tables;
65 static struct file_operations neigh_stat_seq_fops;
69 Neighbour hash table buckets are protected with rwlock tbl->lock.
71 - All the scans/updates to hash buckets MUST be made under this lock.
72 - NOTHING clever should be made under this lock: no callbacks
73 to protocol backends, no attempts to send something to network.
74 It will result in deadlocks, if backend/driver wants to use neighbour
76 - If the entry requires some non-trivial actions, increase
77 its reference count and release table lock.
79 Neighbour entries are protected:
80 - with reference count.
81 - with rwlock neigh->lock
83 Reference count prevents destruction.
85 neigh->lock mainly serializes ll address data and its validity state.
86 However, the same lock is used to protect another entry fields:
90 Again, nothing clever shall be made under neigh->lock,
91 the most complicated procedure, which we allow is dev->hard_header.
92 It is supposed, that dev->hard_header is simplistic and does
93 not make callbacks to neighbour tables.
95 The last lock is neigh_tbl_lock. It is pure SMP lock, protecting
96 list of neighbour tables. This list is used only in process context,
99 static DEFINE_RWLOCK(neigh_tbl_lock);
101 static int neigh_blackhole(struct sk_buff *skb)
108 * It is random distribution in the interval (1/2)*base...(3/2)*base.
109 * It corresponds to default IPv6 settings and is not overridable,
110 * because it is really reasonable choice.
113 unsigned long neigh_rand_reach_time(unsigned long base)
115 return (base ? (net_random() % base) + (base >> 1) : 0);
119 static int neigh_forced_gc(struct neigh_table *tbl)
124 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
126 write_lock_bh(&tbl->lock);
127 for (i = 0; i <= tbl->hash_mask; i++) {
128 struct neighbour *n, **np;
130 np = &tbl->hash_buckets[i];
131 while ((n = *np) != NULL) {
132 /* Neighbour record may be discarded if:
133 * - nobody refers to it.
134 * - it is not permanent
136 write_lock(&n->lock);
137 if (atomic_read(&n->refcnt) == 1 &&
138 !(n->nud_state & NUD_PERMANENT)) {
142 write_unlock(&n->lock);
146 write_unlock(&n->lock);
151 tbl->last_flush = jiffies;
153 write_unlock_bh(&tbl->lock);
158 static int neigh_del_timer(struct neighbour *n)
160 if ((n->nud_state & NUD_IN_TIMER) &&
161 del_timer(&n->timer)) {
168 static void pneigh_queue_purge(struct sk_buff_head *list)
172 while ((skb = skb_dequeue(list)) != NULL) {
178 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
182 write_lock_bh(&tbl->lock);
184 for (i=0; i <= tbl->hash_mask; i++) {
185 struct neighbour *n, **np;
187 np = &tbl->hash_buckets[i];
188 while ((n = *np) != NULL) {
189 if (dev && n->dev != dev) {
194 write_lock_bh(&n->lock);
197 write_unlock_bh(&n->lock);
202 write_unlock_bh(&tbl->lock);
205 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
209 write_lock_bh(&tbl->lock);
211 for (i = 0; i <= tbl->hash_mask; i++) {
212 struct neighbour *n, **np = &tbl->hash_buckets[i];
214 while ((n = *np) != NULL) {
215 if (dev && n->dev != dev) {
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->output = neigh_blackhole;
236 if (n->nud_state & NUD_VALID)
237 n->nud_state = NUD_NOARP;
239 n->nud_state = NUD_NONE;
240 NEIGH_PRINTK2("neigh %p is stray.\n", n);
242 write_unlock(&n->lock);
247 pneigh_ifdown(tbl, dev);
248 write_unlock_bh(&tbl->lock);
250 del_timer_sync(&tbl->proxy_timer);
251 pneigh_queue_purge(&tbl->proxy_queue);
255 static struct neighbour *neigh_alloc(struct neigh_table *tbl)
257 struct neighbour *n = NULL;
258 unsigned long now = jiffies;
261 entries = atomic_inc_return(&tbl->entries) - 1;
262 if (entries >= tbl->gc_thresh3 ||
263 (entries >= tbl->gc_thresh2 &&
264 time_after(now, tbl->last_flush + 5 * HZ))) {
265 if (!neigh_forced_gc(tbl) &&
266 entries >= tbl->gc_thresh3)
270 n = kmem_cache_alloc(tbl->kmem_cachep, SLAB_ATOMIC);
274 memset(n, 0, tbl->entry_size);
276 skb_queue_head_init(&n->arp_queue);
277 rwlock_init(&n->lock);
278 n->updated = n->used = now;
279 n->nud_state = NUD_NONE;
280 n->output = neigh_blackhole;
281 n->parms = neigh_parms_clone(&tbl->parms);
282 init_timer(&n->timer);
283 n->timer.function = neigh_timer_handler;
284 n->timer.data = (unsigned long)n;
286 NEIGH_CACHE_STAT_INC(tbl, allocs);
288 atomic_set(&n->refcnt, 1);
294 atomic_dec(&tbl->entries);
298 static struct neighbour **neigh_hash_alloc(unsigned int entries)
300 unsigned long size = entries * sizeof(struct neighbour *);
301 struct neighbour **ret;
303 if (size <= PAGE_SIZE) {
304 ret = kmalloc(size, GFP_ATOMIC);
306 ret = (struct neighbour **)
307 __get_free_pages(GFP_ATOMIC, get_order(size));
310 memset(ret, 0, size);
315 static void neigh_hash_free(struct neighbour **hash, unsigned int entries)
317 unsigned long size = entries * sizeof(struct neighbour *);
319 if (size <= PAGE_SIZE)
322 free_pages((unsigned long)hash, get_order(size));
325 static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries)
327 struct neighbour **new_hash, **old_hash;
328 unsigned int i, new_hash_mask, old_entries;
330 NEIGH_CACHE_STAT_INC(tbl, hash_grows);
332 BUG_ON(new_entries & (new_entries - 1));
333 new_hash = neigh_hash_alloc(new_entries);
337 old_entries = tbl->hash_mask + 1;
338 new_hash_mask = new_entries - 1;
339 old_hash = tbl->hash_buckets;
341 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
342 for (i = 0; i < old_entries; i++) {
343 struct neighbour *n, *next;
345 for (n = old_hash[i]; n; n = next) {
346 unsigned int hash_val = tbl->hash(n->primary_key, n->dev);
348 hash_val &= new_hash_mask;
351 n->next = new_hash[hash_val];
352 new_hash[hash_val] = n;
355 tbl->hash_buckets = new_hash;
356 tbl->hash_mask = new_hash_mask;
358 neigh_hash_free(old_hash, old_entries);
361 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
362 struct net_device *dev)
365 int key_len = tbl->key_len;
366 u32 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;
368 NEIGH_CACHE_STAT_INC(tbl, lookups);
370 read_lock_bh(&tbl->lock);
371 for (n = tbl->hash_buckets[hash_val]; n; n = n->next) {
372 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
374 NEIGH_CACHE_STAT_INC(tbl, hits);
378 read_unlock_bh(&tbl->lock);
382 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, const void *pkey)
385 int key_len = tbl->key_len;
386 u32 hash_val = tbl->hash(pkey, NULL) & tbl->hash_mask;
388 NEIGH_CACHE_STAT_INC(tbl, lookups);
390 read_lock_bh(&tbl->lock);
391 for (n = tbl->hash_buckets[hash_val]; n; n = n->next) {
392 if (!memcmp(n->primary_key, pkey, key_len)) {
394 NEIGH_CACHE_STAT_INC(tbl, hits);
398 read_unlock_bh(&tbl->lock);
402 struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey,
403 struct net_device *dev)
406 int key_len = tbl->key_len;
408 struct neighbour *n1, *rc, *n = neigh_alloc(tbl);
411 rc = ERR_PTR(-ENOBUFS);
415 memcpy(n->primary_key, pkey, key_len);
419 /* Protocol specific setup. */
420 if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
422 goto out_neigh_release;
425 /* Device specific setup. */
426 if (n->parms->neigh_setup &&
427 (error = n->parms->neigh_setup(n)) < 0) {
429 goto out_neigh_release;
432 n->confirmed = jiffies - (n->parms->base_reachable_time << 1);
434 write_lock_bh(&tbl->lock);
436 if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1))
437 neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1);
439 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;
441 if (n->parms->dead) {
442 rc = ERR_PTR(-EINVAL);
446 for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) {
447 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
454 n->next = tbl->hash_buckets[hash_val];
455 tbl->hash_buckets[hash_val] = n;
458 write_unlock_bh(&tbl->lock);
459 NEIGH_PRINTK2("neigh %p is created.\n", n);
464 write_unlock_bh(&tbl->lock);
470 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, const void *pkey,
471 struct net_device *dev, int creat)
473 struct pneigh_entry *n;
474 int key_len = tbl->key_len;
475 u32 hash_val = *(u32 *)(pkey + key_len - 4);
477 hash_val ^= (hash_val >> 16);
478 hash_val ^= hash_val >> 8;
479 hash_val ^= hash_val >> 4;
480 hash_val &= PNEIGH_HASHMASK;
482 read_lock_bh(&tbl->lock);
484 for (n = tbl->phash_buckets[hash_val]; n; n = n->next) {
485 if (!memcmp(n->key, pkey, key_len) &&
486 (n->dev == dev || !n->dev)) {
487 read_unlock_bh(&tbl->lock);
491 read_unlock_bh(&tbl->lock);
496 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
500 memcpy(n->key, pkey, key_len);
505 if (tbl->pconstructor && tbl->pconstructor(n)) {
513 write_lock_bh(&tbl->lock);
514 n->next = tbl->phash_buckets[hash_val];
515 tbl->phash_buckets[hash_val] = n;
516 write_unlock_bh(&tbl->lock);
522 int pneigh_delete(struct neigh_table *tbl, const void *pkey,
523 struct net_device *dev)
525 struct pneigh_entry *n, **np;
526 int key_len = tbl->key_len;
527 u32 hash_val = *(u32 *)(pkey + key_len - 4);
529 hash_val ^= (hash_val >> 16);
530 hash_val ^= hash_val >> 8;
531 hash_val ^= hash_val >> 4;
532 hash_val &= PNEIGH_HASHMASK;
534 write_lock_bh(&tbl->lock);
535 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
537 if (!memcmp(n->key, pkey, key_len) && n->dev == dev) {
539 write_unlock_bh(&tbl->lock);
540 if (tbl->pdestructor)
548 write_unlock_bh(&tbl->lock);
552 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
554 struct pneigh_entry *n, **np;
557 for (h = 0; h <= PNEIGH_HASHMASK; h++) {
558 np = &tbl->phash_buckets[h];
559 while ((n = *np) != NULL) {
560 if (!dev || n->dev == dev) {
562 if (tbl->pdestructor)
577 * neighbour must already be out of the table;
580 void neigh_destroy(struct neighbour *neigh)
584 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
588 "Destroying alive neighbour %p\n", neigh);
593 if (neigh_del_timer(neigh))
594 printk(KERN_WARNING "Impossible event.\n");
596 while ((hh = neigh->hh) != NULL) {
597 neigh->hh = hh->hh_next;
599 write_lock_bh(&hh->hh_lock);
600 hh->hh_output = neigh_blackhole;
601 write_unlock_bh(&hh->hh_lock);
602 if (atomic_dec_and_test(&hh->hh_refcnt))
606 if (neigh->ops && neigh->ops->destructor)
607 (neigh->ops->destructor)(neigh);
609 skb_queue_purge(&neigh->arp_queue);
612 neigh_parms_put(neigh->parms);
614 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh);
616 atomic_dec(&neigh->tbl->entries);
617 kmem_cache_free(neigh->tbl->kmem_cachep, neigh);
620 /* Neighbour state is suspicious;
623 Called with write_locked neigh.
625 static void neigh_suspect(struct neighbour *neigh)
629 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
631 neigh->output = neigh->ops->output;
633 for (hh = neigh->hh; hh; hh = hh->hh_next)
634 hh->hh_output = neigh->ops->output;
637 /* Neighbour state is OK;
640 Called with write_locked neigh.
642 static void neigh_connect(struct neighbour *neigh)
646 NEIGH_PRINTK2("neigh %p is connected.\n", neigh);
648 neigh->output = neigh->ops->connected_output;
650 for (hh = neigh->hh; hh; hh = hh->hh_next)
651 hh->hh_output = neigh->ops->hh_output;
654 static void neigh_periodic_timer(unsigned long arg)
656 struct neigh_table *tbl = (struct neigh_table *)arg;
657 struct neighbour *n, **np;
658 unsigned long expire, now = jiffies;
660 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
662 write_lock(&tbl->lock);
665 * periodically recompute ReachableTime from random function
668 if (time_after(now, tbl->last_rand + 300 * HZ)) {
669 struct neigh_parms *p;
670 tbl->last_rand = now;
671 for (p = &tbl->parms; p; p = p->next)
673 neigh_rand_reach_time(p->base_reachable_time);
676 np = &tbl->hash_buckets[tbl->hash_chain_gc];
677 tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask);
679 while ((n = *np) != NULL) {
682 write_lock(&n->lock);
684 state = n->nud_state;
685 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
686 write_unlock(&n->lock);
690 if (time_before(n->used, n->confirmed))
691 n->used = n->confirmed;
693 if (atomic_read(&n->refcnt) == 1 &&
694 (state == NUD_FAILED ||
695 time_after(now, n->used + n->parms->gc_staletime))) {
698 write_unlock(&n->lock);
702 write_unlock(&n->lock);
708 /* Cycle through all hash buckets every base_reachable_time/2 ticks.
709 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
710 * base_reachable_time.
712 expire = tbl->parms.base_reachable_time >> 1;
713 expire /= (tbl->hash_mask + 1);
717 mod_timer(&tbl->gc_timer, now + expire);
719 write_unlock(&tbl->lock);
722 static __inline__ int neigh_max_probes(struct neighbour *n)
724 struct neigh_parms *p = n->parms;
725 return (n->nud_state & NUD_PROBE ?
727 p->ucast_probes + p->app_probes + p->mcast_probes);
731 /* Called when a timer expires for a neighbour entry. */
733 static void neigh_timer_handler(unsigned long arg)
735 unsigned long now, next;
736 struct neighbour *neigh = (struct neighbour *)arg;
740 write_lock(&neigh->lock);
742 state = neigh->nud_state;
746 if (!(state & NUD_IN_TIMER)) {
748 printk(KERN_WARNING "neigh: timer & !nud_in_timer\n");
753 if (state & NUD_REACHABLE) {
754 if (time_before_eq(now,
755 neigh->confirmed + neigh->parms->reachable_time)) {
756 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh);
757 next = neigh->confirmed + neigh->parms->reachable_time;
758 } else if (time_before_eq(now,
759 neigh->used + neigh->parms->delay_probe_time)) {
760 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
761 neigh->nud_state = NUD_DELAY;
762 neigh_suspect(neigh);
763 next = now + neigh->parms->delay_probe_time;
765 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
766 neigh->nud_state = NUD_STALE;
767 neigh_suspect(neigh);
769 } else if (state & NUD_DELAY) {
770 if (time_before_eq(now,
771 neigh->confirmed + neigh->parms->delay_probe_time)) {
772 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh);
773 neigh->nud_state = NUD_REACHABLE;
774 neigh_connect(neigh);
775 next = neigh->confirmed + neigh->parms->reachable_time;
777 NEIGH_PRINTK2("neigh %p is probed.\n", neigh);
778 neigh->nud_state = NUD_PROBE;
779 atomic_set(&neigh->probes, 0);
780 next = now + neigh->parms->retrans_time;
783 /* NUD_PROBE|NUD_INCOMPLETE */
784 next = now + neigh->parms->retrans_time;
787 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
788 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
791 neigh->nud_state = NUD_FAILED;
793 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
794 NEIGH_PRINTK2("neigh %p is failed.\n", neigh);
796 /* It is very thin place. report_unreachable is very complicated
797 routine. Particularly, it can hit the same neighbour entry!
799 So that, we try to be accurate and avoid dead loop. --ANK
801 while (neigh->nud_state == NUD_FAILED &&
802 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
803 write_unlock(&neigh->lock);
804 neigh->ops->error_report(neigh, skb);
805 write_lock(&neigh->lock);
807 skb_queue_purge(&neigh->arp_queue);
810 if (neigh->nud_state & NUD_IN_TIMER) {
812 if (time_before(next, jiffies + HZ/2))
813 next = jiffies + HZ/2;
814 neigh->timer.expires = next;
815 add_timer(&neigh->timer);
817 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
818 struct sk_buff *skb = skb_peek(&neigh->arp_queue);
819 /* keep skb alive even if arp_queue overflows */
822 write_unlock(&neigh->lock);
823 neigh->ops->solicit(neigh, skb);
824 atomic_inc(&neigh->probes);
829 write_unlock(&neigh->lock);
833 if (notify && neigh->parms->app_probes)
834 neigh_app_notify(neigh);
836 neigh_release(neigh);
839 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
844 write_lock_bh(&neigh->lock);
847 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
852 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
853 if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
854 atomic_set(&neigh->probes, neigh->parms->ucast_probes);
855 neigh->nud_state = NUD_INCOMPLETE;
857 neigh->timer.expires = now + 1;
858 add_timer(&neigh->timer);
860 neigh->nud_state = NUD_FAILED;
861 write_unlock_bh(&neigh->lock);
867 } else if (neigh->nud_state & NUD_STALE) {
868 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
870 neigh->nud_state = NUD_DELAY;
871 neigh->timer.expires = jiffies + neigh->parms->delay_probe_time;
872 add_timer(&neigh->timer);
875 if (neigh->nud_state == NUD_INCOMPLETE) {
877 if (skb_queue_len(&neigh->arp_queue) >=
878 neigh->parms->queue_len) {
879 struct sk_buff *buff;
880 buff = neigh->arp_queue.next;
881 __skb_unlink(buff, &neigh->arp_queue);
884 __skb_queue_tail(&neigh->arp_queue, skb);
889 write_unlock_bh(&neigh->lock);
893 static __inline__ void neigh_update_hhs(struct neighbour *neigh)
896 void (*update)(struct hh_cache*, struct net_device*, unsigned char *) =
897 neigh->dev->header_cache_update;
900 for (hh = neigh->hh; hh; hh = hh->hh_next) {
901 write_lock_bh(&hh->hh_lock);
902 update(hh, neigh->dev, neigh->ha);
903 write_unlock_bh(&hh->hh_lock);
910 /* Generic update routine.
911 -- lladdr is new lladdr or NULL, if it is not supplied.
914 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
916 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
917 lladdr instead of overriding it
919 It also allows to retain current state
920 if lladdr is unchanged.
921 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
923 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
925 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
928 Caller MUST hold reference count on the entry.
931 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
939 struct net_device *dev;
940 int update_isrouter = 0;
942 write_lock_bh(&neigh->lock);
945 old = neigh->nud_state;
948 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
949 (old & (NUD_NOARP | NUD_PERMANENT)))
952 if (!(new & NUD_VALID)) {
953 neigh_del_timer(neigh);
954 if (old & NUD_CONNECTED)
955 neigh_suspect(neigh);
956 neigh->nud_state = new;
959 notify = old & NUD_VALID;
964 /* Compare new lladdr with cached one */
965 if (!dev->addr_len) {
966 /* First case: device needs no address. */
969 /* The second case: if something is already cached
970 and a new address is proposed:
972 - if they are different, check override flag
974 if ((old & NUD_VALID) &&
975 !memcmp(lladdr, neigh->ha, dev->addr_len))
978 /* No address is supplied; if we know something,
979 use it, otherwise discard the request.
982 if (!(old & NUD_VALID))
987 if (new & NUD_CONNECTED)
988 neigh->confirmed = jiffies;
989 neigh->updated = jiffies;
991 /* If entry was valid and address is not changed,
992 do not change entry state, if new one is STALE.
995 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
996 if (old & NUD_VALID) {
997 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
999 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1000 (old & NUD_CONNECTED)) {
1006 if (lladdr == neigh->ha && new == NUD_STALE &&
1007 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1008 (old & NUD_CONNECTED))
1015 neigh_del_timer(neigh);
1016 if (new & NUD_IN_TIMER) {
1018 neigh->timer.expires = jiffies +
1019 ((new & NUD_REACHABLE) ?
1020 neigh->parms->reachable_time : 0);
1021 add_timer(&neigh->timer);
1023 neigh->nud_state = new;
1026 if (lladdr != neigh->ha) {
1027 memcpy(&neigh->ha, lladdr, dev->addr_len);
1028 neigh_update_hhs(neigh);
1029 if (!(new & NUD_CONNECTED))
1030 neigh->confirmed = jiffies -
1031 (neigh->parms->base_reachable_time << 1);
1038 if (new & NUD_CONNECTED)
1039 neigh_connect(neigh);
1041 neigh_suspect(neigh);
1042 if (!(old & NUD_VALID)) {
1043 struct sk_buff *skb;
1045 /* Again: avoid dead loop if something went wrong */
1047 while (neigh->nud_state & NUD_VALID &&
1048 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1049 struct neighbour *n1 = neigh;
1050 write_unlock_bh(&neigh->lock);
1051 /* On shaper/eql skb->dst->neighbour != neigh :( */
1052 if (skb->dst && skb->dst->neighbour)
1053 n1 = skb->dst->neighbour;
1055 write_lock_bh(&neigh->lock);
1057 skb_queue_purge(&neigh->arp_queue);
1060 if (update_isrouter) {
1061 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1062 (neigh->flags | NTF_ROUTER) :
1063 (neigh->flags & ~NTF_ROUTER);
1065 write_unlock_bh(&neigh->lock);
1067 if (notify && neigh->parms->app_probes)
1068 neigh_app_notify(neigh);
1073 struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1074 u8 *lladdr, void *saddr,
1075 struct net_device *dev)
1077 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1078 lladdr || !dev->addr_len);
1080 neigh_update(neigh, lladdr, NUD_STALE,
1081 NEIGH_UPDATE_F_OVERRIDE);
1085 static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,
1088 struct hh_cache *hh;
1089 struct net_device *dev = dst->dev;
1091 for (hh = n->hh; hh; hh = hh->hh_next)
1092 if (hh->hh_type == protocol)
1095 if (!hh && (hh = kmalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) {
1096 memset(hh, 0, sizeof(struct hh_cache));
1097 rwlock_init(&hh->hh_lock);
1098 hh->hh_type = protocol;
1099 atomic_set(&hh->hh_refcnt, 0);
1101 if (dev->hard_header_cache(n, hh)) {
1105 atomic_inc(&hh->hh_refcnt);
1106 hh->hh_next = n->hh;
1108 if (n->nud_state & NUD_CONNECTED)
1109 hh->hh_output = n->ops->hh_output;
1111 hh->hh_output = n->ops->output;
1115 atomic_inc(&hh->hh_refcnt);
1120 /* This function can be used in contexts, where only old dev_queue_xmit
1121 worked, f.e. if you want to override normal output path (eql, shaper),
1122 but resolution is not made yet.
1125 int neigh_compat_output(struct sk_buff *skb)
1127 struct net_device *dev = skb->dev;
1129 __skb_pull(skb, skb->nh.raw - skb->data);
1131 if (dev->hard_header &&
1132 dev->hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
1134 dev->rebuild_header(skb))
1137 return dev_queue_xmit(skb);
1140 /* Slow and careful. */
1142 int neigh_resolve_output(struct sk_buff *skb)
1144 struct dst_entry *dst = skb->dst;
1145 struct neighbour *neigh;
1148 if (!dst || !(neigh = dst->neighbour))
1151 __skb_pull(skb, skb->nh.raw - skb->data);
1153 if (!neigh_event_send(neigh, skb)) {
1155 struct net_device *dev = neigh->dev;
1156 if (dev->hard_header_cache && !dst->hh) {
1157 write_lock_bh(&neigh->lock);
1159 neigh_hh_init(neigh, dst, dst->ops->protocol);
1160 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1161 neigh->ha, NULL, skb->len);
1162 write_unlock_bh(&neigh->lock);
1164 read_lock_bh(&neigh->lock);
1165 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1166 neigh->ha, NULL, skb->len);
1167 read_unlock_bh(&neigh->lock);
1170 rc = neigh->ops->queue_xmit(skb);
1177 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1178 dst, dst ? dst->neighbour : NULL);
1185 /* As fast as possible without hh cache */
1187 int neigh_connected_output(struct sk_buff *skb)
1190 struct dst_entry *dst = skb->dst;
1191 struct neighbour *neigh = dst->neighbour;
1192 struct net_device *dev = neigh->dev;
1194 __skb_pull(skb, skb->nh.raw - skb->data);
1196 read_lock_bh(&neigh->lock);
1197 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1198 neigh->ha, NULL, skb->len);
1199 read_unlock_bh(&neigh->lock);
1201 err = neigh->ops->queue_xmit(skb);
1209 static void neigh_proxy_process(unsigned long arg)
1211 struct neigh_table *tbl = (struct neigh_table *)arg;
1212 long sched_next = 0;
1213 unsigned long now = jiffies;
1214 struct sk_buff *skb;
1216 spin_lock(&tbl->proxy_queue.lock);
1218 skb = tbl->proxy_queue.next;
1220 while (skb != (struct sk_buff *)&tbl->proxy_queue) {
1221 struct sk_buff *back = skb;
1222 long tdif = NEIGH_CB(back)->sched_next - now;
1226 struct net_device *dev = back->dev;
1227 __skb_unlink(back, &tbl->proxy_queue);
1228 if (tbl->proxy_redo && netif_running(dev))
1229 tbl->proxy_redo(back);
1234 } else if (!sched_next || tdif < sched_next)
1237 del_timer(&tbl->proxy_timer);
1239 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1240 spin_unlock(&tbl->proxy_queue.lock);
1243 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1244 struct sk_buff *skb)
1246 unsigned long now = jiffies;
1247 unsigned long sched_next = now + (net_random() % p->proxy_delay);
1249 if (tbl->proxy_queue.qlen > p->proxy_qlen) {
1254 NEIGH_CB(skb)->sched_next = sched_next;
1255 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
1257 spin_lock(&tbl->proxy_queue.lock);
1258 if (del_timer(&tbl->proxy_timer)) {
1259 if (time_before(tbl->proxy_timer.expires, sched_next))
1260 sched_next = tbl->proxy_timer.expires;
1262 dst_release(skb->dst);
1265 __skb_queue_tail(&tbl->proxy_queue, skb);
1266 mod_timer(&tbl->proxy_timer, sched_next);
1267 spin_unlock(&tbl->proxy_queue.lock);
1271 struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1272 struct neigh_table *tbl)
1274 struct neigh_parms *p = kmalloc(sizeof(*p), GFP_KERNEL);
1277 memcpy(p, &tbl->parms, sizeof(*p));
1279 atomic_set(&p->refcnt, 1);
1280 INIT_RCU_HEAD(&p->rcu_head);
1282 neigh_rand_reach_time(p->base_reachable_time);
1284 if (dev->neigh_setup && dev->neigh_setup(dev, p)) {
1292 p->sysctl_table = NULL;
1293 write_lock_bh(&tbl->lock);
1294 p->next = tbl->parms.next;
1295 tbl->parms.next = p;
1296 write_unlock_bh(&tbl->lock);
1301 static void neigh_rcu_free_parms(struct rcu_head *head)
1303 struct neigh_parms *parms =
1304 container_of(head, struct neigh_parms, rcu_head);
1306 neigh_parms_put(parms);
1309 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1311 struct neigh_parms **p;
1313 if (!parms || parms == &tbl->parms)
1315 write_lock_bh(&tbl->lock);
1316 for (p = &tbl->parms.next; *p; p = &(*p)->next) {
1320 write_unlock_bh(&tbl->lock);
1322 dev_put(parms->dev);
1323 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1327 write_unlock_bh(&tbl->lock);
1328 NEIGH_PRINTK1("neigh_parms_release: not found\n");
1331 void neigh_parms_destroy(struct neigh_parms *parms)
1337 void neigh_table_init(struct neigh_table *tbl)
1339 unsigned long now = jiffies;
1340 unsigned long phsize;
1342 atomic_set(&tbl->parms.refcnt, 1);
1343 INIT_RCU_HEAD(&tbl->parms.rcu_head);
1344 tbl->parms.reachable_time =
1345 neigh_rand_reach_time(tbl->parms.base_reachable_time);
1347 if (!tbl->kmem_cachep)
1348 tbl->kmem_cachep = kmem_cache_create(tbl->id,
1350 0, SLAB_HWCACHE_ALIGN,
1353 if (!tbl->kmem_cachep)
1354 panic("cannot create neighbour cache");
1356 tbl->stats = alloc_percpu(struct neigh_statistics);
1358 panic("cannot create neighbour cache statistics");
1360 #ifdef CONFIG_PROC_FS
1361 tbl->pde = create_proc_entry(tbl->id, 0, proc_net_stat);
1363 panic("cannot create neighbour proc dir entry");
1364 tbl->pde->proc_fops = &neigh_stat_seq_fops;
1365 tbl->pde->data = tbl;
1369 tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1);
1371 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
1372 tbl->phash_buckets = kmalloc(phsize, GFP_KERNEL);
1374 if (!tbl->hash_buckets || !tbl->phash_buckets)
1375 panic("cannot allocate neighbour cache hashes");
1377 memset(tbl->phash_buckets, 0, phsize);
1379 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
1381 rwlock_init(&tbl->lock);
1382 init_timer(&tbl->gc_timer);
1383 tbl->gc_timer.data = (unsigned long)tbl;
1384 tbl->gc_timer.function = neigh_periodic_timer;
1385 tbl->gc_timer.expires = now + 1;
1386 add_timer(&tbl->gc_timer);
1388 init_timer(&tbl->proxy_timer);
1389 tbl->proxy_timer.data = (unsigned long)tbl;
1390 tbl->proxy_timer.function = neigh_proxy_process;
1391 skb_queue_head_init(&tbl->proxy_queue);
1393 tbl->last_flush = now;
1394 tbl->last_rand = now + tbl->parms.reachable_time * 20;
1395 write_lock(&neigh_tbl_lock);
1396 tbl->next = neigh_tables;
1398 write_unlock(&neigh_tbl_lock);
1401 int neigh_table_clear(struct neigh_table *tbl)
1403 struct neigh_table **tp;
1405 /* It is not clean... Fix it to unload IPv6 module safely */
1406 del_timer_sync(&tbl->gc_timer);
1407 del_timer_sync(&tbl->proxy_timer);
1408 pneigh_queue_purge(&tbl->proxy_queue);
1409 neigh_ifdown(tbl, NULL);
1410 if (atomic_read(&tbl->entries))
1411 printk(KERN_CRIT "neighbour leakage\n");
1412 write_lock(&neigh_tbl_lock);
1413 for (tp = &neigh_tables; *tp; tp = &(*tp)->next) {
1419 write_unlock(&neigh_tbl_lock);
1421 neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1);
1422 tbl->hash_buckets = NULL;
1424 kfree(tbl->phash_buckets);
1425 tbl->phash_buckets = NULL;
1430 int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1432 struct ndmsg *ndm = NLMSG_DATA(nlh);
1433 struct rtattr **nda = arg;
1434 struct neigh_table *tbl;
1435 struct net_device *dev = NULL;
1438 if (ndm->ndm_ifindex &&
1439 (dev = dev_get_by_index(ndm->ndm_ifindex)) == NULL)
1442 read_lock(&neigh_tbl_lock);
1443 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1444 struct rtattr *dst_attr = nda[NDA_DST - 1];
1445 struct neighbour *n;
1447 if (tbl->family != ndm->ndm_family)
1449 read_unlock(&neigh_tbl_lock);
1452 if (!dst_attr || RTA_PAYLOAD(dst_attr) < tbl->key_len)
1455 if (ndm->ndm_flags & NTF_PROXY) {
1456 err = pneigh_delete(tbl, RTA_DATA(dst_attr), dev);
1463 n = neigh_lookup(tbl, RTA_DATA(dst_attr), dev);
1465 err = neigh_update(n, NULL, NUD_FAILED,
1466 NEIGH_UPDATE_F_OVERRIDE|
1467 NEIGH_UPDATE_F_ADMIN);
1472 read_unlock(&neigh_tbl_lock);
1473 err = -EADDRNOTAVAIL;
1481 int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1483 struct ndmsg *ndm = NLMSG_DATA(nlh);
1484 struct rtattr **nda = arg;
1485 struct neigh_table *tbl;
1486 struct net_device *dev = NULL;
1489 if (ndm->ndm_ifindex &&
1490 (dev = dev_get_by_index(ndm->ndm_ifindex)) == NULL)
1493 read_lock(&neigh_tbl_lock);
1494 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1495 struct rtattr *lladdr_attr = nda[NDA_LLADDR - 1];
1496 struct rtattr *dst_attr = nda[NDA_DST - 1];
1498 struct neighbour *n;
1500 if (tbl->family != ndm->ndm_family)
1502 read_unlock(&neigh_tbl_lock);
1505 if (!dst_attr || RTA_PAYLOAD(dst_attr) < tbl->key_len)
1508 if (ndm->ndm_flags & NTF_PROXY) {
1510 if (pneigh_lookup(tbl, RTA_DATA(dst_attr), dev, 1))
1518 if (lladdr_attr && RTA_PAYLOAD(lladdr_attr) < dev->addr_len)
1521 n = neigh_lookup(tbl, RTA_DATA(dst_attr), dev);
1523 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1529 override = nlh->nlmsg_flags & NLM_F_REPLACE;
1530 } else if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1534 n = __neigh_lookup_errno(tbl, RTA_DATA(dst_attr), dev);
1541 err = neigh_update(n,
1542 lladdr_attr ? RTA_DATA(lladdr_attr) : NULL,
1544 (override ? NEIGH_UPDATE_F_OVERRIDE : 0) |
1545 NEIGH_UPDATE_F_ADMIN);
1551 read_unlock(&neigh_tbl_lock);
1552 err = -EADDRNOTAVAIL;
1560 static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1562 struct rtattr *nest = NULL;
1564 nest = RTA_NEST(skb, NDTA_PARMS);
1567 RTA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex);
1569 RTA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt));
1570 RTA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len);
1571 RTA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen);
1572 RTA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes);
1573 RTA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes);
1574 RTA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes);
1575 RTA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time);
1576 RTA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME,
1577 parms->base_reachable_time);
1578 RTA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime);
1579 RTA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time);
1580 RTA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time);
1581 RTA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay);
1582 RTA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay);
1583 RTA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime);
1585 return RTA_NEST_END(skb, nest);
1588 return RTA_NEST_CANCEL(skb, nest);
1591 static int neightbl_fill_info(struct neigh_table *tbl, struct sk_buff *skb,
1592 struct netlink_callback *cb)
1594 struct nlmsghdr *nlh;
1595 struct ndtmsg *ndtmsg;
1597 nlh = NLMSG_NEW_ANSWER(skb, cb, RTM_NEWNEIGHTBL, sizeof(struct ndtmsg),
1600 ndtmsg = NLMSG_DATA(nlh);
1602 read_lock_bh(&tbl->lock);
1603 ndtmsg->ndtm_family = tbl->family;
1604 ndtmsg->ndtm_pad1 = 0;
1605 ndtmsg->ndtm_pad2 = 0;
1607 RTA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1608 RTA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval);
1609 RTA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1);
1610 RTA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2);
1611 RTA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3);
1614 unsigned long now = jiffies;
1615 unsigned int flush_delta = now - tbl->last_flush;
1616 unsigned int rand_delta = now - tbl->last_rand;
1618 struct ndt_config ndc = {
1619 .ndtc_key_len = tbl->key_len,
1620 .ndtc_entry_size = tbl->entry_size,
1621 .ndtc_entries = atomic_read(&tbl->entries),
1622 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
1623 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
1624 .ndtc_hash_rnd = tbl->hash_rnd,
1625 .ndtc_hash_mask = tbl->hash_mask,
1626 .ndtc_hash_chain_gc = tbl->hash_chain_gc,
1627 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
1630 RTA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc);
1635 struct ndt_stats ndst;
1637 memset(&ndst, 0, sizeof(ndst));
1639 for (cpu = 0; cpu < NR_CPUS; cpu++) {
1640 struct neigh_statistics *st;
1642 if (!cpu_possible(cpu))
1645 st = per_cpu_ptr(tbl->stats, cpu);
1646 ndst.ndts_allocs += st->allocs;
1647 ndst.ndts_destroys += st->destroys;
1648 ndst.ndts_hash_grows += st->hash_grows;
1649 ndst.ndts_res_failed += st->res_failed;
1650 ndst.ndts_lookups += st->lookups;
1651 ndst.ndts_hits += st->hits;
1652 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1653 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1654 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1655 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1658 RTA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst);
1661 BUG_ON(tbl->parms.dev);
1662 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
1663 goto rtattr_failure;
1665 read_unlock_bh(&tbl->lock);
1666 return NLMSG_END(skb, nlh);
1669 read_unlock_bh(&tbl->lock);
1670 return NLMSG_CANCEL(skb, nlh);
1676 static int neightbl_fill_param_info(struct neigh_table *tbl,
1677 struct neigh_parms *parms,
1678 struct sk_buff *skb,
1679 struct netlink_callback *cb)
1681 struct ndtmsg *ndtmsg;
1682 struct nlmsghdr *nlh;
1684 nlh = NLMSG_NEW_ANSWER(skb, cb, RTM_NEWNEIGHTBL, sizeof(struct ndtmsg),
1687 ndtmsg = NLMSG_DATA(nlh);
1689 read_lock_bh(&tbl->lock);
1690 ndtmsg->ndtm_family = tbl->family;
1691 ndtmsg->ndtm_pad1 = 0;
1692 ndtmsg->ndtm_pad2 = 0;
1693 RTA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1695 if (neightbl_fill_parms(skb, parms) < 0)
1696 goto rtattr_failure;
1698 read_unlock_bh(&tbl->lock);
1699 return NLMSG_END(skb, nlh);
1702 read_unlock_bh(&tbl->lock);
1703 return NLMSG_CANCEL(skb, nlh);
1709 static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl,
1712 struct neigh_parms *p;
1714 for (p = &tbl->parms; p; p = p->next)
1715 if ((p->dev && p->dev->ifindex == ifindex) ||
1716 (!p->dev && !ifindex))
1722 int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1724 struct neigh_table *tbl;
1725 struct ndtmsg *ndtmsg = NLMSG_DATA(nlh);
1726 struct rtattr **tb = arg;
1729 if (!tb[NDTA_NAME - 1] || !RTA_PAYLOAD(tb[NDTA_NAME - 1]))
1732 read_lock(&neigh_tbl_lock);
1733 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1734 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1737 if (!rtattr_strcmp(tb[NDTA_NAME - 1], tbl->id))
1747 * We acquire tbl->lock to be nice to the periodic timers and
1748 * make sure they always see a consistent set of values.
1750 write_lock_bh(&tbl->lock);
1752 if (tb[NDTA_THRESH1 - 1])
1753 tbl->gc_thresh1 = RTA_GET_U32(tb[NDTA_THRESH1 - 1]);
1755 if (tb[NDTA_THRESH2 - 1])
1756 tbl->gc_thresh2 = RTA_GET_U32(tb[NDTA_THRESH2 - 1]);
1758 if (tb[NDTA_THRESH3 - 1])
1759 tbl->gc_thresh3 = RTA_GET_U32(tb[NDTA_THRESH3 - 1]);
1761 if (tb[NDTA_GC_INTERVAL - 1])
1762 tbl->gc_interval = RTA_GET_MSECS(tb[NDTA_GC_INTERVAL - 1]);
1764 if (tb[NDTA_PARMS - 1]) {
1765 struct rtattr *tbp[NDTPA_MAX];
1766 struct neigh_parms *p;
1769 if (rtattr_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS - 1]) < 0)
1770 goto rtattr_failure;
1772 if (tbp[NDTPA_IFINDEX - 1])
1773 ifindex = RTA_GET_U32(tbp[NDTPA_IFINDEX - 1]);
1775 p = lookup_neigh_params(tbl, ifindex);
1778 goto rtattr_failure;
1781 if (tbp[NDTPA_QUEUE_LEN - 1])
1782 p->queue_len = RTA_GET_U32(tbp[NDTPA_QUEUE_LEN - 1]);
1784 if (tbp[NDTPA_PROXY_QLEN - 1])
1785 p->proxy_qlen = RTA_GET_U32(tbp[NDTPA_PROXY_QLEN - 1]);
1787 if (tbp[NDTPA_APP_PROBES - 1])
1788 p->app_probes = RTA_GET_U32(tbp[NDTPA_APP_PROBES - 1]);
1790 if (tbp[NDTPA_UCAST_PROBES - 1])
1792 RTA_GET_U32(tbp[NDTPA_UCAST_PROBES - 1]);
1794 if (tbp[NDTPA_MCAST_PROBES - 1])
1796 RTA_GET_U32(tbp[NDTPA_MCAST_PROBES - 1]);
1798 if (tbp[NDTPA_BASE_REACHABLE_TIME - 1])
1799 p->base_reachable_time =
1800 RTA_GET_MSECS(tbp[NDTPA_BASE_REACHABLE_TIME - 1]);
1802 if (tbp[NDTPA_GC_STALETIME - 1])
1804 RTA_GET_MSECS(tbp[NDTPA_GC_STALETIME - 1]);
1806 if (tbp[NDTPA_DELAY_PROBE_TIME - 1])
1807 p->delay_probe_time =
1808 RTA_GET_MSECS(tbp[NDTPA_DELAY_PROBE_TIME - 1]);
1810 if (tbp[NDTPA_RETRANS_TIME - 1])
1812 RTA_GET_MSECS(tbp[NDTPA_RETRANS_TIME - 1]);
1814 if (tbp[NDTPA_ANYCAST_DELAY - 1])
1816 RTA_GET_MSECS(tbp[NDTPA_ANYCAST_DELAY - 1]);
1818 if (tbp[NDTPA_PROXY_DELAY - 1])
1820 RTA_GET_MSECS(tbp[NDTPA_PROXY_DELAY - 1]);
1822 if (tbp[NDTPA_LOCKTIME - 1])
1823 p->locktime = RTA_GET_MSECS(tbp[NDTPA_LOCKTIME - 1]);
1829 write_unlock_bh(&tbl->lock);
1831 read_unlock(&neigh_tbl_lock);
1835 int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1838 int s_idx = cb->args[0];
1839 struct neigh_table *tbl;
1841 family = ((struct rtgenmsg *)NLMSG_DATA(cb->nlh))->rtgen_family;
1843 read_lock(&neigh_tbl_lock);
1844 for (tbl = neigh_tables, idx = 0; tbl; tbl = tbl->next) {
1845 struct neigh_parms *p;
1847 if (idx < s_idx || (family && tbl->family != family))
1850 if (neightbl_fill_info(tbl, skb, cb) <= 0)
1853 for (++idx, p = tbl->parms.next; p; p = p->next, idx++) {
1857 if (neightbl_fill_param_info(tbl, p, skb, cb) <= 0)
1863 read_unlock(&neigh_tbl_lock);
1869 static int neigh_fill_info(struct sk_buff *skb, struct neighbour *n,
1870 u32 pid, u32 seq, int event, unsigned int flags)
1872 unsigned long now = jiffies;
1873 unsigned char *b = skb->tail;
1874 struct nda_cacheinfo ci;
1877 struct nlmsghdr *nlh = NLMSG_NEW(skb, pid, seq, event,
1878 sizeof(struct ndmsg), flags);
1879 struct ndmsg *ndm = NLMSG_DATA(nlh);
1881 ndm->ndm_family = n->ops->family;
1884 ndm->ndm_flags = n->flags;
1885 ndm->ndm_type = n->type;
1886 ndm->ndm_ifindex = n->dev->ifindex;
1887 RTA_PUT(skb, NDA_DST, n->tbl->key_len, n->primary_key);
1888 read_lock_bh(&n->lock);
1890 ndm->ndm_state = n->nud_state;
1891 if (n->nud_state & NUD_VALID)
1892 RTA_PUT(skb, NDA_LLADDR, n->dev->addr_len, n->ha);
1893 ci.ndm_used = now - n->used;
1894 ci.ndm_confirmed = now - n->confirmed;
1895 ci.ndm_updated = now - n->updated;
1896 ci.ndm_refcnt = atomic_read(&n->refcnt) - 1;
1897 probes = atomic_read(&n->probes);
1898 read_unlock_bh(&n->lock);
1900 RTA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
1901 RTA_PUT(skb, NDA_PROBES, sizeof(probes), &probes);
1902 nlh->nlmsg_len = skb->tail - b;
1908 read_unlock_bh(&n->lock);
1909 skb_trim(skb, b - skb->data);
1914 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
1915 struct netlink_callback *cb)
1917 struct neighbour *n;
1918 int rc, h, s_h = cb->args[1];
1919 int idx, s_idx = idx = cb->args[2];
1921 for (h = 0; h <= tbl->hash_mask; h++) {
1926 read_lock_bh(&tbl->lock);
1927 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next, idx++) {
1930 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid,
1933 NLM_F_MULTI) <= 0) {
1934 read_unlock_bh(&tbl->lock);
1939 read_unlock_bh(&tbl->lock);
1948 int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1950 struct neigh_table *tbl;
1953 read_lock(&neigh_tbl_lock);
1954 family = ((struct rtgenmsg *)NLMSG_DATA(cb->nlh))->rtgen_family;
1957 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
1958 if (t < s_t || (family && tbl->family != family))
1961 memset(&cb->args[1], 0, sizeof(cb->args) -
1962 sizeof(cb->args[0]));
1963 if (neigh_dump_table(tbl, skb, cb) < 0)
1966 read_unlock(&neigh_tbl_lock);
1972 void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
1976 read_lock_bh(&tbl->lock);
1977 for (chain = 0; chain <= tbl->hash_mask; chain++) {
1978 struct neighbour *n;
1980 for (n = tbl->hash_buckets[chain]; n; n = n->next)
1983 read_unlock_bh(&tbl->lock);
1985 EXPORT_SYMBOL(neigh_for_each);
1987 /* The tbl->lock must be held as a writer and BH disabled. */
1988 void __neigh_for_each_release(struct neigh_table *tbl,
1989 int (*cb)(struct neighbour *))
1993 for (chain = 0; chain <= tbl->hash_mask; chain++) {
1994 struct neighbour *n, **np;
1996 np = &tbl->hash_buckets[chain];
1997 while ((n = *np) != NULL) {
2000 write_lock(&n->lock);
2007 write_unlock(&n->lock);
2013 EXPORT_SYMBOL(__neigh_for_each_release);
2015 #ifdef CONFIG_PROC_FS
2017 static struct neighbour *neigh_get_first(struct seq_file *seq)
2019 struct neigh_seq_state *state = seq->private;
2020 struct neigh_table *tbl = state->tbl;
2021 struct neighbour *n = NULL;
2022 int bucket = state->bucket;
2024 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2025 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) {
2026 n = tbl->hash_buckets[bucket];
2029 if (state->neigh_sub_iter) {
2033 v = state->neigh_sub_iter(state, n, &fakep);
2037 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2039 if (n->nud_state & ~NUD_NOARP)
2048 state->bucket = bucket;
2053 static struct neighbour *neigh_get_next(struct seq_file *seq,
2054 struct neighbour *n,
2057 struct neigh_seq_state *state = seq->private;
2058 struct neigh_table *tbl = state->tbl;
2060 if (state->neigh_sub_iter) {
2061 void *v = state->neigh_sub_iter(state, n, pos);
2069 if (state->neigh_sub_iter) {
2070 void *v = state->neigh_sub_iter(state, n, pos);
2075 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2078 if (n->nud_state & ~NUD_NOARP)
2087 if (++state->bucket > tbl->hash_mask)
2090 n = tbl->hash_buckets[state->bucket];
2098 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2100 struct neighbour *n = neigh_get_first(seq);
2104 n = neigh_get_next(seq, n, pos);
2109 return *pos ? NULL : n;
2112 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2114 struct neigh_seq_state *state = seq->private;
2115 struct neigh_table *tbl = state->tbl;
2116 struct pneigh_entry *pn = NULL;
2117 int bucket = state->bucket;
2119 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2120 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2121 pn = tbl->phash_buckets[bucket];
2125 state->bucket = bucket;
2130 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2131 struct pneigh_entry *pn,
2134 struct neigh_seq_state *state = seq->private;
2135 struct neigh_table *tbl = state->tbl;
2139 if (++state->bucket > PNEIGH_HASHMASK)
2141 pn = tbl->phash_buckets[state->bucket];
2152 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2154 struct pneigh_entry *pn = pneigh_get_first(seq);
2158 pn = pneigh_get_next(seq, pn, pos);
2163 return *pos ? NULL : pn;
2166 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2168 struct neigh_seq_state *state = seq->private;
2171 rc = neigh_get_idx(seq, pos);
2172 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2173 rc = pneigh_get_idx(seq, pos);
2178 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
2180 struct neigh_seq_state *state = seq->private;
2181 loff_t pos_minus_one;
2185 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2187 read_lock_bh(&tbl->lock);
2189 pos_minus_one = *pos - 1;
2190 return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN;
2192 EXPORT_SYMBOL(neigh_seq_start);
2194 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2196 struct neigh_seq_state *state;
2199 if (v == SEQ_START_TOKEN) {
2200 rc = neigh_get_idx(seq, pos);
2204 state = seq->private;
2205 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2206 rc = neigh_get_next(seq, v, NULL);
2209 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2210 rc = pneigh_get_first(seq);
2212 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2213 rc = pneigh_get_next(seq, v, NULL);
2219 EXPORT_SYMBOL(neigh_seq_next);
2221 void neigh_seq_stop(struct seq_file *seq, void *v)
2223 struct neigh_seq_state *state = seq->private;
2224 struct neigh_table *tbl = state->tbl;
2226 read_unlock_bh(&tbl->lock);
2228 EXPORT_SYMBOL(neigh_seq_stop);
2230 /* statistics via seq_file */
2232 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2234 struct proc_dir_entry *pde = seq->private;
2235 struct neigh_table *tbl = pde->data;
2239 return SEQ_START_TOKEN;
2241 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
2242 if (!cpu_possible(cpu))
2245 return per_cpu_ptr(tbl->stats, cpu);
2250 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2252 struct proc_dir_entry *pde = seq->private;
2253 struct neigh_table *tbl = pde->data;
2256 for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
2257 if (!cpu_possible(cpu))
2260 return per_cpu_ptr(tbl->stats, cpu);
2265 static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2270 static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2272 struct proc_dir_entry *pde = seq->private;
2273 struct neigh_table *tbl = pde->data;
2274 struct neigh_statistics *st = v;
2276 if (v == SEQ_START_TOKEN) {
2277 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");
2281 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2282 "%08lx %08lx %08lx %08lx\n",
2283 atomic_read(&tbl->entries),
2294 st->rcv_probes_mcast,
2295 st->rcv_probes_ucast,
2297 st->periodic_gc_runs,
2304 static struct seq_operations neigh_stat_seq_ops = {
2305 .start = neigh_stat_seq_start,
2306 .next = neigh_stat_seq_next,
2307 .stop = neigh_stat_seq_stop,
2308 .show = neigh_stat_seq_show,
2311 static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2313 int ret = seq_open(file, &neigh_stat_seq_ops);
2316 struct seq_file *sf = file->private_data;
2317 sf->private = PDE(inode);
2322 static struct file_operations neigh_stat_seq_fops = {
2323 .owner = THIS_MODULE,
2324 .open = neigh_stat_seq_open,
2326 .llseek = seq_lseek,
2327 .release = seq_release,
2330 #endif /* CONFIG_PROC_FS */
2333 void neigh_app_ns(struct neighbour *n)
2335 struct nlmsghdr *nlh;
2336 int size = NLMSG_SPACE(sizeof(struct ndmsg) + 256);
2337 struct sk_buff *skb = alloc_skb(size, GFP_ATOMIC);
2342 if (neigh_fill_info(skb, n, 0, 0, RTM_GETNEIGH, 0) < 0) {
2346 nlh = (struct nlmsghdr *)skb->data;
2347 nlh->nlmsg_flags = NLM_F_REQUEST;
2348 NETLINK_CB(skb).dst_group = RTNLGRP_NEIGH;
2349 netlink_broadcast(rtnl, skb, 0, RTNLGRP_NEIGH, GFP_ATOMIC);
2352 static void neigh_app_notify(struct neighbour *n)
2354 struct nlmsghdr *nlh;
2355 int size = NLMSG_SPACE(sizeof(struct ndmsg) + 256);
2356 struct sk_buff *skb = alloc_skb(size, GFP_ATOMIC);
2361 if (neigh_fill_info(skb, n, 0, 0, RTM_NEWNEIGH, 0) < 0) {
2365 nlh = (struct nlmsghdr *)skb->data;
2366 NETLINK_CB(skb).dst_group = RTNLGRP_NEIGH;
2367 netlink_broadcast(rtnl, skb, 0, RTNLGRP_NEIGH, GFP_ATOMIC);
2370 #endif /* CONFIG_ARPD */
2372 #ifdef CONFIG_SYSCTL
2374 static struct neigh_sysctl_table {
2375 struct ctl_table_header *sysctl_header;
2376 ctl_table neigh_vars[__NET_NEIGH_MAX];
2377 ctl_table neigh_dev[2];
2378 ctl_table neigh_neigh_dir[2];
2379 ctl_table neigh_proto_dir[2];
2380 ctl_table neigh_root_dir[2];
2381 } neigh_sysctl_template = {
2384 .ctl_name = NET_NEIGH_MCAST_SOLICIT,
2385 .procname = "mcast_solicit",
2386 .maxlen = sizeof(int),
2388 .proc_handler = &proc_dointvec,
2391 .ctl_name = NET_NEIGH_UCAST_SOLICIT,
2392 .procname = "ucast_solicit",
2393 .maxlen = sizeof(int),
2395 .proc_handler = &proc_dointvec,
2398 .ctl_name = NET_NEIGH_APP_SOLICIT,
2399 .procname = "app_solicit",
2400 .maxlen = sizeof(int),
2402 .proc_handler = &proc_dointvec,
2405 .ctl_name = NET_NEIGH_RETRANS_TIME,
2406 .procname = "retrans_time",
2407 .maxlen = sizeof(int),
2409 .proc_handler = &proc_dointvec_userhz_jiffies,
2412 .ctl_name = NET_NEIGH_REACHABLE_TIME,
2413 .procname = "base_reachable_time",
2414 .maxlen = sizeof(int),
2416 .proc_handler = &proc_dointvec_jiffies,
2417 .strategy = &sysctl_jiffies,
2420 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME,
2421 .procname = "delay_first_probe_time",
2422 .maxlen = sizeof(int),
2424 .proc_handler = &proc_dointvec_jiffies,
2425 .strategy = &sysctl_jiffies,
2428 .ctl_name = NET_NEIGH_GC_STALE_TIME,
2429 .procname = "gc_stale_time",
2430 .maxlen = sizeof(int),
2432 .proc_handler = &proc_dointvec_jiffies,
2433 .strategy = &sysctl_jiffies,
2436 .ctl_name = NET_NEIGH_UNRES_QLEN,
2437 .procname = "unres_qlen",
2438 .maxlen = sizeof(int),
2440 .proc_handler = &proc_dointvec,
2443 .ctl_name = NET_NEIGH_PROXY_QLEN,
2444 .procname = "proxy_qlen",
2445 .maxlen = sizeof(int),
2447 .proc_handler = &proc_dointvec,
2450 .ctl_name = NET_NEIGH_ANYCAST_DELAY,
2451 .procname = "anycast_delay",
2452 .maxlen = sizeof(int),
2454 .proc_handler = &proc_dointvec_userhz_jiffies,
2457 .ctl_name = NET_NEIGH_PROXY_DELAY,
2458 .procname = "proxy_delay",
2459 .maxlen = sizeof(int),
2461 .proc_handler = &proc_dointvec_userhz_jiffies,
2464 .ctl_name = NET_NEIGH_LOCKTIME,
2465 .procname = "locktime",
2466 .maxlen = sizeof(int),
2468 .proc_handler = &proc_dointvec_userhz_jiffies,
2471 .ctl_name = NET_NEIGH_GC_INTERVAL,
2472 .procname = "gc_interval",
2473 .maxlen = sizeof(int),
2475 .proc_handler = &proc_dointvec_jiffies,
2476 .strategy = &sysctl_jiffies,
2479 .ctl_name = NET_NEIGH_GC_THRESH1,
2480 .procname = "gc_thresh1",
2481 .maxlen = sizeof(int),
2483 .proc_handler = &proc_dointvec,
2486 .ctl_name = NET_NEIGH_GC_THRESH2,
2487 .procname = "gc_thresh2",
2488 .maxlen = sizeof(int),
2490 .proc_handler = &proc_dointvec,
2493 .ctl_name = NET_NEIGH_GC_THRESH3,
2494 .procname = "gc_thresh3",
2495 .maxlen = sizeof(int),
2497 .proc_handler = &proc_dointvec,
2500 .ctl_name = NET_NEIGH_RETRANS_TIME_MS,
2501 .procname = "retrans_time_ms",
2502 .maxlen = sizeof(int),
2504 .proc_handler = &proc_dointvec_ms_jiffies,
2505 .strategy = &sysctl_ms_jiffies,
2508 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS,
2509 .procname = "base_reachable_time_ms",
2510 .maxlen = sizeof(int),
2512 .proc_handler = &proc_dointvec_ms_jiffies,
2513 .strategy = &sysctl_ms_jiffies,
2518 .ctl_name = NET_PROTO_CONF_DEFAULT,
2519 .procname = "default",
2523 .neigh_neigh_dir = {
2525 .procname = "neigh",
2529 .neigh_proto_dir = {
2536 .ctl_name = CTL_NET,
2543 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
2544 int p_id, int pdev_id, char *p_name,
2545 proc_handler *handler, ctl_handler *strategy)
2547 struct neigh_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
2548 const char *dev_name_source = NULL;
2549 char *dev_name = NULL;
2554 memcpy(t, &neigh_sysctl_template, sizeof(*t));
2555 t->neigh_vars[0].data = &p->mcast_probes;
2556 t->neigh_vars[1].data = &p->ucast_probes;
2557 t->neigh_vars[2].data = &p->app_probes;
2558 t->neigh_vars[3].data = &p->retrans_time;
2559 t->neigh_vars[4].data = &p->base_reachable_time;
2560 t->neigh_vars[5].data = &p->delay_probe_time;
2561 t->neigh_vars[6].data = &p->gc_staletime;
2562 t->neigh_vars[7].data = &p->queue_len;
2563 t->neigh_vars[8].data = &p->proxy_qlen;
2564 t->neigh_vars[9].data = &p->anycast_delay;
2565 t->neigh_vars[10].data = &p->proxy_delay;
2566 t->neigh_vars[11].data = &p->locktime;
2569 dev_name_source = dev->name;
2570 t->neigh_dev[0].ctl_name = dev->ifindex;
2571 t->neigh_vars[12].procname = NULL;
2572 t->neigh_vars[13].procname = NULL;
2573 t->neigh_vars[14].procname = NULL;
2574 t->neigh_vars[15].procname = NULL;
2576 dev_name_source = t->neigh_dev[0].procname;
2577 t->neigh_vars[12].data = (int *)(p + 1);
2578 t->neigh_vars[13].data = (int *)(p + 1) + 1;
2579 t->neigh_vars[14].data = (int *)(p + 1) + 2;
2580 t->neigh_vars[15].data = (int *)(p + 1) + 3;
2583 t->neigh_vars[16].data = &p->retrans_time;
2584 t->neigh_vars[17].data = &p->base_reachable_time;
2586 if (handler || strategy) {
2588 t->neigh_vars[3].proc_handler = handler;
2589 t->neigh_vars[3].strategy = strategy;
2590 t->neigh_vars[3].extra1 = dev;
2592 t->neigh_vars[4].proc_handler = handler;
2593 t->neigh_vars[4].strategy = strategy;
2594 t->neigh_vars[4].extra1 = dev;
2595 /* RetransTime (in milliseconds)*/
2596 t->neigh_vars[16].proc_handler = handler;
2597 t->neigh_vars[16].strategy = strategy;
2598 t->neigh_vars[16].extra1 = dev;
2599 /* ReachableTime (in milliseconds) */
2600 t->neigh_vars[17].proc_handler = handler;
2601 t->neigh_vars[17].strategy = strategy;
2602 t->neigh_vars[17].extra1 = dev;
2605 dev_name = kstrdup(dev_name_source, GFP_KERNEL);
2611 t->neigh_dev[0].procname = dev_name;
2613 t->neigh_neigh_dir[0].ctl_name = pdev_id;
2615 t->neigh_proto_dir[0].procname = p_name;
2616 t->neigh_proto_dir[0].ctl_name = p_id;
2618 t->neigh_dev[0].child = t->neigh_vars;
2619 t->neigh_neigh_dir[0].child = t->neigh_dev;
2620 t->neigh_proto_dir[0].child = t->neigh_neigh_dir;
2621 t->neigh_root_dir[0].child = t->neigh_proto_dir;
2623 t->sysctl_header = register_sysctl_table(t->neigh_root_dir, 0);
2624 if (!t->sysctl_header) {
2628 p->sysctl_table = t;
2640 void neigh_sysctl_unregister(struct neigh_parms *p)
2642 if (p->sysctl_table) {
2643 struct neigh_sysctl_table *t = p->sysctl_table;
2644 p->sysctl_table = NULL;
2645 unregister_sysctl_table(t->sysctl_header);
2646 kfree(t->neigh_dev[0].procname);
2651 #endif /* CONFIG_SYSCTL */
2653 EXPORT_SYMBOL(__neigh_event_send);
2654 EXPORT_SYMBOL(neigh_add);
2655 EXPORT_SYMBOL(neigh_changeaddr);
2656 EXPORT_SYMBOL(neigh_compat_output);
2657 EXPORT_SYMBOL(neigh_connected_output);
2658 EXPORT_SYMBOL(neigh_create);
2659 EXPORT_SYMBOL(neigh_delete);
2660 EXPORT_SYMBOL(neigh_destroy);
2661 EXPORT_SYMBOL(neigh_dump_info);
2662 EXPORT_SYMBOL(neigh_event_ns);
2663 EXPORT_SYMBOL(neigh_ifdown);
2664 EXPORT_SYMBOL(neigh_lookup);
2665 EXPORT_SYMBOL(neigh_lookup_nodev);
2666 EXPORT_SYMBOL(neigh_parms_alloc);
2667 EXPORT_SYMBOL(neigh_parms_release);
2668 EXPORT_SYMBOL(neigh_rand_reach_time);
2669 EXPORT_SYMBOL(neigh_resolve_output);
2670 EXPORT_SYMBOL(neigh_table_clear);
2671 EXPORT_SYMBOL(neigh_table_init);
2672 EXPORT_SYMBOL(neigh_update);
2673 EXPORT_SYMBOL(neigh_update_hhs);
2674 EXPORT_SYMBOL(pneigh_enqueue);
2675 EXPORT_SYMBOL(pneigh_lookup);
2676 EXPORT_SYMBOL(neightbl_dump_info);
2677 EXPORT_SYMBOL(neightbl_set);
2680 EXPORT_SYMBOL(neigh_app_ns);
2682 #ifdef CONFIG_SYSCTL
2683 EXPORT_SYMBOL(neigh_sysctl_register);
2684 EXPORT_SYMBOL(neigh_sysctl_unregister);