2 * Generic address resolution entity
5 * Pedro Roque <roque@di.fc.ul.pt>
6 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
14 * Vitaly E. Lavrov releasing NULL neighbor in neigh_add.
15 * Harald Welte Add neighbour cache statistics like rtstat
18 #include <linux/types.h>
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/socket.h>
22 #include <linux/netdevice.h>
23 #include <linux/proc_fs.h>
25 #include <linux/sysctl.h>
27 #include <linux/times.h>
28 #include <net/neighbour.h>
31 #include <net/netevent.h>
32 #include <net/netlink.h>
33 #include <linux/rtnetlink.h>
34 #include <linux/random.h>
35 #include <linux/string.h>
36 #include <linux/log2.h>
40 #define NEIGH_PRINTK(x...) printk(x)
41 #define NEIGH_NOPRINTK(x...) do { ; } while(0)
42 #define NEIGH_PRINTK0 NEIGH_PRINTK
43 #define NEIGH_PRINTK1 NEIGH_NOPRINTK
44 #define NEIGH_PRINTK2 NEIGH_NOPRINTK
48 #define NEIGH_PRINTK1 NEIGH_PRINTK
52 #define NEIGH_PRINTK2 NEIGH_PRINTK
55 #define PNEIGH_HASHMASK 0xF
57 static void neigh_timer_handler(unsigned long arg);
59 static void neigh_app_notify(struct neighbour *n);
61 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
62 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
64 static struct neigh_table *neigh_tables;
66 static const struct file_operations neigh_stat_seq_fops;
70 Neighbour hash table buckets are protected with rwlock tbl->lock.
72 - All the scans/updates to hash buckets MUST be made under this lock.
73 - NOTHING clever should be made under this lock: no callbacks
74 to protocol backends, no attempts to send something to network.
75 It will result in deadlocks, if backend/driver wants to use neighbour
77 - If the entry requires some non-trivial actions, increase
78 its reference count and release table lock.
80 Neighbour entries are protected:
81 - with reference count.
82 - with rwlock neigh->lock
84 Reference count prevents destruction.
86 neigh->lock mainly serializes ll address data and its validity state.
87 However, the same lock is used to protect another entry fields:
91 Again, nothing clever shall be made under neigh->lock,
92 the most complicated procedure, which we allow is dev->hard_header.
93 It is supposed, that dev->hard_header is simplistic and does
94 not make callbacks to neighbour tables.
96 The last lock is neigh_tbl_lock. It is pure SMP lock, protecting
97 list of neighbour tables. This list is used only in process context,
100 static DEFINE_RWLOCK(neigh_tbl_lock);
102 static int neigh_blackhole(struct sk_buff *skb)
108 static void neigh_cleanup_and_release(struct neighbour *neigh)
110 if (neigh->parms->neigh_cleanup)
111 neigh->parms->neigh_cleanup(neigh);
113 neigh_release(neigh);
117 * It is random distribution in the interval (1/2)*base...(3/2)*base.
118 * It corresponds to default IPv6 settings and is not overridable,
119 * because it is really reasonable choice.
122 unsigned long neigh_rand_reach_time(unsigned long base)
124 return (base ? (net_random() % base) + (base >> 1) : 0);
128 static int neigh_forced_gc(struct neigh_table *tbl)
133 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
135 write_lock_bh(&tbl->lock);
136 for (i = 0; i <= tbl->hash_mask; i++) {
137 struct neighbour *n, **np;
139 np = &tbl->hash_buckets[i];
140 while ((n = *np) != 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)) {
151 write_unlock(&n->lock);
152 neigh_cleanup_and_release(n);
155 write_unlock(&n->lock);
160 tbl->last_flush = jiffies;
162 write_unlock_bh(&tbl->lock);
167 static int neigh_del_timer(struct neighbour *n)
169 if ((n->nud_state & NUD_IN_TIMER) &&
170 del_timer(&n->timer)) {
177 static void pneigh_queue_purge(struct sk_buff_head *list)
181 while ((skb = skb_dequeue(list)) != NULL) {
187 static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
191 for (i = 0; i <= tbl->hash_mask; i++) {
192 struct neighbour *n, **np = &tbl->hash_buckets[i];
194 while ((n = *np) != NULL) {
195 if (dev && n->dev != dev) {
200 write_lock(&n->lock);
204 if (atomic_read(&n->refcnt) != 1) {
205 /* The most unpleasant situation.
206 We must destroy neighbour entry,
207 but someone still uses it.
209 The destroy will be delayed until
210 the last user releases us, but
211 we must kill timers etc. and move
214 skb_queue_purge(&n->arp_queue);
215 n->output = neigh_blackhole;
216 if (n->nud_state & NUD_VALID)
217 n->nud_state = NUD_NOARP;
219 n->nud_state = NUD_NONE;
220 NEIGH_PRINTK2("neigh %p is stray.\n", n);
222 write_unlock(&n->lock);
223 neigh_cleanup_and_release(n);
228 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
230 write_lock_bh(&tbl->lock);
231 neigh_flush_dev(tbl, dev);
232 write_unlock_bh(&tbl->lock);
235 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
237 write_lock_bh(&tbl->lock);
238 neigh_flush_dev(tbl, dev);
239 pneigh_ifdown(tbl, dev);
240 write_unlock_bh(&tbl->lock);
242 del_timer_sync(&tbl->proxy_timer);
243 pneigh_queue_purge(&tbl->proxy_queue);
247 static struct neighbour *neigh_alloc(struct neigh_table *tbl)
249 struct neighbour *n = NULL;
250 unsigned long now = jiffies;
253 entries = atomic_inc_return(&tbl->entries) - 1;
254 if (entries >= tbl->gc_thresh3 ||
255 (entries >= tbl->gc_thresh2 &&
256 time_after(now, tbl->last_flush + 5 * HZ))) {
257 if (!neigh_forced_gc(tbl) &&
258 entries >= tbl->gc_thresh3)
262 n = kmem_cache_zalloc(tbl->kmem_cachep, GFP_ATOMIC);
266 skb_queue_head_init(&n->arp_queue);
267 rwlock_init(&n->lock);
268 n->updated = n->used = now;
269 n->nud_state = NUD_NONE;
270 n->output = neigh_blackhole;
271 n->parms = neigh_parms_clone(&tbl->parms);
272 init_timer(&n->timer);
273 n->timer.function = neigh_timer_handler;
274 n->timer.data = (unsigned long)n;
276 NEIGH_CACHE_STAT_INC(tbl, allocs);
278 atomic_set(&n->refcnt, 1);
284 atomic_dec(&tbl->entries);
288 static struct neighbour **neigh_hash_alloc(unsigned int entries)
290 unsigned long size = entries * sizeof(struct neighbour *);
291 struct neighbour **ret;
293 if (size <= PAGE_SIZE) {
294 ret = kzalloc(size, GFP_ATOMIC);
296 ret = (struct neighbour **)
297 __get_free_pages(GFP_ATOMIC|__GFP_ZERO, get_order(size));
302 static void neigh_hash_free(struct neighbour **hash, unsigned int entries)
304 unsigned long size = entries * sizeof(struct neighbour *);
306 if (size <= PAGE_SIZE)
309 free_pages((unsigned long)hash, get_order(size));
312 static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries)
314 struct neighbour **new_hash, **old_hash;
315 unsigned int i, new_hash_mask, old_entries;
317 NEIGH_CACHE_STAT_INC(tbl, hash_grows);
319 BUG_ON(!is_power_of_2(new_entries));
320 new_hash = neigh_hash_alloc(new_entries);
324 old_entries = tbl->hash_mask + 1;
325 new_hash_mask = new_entries - 1;
326 old_hash = tbl->hash_buckets;
328 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
329 for (i = 0; i < old_entries; i++) {
330 struct neighbour *n, *next;
332 for (n = old_hash[i]; n; n = next) {
333 unsigned int hash_val = tbl->hash(n->primary_key, n->dev);
335 hash_val &= new_hash_mask;
338 n->next = new_hash[hash_val];
339 new_hash[hash_val] = n;
342 tbl->hash_buckets = new_hash;
343 tbl->hash_mask = new_hash_mask;
345 neigh_hash_free(old_hash, old_entries);
348 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
349 struct net_device *dev)
352 int key_len = tbl->key_len;
353 u32 hash_val = tbl->hash(pkey, dev);
355 NEIGH_CACHE_STAT_INC(tbl, lookups);
357 read_lock_bh(&tbl->lock);
358 for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) {
359 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
361 NEIGH_CACHE_STAT_INC(tbl, hits);
365 read_unlock_bh(&tbl->lock);
369 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, const void *pkey)
372 int key_len = tbl->key_len;
373 u32 hash_val = tbl->hash(pkey, NULL);
375 NEIGH_CACHE_STAT_INC(tbl, lookups);
377 read_lock_bh(&tbl->lock);
378 for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) {
379 if (!memcmp(n->primary_key, pkey, key_len)) {
381 NEIGH_CACHE_STAT_INC(tbl, hits);
385 read_unlock_bh(&tbl->lock);
389 struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey,
390 struct net_device *dev)
393 int key_len = tbl->key_len;
395 struct neighbour *n1, *rc, *n = neigh_alloc(tbl);
398 rc = ERR_PTR(-ENOBUFS);
402 memcpy(n->primary_key, pkey, key_len);
406 /* Protocol specific setup. */
407 if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
409 goto out_neigh_release;
412 /* Device specific setup. */
413 if (n->parms->neigh_setup &&
414 (error = n->parms->neigh_setup(n)) < 0) {
416 goto out_neigh_release;
419 n->confirmed = jiffies - (n->parms->base_reachable_time << 1);
421 write_lock_bh(&tbl->lock);
423 if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1))
424 neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1);
426 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;
428 if (n->parms->dead) {
429 rc = ERR_PTR(-EINVAL);
433 for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) {
434 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
441 n->next = tbl->hash_buckets[hash_val];
442 tbl->hash_buckets[hash_val] = n;
445 write_unlock_bh(&tbl->lock);
446 NEIGH_PRINTK2("neigh %p is created.\n", n);
451 write_unlock_bh(&tbl->lock);
457 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, const void *pkey,
458 struct net_device *dev, int creat)
460 struct pneigh_entry *n;
461 int key_len = tbl->key_len;
462 u32 hash_val = *(u32 *)(pkey + key_len - 4);
464 hash_val ^= (hash_val >> 16);
465 hash_val ^= hash_val >> 8;
466 hash_val ^= hash_val >> 4;
467 hash_val &= PNEIGH_HASHMASK;
469 read_lock_bh(&tbl->lock);
471 for (n = tbl->phash_buckets[hash_val]; n; n = n->next) {
472 if (!memcmp(n->key, pkey, key_len) &&
473 (n->dev == dev || !n->dev)) {
474 read_unlock_bh(&tbl->lock);
478 read_unlock_bh(&tbl->lock);
483 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
487 memcpy(n->key, pkey, key_len);
492 if (tbl->pconstructor && tbl->pconstructor(n)) {
500 write_lock_bh(&tbl->lock);
501 n->next = tbl->phash_buckets[hash_val];
502 tbl->phash_buckets[hash_val] = n;
503 write_unlock_bh(&tbl->lock);
509 int pneigh_delete(struct neigh_table *tbl, const void *pkey,
510 struct net_device *dev)
512 struct pneigh_entry *n, **np;
513 int key_len = tbl->key_len;
514 u32 hash_val = *(u32 *)(pkey + key_len - 4);
516 hash_val ^= (hash_val >> 16);
517 hash_val ^= hash_val >> 8;
518 hash_val ^= hash_val >> 4;
519 hash_val &= PNEIGH_HASHMASK;
521 write_lock_bh(&tbl->lock);
522 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
524 if (!memcmp(n->key, pkey, key_len) && n->dev == dev) {
526 write_unlock_bh(&tbl->lock);
527 if (tbl->pdestructor)
535 write_unlock_bh(&tbl->lock);
539 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
541 struct pneigh_entry *n, **np;
544 for (h = 0; h <= PNEIGH_HASHMASK; h++) {
545 np = &tbl->phash_buckets[h];
546 while ((n = *np) != NULL) {
547 if (!dev || n->dev == dev) {
549 if (tbl->pdestructor)
564 * neighbour must already be out of the table;
567 void neigh_destroy(struct neighbour *neigh)
571 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
575 "Destroying alive neighbour %p\n", neigh);
580 if (neigh_del_timer(neigh))
581 printk(KERN_WARNING "Impossible event.\n");
583 while ((hh = neigh->hh) != NULL) {
584 neigh->hh = hh->hh_next;
587 write_seqlock_bh(&hh->hh_lock);
588 hh->hh_output = neigh_blackhole;
589 write_sequnlock_bh(&hh->hh_lock);
590 if (atomic_dec_and_test(&hh->hh_refcnt))
594 skb_queue_purge(&neigh->arp_queue);
597 neigh_parms_put(neigh->parms);
599 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh);
601 atomic_dec(&neigh->tbl->entries);
602 kmem_cache_free(neigh->tbl->kmem_cachep, neigh);
605 /* Neighbour state is suspicious;
608 Called with write_locked neigh.
610 static void neigh_suspect(struct neighbour *neigh)
614 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
616 neigh->output = neigh->ops->output;
618 for (hh = neigh->hh; hh; hh = hh->hh_next)
619 hh->hh_output = neigh->ops->output;
622 /* Neighbour state is OK;
625 Called with write_locked neigh.
627 static void neigh_connect(struct neighbour *neigh)
631 NEIGH_PRINTK2("neigh %p is connected.\n", neigh);
633 neigh->output = neigh->ops->connected_output;
635 for (hh = neigh->hh; hh; hh = hh->hh_next)
636 hh->hh_output = neigh->ops->hh_output;
639 static void neigh_periodic_timer(unsigned long arg)
641 struct neigh_table *tbl = (struct neigh_table *)arg;
642 struct neighbour *n, **np;
643 unsigned long expire, now = jiffies;
645 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
647 write_lock(&tbl->lock);
650 * periodically recompute ReachableTime from random function
653 if (time_after(now, tbl->last_rand + 300 * HZ)) {
654 struct neigh_parms *p;
655 tbl->last_rand = now;
656 for (p = &tbl->parms; p; p = p->next)
658 neigh_rand_reach_time(p->base_reachable_time);
661 np = &tbl->hash_buckets[tbl->hash_chain_gc];
662 tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask);
664 while ((n = *np) != NULL) {
667 write_lock(&n->lock);
669 state = n->nud_state;
670 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
671 write_unlock(&n->lock);
675 if (time_before(n->used, n->confirmed))
676 n->used = n->confirmed;
678 if (atomic_read(&n->refcnt) == 1 &&
679 (state == NUD_FAILED ||
680 time_after(now, n->used + n->parms->gc_staletime))) {
683 write_unlock(&n->lock);
684 neigh_cleanup_and_release(n);
687 write_unlock(&n->lock);
693 /* Cycle through all hash buckets every base_reachable_time/2 ticks.
694 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
695 * base_reachable_time.
697 expire = tbl->parms.base_reachable_time >> 1;
698 expire /= (tbl->hash_mask + 1);
703 mod_timer(&tbl->gc_timer, round_jiffies(now + expire));
705 mod_timer(&tbl->gc_timer, now + expire);
707 write_unlock(&tbl->lock);
710 static __inline__ int neigh_max_probes(struct neighbour *n)
712 struct neigh_parms *p = n->parms;
713 return (n->nud_state & NUD_PROBE ?
715 p->ucast_probes + p->app_probes + p->mcast_probes);
718 static inline void neigh_add_timer(struct neighbour *n, unsigned long when)
720 if (unlikely(mod_timer(&n->timer, when))) {
721 printk("NEIGH: BUG, double timer add, state is %x\n",
727 /* Called when a timer expires for a neighbour entry. */
729 static void neigh_timer_handler(unsigned long arg)
731 unsigned long now, next;
732 struct neighbour *neigh = (struct neighbour *)arg;
736 write_lock(&neigh->lock);
738 state = neigh->nud_state;
742 if (!(state & NUD_IN_TIMER)) {
744 printk(KERN_WARNING "neigh: timer & !nud_in_timer\n");
749 if (state & NUD_REACHABLE) {
750 if (time_before_eq(now,
751 neigh->confirmed + neigh->parms->reachable_time)) {
752 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh);
753 next = neigh->confirmed + neigh->parms->reachable_time;
754 } else if (time_before_eq(now,
755 neigh->used + neigh->parms->delay_probe_time)) {
756 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
757 neigh->nud_state = NUD_DELAY;
758 neigh->updated = jiffies;
759 neigh_suspect(neigh);
760 next = now + neigh->parms->delay_probe_time;
762 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
763 neigh->nud_state = NUD_STALE;
764 neigh->updated = jiffies;
765 neigh_suspect(neigh);
768 } else if (state & NUD_DELAY) {
769 if (time_before_eq(now,
770 neigh->confirmed + neigh->parms->delay_probe_time)) {
771 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh);
772 neigh->nud_state = NUD_REACHABLE;
773 neigh->updated = jiffies;
774 neigh_connect(neigh);
776 next = neigh->confirmed + neigh->parms->reachable_time;
778 NEIGH_PRINTK2("neigh %p is probed.\n", neigh);
779 neigh->nud_state = NUD_PROBE;
780 neigh->updated = jiffies;
781 atomic_set(&neigh->probes, 0);
782 next = now + neigh->parms->retrans_time;
785 /* NUD_PROBE|NUD_INCOMPLETE */
786 next = now + neigh->parms->retrans_time;
789 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
790 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
793 neigh->nud_state = NUD_FAILED;
794 neigh->updated = jiffies;
796 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
797 NEIGH_PRINTK2("neigh %p is failed.\n", neigh);
799 /* It is very thin place. report_unreachable is very complicated
800 routine. Particularly, it can hit the same neighbour entry!
802 So that, we try to be accurate and avoid dead loop. --ANK
804 while (neigh->nud_state == NUD_FAILED &&
805 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
806 write_unlock(&neigh->lock);
807 neigh->ops->error_report(neigh, skb);
808 write_lock(&neigh->lock);
810 skb_queue_purge(&neigh->arp_queue);
813 if (neigh->nud_state & NUD_IN_TIMER) {
814 if (time_before(next, jiffies + HZ/2))
815 next = jiffies + HZ/2;
816 if (!mod_timer(&neigh->timer, next))
819 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
820 struct sk_buff *skb = skb_peek(&neigh->arp_queue);
821 /* keep skb alive even if arp_queue overflows */
824 write_unlock(&neigh->lock);
825 neigh->ops->solicit(neigh, skb);
826 atomic_inc(&neigh->probes);
831 write_unlock(&neigh->lock);
834 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
837 if (notify && neigh->parms->app_probes)
838 neigh_app_notify(neigh);
840 neigh_release(neigh);
843 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
848 write_lock_bh(&neigh->lock);
851 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
856 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
857 if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
858 atomic_set(&neigh->probes, neigh->parms->ucast_probes);
859 neigh->nud_state = NUD_INCOMPLETE;
860 neigh->updated = jiffies;
862 neigh_add_timer(neigh, now + 1);
864 neigh->nud_state = NUD_FAILED;
865 neigh->updated = jiffies;
866 write_unlock_bh(&neigh->lock);
872 } else if (neigh->nud_state & NUD_STALE) {
873 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
875 neigh->nud_state = NUD_DELAY;
876 neigh->updated = jiffies;
877 neigh_add_timer(neigh,
878 jiffies + neigh->parms->delay_probe_time);
881 if (neigh->nud_state == NUD_INCOMPLETE) {
883 if (skb_queue_len(&neigh->arp_queue) >=
884 neigh->parms->queue_len) {
885 struct sk_buff *buff;
886 buff = neigh->arp_queue.next;
887 __skb_unlink(buff, &neigh->arp_queue);
890 __skb_queue_tail(&neigh->arp_queue, skb);
895 write_unlock_bh(&neigh->lock);
899 static void neigh_update_hhs(struct neighbour *neigh)
902 void (*update)(struct hh_cache*, struct net_device*, unsigned char *) =
903 neigh->dev->header_cache_update;
906 for (hh = neigh->hh; hh; hh = hh->hh_next) {
907 write_seqlock_bh(&hh->hh_lock);
908 update(hh, neigh->dev, neigh->ha);
909 write_sequnlock_bh(&hh->hh_lock);
916 /* Generic update routine.
917 -- lladdr is new lladdr or NULL, if it is not supplied.
920 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
922 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
923 lladdr instead of overriding it
925 It also allows to retain current state
926 if lladdr is unchanged.
927 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
929 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
931 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
934 Caller MUST hold reference count on the entry.
937 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
943 struct net_device *dev;
944 int update_isrouter = 0;
946 write_lock_bh(&neigh->lock);
949 old = neigh->nud_state;
952 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
953 (old & (NUD_NOARP | NUD_PERMANENT)))
956 if (!(new & NUD_VALID)) {
957 neigh_del_timer(neigh);
958 if (old & NUD_CONNECTED)
959 neigh_suspect(neigh);
960 neigh->nud_state = new;
962 notify = old & NUD_VALID;
966 /* Compare new lladdr with cached one */
967 if (!dev->addr_len) {
968 /* First case: device needs no address. */
971 /* The second case: if something is already cached
972 and a new address is proposed:
974 - if they are different, check override flag
976 if ((old & NUD_VALID) &&
977 !memcmp(lladdr, neigh->ha, dev->addr_len))
980 /* No address is supplied; if we know something,
981 use it, otherwise discard the request.
984 if (!(old & NUD_VALID))
989 if (new & NUD_CONNECTED)
990 neigh->confirmed = jiffies;
991 neigh->updated = jiffies;
993 /* If entry was valid and address is not changed,
994 do not change entry state, if new one is STALE.
997 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
998 if (old & NUD_VALID) {
999 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1000 update_isrouter = 0;
1001 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1002 (old & NUD_CONNECTED)) {
1008 if (lladdr == neigh->ha && new == NUD_STALE &&
1009 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1010 (old & NUD_CONNECTED))
1017 neigh_del_timer(neigh);
1018 if (new & NUD_IN_TIMER) {
1020 neigh_add_timer(neigh, (jiffies +
1021 ((new & NUD_REACHABLE) ?
1022 neigh->parms->reachable_time :
1025 neigh->nud_state = new;
1028 if (lladdr != neigh->ha) {
1029 memcpy(&neigh->ha, lladdr, dev->addr_len);
1030 neigh_update_hhs(neigh);
1031 if (!(new & NUD_CONNECTED))
1032 neigh->confirmed = jiffies -
1033 (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);
1068 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
1070 if (notify && neigh->parms->app_probes)
1071 neigh_app_notify(neigh);
1076 struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1077 u8 *lladdr, void *saddr,
1078 struct net_device *dev)
1080 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1081 lladdr || !dev->addr_len);
1083 neigh_update(neigh, lladdr, NUD_STALE,
1084 NEIGH_UPDATE_F_OVERRIDE);
1088 static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,
1091 struct hh_cache *hh;
1092 struct net_device *dev = dst->dev;
1094 for (hh = n->hh; hh; hh = hh->hh_next)
1095 if (hh->hh_type == protocol)
1098 if (!hh && (hh = kzalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) {
1099 seqlock_init(&hh->hh_lock);
1100 hh->hh_type = protocol;
1101 atomic_set(&hh->hh_refcnt, 0);
1103 if (dev->hard_header_cache(n, hh)) {
1107 atomic_inc(&hh->hh_refcnt);
1108 hh->hh_next = n->hh;
1110 if (n->nud_state & NUD_CONNECTED)
1111 hh->hh_output = n->ops->hh_output;
1113 hh->hh_output = n->ops->output;
1117 atomic_inc(&hh->hh_refcnt);
1122 /* This function can be used in contexts, where only old dev_queue_xmit
1123 worked, f.e. if you want to override normal output path (eql, shaper),
1124 but resolution is not made yet.
1127 int neigh_compat_output(struct sk_buff *skb)
1129 struct net_device *dev = skb->dev;
1131 __skb_pull(skb, skb_network_offset(skb));
1133 if (dev->hard_header &&
1134 dev->hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
1136 dev->rebuild_header(skb))
1139 return dev_queue_xmit(skb);
1142 /* Slow and careful. */
1144 int neigh_resolve_output(struct sk_buff *skb)
1146 struct dst_entry *dst = skb->dst;
1147 struct neighbour *neigh;
1150 if (!dst || !(neigh = dst->neighbour))
1153 __skb_pull(skb, skb_network_offset(skb));
1155 if (!neigh_event_send(neigh, skb)) {
1157 struct net_device *dev = neigh->dev;
1158 if (dev->hard_header_cache && !dst->hh) {
1159 write_lock_bh(&neigh->lock);
1161 neigh_hh_init(neigh, dst, dst->ops->protocol);
1162 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1163 neigh->ha, NULL, skb->len);
1164 write_unlock_bh(&neigh->lock);
1166 read_lock_bh(&neigh->lock);
1167 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1168 neigh->ha, NULL, skb->len);
1169 read_unlock_bh(&neigh->lock);
1172 rc = neigh->ops->queue_xmit(skb);
1179 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1180 dst, dst ? dst->neighbour : NULL);
1187 /* As fast as possible without hh cache */
1189 int neigh_connected_output(struct sk_buff *skb)
1192 struct dst_entry *dst = skb->dst;
1193 struct neighbour *neigh = dst->neighbour;
1194 struct net_device *dev = neigh->dev;
1196 __skb_pull(skb, skb_network_offset(skb));
1198 read_lock_bh(&neigh->lock);
1199 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1200 neigh->ha, NULL, skb->len);
1201 read_unlock_bh(&neigh->lock);
1203 err = neigh->ops->queue_xmit(skb);
1211 static void neigh_proxy_process(unsigned long arg)
1213 struct neigh_table *tbl = (struct neigh_table *)arg;
1214 long sched_next = 0;
1215 unsigned long now = jiffies;
1216 struct sk_buff *skb;
1218 spin_lock(&tbl->proxy_queue.lock);
1220 skb = tbl->proxy_queue.next;
1222 while (skb != (struct sk_buff *)&tbl->proxy_queue) {
1223 struct sk_buff *back = skb;
1224 long tdif = NEIGH_CB(back)->sched_next - now;
1228 struct net_device *dev = back->dev;
1229 __skb_unlink(back, &tbl->proxy_queue);
1230 if (tbl->proxy_redo && netif_running(dev))
1231 tbl->proxy_redo(back);
1236 } else if (!sched_next || tdif < sched_next)
1239 del_timer(&tbl->proxy_timer);
1241 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1242 spin_unlock(&tbl->proxy_queue.lock);
1245 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1246 struct sk_buff *skb)
1248 unsigned long now = jiffies;
1249 unsigned long sched_next = now + (net_random() % p->proxy_delay);
1251 if (tbl->proxy_queue.qlen > p->proxy_qlen) {
1256 NEIGH_CB(skb)->sched_next = sched_next;
1257 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
1259 spin_lock(&tbl->proxy_queue.lock);
1260 if (del_timer(&tbl->proxy_timer)) {
1261 if (time_before(tbl->proxy_timer.expires, sched_next))
1262 sched_next = tbl->proxy_timer.expires;
1264 dst_release(skb->dst);
1267 __skb_queue_tail(&tbl->proxy_queue, skb);
1268 mod_timer(&tbl->proxy_timer, sched_next);
1269 spin_unlock(&tbl->proxy_queue.lock);
1273 struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1274 struct neigh_table *tbl)
1276 struct neigh_parms *p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL);
1280 atomic_set(&p->refcnt, 1);
1281 INIT_RCU_HEAD(&p->rcu_head);
1283 neigh_rand_reach_time(p->base_reachable_time);
1285 if (dev->neigh_setup && dev->neigh_setup(dev, p)) {
1293 p->sysctl_table = NULL;
1294 write_lock_bh(&tbl->lock);
1295 p->next = tbl->parms.next;
1296 tbl->parms.next = p;
1297 write_unlock_bh(&tbl->lock);
1302 static void neigh_rcu_free_parms(struct rcu_head *head)
1304 struct neigh_parms *parms =
1305 container_of(head, struct neigh_parms, rcu_head);
1307 neigh_parms_put(parms);
1310 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1312 struct neigh_parms **p;
1314 if (!parms || parms == &tbl->parms)
1316 write_lock_bh(&tbl->lock);
1317 for (p = &tbl->parms.next; *p; p = &(*p)->next) {
1321 write_unlock_bh(&tbl->lock);
1323 dev_put(parms->dev);
1324 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1328 write_unlock_bh(&tbl->lock);
1329 NEIGH_PRINTK1("neigh_parms_release: not found\n");
1332 void neigh_parms_destroy(struct neigh_parms *parms)
1337 static struct lock_class_key neigh_table_proxy_queue_class;
1339 void neigh_table_init_no_netlink(struct neigh_table *tbl)
1341 unsigned long now = jiffies;
1342 unsigned long phsize;
1344 atomic_set(&tbl->parms.refcnt, 1);
1345 INIT_RCU_HEAD(&tbl->parms.rcu_head);
1346 tbl->parms.reachable_time =
1347 neigh_rand_reach_time(tbl->parms.base_reachable_time);
1349 if (!tbl->kmem_cachep)
1351 kmem_cache_create(tbl->id, tbl->entry_size, 0,
1352 SLAB_HWCACHE_ALIGN|SLAB_PANIC,
1354 tbl->stats = alloc_percpu(struct neigh_statistics);
1356 panic("cannot create neighbour cache statistics");
1358 #ifdef CONFIG_PROC_FS
1359 tbl->pde = create_proc_entry(tbl->id, 0, proc_net_stat);
1361 panic("cannot create neighbour proc dir entry");
1362 tbl->pde->proc_fops = &neigh_stat_seq_fops;
1363 tbl->pde->data = tbl;
1367 tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1);
1369 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
1370 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
1372 if (!tbl->hash_buckets || !tbl->phash_buckets)
1373 panic("cannot allocate neighbour cache hashes");
1375 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
1377 rwlock_init(&tbl->lock);
1378 init_timer(&tbl->gc_timer);
1379 tbl->gc_timer.data = (unsigned long)tbl;
1380 tbl->gc_timer.function = neigh_periodic_timer;
1381 tbl->gc_timer.expires = now + 1;
1382 add_timer(&tbl->gc_timer);
1384 init_timer(&tbl->proxy_timer);
1385 tbl->proxy_timer.data = (unsigned long)tbl;
1386 tbl->proxy_timer.function = neigh_proxy_process;
1387 skb_queue_head_init_class(&tbl->proxy_queue,
1388 &neigh_table_proxy_queue_class);
1390 tbl->last_flush = now;
1391 tbl->last_rand = now + tbl->parms.reachable_time * 20;
1394 void neigh_table_init(struct neigh_table *tbl)
1396 struct neigh_table *tmp;
1398 neigh_table_init_no_netlink(tbl);
1399 write_lock(&neigh_tbl_lock);
1400 for (tmp = neigh_tables; tmp; tmp = tmp->next) {
1401 if (tmp->family == tbl->family)
1404 tbl->next = neigh_tables;
1406 write_unlock(&neigh_tbl_lock);
1408 if (unlikely(tmp)) {
1409 printk(KERN_ERR "NEIGH: Registering multiple tables for "
1410 "family %d\n", tbl->family);
1415 int neigh_table_clear(struct neigh_table *tbl)
1417 struct neigh_table **tp;
1419 /* It is not clean... Fix it to unload IPv6 module safely */
1420 del_timer_sync(&tbl->gc_timer);
1421 del_timer_sync(&tbl->proxy_timer);
1422 pneigh_queue_purge(&tbl->proxy_queue);
1423 neigh_ifdown(tbl, NULL);
1424 if (atomic_read(&tbl->entries))
1425 printk(KERN_CRIT "neighbour leakage\n");
1426 write_lock(&neigh_tbl_lock);
1427 for (tp = &neigh_tables; *tp; tp = &(*tp)->next) {
1433 write_unlock(&neigh_tbl_lock);
1435 neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1);
1436 tbl->hash_buckets = NULL;
1438 kfree(tbl->phash_buckets);
1439 tbl->phash_buckets = NULL;
1441 free_percpu(tbl->stats);
1447 static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1450 struct nlattr *dst_attr;
1451 struct neigh_table *tbl;
1452 struct net_device *dev = NULL;
1455 if (nlmsg_len(nlh) < sizeof(*ndm))
1458 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1459 if (dst_attr == NULL)
1462 ndm = nlmsg_data(nlh);
1463 if (ndm->ndm_ifindex) {
1464 dev = dev_get_by_index(ndm->ndm_ifindex);
1471 read_lock(&neigh_tbl_lock);
1472 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1473 struct neighbour *neigh;
1475 if (tbl->family != ndm->ndm_family)
1477 read_unlock(&neigh_tbl_lock);
1479 if (nla_len(dst_attr) < tbl->key_len)
1482 if (ndm->ndm_flags & NTF_PROXY) {
1483 err = pneigh_delete(tbl, nla_data(dst_attr), dev);
1490 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1491 if (neigh == NULL) {
1496 err = neigh_update(neigh, NULL, NUD_FAILED,
1497 NEIGH_UPDATE_F_OVERRIDE |
1498 NEIGH_UPDATE_F_ADMIN);
1499 neigh_release(neigh);
1502 read_unlock(&neigh_tbl_lock);
1503 err = -EAFNOSUPPORT;
1512 static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1515 struct nlattr *tb[NDA_MAX+1];
1516 struct neigh_table *tbl;
1517 struct net_device *dev = NULL;
1520 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
1525 if (tb[NDA_DST] == NULL)
1528 ndm = nlmsg_data(nlh);
1529 if (ndm->ndm_ifindex) {
1530 dev = dev_get_by_index(ndm->ndm_ifindex);
1536 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
1540 read_lock(&neigh_tbl_lock);
1541 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1542 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
1543 struct neighbour *neigh;
1546 if (tbl->family != ndm->ndm_family)
1548 read_unlock(&neigh_tbl_lock);
1550 if (nla_len(tb[NDA_DST]) < tbl->key_len)
1552 dst = nla_data(tb[NDA_DST]);
1553 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
1555 if (ndm->ndm_flags & NTF_PROXY) {
1556 struct pneigh_entry *pn;
1559 pn = pneigh_lookup(tbl, dst, dev, 1);
1561 pn->flags = ndm->ndm_flags;
1570 neigh = neigh_lookup(tbl, dst, dev);
1571 if (neigh == NULL) {
1572 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1577 neigh = __neigh_lookup_errno(tbl, dst, dev);
1578 if (IS_ERR(neigh)) {
1579 err = PTR_ERR(neigh);
1583 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1585 neigh_release(neigh);
1589 if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
1590 flags &= ~NEIGH_UPDATE_F_OVERRIDE;
1593 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
1594 neigh_release(neigh);
1598 read_unlock(&neigh_tbl_lock);
1599 err = -EAFNOSUPPORT;
1608 static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1610 struct nlattr *nest;
1612 nest = nla_nest_start(skb, NDTA_PARMS);
1617 NLA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex);
1619 NLA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt));
1620 NLA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len);
1621 NLA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen);
1622 NLA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes);
1623 NLA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes);
1624 NLA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes);
1625 NLA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time);
1626 NLA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME,
1627 parms->base_reachable_time);
1628 NLA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime);
1629 NLA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time);
1630 NLA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time);
1631 NLA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay);
1632 NLA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay);
1633 NLA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime);
1635 return nla_nest_end(skb, nest);
1638 return nla_nest_cancel(skb, nest);
1641 static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
1642 u32 pid, u32 seq, int type, int flags)
1644 struct nlmsghdr *nlh;
1645 struct ndtmsg *ndtmsg;
1647 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1651 ndtmsg = nlmsg_data(nlh);
1653 read_lock_bh(&tbl->lock);
1654 ndtmsg->ndtm_family = tbl->family;
1655 ndtmsg->ndtm_pad1 = 0;
1656 ndtmsg->ndtm_pad2 = 0;
1658 NLA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1659 NLA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval);
1660 NLA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1);
1661 NLA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2);
1662 NLA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3);
1665 unsigned long now = jiffies;
1666 unsigned int flush_delta = now - tbl->last_flush;
1667 unsigned int rand_delta = now - tbl->last_rand;
1669 struct ndt_config ndc = {
1670 .ndtc_key_len = tbl->key_len,
1671 .ndtc_entry_size = tbl->entry_size,
1672 .ndtc_entries = atomic_read(&tbl->entries),
1673 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
1674 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
1675 .ndtc_hash_rnd = tbl->hash_rnd,
1676 .ndtc_hash_mask = tbl->hash_mask,
1677 .ndtc_hash_chain_gc = tbl->hash_chain_gc,
1678 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
1681 NLA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc);
1686 struct ndt_stats ndst;
1688 memset(&ndst, 0, sizeof(ndst));
1690 for_each_possible_cpu(cpu) {
1691 struct neigh_statistics *st;
1693 st = per_cpu_ptr(tbl->stats, cpu);
1694 ndst.ndts_allocs += st->allocs;
1695 ndst.ndts_destroys += st->destroys;
1696 ndst.ndts_hash_grows += st->hash_grows;
1697 ndst.ndts_res_failed += st->res_failed;
1698 ndst.ndts_lookups += st->lookups;
1699 ndst.ndts_hits += st->hits;
1700 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1701 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1702 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1703 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1706 NLA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst);
1709 BUG_ON(tbl->parms.dev);
1710 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
1711 goto nla_put_failure;
1713 read_unlock_bh(&tbl->lock);
1714 return nlmsg_end(skb, nlh);
1717 read_unlock_bh(&tbl->lock);
1718 nlmsg_cancel(skb, nlh);
1722 static int neightbl_fill_param_info(struct sk_buff *skb,
1723 struct neigh_table *tbl,
1724 struct neigh_parms *parms,
1725 u32 pid, u32 seq, int type,
1728 struct ndtmsg *ndtmsg;
1729 struct nlmsghdr *nlh;
1731 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1735 ndtmsg = nlmsg_data(nlh);
1737 read_lock_bh(&tbl->lock);
1738 ndtmsg->ndtm_family = tbl->family;
1739 ndtmsg->ndtm_pad1 = 0;
1740 ndtmsg->ndtm_pad2 = 0;
1742 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
1743 neightbl_fill_parms(skb, parms) < 0)
1746 read_unlock_bh(&tbl->lock);
1747 return nlmsg_end(skb, nlh);
1749 read_unlock_bh(&tbl->lock);
1750 nlmsg_cancel(skb, nlh);
1754 static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl,
1757 struct neigh_parms *p;
1759 for (p = &tbl->parms; p; p = p->next)
1760 if ((p->dev && p->dev->ifindex == ifindex) ||
1761 (!p->dev && !ifindex))
1767 static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
1768 [NDTA_NAME] = { .type = NLA_STRING },
1769 [NDTA_THRESH1] = { .type = NLA_U32 },
1770 [NDTA_THRESH2] = { .type = NLA_U32 },
1771 [NDTA_THRESH3] = { .type = NLA_U32 },
1772 [NDTA_GC_INTERVAL] = { .type = NLA_U64 },
1773 [NDTA_PARMS] = { .type = NLA_NESTED },
1776 static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
1777 [NDTPA_IFINDEX] = { .type = NLA_U32 },
1778 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 },
1779 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 },
1780 [NDTPA_APP_PROBES] = { .type = NLA_U32 },
1781 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 },
1782 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 },
1783 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 },
1784 [NDTPA_GC_STALETIME] = { .type = NLA_U64 },
1785 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 },
1786 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 },
1787 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 },
1788 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 },
1789 [NDTPA_LOCKTIME] = { .type = NLA_U64 },
1792 static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1794 struct neigh_table *tbl;
1795 struct ndtmsg *ndtmsg;
1796 struct nlattr *tb[NDTA_MAX+1];
1799 err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
1800 nl_neightbl_policy);
1804 if (tb[NDTA_NAME] == NULL) {
1809 ndtmsg = nlmsg_data(nlh);
1810 read_lock(&neigh_tbl_lock);
1811 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1812 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1815 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0)
1825 * We acquire tbl->lock to be nice to the periodic timers and
1826 * make sure they always see a consistent set of values.
1828 write_lock_bh(&tbl->lock);
1830 if (tb[NDTA_PARMS]) {
1831 struct nlattr *tbp[NDTPA_MAX+1];
1832 struct neigh_parms *p;
1835 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
1836 nl_ntbl_parm_policy);
1838 goto errout_tbl_lock;
1840 if (tbp[NDTPA_IFINDEX])
1841 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
1843 p = lookup_neigh_params(tbl, ifindex);
1846 goto errout_tbl_lock;
1849 for (i = 1; i <= NDTPA_MAX; i++) {
1854 case NDTPA_QUEUE_LEN:
1855 p->queue_len = nla_get_u32(tbp[i]);
1857 case NDTPA_PROXY_QLEN:
1858 p->proxy_qlen = nla_get_u32(tbp[i]);
1860 case NDTPA_APP_PROBES:
1861 p->app_probes = nla_get_u32(tbp[i]);
1863 case NDTPA_UCAST_PROBES:
1864 p->ucast_probes = nla_get_u32(tbp[i]);
1866 case NDTPA_MCAST_PROBES:
1867 p->mcast_probes = nla_get_u32(tbp[i]);
1869 case NDTPA_BASE_REACHABLE_TIME:
1870 p->base_reachable_time = nla_get_msecs(tbp[i]);
1872 case NDTPA_GC_STALETIME:
1873 p->gc_staletime = nla_get_msecs(tbp[i]);
1875 case NDTPA_DELAY_PROBE_TIME:
1876 p->delay_probe_time = nla_get_msecs(tbp[i]);
1878 case NDTPA_RETRANS_TIME:
1879 p->retrans_time = nla_get_msecs(tbp[i]);
1881 case NDTPA_ANYCAST_DELAY:
1882 p->anycast_delay = nla_get_msecs(tbp[i]);
1884 case NDTPA_PROXY_DELAY:
1885 p->proxy_delay = nla_get_msecs(tbp[i]);
1887 case NDTPA_LOCKTIME:
1888 p->locktime = nla_get_msecs(tbp[i]);
1894 if (tb[NDTA_THRESH1])
1895 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
1897 if (tb[NDTA_THRESH2])
1898 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
1900 if (tb[NDTA_THRESH3])
1901 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
1903 if (tb[NDTA_GC_INTERVAL])
1904 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
1909 write_unlock_bh(&tbl->lock);
1911 read_unlock(&neigh_tbl_lock);
1916 static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1918 int family, tidx, nidx = 0;
1919 int tbl_skip = cb->args[0];
1920 int neigh_skip = cb->args[1];
1921 struct neigh_table *tbl;
1923 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
1925 read_lock(&neigh_tbl_lock);
1926 for (tbl = neigh_tables, tidx = 0; tbl; tbl = tbl->next, tidx++) {
1927 struct neigh_parms *p;
1929 if (tidx < tbl_skip || (family && tbl->family != family))
1932 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).pid,
1933 cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
1937 for (nidx = 0, p = tbl->parms.next; p; p = p->next, nidx++) {
1938 if (nidx < neigh_skip)
1941 if (neightbl_fill_param_info(skb, tbl, p,
1942 NETLINK_CB(cb->skb).pid,
1952 read_unlock(&neigh_tbl_lock);
1959 static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
1960 u32 pid, u32 seq, int type, unsigned int flags)
1962 unsigned long now = jiffies;
1963 struct nda_cacheinfo ci;
1964 struct nlmsghdr *nlh;
1967 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
1971 ndm = nlmsg_data(nlh);
1972 ndm->ndm_family = neigh->ops->family;
1975 ndm->ndm_flags = neigh->flags;
1976 ndm->ndm_type = neigh->type;
1977 ndm->ndm_ifindex = neigh->dev->ifindex;
1979 NLA_PUT(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key);
1981 read_lock_bh(&neigh->lock);
1982 ndm->ndm_state = neigh->nud_state;
1983 if ((neigh->nud_state & NUD_VALID) &&
1984 nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, neigh->ha) < 0) {
1985 read_unlock_bh(&neigh->lock);
1986 goto nla_put_failure;
1989 ci.ndm_used = now - neigh->used;
1990 ci.ndm_confirmed = now - neigh->confirmed;
1991 ci.ndm_updated = now - neigh->updated;
1992 ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1;
1993 read_unlock_bh(&neigh->lock);
1995 NLA_PUT_U32(skb, NDA_PROBES, atomic_read(&neigh->probes));
1996 NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
1998 return nlmsg_end(skb, nlh);
2001 nlmsg_cancel(skb, nlh);
2006 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2007 struct netlink_callback *cb)
2009 struct neighbour *n;
2010 int rc, h, s_h = cb->args[1];
2011 int idx, s_idx = idx = cb->args[2];
2013 read_lock_bh(&tbl->lock);
2014 for (h = 0; h <= tbl->hash_mask; h++) {
2019 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next, idx++) {
2022 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid,
2025 NLM_F_MULTI) <= 0) {
2026 read_unlock_bh(&tbl->lock);
2032 read_unlock_bh(&tbl->lock);
2040 static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
2042 struct neigh_table *tbl;
2045 read_lock(&neigh_tbl_lock);
2046 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
2049 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
2050 if (t < s_t || (family && tbl->family != family))
2053 memset(&cb->args[1], 0, sizeof(cb->args) -
2054 sizeof(cb->args[0]));
2055 if (neigh_dump_table(tbl, skb, cb) < 0)
2058 read_unlock(&neigh_tbl_lock);
2064 void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2068 read_lock_bh(&tbl->lock);
2069 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2070 struct neighbour *n;
2072 for (n = tbl->hash_buckets[chain]; n; n = n->next)
2075 read_unlock_bh(&tbl->lock);
2077 EXPORT_SYMBOL(neigh_for_each);
2079 /* The tbl->lock must be held as a writer and BH disabled. */
2080 void __neigh_for_each_release(struct neigh_table *tbl,
2081 int (*cb)(struct neighbour *))
2085 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2086 struct neighbour *n, **np;
2088 np = &tbl->hash_buckets[chain];
2089 while ((n = *np) != NULL) {
2092 write_lock(&n->lock);
2099 write_unlock(&n->lock);
2101 neigh_cleanup_and_release(n);
2105 EXPORT_SYMBOL(__neigh_for_each_release);
2107 #ifdef CONFIG_PROC_FS
2109 static struct neighbour *neigh_get_first(struct seq_file *seq)
2111 struct neigh_seq_state *state = seq->private;
2112 struct neigh_table *tbl = state->tbl;
2113 struct neighbour *n = NULL;
2114 int bucket = state->bucket;
2116 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2117 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) {
2118 n = tbl->hash_buckets[bucket];
2121 if (state->neigh_sub_iter) {
2125 v = state->neigh_sub_iter(state, n, &fakep);
2129 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2131 if (n->nud_state & ~NUD_NOARP)
2140 state->bucket = bucket;
2145 static struct neighbour *neigh_get_next(struct seq_file *seq,
2146 struct neighbour *n,
2149 struct neigh_seq_state *state = seq->private;
2150 struct neigh_table *tbl = state->tbl;
2152 if (state->neigh_sub_iter) {
2153 void *v = state->neigh_sub_iter(state, n, pos);
2161 if (state->neigh_sub_iter) {
2162 void *v = state->neigh_sub_iter(state, n, pos);
2167 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2170 if (n->nud_state & ~NUD_NOARP)
2179 if (++state->bucket > tbl->hash_mask)
2182 n = tbl->hash_buckets[state->bucket];
2190 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2192 struct neighbour *n = neigh_get_first(seq);
2196 n = neigh_get_next(seq, n, pos);
2201 return *pos ? NULL : n;
2204 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2206 struct neigh_seq_state *state = seq->private;
2207 struct neigh_table *tbl = state->tbl;
2208 struct pneigh_entry *pn = NULL;
2209 int bucket = state->bucket;
2211 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2212 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2213 pn = tbl->phash_buckets[bucket];
2217 state->bucket = bucket;
2222 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2223 struct pneigh_entry *pn,
2226 struct neigh_seq_state *state = seq->private;
2227 struct neigh_table *tbl = state->tbl;
2231 if (++state->bucket > PNEIGH_HASHMASK)
2233 pn = tbl->phash_buckets[state->bucket];
2244 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2246 struct pneigh_entry *pn = pneigh_get_first(seq);
2250 pn = pneigh_get_next(seq, pn, pos);
2255 return *pos ? NULL : pn;
2258 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2260 struct neigh_seq_state *state = seq->private;
2263 rc = neigh_get_idx(seq, pos);
2264 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2265 rc = pneigh_get_idx(seq, pos);
2270 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
2272 struct neigh_seq_state *state = seq->private;
2273 loff_t pos_minus_one;
2277 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2279 read_lock_bh(&tbl->lock);
2281 pos_minus_one = *pos - 1;
2282 return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN;
2284 EXPORT_SYMBOL(neigh_seq_start);
2286 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2288 struct neigh_seq_state *state;
2291 if (v == SEQ_START_TOKEN) {
2292 rc = neigh_get_idx(seq, pos);
2296 state = seq->private;
2297 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2298 rc = neigh_get_next(seq, v, NULL);
2301 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2302 rc = pneigh_get_first(seq);
2304 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2305 rc = pneigh_get_next(seq, v, NULL);
2311 EXPORT_SYMBOL(neigh_seq_next);
2313 void neigh_seq_stop(struct seq_file *seq, void *v)
2315 struct neigh_seq_state *state = seq->private;
2316 struct neigh_table *tbl = state->tbl;
2318 read_unlock_bh(&tbl->lock);
2320 EXPORT_SYMBOL(neigh_seq_stop);
2322 /* statistics via seq_file */
2324 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2326 struct proc_dir_entry *pde = seq->private;
2327 struct neigh_table *tbl = pde->data;
2331 return SEQ_START_TOKEN;
2333 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
2334 if (!cpu_possible(cpu))
2337 return per_cpu_ptr(tbl->stats, cpu);
2342 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2344 struct proc_dir_entry *pde = seq->private;
2345 struct neigh_table *tbl = pde->data;
2348 for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
2349 if (!cpu_possible(cpu))
2352 return per_cpu_ptr(tbl->stats, cpu);
2357 static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2362 static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2364 struct proc_dir_entry *pde = seq->private;
2365 struct neigh_table *tbl = pde->data;
2366 struct neigh_statistics *st = v;
2368 if (v == SEQ_START_TOKEN) {
2369 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");
2373 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2374 "%08lx %08lx %08lx %08lx\n",
2375 atomic_read(&tbl->entries),
2386 st->rcv_probes_mcast,
2387 st->rcv_probes_ucast,
2389 st->periodic_gc_runs,
2396 static const struct seq_operations neigh_stat_seq_ops = {
2397 .start = neigh_stat_seq_start,
2398 .next = neigh_stat_seq_next,
2399 .stop = neigh_stat_seq_stop,
2400 .show = neigh_stat_seq_show,
2403 static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2405 int ret = seq_open(file, &neigh_stat_seq_ops);
2408 struct seq_file *sf = file->private_data;
2409 sf->private = PDE(inode);
2414 static const struct file_operations neigh_stat_seq_fops = {
2415 .owner = THIS_MODULE,
2416 .open = neigh_stat_seq_open,
2418 .llseek = seq_lseek,
2419 .release = seq_release,
2422 #endif /* CONFIG_PROC_FS */
2425 static inline size_t neigh_nlmsg_size(void)
2427 return NLMSG_ALIGN(sizeof(struct ndmsg))
2428 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2429 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2430 + nla_total_size(sizeof(struct nda_cacheinfo))
2431 + nla_total_size(4); /* NDA_PROBES */
2434 static void __neigh_notify(struct neighbour *n, int type, int flags)
2436 struct sk_buff *skb;
2439 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
2443 err = neigh_fill_info(skb, n, 0, 0, type, flags);
2445 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2446 WARN_ON(err == -EMSGSIZE);
2450 err = rtnl_notify(skb, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
2453 rtnl_set_sk_err(RTNLGRP_NEIGH, err);
2456 void neigh_app_ns(struct neighbour *n)
2458 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
2461 static void neigh_app_notify(struct neighbour *n)
2463 __neigh_notify(n, RTM_NEWNEIGH, 0);
2466 #endif /* CONFIG_ARPD */
2468 #ifdef CONFIG_SYSCTL
2470 static struct neigh_sysctl_table {
2471 struct ctl_table_header *sysctl_header;
2472 ctl_table neigh_vars[__NET_NEIGH_MAX];
2473 ctl_table neigh_dev[2];
2474 ctl_table neigh_neigh_dir[2];
2475 ctl_table neigh_proto_dir[2];
2476 ctl_table neigh_root_dir[2];
2477 } neigh_sysctl_template __read_mostly = {
2480 .ctl_name = NET_NEIGH_MCAST_SOLICIT,
2481 .procname = "mcast_solicit",
2482 .maxlen = sizeof(int),
2484 .proc_handler = &proc_dointvec,
2487 .ctl_name = NET_NEIGH_UCAST_SOLICIT,
2488 .procname = "ucast_solicit",
2489 .maxlen = sizeof(int),
2491 .proc_handler = &proc_dointvec,
2494 .ctl_name = NET_NEIGH_APP_SOLICIT,
2495 .procname = "app_solicit",
2496 .maxlen = sizeof(int),
2498 .proc_handler = &proc_dointvec,
2501 .ctl_name = NET_NEIGH_RETRANS_TIME,
2502 .procname = "retrans_time",
2503 .maxlen = sizeof(int),
2505 .proc_handler = &proc_dointvec_userhz_jiffies,
2508 .ctl_name = NET_NEIGH_REACHABLE_TIME,
2509 .procname = "base_reachable_time",
2510 .maxlen = sizeof(int),
2512 .proc_handler = &proc_dointvec_jiffies,
2513 .strategy = &sysctl_jiffies,
2516 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME,
2517 .procname = "delay_first_probe_time",
2518 .maxlen = sizeof(int),
2520 .proc_handler = &proc_dointvec_jiffies,
2521 .strategy = &sysctl_jiffies,
2524 .ctl_name = NET_NEIGH_GC_STALE_TIME,
2525 .procname = "gc_stale_time",
2526 .maxlen = sizeof(int),
2528 .proc_handler = &proc_dointvec_jiffies,
2529 .strategy = &sysctl_jiffies,
2532 .ctl_name = NET_NEIGH_UNRES_QLEN,
2533 .procname = "unres_qlen",
2534 .maxlen = sizeof(int),
2536 .proc_handler = &proc_dointvec,
2539 .ctl_name = NET_NEIGH_PROXY_QLEN,
2540 .procname = "proxy_qlen",
2541 .maxlen = sizeof(int),
2543 .proc_handler = &proc_dointvec,
2546 .ctl_name = NET_NEIGH_ANYCAST_DELAY,
2547 .procname = "anycast_delay",
2548 .maxlen = sizeof(int),
2550 .proc_handler = &proc_dointvec_userhz_jiffies,
2553 .ctl_name = NET_NEIGH_PROXY_DELAY,
2554 .procname = "proxy_delay",
2555 .maxlen = sizeof(int),
2557 .proc_handler = &proc_dointvec_userhz_jiffies,
2560 .ctl_name = NET_NEIGH_LOCKTIME,
2561 .procname = "locktime",
2562 .maxlen = sizeof(int),
2564 .proc_handler = &proc_dointvec_userhz_jiffies,
2567 .ctl_name = NET_NEIGH_GC_INTERVAL,
2568 .procname = "gc_interval",
2569 .maxlen = sizeof(int),
2571 .proc_handler = &proc_dointvec_jiffies,
2572 .strategy = &sysctl_jiffies,
2575 .ctl_name = NET_NEIGH_GC_THRESH1,
2576 .procname = "gc_thresh1",
2577 .maxlen = sizeof(int),
2579 .proc_handler = &proc_dointvec,
2582 .ctl_name = NET_NEIGH_GC_THRESH2,
2583 .procname = "gc_thresh2",
2584 .maxlen = sizeof(int),
2586 .proc_handler = &proc_dointvec,
2589 .ctl_name = NET_NEIGH_GC_THRESH3,
2590 .procname = "gc_thresh3",
2591 .maxlen = sizeof(int),
2593 .proc_handler = &proc_dointvec,
2596 .ctl_name = NET_NEIGH_RETRANS_TIME_MS,
2597 .procname = "retrans_time_ms",
2598 .maxlen = sizeof(int),
2600 .proc_handler = &proc_dointvec_ms_jiffies,
2601 .strategy = &sysctl_ms_jiffies,
2604 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS,
2605 .procname = "base_reachable_time_ms",
2606 .maxlen = sizeof(int),
2608 .proc_handler = &proc_dointvec_ms_jiffies,
2609 .strategy = &sysctl_ms_jiffies,
2614 .ctl_name = NET_PROTO_CONF_DEFAULT,
2615 .procname = "default",
2619 .neigh_neigh_dir = {
2621 .procname = "neigh",
2625 .neigh_proto_dir = {
2632 .ctl_name = CTL_NET,
2639 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
2640 int p_id, int pdev_id, char *p_name,
2641 proc_handler *handler, ctl_handler *strategy)
2643 struct neigh_sysctl_table *t = kmemdup(&neigh_sysctl_template,
2644 sizeof(*t), GFP_KERNEL);
2645 const char *dev_name_source = NULL;
2646 char *dev_name = NULL;
2651 t->neigh_vars[0].data = &p->mcast_probes;
2652 t->neigh_vars[1].data = &p->ucast_probes;
2653 t->neigh_vars[2].data = &p->app_probes;
2654 t->neigh_vars[3].data = &p->retrans_time;
2655 t->neigh_vars[4].data = &p->base_reachable_time;
2656 t->neigh_vars[5].data = &p->delay_probe_time;
2657 t->neigh_vars[6].data = &p->gc_staletime;
2658 t->neigh_vars[7].data = &p->queue_len;
2659 t->neigh_vars[8].data = &p->proxy_qlen;
2660 t->neigh_vars[9].data = &p->anycast_delay;
2661 t->neigh_vars[10].data = &p->proxy_delay;
2662 t->neigh_vars[11].data = &p->locktime;
2665 dev_name_source = dev->name;
2666 t->neigh_dev[0].ctl_name = dev->ifindex;
2667 t->neigh_vars[12].procname = NULL;
2668 t->neigh_vars[13].procname = NULL;
2669 t->neigh_vars[14].procname = NULL;
2670 t->neigh_vars[15].procname = NULL;
2672 dev_name_source = t->neigh_dev[0].procname;
2673 t->neigh_vars[12].data = (int *)(p + 1);
2674 t->neigh_vars[13].data = (int *)(p + 1) + 1;
2675 t->neigh_vars[14].data = (int *)(p + 1) + 2;
2676 t->neigh_vars[15].data = (int *)(p + 1) + 3;
2679 t->neigh_vars[16].data = &p->retrans_time;
2680 t->neigh_vars[17].data = &p->base_reachable_time;
2682 if (handler || strategy) {
2684 t->neigh_vars[3].proc_handler = handler;
2685 t->neigh_vars[3].strategy = strategy;
2686 t->neigh_vars[3].extra1 = dev;
2688 t->neigh_vars[4].proc_handler = handler;
2689 t->neigh_vars[4].strategy = strategy;
2690 t->neigh_vars[4].extra1 = dev;
2691 /* RetransTime (in milliseconds)*/
2692 t->neigh_vars[16].proc_handler = handler;
2693 t->neigh_vars[16].strategy = strategy;
2694 t->neigh_vars[16].extra1 = dev;
2695 /* ReachableTime (in milliseconds) */
2696 t->neigh_vars[17].proc_handler = handler;
2697 t->neigh_vars[17].strategy = strategy;
2698 t->neigh_vars[17].extra1 = dev;
2701 dev_name = kstrdup(dev_name_source, GFP_KERNEL);
2707 t->neigh_dev[0].procname = dev_name;
2709 t->neigh_neigh_dir[0].ctl_name = pdev_id;
2711 t->neigh_proto_dir[0].procname = p_name;
2712 t->neigh_proto_dir[0].ctl_name = p_id;
2714 t->neigh_dev[0].child = t->neigh_vars;
2715 t->neigh_neigh_dir[0].child = t->neigh_dev;
2716 t->neigh_proto_dir[0].child = t->neigh_neigh_dir;
2717 t->neigh_root_dir[0].child = t->neigh_proto_dir;
2719 t->sysctl_header = register_sysctl_table(t->neigh_root_dir);
2720 if (!t->sysctl_header) {
2724 p->sysctl_table = t;
2736 void neigh_sysctl_unregister(struct neigh_parms *p)
2738 if (p->sysctl_table) {
2739 struct neigh_sysctl_table *t = p->sysctl_table;
2740 p->sysctl_table = NULL;
2741 unregister_sysctl_table(t->sysctl_header);
2742 kfree(t->neigh_dev[0].procname);
2747 #endif /* CONFIG_SYSCTL */
2749 static int __init neigh_init(void)
2751 rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL);
2752 rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL);
2753 rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info);
2755 rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info);
2756 rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL);
2761 subsys_initcall(neigh_init);
2763 EXPORT_SYMBOL(__neigh_event_send);
2764 EXPORT_SYMBOL(neigh_changeaddr);
2765 EXPORT_SYMBOL(neigh_compat_output);
2766 EXPORT_SYMBOL(neigh_connected_output);
2767 EXPORT_SYMBOL(neigh_create);
2768 EXPORT_SYMBOL(neigh_destroy);
2769 EXPORT_SYMBOL(neigh_event_ns);
2770 EXPORT_SYMBOL(neigh_ifdown);
2771 EXPORT_SYMBOL(neigh_lookup);
2772 EXPORT_SYMBOL(neigh_lookup_nodev);
2773 EXPORT_SYMBOL(neigh_parms_alloc);
2774 EXPORT_SYMBOL(neigh_parms_release);
2775 EXPORT_SYMBOL(neigh_rand_reach_time);
2776 EXPORT_SYMBOL(neigh_resolve_output);
2777 EXPORT_SYMBOL(neigh_table_clear);
2778 EXPORT_SYMBOL(neigh_table_init);
2779 EXPORT_SYMBOL(neigh_table_init_no_netlink);
2780 EXPORT_SYMBOL(neigh_update);
2781 EXPORT_SYMBOL(pneigh_enqueue);
2782 EXPORT_SYMBOL(pneigh_lookup);
2785 EXPORT_SYMBOL(neigh_app_ns);
2787 #ifdef CONFIG_SYSCTL
2788 EXPORT_SYMBOL(neigh_sysctl_register);
2789 EXPORT_SYMBOL(neigh_sysctl_unregister);