projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[DECNET]: Remove some redundant ifdeffed code
[linux-2.6-block.git] / net / core / neighbour.c
CommitLineData
1da177e4
LT		 1/*
2 * Generic address resolution entity
3 *
4 * Authors:
5 * Pedro Roque <roque@di.fc.ul.pt>
6 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
7 *
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.
12 *
13 * Fixes:
14 * Vitaly E. Lavrov releasing NULL neighbor in neigh_add.
15 * Harald Welte Add neighbour cache statistics like rtstat
16 */
17
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>
26#ifdef CONFIG_SYSCTL
27#include <linux/sysctl.h>
28#endif
29#include <linux/times.h>
30#include <net/neighbour.h>
31#include <net/dst.h>
32#include <net/sock.h>
33#include <linux/rtnetlink.h>
34#include <linux/random.h>
543537bd 35#include <linux/string.h>
1da177e4
LT		 36
37#define NEIGH_DEBUG 1
38
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
44
45#if NEIGH_DEBUG >= 1
46#undef NEIGH_PRINTK1
47#define NEIGH_PRINTK1 NEIGH_PRINTK
48#endif
49#if NEIGH_DEBUG >= 2
50#undef NEIGH_PRINTK2
51#define NEIGH_PRINTK2 NEIGH_PRINTK
52#endif
53
54#define PNEIGH_HASHMASK 0xF
55
56static void neigh_timer_handler(unsigned long arg);
57#ifdef CONFIG_ARPD
58static void neigh_app_notify(struct neighbour *n);
59#endif
60static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
61void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
62
63static struct neigh_table *neigh_tables;
45fc3b11 64#ifdef CONFIG_PROC_FS
1da177e4 65static struct file_operations neigh_stat_seq_fops;
45fc3b11 66#endif
1da177e4
LT		 67
68/*
69 Neighbour hash table buckets are protected with rwlock tbl->lock.
70
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
75 cache.
76 - If the entry requires some non-trivial actions, increase
77 its reference count and release table lock.
78
79 Neighbour entries are protected:
80 - with reference count.
81 - with rwlock neigh->lock
82
83 Reference count prevents destruction.
84
85 neigh->lock mainly serializes ll address data and its validity state.
86 However, the same lock is used to protect another entry fields:
87 - timer
88 - resolution queue
89
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.
94
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,
97 */
98
99static DEFINE_RWLOCK(neigh_tbl_lock);
100
101static int neigh_blackhole(struct sk_buff *skb)
102{
103 kfree_skb(skb);
104 return -ENETDOWN;
105}
106
107/*
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.
111 */
112
113unsigned long neigh_rand_reach_time(unsigned long base)
114{
115 return (base ? (net_random() % base) + (base >> 1) : 0);
116}
117
118
119static int neigh_forced_gc(struct neigh_table *tbl)
120{
121 int shrunk = 0;
122 int i;
123
124 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
125
126 write_lock_bh(&tbl->lock);
127 for (i = 0; i <= tbl->hash_mask; i++) {
128 struct neighbour *n, **np;
129
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
135 */
136 write_lock(&n->lock);
137 if (atomic_read(&n->refcnt) == 1 &&
138 !(n->nud_state & NUD_PERMANENT)) {
139 *np = n->next;
140 n->dead = 1;
141 shrunk = 1;
142 write_unlock(&n->lock);
143 neigh_release(n);
144 continue;
145 }
146 write_unlock(&n->lock);
147 np = &n->next;
148 }
149 }
150
151 tbl->last_flush = jiffies;
152
153 write_unlock_bh(&tbl->lock);
154
155 return shrunk;
156}
157
158static int neigh_del_timer(struct neighbour *n)
159{
160 if ((n->nud_state & NUD_IN_TIMER) &&
161 del_timer(&n->timer)) {
162 neigh_release(n);
163 return 1;
164 }
165 return 0;
166}
167
168static void pneigh_queue_purge(struct sk_buff_head *list)
169{
170 struct sk_buff *skb;
171
172 while ((skb = skb_dequeue(list)) != NULL) {
173 dev_put(skb->dev);
174 kfree_skb(skb);
175 }
176}
177
49636bb1 178static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
1da177e4
LT		 179{
180 int i;
181
1da177e4
LT		 182 for (i = 0; i <= tbl->hash_mask; i++) {
183 struct neighbour *n, **np = &tbl->hash_buckets[i];
184
185 while ((n = *np) != NULL) {
186 if (dev && n->dev != dev) {
187 np = &n->next;
188 continue;
189 }
190 *np = n->next;
191 write_lock(&n->lock);
192 neigh_del_timer(n);
193 n->dead = 1;
194
195 if (atomic_read(&n->refcnt) != 1) {
196 /* The most unpleasant situation.
197 We must destroy neighbour entry,
198 but someone still uses it.
199
200 The destroy will be delayed until
201 the last user releases us, but
202 we must kill timers etc. and move
203 it to safe state.
204 */
205 skb_queue_purge(&n->arp_queue);
206 n->output = neigh_blackhole;
207 if (n->nud_state & NUD_VALID)
208 n->nud_state = NUD_NOARP;
209 else
210 n->nud_state = NUD_NONE;
211 NEIGH_PRINTK2("neigh %p is stray.\n", n);
212 }
213 write_unlock(&n->lock);
214 neigh_release(n);
215 }
216 }
49636bb1 217}
1da177e4 218
49636bb1
HX		 219void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
220{
221 write_lock_bh(&tbl->lock);
222 neigh_flush_dev(tbl, dev);
223 write_unlock_bh(&tbl->lock);
224}
225
226int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
227{
228 write_lock_bh(&tbl->lock);
229 neigh_flush_dev(tbl, dev);
1da177e4
LT		 230 pneigh_ifdown(tbl, dev);
231 write_unlock_bh(&tbl->lock);
232
233 del_timer_sync(&tbl->proxy_timer);
234 pneigh_queue_purge(&tbl->proxy_queue);
235 return 0;
236}
237
238static struct neighbour *neigh_alloc(struct neigh_table *tbl)
239{
240 struct neighbour *n = NULL;
241 unsigned long now = jiffies;
242 int entries;
243
244 entries = atomic_inc_return(&tbl->entries) - 1;
245 if (entries >= tbl->gc_thresh3 ||
246 (entries >= tbl->gc_thresh2 &&
247 time_after(now, tbl->last_flush + 5 * HZ))) {
248 if (!neigh_forced_gc(tbl) &&
249 entries >= tbl->gc_thresh3)
250 goto out_entries;
251 }
252
253 n = kmem_cache_alloc(tbl->kmem_cachep, SLAB_ATOMIC);
254 if (!n)
255 goto out_entries;
256
257 memset(n, 0, tbl->entry_size);
258
259 skb_queue_head_init(&n->arp_queue);
260 rwlock_init(&n->lock);
261 n->updated = n->used = now;
262 n->nud_state = NUD_NONE;
263 n->output = neigh_blackhole;
264 n->parms = neigh_parms_clone(&tbl->parms);
265 init_timer(&n->timer);
266 n->timer.function = neigh_timer_handler;
267 n->timer.data = (unsigned long)n;
268
269 NEIGH_CACHE_STAT_INC(tbl, allocs);
270 n->tbl = tbl;
271 atomic_set(&n->refcnt, 1);
272 n->dead = 1;
273out:
274 return n;
275
276out_entries:
277 atomic_dec(&tbl->entries);
278 goto out;
279}
280
281static struct neighbour **neigh_hash_alloc(unsigned int entries)
282{
283 unsigned long size = entries * sizeof(struct neighbour *);
284 struct neighbour **ret;
285
286 if (size <= PAGE_SIZE) {
287 ret = kmalloc(size, GFP_ATOMIC);
288 } else {
289 ret = (struct neighbour **)
290 __get_free_pages(GFP_ATOMIC, get_order(size));
291 }
292 if (ret)
293 memset(ret, 0, size);
294
295 return ret;
296}
297
298static void neigh_hash_free(struct neighbour **hash, unsigned int entries)
299{
300 unsigned long size = entries * sizeof(struct neighbour *);
301
302 if (size <= PAGE_SIZE)
303 kfree(hash);
304 else
305 free_pages((unsigned long)hash, get_order(size));
306}
307
308static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries)
309{
310 struct neighbour **new_hash, **old_hash;
311 unsigned int i, new_hash_mask, old_entries;
312
313 NEIGH_CACHE_STAT_INC(tbl, hash_grows);
314
315 BUG_ON(new_entries & (new_entries - 1));
316 new_hash = neigh_hash_alloc(new_entries);
317 if (!new_hash)
318 return;
319
320 old_entries = tbl->hash_mask + 1;
321 new_hash_mask = new_entries - 1;
322 old_hash = tbl->hash_buckets;
323
324 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
325 for (i = 0; i < old_entries; i++) {
326 struct neighbour *n, *next;
327
328 for (n = old_hash[i]; n; n = next) {
329 unsigned int hash_val = tbl->hash(n->primary_key, n->dev);
330
331 hash_val &= new_hash_mask;
332 next = n->next;
333
334 n->next = new_hash[hash_val];
335 new_hash[hash_val] = n;
336 }
337 }
338 tbl->hash_buckets = new_hash;
339 tbl->hash_mask = new_hash_mask;
340
341 neigh_hash_free(old_hash, old_entries);
342}
343
344struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
345 struct net_device *dev)
346{
347 struct neighbour *n;
348 int key_len = tbl->key_len;
349 u32 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;
350
351 NEIGH_CACHE_STAT_INC(tbl, lookups);
352
353 read_lock_bh(&tbl->lock);
354 for (n = tbl->hash_buckets[hash_val]; n; n = n->next) {
355 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
356 neigh_hold(n);
357 NEIGH_CACHE_STAT_INC(tbl, hits);
358 break;
359 }
360 }
361 read_unlock_bh(&tbl->lock);
362 return n;
363}
364
365struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, const void *pkey)
366{
367 struct neighbour *n;
368 int key_len = tbl->key_len;
369 u32 hash_val = tbl->hash(pkey, NULL) & tbl->hash_mask;
370
371 NEIGH_CACHE_STAT_INC(tbl, lookups);
372
373 read_lock_bh(&tbl->lock);
374 for (n = tbl->hash_buckets[hash_val]; n; n = n->next) {
375 if (!memcmp(n->primary_key, pkey, key_len)) {
376 neigh_hold(n);
377 NEIGH_CACHE_STAT_INC(tbl, hits);
378 break;
379 }
380 }
381 read_unlock_bh(&tbl->lock);
382 return n;
383}
384
385struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey,
386 struct net_device *dev)
387{
388 u32 hash_val;
389 int key_len = tbl->key_len;
390 int error;
391 struct neighbour *n1, *rc, *n = neigh_alloc(tbl);
392
393 if (!n) {
394 rc = ERR_PTR(-ENOBUFS);
395 goto out;
396 }
397
398 memcpy(n->primary_key, pkey, key_len);
399 n->dev = dev;
400 dev_hold(dev);
401
402 /* Protocol specific setup. */
403 if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
404 rc = ERR_PTR(error);
405 goto out_neigh_release;
406 }
407
408 /* Device specific setup. */
409 if (n->parms->neigh_setup &&
410 (error = n->parms->neigh_setup(n)) < 0) {
411 rc = ERR_PTR(error);
412 goto out_neigh_release;
413 }
414
415 n->confirmed = jiffies - (n->parms->base_reachable_time << 1);
416
417 write_lock_bh(&tbl->lock);
418
419 if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1))
420 neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1);
421
422 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;
423
424 if (n->parms->dead) {
425 rc = ERR_PTR(-EINVAL);
426 goto out_tbl_unlock;
427 }
428
429 for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) {
430 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
431 neigh_hold(n1);
432 rc = n1;
433 goto out_tbl_unlock;
434 }
435 }
436
437 n->next = tbl->hash_buckets[hash_val];
438 tbl->hash_buckets[hash_val] = n;
439 n->dead = 0;
440 neigh_hold(n);
441 write_unlock_bh(&tbl->lock);
442 NEIGH_PRINTK2("neigh %p is created.\n", n);
443 rc = n;
444out:
445 return rc;
446out_tbl_unlock:
447 write_unlock_bh(&tbl->lock);
448out_neigh_release:
449 neigh_release(n);
450 goto out;
451}
452
453struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, const void *pkey,
454 struct net_device *dev, int creat)
455{
456 struct pneigh_entry *n;
457 int key_len = tbl->key_len;
458 u32 hash_val = *(u32 *)(pkey + key_len - 4);
459
460 hash_val ^= (hash_val >> 16);
461 hash_val ^= hash_val >> 8;
462 hash_val ^= hash_val >> 4;
463 hash_val &= PNEIGH_HASHMASK;
464
465 read_lock_bh(&tbl->lock);
466
467 for (n = tbl->phash_buckets[hash_val]; n; n = n->next) {
468 if (!memcmp(n->key, pkey, key_len) &&
469 (n->dev == dev || !n->dev)) {
470 read_unlock_bh(&tbl->lock);
471 goto out;
472 }
473 }
474 read_unlock_bh(&tbl->lock);
475 n = NULL;
476 if (!creat)
477 goto out;
478
479 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
480 if (!n)
481 goto out;
482
483 memcpy(n->key, pkey, key_len);
484 n->dev = dev;
485 if (dev)
486 dev_hold(dev);
487
488 if (tbl->pconstructor && tbl->pconstructor(n)) {
489 if (dev)
490 dev_put(dev);
491 kfree(n);
492 n = NULL;
493 goto out;
494 }
495
496 write_lock_bh(&tbl->lock);
497 n->next = tbl->phash_buckets[hash_val];
498 tbl->phash_buckets[hash_val] = n;
499 write_unlock_bh(&tbl->lock);
500out:
501 return n;
502}
503
504
505int pneigh_delete(struct neigh_table *tbl, const void *pkey,
506 struct net_device *dev)
507{
508 struct pneigh_entry *n, **np;
509 int key_len = tbl->key_len;
510 u32 hash_val = *(u32 *)(pkey + key_len - 4);
511
512 hash_val ^= (hash_val >> 16);
513 hash_val ^= hash_val >> 8;
514 hash_val ^= hash_val >> 4;
515 hash_val &= PNEIGH_HASHMASK;
516
517 write_lock_bh(&tbl->lock);
518 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
519 np = &n->next) {
520 if (!memcmp(n->key, pkey, key_len) && n->dev == dev) {
521 *np = n->next;
522 write_unlock_bh(&tbl->lock);
523 if (tbl->pdestructor)
524 tbl->pdestructor(n);
525 if (n->dev)
526 dev_put(n->dev);
527 kfree(n);
528 return 0;
529 }
530 }
531 write_unlock_bh(&tbl->lock);
532 return -ENOENT;
533}
534
535static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
536{
537 struct pneigh_entry *n, **np;
538 u32 h;
539
540 for (h = 0; h <= PNEIGH_HASHMASK; h++) {
541 np = &tbl->phash_buckets[h];
542 while ((n = *np) != NULL) {
543 if (!dev || n->dev == dev) {
544 *np = n->next;
545 if (tbl->pdestructor)
546 tbl->pdestructor(n);
547 if (n->dev)
548 dev_put(n->dev);
549 kfree(n);
550 continue;
551 }
552 np = &n->next;
553 }
554 }
555 return -ENOENT;
556}
557
558
559/*
560 * neighbour must already be out of the table;
561 *
562 */
563void neigh_destroy(struct neighbour *neigh)
564{
565 struct hh_cache *hh;
566
567 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
568
569 if (!neigh->dead) {
570 printk(KERN_WARNING
571 "Destroying alive neighbour %p\n", neigh);
572 dump_stack();
573 return;
574 }
575
576 if (neigh_del_timer(neigh))
577 printk(KERN_WARNING "Impossible event.\n");
578
579 while ((hh = neigh->hh) != NULL) {
580 neigh->hh = hh->hh_next;
581 hh->hh_next = NULL;
582 write_lock_bh(&hh->hh_lock);
583 hh->hh_output = neigh_blackhole;
584 write_unlock_bh(&hh->hh_lock);
585 if (atomic_dec_and_test(&hh->hh_refcnt))
586 kfree(hh);
587 }
588
589 if (neigh->ops && neigh->ops->destructor)
590 (neigh->ops->destructor)(neigh);
591
592 skb_queue_purge(&neigh->arp_queue);
593
594 dev_put(neigh->dev);
595 neigh_parms_put(neigh->parms);
596
597 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh);
598
599 atomic_dec(&neigh->tbl->entries);
600 kmem_cache_free(neigh->tbl->kmem_cachep, neigh);
601}
602
603/* Neighbour state is suspicious;
604 disable fast path.
605
606 Called with write_locked neigh.
607 */
608static void neigh_suspect(struct neighbour *neigh)
609{
610 struct hh_cache *hh;
611
612 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
613
614 neigh->output = neigh->ops->output;
615
616 for (hh = neigh->hh; hh; hh = hh->hh_next)
617 hh->hh_output = neigh->ops->output;
618}
619
620/* Neighbour state is OK;
621 enable fast path.
622
623 Called with write_locked neigh.
624 */
625static void neigh_connect(struct neighbour *neigh)
626{
627 struct hh_cache *hh;
628
629 NEIGH_PRINTK2("neigh %p is connected.\n", neigh);
630
631 neigh->output = neigh->ops->connected_output;
632
633 for (hh = neigh->hh; hh; hh = hh->hh_next)
634 hh->hh_output = neigh->ops->hh_output;
635}
636
637static void neigh_periodic_timer(unsigned long arg)
638{
639 struct neigh_table *tbl = (struct neigh_table *)arg;
640 struct neighbour *n, **np;
641 unsigned long expire, now = jiffies;
642
643 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
644
645 write_lock(&tbl->lock);
646
647 /*
648 * periodically recompute ReachableTime from random function
649 */
650
651 if (time_after(now, tbl->last_rand + 300 * HZ)) {
652 struct neigh_parms *p;
653 tbl->last_rand = now;
654 for (p = &tbl->parms; p; p = p->next)
655 p->reachable_time =
656 neigh_rand_reach_time(p->base_reachable_time);
657 }
658
659 np = &tbl->hash_buckets[tbl->hash_chain_gc];
660 tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask);
661
662 while ((n = *np) != NULL) {
663 unsigned int state;
664
665 write_lock(&n->lock);
666
667 state = n->nud_state;
668 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
669 write_unlock(&n->lock);
670 goto next_elt;
671 }
672
673 if (time_before(n->used, n->confirmed))
674 n->used = n->confirmed;
675
676 if (atomic_read(&n->refcnt) == 1 &&
677 (state == NUD_FAILED ||
678 time_after(now, n->used + n->parms->gc_staletime))) {
679 *np = n->next;
680 n->dead = 1;
681 write_unlock(&n->lock);
682 neigh_release(n);
683 continue;
684 }
685 write_unlock(&n->lock);
686
687next_elt:
688 np = &n->next;
689 }
690
691 /* Cycle through all hash buckets every base_reachable_time/2 ticks.
692 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
693 * base_reachable_time.
694 */
695 expire = tbl->parms.base_reachable_time >> 1;
696 expire /= (tbl->hash_mask + 1);
697 if (!expire)
698 expire = 1;
699
700 mod_timer(&tbl->gc_timer, now + expire);
701
702 write_unlock(&tbl->lock);
703}
704
705static __inline__ int neigh_max_probes(struct neighbour *n)
706{
707 struct neigh_parms *p = n->parms;
708 return (n->nud_state & NUD_PROBE ?
709 p->ucast_probes :
710 p->ucast_probes + p->app_probes + p->mcast_probes);
711}
712
667347f1
DM		 713static inline void neigh_add_timer(struct neighbour *n, unsigned long when)
714{
715 if (unlikely(mod_timer(&n->timer, when))) {
716 printk("NEIGH: BUG, double timer add, state is %x\n",
717 n->nud_state);
20375502 718 dump_stack();
667347f1
DM		 719 }
720}
1da177e4
LT		 721
722/* Called when a timer expires for a neighbour entry. */
723
724static void neigh_timer_handler(unsigned long arg)
725{
726 unsigned long now, next;
727 struct neighbour *neigh = (struct neighbour *)arg;
728 unsigned state;
729 int notify = 0;
730
731 write_lock(&neigh->lock);
732
733 state = neigh->nud_state;
734 now = jiffies;
735 next = now + HZ;
736
737 if (!(state & NUD_IN_TIMER)) {
738#ifndef CONFIG_SMP
739 printk(KERN_WARNING "neigh: timer & !nud_in_timer\n");
740#endif
741 goto out;
742 }
743
744 if (state & NUD_REACHABLE) {
745 if (time_before_eq(now,
746 neigh->confirmed + neigh->parms->reachable_time)) {
747 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh);
748 next = neigh->confirmed + neigh->parms->reachable_time;
749 } else if (time_before_eq(now,
750 neigh->used + neigh->parms->delay_probe_time)) {
751 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
752 neigh->nud_state = NUD_DELAY;
753 neigh_suspect(neigh);
754 next = now + neigh->parms->delay_probe_time;
755 } else {
756 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
757 neigh->nud_state = NUD_STALE;
758 neigh_suspect(neigh);
759 }
760 } else if (state & NUD_DELAY) {
761 if (time_before_eq(now,
762 neigh->confirmed + neigh->parms->delay_probe_time)) {
763 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh);
764 neigh->nud_state = NUD_REACHABLE;
765 neigh_connect(neigh);
766 next = neigh->confirmed + neigh->parms->reachable_time;
767 } else {
768 NEIGH_PRINTK2("neigh %p is probed.\n", neigh);
769 neigh->nud_state = NUD_PROBE;
770 atomic_set(&neigh->probes, 0);
771 next = now + neigh->parms->retrans_time;
772 }
773 } else {
774 /* NUD_PROBE|NUD_INCOMPLETE */
775 next = now + neigh->parms->retrans_time;
776 }
777
778 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
779 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
780 struct sk_buff *skb;
781
782 neigh->nud_state = NUD_FAILED;
783 notify = 1;
784 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
785 NEIGH_PRINTK2("neigh %p is failed.\n", neigh);
786
787 /* It is very thin place. report_unreachable is very complicated
788 routine. Particularly, it can hit the same neighbour entry!
789
790 So that, we try to be accurate and avoid dead loop. --ANK
791 */
792 while (neigh->nud_state == NUD_FAILED &&
793 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
794 write_unlock(&neigh->lock);
795 neigh->ops->error_report(neigh, skb);
796 write_lock(&neigh->lock);
797 }
798 skb_queue_purge(&neigh->arp_queue);
799 }
800
801 if (neigh->nud_state & NUD_IN_TIMER) {
1da177e4
LT		 802 if (time_before(next, jiffies + HZ/2))
803 next = jiffies + HZ/2;
6fb9974f
HX		 804 if (!mod_timer(&neigh->timer, next))
805 neigh_hold(neigh);
1da177e4
LT		 806 }
807 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
808 struct sk_buff *skb = skb_peek(&neigh->arp_queue);
809 /* keep skb alive even if arp_queue overflows */
810 if (skb)
811 skb_get(skb);
812 write_unlock(&neigh->lock);
813 neigh->ops->solicit(neigh, skb);
814 atomic_inc(&neigh->probes);
815 if (skb)
816 kfree_skb(skb);
817 } else {
818out:
819 write_unlock(&neigh->lock);
820 }
821
822#ifdef CONFIG_ARPD
823 if (notify && neigh->parms->app_probes)
824 neigh_app_notify(neigh);
825#endif
826 neigh_release(neigh);
827}
828
829int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
830{
831 int rc;
832 unsigned long now;
833
834 write_lock_bh(&neigh->lock);
835
836 rc = 0;
837 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
838 goto out_unlock_bh;
839
840 now = jiffies;
841
842 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
843 if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
844 atomic_set(&neigh->probes, neigh->parms->ucast_probes);
845 neigh->nud_state = NUD_INCOMPLETE;
846 neigh_hold(neigh);
667347f1 847 neigh_add_timer(neigh, now + 1);
1da177e4
LT		 848 } else {
849 neigh->nud_state = NUD_FAILED;
850 write_unlock_bh(&neigh->lock);
851
852 if (skb)
853 kfree_skb(skb);
854 return 1;
855 }
856 } else if (neigh->nud_state & NUD_STALE) {
857 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
858 neigh_hold(neigh);
859 neigh->nud_state = NUD_DELAY;
667347f1
DM		 860 neigh_add_timer(neigh,
861 jiffies + neigh->parms->delay_probe_time);
1da177e4
LT		 862 }
863
864 if (neigh->nud_state == NUD_INCOMPLETE) {
865 if (skb) {
866 if (skb_queue_len(&neigh->arp_queue) >=
867 neigh->parms->queue_len) {
868 struct sk_buff *buff;
869 buff = neigh->arp_queue.next;
870 __skb_unlink(buff, &neigh->arp_queue);
871 kfree_skb(buff);
872 }
873 __skb_queue_tail(&neigh->arp_queue, skb);
874 }
875 rc = 1;
876 }
877out_unlock_bh:
878 write_unlock_bh(&neigh->lock);
879 return rc;
880}
881
882static __inline__ void neigh_update_hhs(struct neighbour *neigh)
883{
884 struct hh_cache *hh;
885 void (*update)(struct hh_cache*, struct net_device*, unsigned char *) =
886 neigh->dev->header_cache_update;
887
888 if (update) {
889 for (hh = neigh->hh; hh; hh = hh->hh_next) {
890 write_lock_bh(&hh->hh_lock);
891 update(hh, neigh->dev, neigh->ha);
892 write_unlock_bh(&hh->hh_lock);
893 }
894 }
895}
896
897
898
899/* Generic update routine.
900 -- lladdr is new lladdr or NULL, if it is not supplied.
901 -- new is new state.
902 -- flags
903 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
904 if it is different.
905 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
906 lladdr instead of overriding it
907 if it is different.
908 It also allows to retain current state
909 if lladdr is unchanged.
910 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
911
912 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
913 NTF_ROUTER flag.
914 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
915 a router.
916
917 Caller MUST hold reference count on the entry.
918 */
919
920int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
921 u32 flags)
922{
923 u8 old;
924 int err;
925#ifdef CONFIG_ARPD
926 int notify = 0;
927#endif
928 struct net_device *dev;
929 int update_isrouter = 0;
930
931 write_lock_bh(&neigh->lock);
932
933 dev = neigh->dev;
934 old = neigh->nud_state;
935 err = -EPERM;
936
937 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
938 (old & (NUD_NOARP | NUD_PERMANENT)))
939 goto out;
940
941 if (!(new & NUD_VALID)) {
942 neigh_del_timer(neigh);
943 if (old & NUD_CONNECTED)
944 neigh_suspect(neigh);
945 neigh->nud_state = new;
946 err = 0;
947#ifdef CONFIG_ARPD
948 notify = old & NUD_VALID;
949#endif
950 goto out;
951 }
952
953 /* Compare new lladdr with cached one */
954 if (!dev->addr_len) {
955 /* First case: device needs no address. */
956 lladdr = neigh->ha;
957 } else if (lladdr) {
958 /* The second case: if something is already cached
959 and a new address is proposed:
960 - compare new & old
961 - if they are different, check override flag
962 */
963 if ((old & NUD_VALID) &&
964 !memcmp(lladdr, neigh->ha, dev->addr_len))
965 lladdr = neigh->ha;
966 } else {
967 /* No address is supplied; if we know something,
968 use it, otherwise discard the request.
969 */
970 err = -EINVAL;
971 if (!(old & NUD_VALID))
972 goto out;
973 lladdr = neigh->ha;
974 }
975
976 if (new & NUD_CONNECTED)
977 neigh->confirmed = jiffies;
978 neigh->updated = jiffies;
979
980 /* If entry was valid and address is not changed,
981 do not change entry state, if new one is STALE.
982 */
983 err = 0;
984 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
985 if (old & NUD_VALID) {
986 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
987 update_isrouter = 0;
988 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
989 (old & NUD_CONNECTED)) {
990 lladdr = neigh->ha;
991 new = NUD_STALE;
992 } else
993 goto out;
994 } else {
995 if (lladdr == neigh->ha && new == NUD_STALE &&
996 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
997 (old & NUD_CONNECTED))
998 )
999 new = old;
1000 }
1001 }
1002
1003 if (new != old) {
1004 neigh_del_timer(neigh);
1005 if (new & NUD_IN_TIMER) {
1006 neigh_hold(neigh);
667347f1 1007 neigh_add_timer(neigh, (jiffies +
1da177e4 1008 ((new & NUD_REACHABLE) ?
667347f1
DM		 1009 neigh->parms->reachable_time :
1010 0)));
1da177e4
LT		 1011 }
1012 neigh->nud_state = new;
1013 }
1014
1015 if (lladdr != neigh->ha) {
1016 memcpy(&neigh->ha, lladdr, dev->addr_len);
1017 neigh_update_hhs(neigh);
1018 if (!(new & NUD_CONNECTED))
1019 neigh->confirmed = jiffies -
1020 (neigh->parms->base_reachable_time << 1);
1021#ifdef CONFIG_ARPD
1022 notify = 1;
1023#endif
1024 }
1025 if (new == old)
1026 goto out;
1027 if (new & NUD_CONNECTED)
1028 neigh_connect(neigh);
1029 else
1030 neigh_suspect(neigh);
1031 if (!(old & NUD_VALID)) {
1032 struct sk_buff *skb;
1033
1034 /* Again: avoid dead loop if something went wrong */
1035
1036 while (neigh->nud_state & NUD_VALID &&
1037 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1038 struct neighbour *n1 = neigh;
1039 write_unlock_bh(&neigh->lock);
1040 /* On shaper/eql skb->dst->neighbour != neigh :( */
1041 if (skb->dst && skb->dst->neighbour)
1042 n1 = skb->dst->neighbour;
1043 n1->output(skb);
1044 write_lock_bh(&neigh->lock);
1045 }
1046 skb_queue_purge(&neigh->arp_queue);
1047 }
1048out:
1049 if (update_isrouter) {
1050 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1051 (neigh->flags | NTF_ROUTER) :
1052 (neigh->flags & ~NTF_ROUTER);
1053 }
1054 write_unlock_bh(&neigh->lock);
1055#ifdef CONFIG_ARPD
1056 if (notify && neigh->parms->app_probes)
1057 neigh_app_notify(neigh);
1058#endif
1059 return err;
1060}
1061
1062struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1063 u8 *lladdr, void *saddr,
1064 struct net_device *dev)
1065{
1066 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1067 lladdr || !dev->addr_len);
1068 if (neigh)
1069 neigh_update(neigh, lladdr, NUD_STALE,
1070 NEIGH_UPDATE_F_OVERRIDE);
1071 return neigh;
1072}
1073
1074static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,
1075 u16 protocol)
1076{
1077 struct hh_cache *hh;
1078 struct net_device *dev = dst->dev;
1079
1080 for (hh = n->hh; hh; hh = hh->hh_next)
1081 if (hh->hh_type == protocol)
1082 break;
1083
1084 if (!hh && (hh = kmalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) {
1085 memset(hh, 0, sizeof(struct hh_cache));
1086 rwlock_init(&hh->hh_lock);
1087 hh->hh_type = protocol;
1088 atomic_set(&hh->hh_refcnt, 0);
1089 hh->hh_next = NULL;
1090 if (dev->hard_header_cache(n, hh)) {
1091 kfree(hh);
1092 hh = NULL;
1093 } else {
1094 atomic_inc(&hh->hh_refcnt);
1095 hh->hh_next = n->hh;
1096 n->hh = hh;
1097 if (n->nud_state & NUD_CONNECTED)
1098 hh->hh_output = n->ops->hh_output;
1099 else
1100 hh->hh_output = n->ops->output;
1101 }
1102 }
1103 if (hh) {
1104 atomic_inc(&hh->hh_refcnt);
1105 dst->hh = hh;
1106 }
1107}
1108
1109/* This function can be used in contexts, where only old dev_queue_xmit
1110 worked, f.e. if you want to override normal output path (eql, shaper),
1111 but resolution is not made yet.
1112 */
1113
1114int neigh_compat_output(struct sk_buff *skb)
1115{
1116 struct net_device *dev = skb->dev;
1117
1118 __skb_pull(skb, skb->nh.raw - skb->data);
1119
1120 if (dev->hard_header &&
1121 dev->hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
1122 skb->len) < 0 &&
1123 dev->rebuild_header(skb))
1124 return 0;
1125
1126 return dev_queue_xmit(skb);
1127}
1128
1129/* Slow and careful. */
1130
1131int neigh_resolve_output(struct sk_buff *skb)
1132{
1133 struct dst_entry *dst = skb->dst;
1134 struct neighbour *neigh;
1135 int rc = 0;
1136
1137 if (!dst || !(neigh = dst->neighbour))
1138 goto discard;
1139
1140 __skb_pull(skb, skb->nh.raw - skb->data);
1141
1142 if (!neigh_event_send(neigh, skb)) {
1143 int err;
1144 struct net_device *dev = neigh->dev;
1145 if (dev->hard_header_cache && !dst->hh) {
1146 write_lock_bh(&neigh->lock);
1147 if (!dst->hh)
1148 neigh_hh_init(neigh, dst, dst->ops->protocol);
1149 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1150 neigh->ha, NULL, skb->len);
1151 write_unlock_bh(&neigh->lock);
1152 } else {
1153 read_lock_bh(&neigh->lock);
1154 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1155 neigh->ha, NULL, skb->len);
1156 read_unlock_bh(&neigh->lock);
1157 }
1158 if (err >= 0)
1159 rc = neigh->ops->queue_xmit(skb);
1160 else
1161 goto out_kfree_skb;
1162 }
1163out:
1164 return rc;
1165discard:
1166 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1167 dst, dst ? dst->neighbour : NULL);
1168out_kfree_skb:
1169 rc = -EINVAL;
1170 kfree_skb(skb);
1171 goto out;
1172}
1173
1174/* As fast as possible without hh cache */
1175
1176int neigh_connected_output(struct sk_buff *skb)
1177{
1178 int err;
1179 struct dst_entry *dst = skb->dst;
1180 struct neighbour *neigh = dst->neighbour;
1181 struct net_device *dev = neigh->dev;
1182
1183 __skb_pull(skb, skb->nh.raw - skb->data);
1184
1185 read_lock_bh(&neigh->lock);
1186 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1187 neigh->ha, NULL, skb->len);
1188 read_unlock_bh(&neigh->lock);
1189 if (err >= 0)
1190 err = neigh->ops->queue_xmit(skb);
1191 else {
1192 err = -EINVAL;
1193 kfree_skb(skb);
1194 }
1195 return err;
1196}
1197
1198static void neigh_proxy_process(unsigned long arg)
1199{
1200 struct neigh_table *tbl = (struct neigh_table *)arg;
1201 long sched_next = 0;
1202 unsigned long now = jiffies;
1203 struct sk_buff *skb;
1204
1205 spin_lock(&tbl->proxy_queue.lock);
1206
1207 skb = tbl->proxy_queue.next;
1208
1209 while (skb != (struct sk_buff *)&tbl->proxy_queue) {
1210 struct sk_buff *back = skb;
a61bbcf2 1211 long tdif = NEIGH_CB(back)->sched_next - now;
1da177e4
LT		 1212
1213 skb = skb->next;
1214 if (tdif <= 0) {
1215 struct net_device *dev = back->dev;
1216 __skb_unlink(back, &tbl->proxy_queue);
1217 if (tbl->proxy_redo && netif_running(dev))
1218 tbl->proxy_redo(back);
1219 else
1220 kfree_skb(back);
1221
1222 dev_put(dev);
1223 } else if (!sched_next || tdif < sched_next)
1224 sched_next = tdif;
1225 }
1226 del_timer(&tbl->proxy_timer);
1227 if (sched_next)
1228 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1229 spin_unlock(&tbl->proxy_queue.lock);
1230}
1231
1232void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1233 struct sk_buff *skb)
1234{
1235 unsigned long now = jiffies;
1236 unsigned long sched_next = now + (net_random() % p->proxy_delay);
1237
1238 if (tbl->proxy_queue.qlen > p->proxy_qlen) {
1239 kfree_skb(skb);
1240 return;
1241 }
a61bbcf2
PM		 1242
1243 NEIGH_CB(skb)->sched_next = sched_next;
1244 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
1da177e4
LT		 1245
1246 spin_lock(&tbl->proxy_queue.lock);
1247 if (del_timer(&tbl->proxy_timer)) {
1248 if (time_before(tbl->proxy_timer.expires, sched_next))
1249 sched_next = tbl->proxy_timer.expires;
1250 }
1251 dst_release(skb->dst);
1252 skb->dst = NULL;
1253 dev_hold(skb->dev);
1254 __skb_queue_tail(&tbl->proxy_queue, skb);
1255 mod_timer(&tbl->proxy_timer, sched_next);
1256 spin_unlock(&tbl->proxy_queue.lock);
1257}
1258
1259
1260struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1261 struct neigh_table *tbl)
1262{
1263 struct neigh_parms *p = kmalloc(sizeof(*p), GFP_KERNEL);
1264
1265 if (p) {
1266 memcpy(p, &tbl->parms, sizeof(*p));
1267 p->tbl = tbl;
1268 atomic_set(&p->refcnt, 1);
1269 INIT_RCU_HEAD(&p->rcu_head);
1270 p->reachable_time =
1271 neigh_rand_reach_time(p->base_reachable_time);
c7fb64db
TG		 1272 if (dev) {
1273 if (dev->neigh_setup && dev->neigh_setup(dev, p)) {
1274 kfree(p);
1275 return NULL;
1276 }
1277
1278 dev_hold(dev);
1279 p->dev = dev;
1da177e4
LT		 1280 }
1281 p->sysctl_table = NULL;
1282 write_lock_bh(&tbl->lock);
1283 p->next = tbl->parms.next;
1284 tbl->parms.next = p;
1285 write_unlock_bh(&tbl->lock);
1286 }
1287 return p;
1288}
1289
1290static void neigh_rcu_free_parms(struct rcu_head *head)
1291{
1292 struct neigh_parms *parms =
1293 container_of(head, struct neigh_parms, rcu_head);
1294
1295 neigh_parms_put(parms);
1296}
1297
1298void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1299{
1300 struct neigh_parms **p;
1301
1302 if (!parms || parms == &tbl->parms)
1303 return;
1304 write_lock_bh(&tbl->lock);
1305 for (p = &tbl->parms.next; *p; p = &(*p)->next) {
1306 if (*p == parms) {
1307 *p = parms->next;
1308 parms->dead = 1;
1309 write_unlock_bh(&tbl->lock);
c7fb64db
TG		 1310 if (parms->dev)
1311 dev_put(parms->dev);
1da177e4
LT		 1312 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1313 return;
1314 }
1315 }
1316 write_unlock_bh(&tbl->lock);
1317 NEIGH_PRINTK1("neigh_parms_release: not found\n");
1318}
1319
1320void neigh_parms_destroy(struct neigh_parms *parms)
1321{
1322 kfree(parms);
1323}
1324
1325
1326void neigh_table_init(struct neigh_table *tbl)
1327{
1328 unsigned long now = jiffies;
1329 unsigned long phsize;
1330
1331 atomic_set(&tbl->parms.refcnt, 1);
1332 INIT_RCU_HEAD(&tbl->parms.rcu_head);
1333 tbl->parms.reachable_time =
1334 neigh_rand_reach_time(tbl->parms.base_reachable_time);
1335
1336 if (!tbl->kmem_cachep)
1337 tbl->kmem_cachep = kmem_cache_create(tbl->id,
1338 tbl->entry_size,
1339 0, SLAB_HWCACHE_ALIGN,
1340 NULL, NULL);
1341
1342 if (!tbl->kmem_cachep)
1343 panic("cannot create neighbour cache");
1344
1345 tbl->stats = alloc_percpu(struct neigh_statistics);
1346 if (!tbl->stats)
1347 panic("cannot create neighbour cache statistics");
1348
1349#ifdef CONFIG_PROC_FS
1350 tbl->pde = create_proc_entry(tbl->id, 0, proc_net_stat);
1351 if (!tbl->pde)
1352 panic("cannot create neighbour proc dir entry");
1353 tbl->pde->proc_fops = &neigh_stat_seq_fops;
1354 tbl->pde->data = tbl;
1355#endif
1356
1357 tbl->hash_mask = 1;
1358 tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1);
1359
1360 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
1361 tbl->phash_buckets = kmalloc(phsize, GFP_KERNEL);
1362
1363 if (!tbl->hash_buckets || !tbl->phash_buckets)
1364 panic("cannot allocate neighbour cache hashes");
1365
1366 memset(tbl->phash_buckets, 0, phsize);
1367
1368 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
1369
1370 rwlock_init(&tbl->lock);
1371 init_timer(&tbl->gc_timer);
1372 tbl->gc_timer.data = (unsigned long)tbl;
1373 tbl->gc_timer.function = neigh_periodic_timer;
1374 tbl->gc_timer.expires = now + 1;
1375 add_timer(&tbl->gc_timer);
1376
1377 init_timer(&tbl->proxy_timer);
1378 tbl->proxy_timer.data = (unsigned long)tbl;
1379 tbl->proxy_timer.function = neigh_proxy_process;
1380 skb_queue_head_init(&tbl->proxy_queue);
1381
1382 tbl->last_flush = now;
1383 tbl->last_rand = now + tbl->parms.reachable_time * 20;
1384 write_lock(&neigh_tbl_lock);
1385 tbl->next = neigh_tables;
1386 neigh_tables = tbl;
1387 write_unlock(&neigh_tbl_lock);
1388}
1389
1390int neigh_table_clear(struct neigh_table *tbl)
1391{
1392 struct neigh_table **tp;
1393
1394 /* It is not clean... Fix it to unload IPv6 module safely */
1395 del_timer_sync(&tbl->gc_timer);
1396 del_timer_sync(&tbl->proxy_timer);
1397 pneigh_queue_purge(&tbl->proxy_queue);
1398 neigh_ifdown(tbl, NULL);
1399 if (atomic_read(&tbl->entries))
1400 printk(KERN_CRIT "neighbour leakage\n");
1401 write_lock(&neigh_tbl_lock);
1402 for (tp = &neigh_tables; *tp; tp = &(*tp)->next) {
1403 if (*tp == tbl) {
1404 *tp = tbl->next;
1405 break;
1406 }
1407 }
1408 write_unlock(&neigh_tbl_lock);
1409
1410 neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1);
1411 tbl->hash_buckets = NULL;
1412
1413 kfree(tbl->phash_buckets);
1414 tbl->phash_buckets = NULL;
1415
1416 return 0;
1417}
1418
1419int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1420{
1421 struct ndmsg *ndm = NLMSG_DATA(nlh);
1422 struct rtattr **nda = arg;
1423 struct neigh_table *tbl;
1424 struct net_device *dev = NULL;
1425 int err = -ENODEV;
1426
1427 if (ndm->ndm_ifindex &&
1428 (dev = dev_get_by_index(ndm->ndm_ifindex)) == NULL)
1429 goto out;
1430
1431 read_lock(&neigh_tbl_lock);
1432 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1433 struct rtattr *dst_attr = nda[NDA_DST - 1];
1434 struct neighbour *n;
1435
1436 if (tbl->family != ndm->ndm_family)
1437 continue;
1438 read_unlock(&neigh_tbl_lock);
1439
1440 err = -EINVAL;
1441 if (!dst_attr || RTA_PAYLOAD(dst_attr) < tbl->key_len)
1442 goto out_dev_put;
1443
1444 if (ndm->ndm_flags & NTF_PROXY) {
1445 err = pneigh_delete(tbl, RTA_DATA(dst_attr), dev);
1446 goto out_dev_put;
1447 }
1448
1449 if (!dev)
1450 goto out;
1451
1452 n = neigh_lookup(tbl, RTA_DATA(dst_attr), dev);
1453 if (n) {
1454 err = neigh_update(n, NULL, NUD_FAILED,
1455 NEIGH_UPDATE_F_OVERRIDE|
1456 NEIGH_UPDATE_F_ADMIN);
1457 neigh_release(n);
1458 }
1459 goto out_dev_put;
1460 }
1461 read_unlock(&neigh_tbl_lock);
1462 err = -EADDRNOTAVAIL;
1463out_dev_put:
1464 if (dev)
1465 dev_put(dev);
1466out:
1467 return err;
1468}
1469
1470int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1471{
1472 struct ndmsg *ndm = NLMSG_DATA(nlh);
1473 struct rtattr **nda = arg;
1474 struct neigh_table *tbl;
1475 struct net_device *dev = NULL;
1476 int err = -ENODEV;
1477
1478 if (ndm->ndm_ifindex &&
1479 (dev = dev_get_by_index(ndm->ndm_ifindex)) == NULL)
1480 goto out;
1481
1482 read_lock(&neigh_tbl_lock);
1483 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1484 struct rtattr *lladdr_attr = nda[NDA_LLADDR - 1];
1485 struct rtattr *dst_attr = nda[NDA_DST - 1];
1486 int override = 1;
1487 struct neighbour *n;
1488
1489 if (tbl->family != ndm->ndm_family)
1490 continue;
1491 read_unlock(&neigh_tbl_lock);
1492
1493 err = -EINVAL;
1494 if (!dst_attr || RTA_PAYLOAD(dst_attr) < tbl->key_len)
1495 goto out_dev_put;
1496
1497 if (ndm->ndm_flags & NTF_PROXY) {
1498 err = -ENOBUFS;
1499 if (pneigh_lookup(tbl, RTA_DATA(dst_attr), dev, 1))
1500 err = 0;
1501 goto out_dev_put;
1502 }
1503
1504 err = -EINVAL;
1505 if (!dev)
1506 goto out;
1507 if (lladdr_attr && RTA_PAYLOAD(lladdr_attr) < dev->addr_len)
1508 goto out_dev_put;
1509
1510 n = neigh_lookup(tbl, RTA_DATA(dst_attr), dev);
1511 if (n) {
1512 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1513 err = -EEXIST;
1514 neigh_release(n);
1515 goto out_dev_put;
1516 }
1517
1518 override = nlh->nlmsg_flags & NLM_F_REPLACE;
1519 } else if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1520 err = -ENOENT;
1521 goto out_dev_put;
1522 } else {
1523 n = __neigh_lookup_errno(tbl, RTA_DATA(dst_attr), dev);
1524 if (IS_ERR(n)) {
1525 err = PTR_ERR(n);
1526 goto out_dev_put;
1527 }
1528 }
1529
1530 err = neigh_update(n,
1531 lladdr_attr ? RTA_DATA(lladdr_attr) : NULL,
1532 ndm->ndm_state,
1533 (override ? NEIGH_UPDATE_F_OVERRIDE : 0) |
1534 NEIGH_UPDATE_F_ADMIN);
1535
1536 neigh_release(n);
1537 goto out_dev_put;
1538 }
1539
1540 read_unlock(&neigh_tbl_lock);
1541 err = -EADDRNOTAVAIL;
1542out_dev_put:
1543 if (dev)
1544 dev_put(dev);
1545out:
1546 return err;
1547}
1548
c7fb64db
TG		 1549static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1550{
e386c6eb
TG		 1551 struct rtattr *nest = NULL;
1552
1553 nest = RTA_NEST(skb, NDTA_PARMS);
c7fb64db
TG		 1554
1555 if (parms->dev)
1556 RTA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex);
1557
1558 RTA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt));
1559 RTA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len);
1560 RTA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen);
1561 RTA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes);
1562 RTA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes);
1563 RTA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes);
1564 RTA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time);
1565 RTA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME,
1566 parms->base_reachable_time);
1567 RTA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime);
1568 RTA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time);
1569 RTA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time);
1570 RTA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay);
1571 RTA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay);
1572 RTA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime);
1573
1574 return RTA_NEST_END(skb, nest);
1575
1576rtattr_failure:
1577 return RTA_NEST_CANCEL(skb, nest);
1578}
1579
1580static int neightbl_fill_info(struct neigh_table *tbl, struct sk_buff *skb,
1581 struct netlink_callback *cb)
1582{
1583 struct nlmsghdr *nlh;
1584 struct ndtmsg *ndtmsg;
1585
1797754e
TG		 1586 nlh = NLMSG_NEW_ANSWER(skb, cb, RTM_NEWNEIGHTBL, sizeof(struct ndtmsg),
1587 NLM_F_MULTI);
c7fb64db 1588
4b6ea82d 1589 ndtmsg = NLMSG_DATA(nlh);
c7fb64db
TG		 1590
1591 read_lock_bh(&tbl->lock);
1592 ndtmsg->ndtm_family = tbl->family;
9ef1d4c7
PM		 1593 ndtmsg->ndtm_pad1 = 0;
1594 ndtmsg->ndtm_pad2 = 0;
c7fb64db
TG		 1595
1596 RTA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1597 RTA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval);
1598 RTA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1);
1599 RTA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2);
1600 RTA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3);
1601
1602 {
1603 unsigned long now = jiffies;
1604 unsigned int flush_delta = now - tbl->last_flush;
1605 unsigned int rand_delta = now - tbl->last_rand;
1606
1607 struct ndt_config ndc = {
1608 .ndtc_key_len = tbl->key_len,
1609 .ndtc_entry_size = tbl->entry_size,
1610 .ndtc_entries = atomic_read(&tbl->entries),
1611 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
1612 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
1613 .ndtc_hash_rnd = tbl->hash_rnd,
1614 .ndtc_hash_mask = tbl->hash_mask,
1615 .ndtc_hash_chain_gc = tbl->hash_chain_gc,
1616 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
1617 };
1618
1619 RTA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc);
1620 }
1621
1622 {
1623 int cpu;
1624 struct ndt_stats ndst;
1625
1626 memset(&ndst, 0, sizeof(ndst));
1627
1628 for (cpu = 0; cpu < NR_CPUS; cpu++) {
1629 struct neigh_statistics *st;
1630
1631 if (!cpu_possible(cpu))
1632 continue;
1633
1634 st = per_cpu_ptr(tbl->stats, cpu);
1635 ndst.ndts_allocs += st->allocs;
1636 ndst.ndts_destroys += st->destroys;
1637 ndst.ndts_hash_grows += st->hash_grows;
1638 ndst.ndts_res_failed += st->res_failed;
1639 ndst.ndts_lookups += st->lookups;
1640 ndst.ndts_hits += st->hits;
1641 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1642 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1643 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1644 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1645 }
1646
1647 RTA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst);
1648 }
1649
1650 BUG_ON(tbl->parms.dev);
1651 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
1652 goto rtattr_failure;
1653
1654 read_unlock_bh(&tbl->lock);
1655 return NLMSG_END(skb, nlh);
1656
1657rtattr_failure:
1658 read_unlock_bh(&tbl->lock);
1659 return NLMSG_CANCEL(skb, nlh);
1660
1661nlmsg_failure:
1662 return -1;
1663}
1664
1665static int neightbl_fill_param_info(struct neigh_table *tbl,
1666 struct neigh_parms *parms,
1667 struct sk_buff *skb,
1668 struct netlink_callback *cb)
1669{
1670 struct ndtmsg *ndtmsg;
1671 struct nlmsghdr *nlh;
1672
1797754e
TG		 1673 nlh = NLMSG_NEW_ANSWER(skb, cb, RTM_NEWNEIGHTBL, sizeof(struct ndtmsg),
1674 NLM_F_MULTI);
c7fb64db 1675
4b6ea82d 1676 ndtmsg = NLMSG_DATA(nlh);
c7fb64db
TG		 1677
1678 read_lock_bh(&tbl->lock);
1679 ndtmsg->ndtm_family = tbl->family;
9ef1d4c7
PM		 1680 ndtmsg->ndtm_pad1 = 0;
1681 ndtmsg->ndtm_pad2 = 0;
c7fb64db
TG		 1682 RTA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1683
1684 if (neightbl_fill_parms(skb, parms) < 0)
1685 goto rtattr_failure;
1686
1687 read_unlock_bh(&tbl->lock);
1688 return NLMSG_END(skb, nlh);
1689
1690rtattr_failure:
1691 read_unlock_bh(&tbl->lock);
1692 return NLMSG_CANCEL(skb, nlh);
1693
1694nlmsg_failure:
1695 return -1;
1696}
1697
1698static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl,
1699 int ifindex)
1700{
1701 struct neigh_parms *p;
1702
1703 for (p = &tbl->parms; p; p = p->next)
1704 if ((p->dev && p->dev->ifindex == ifindex) ||
1705 (!p->dev && !ifindex))
1706 return p;
1707
1708 return NULL;
1709}
1710
1711int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1712{
1713 struct neigh_table *tbl;
1714 struct ndtmsg *ndtmsg = NLMSG_DATA(nlh);
1715 struct rtattr **tb = arg;
1716 int err = -EINVAL;
1717
1718 if (!tb[NDTA_NAME - 1] || !RTA_PAYLOAD(tb[NDTA_NAME - 1]))
1719 return -EINVAL;
1720
1721 read_lock(&neigh_tbl_lock);
1722 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1723 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1724 continue;
1725
1726 if (!rtattr_strcmp(tb[NDTA_NAME - 1], tbl->id))
1727 break;
1728 }
1729
1730 if (tbl == NULL) {
1731 err = -ENOENT;
1732 goto errout;
1733 }
1734
1735 /*
1736 * We acquire tbl->lock to be nice to the periodic timers and
1737 * make sure they always see a consistent set of values.
1738 */
1739 write_lock_bh(&tbl->lock);
1740
1741 if (tb[NDTA_THRESH1 - 1])
1742 tbl->gc_thresh1 = RTA_GET_U32(tb[NDTA_THRESH1 - 1]);
1743
1744 if (tb[NDTA_THRESH2 - 1])
1745 tbl->gc_thresh2 = RTA_GET_U32(tb[NDTA_THRESH2 - 1]);
1746
1747 if (tb[NDTA_THRESH3 - 1])
1748 tbl->gc_thresh3 = RTA_GET_U32(tb[NDTA_THRESH3 - 1]);
1749
1750 if (tb[NDTA_GC_INTERVAL - 1])
1751 tbl->gc_interval = RTA_GET_MSECS(tb[NDTA_GC_INTERVAL - 1]);
1752
1753 if (tb[NDTA_PARMS - 1]) {
1754 struct rtattr *tbp[NDTPA_MAX];
1755 struct neigh_parms *p;
1756 u32 ifindex = 0;
1757
1758 if (rtattr_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS - 1]) < 0)
1759 goto rtattr_failure;
1760
1761 if (tbp[NDTPA_IFINDEX - 1])
1762 ifindex = RTA_GET_U32(tbp[NDTPA_IFINDEX - 1]);
1763
1764 p = lookup_neigh_params(tbl, ifindex);
1765 if (p == NULL) {
1766 err = -ENOENT;
1767 goto rtattr_failure;
1768 }
1769
1770 if (tbp[NDTPA_QUEUE_LEN - 1])
1771 p->queue_len = RTA_GET_U32(tbp[NDTPA_QUEUE_LEN - 1]);
1772
1773 if (tbp[NDTPA_PROXY_QLEN - 1])
1774 p->proxy_qlen = RTA_GET_U32(tbp[NDTPA_PROXY_QLEN - 1]);
1775
1776 if (tbp[NDTPA_APP_PROBES - 1])
1777 p->app_probes = RTA_GET_U32(tbp[NDTPA_APP_PROBES - 1]);
1778
1779 if (tbp[NDTPA_UCAST_PROBES - 1])
1780 p->ucast_probes =
1781 RTA_GET_U32(tbp[NDTPA_UCAST_PROBES - 1]);
1782
1783 if (tbp[NDTPA_MCAST_PROBES - 1])
1784 p->mcast_probes =
1785 RTA_GET_U32(tbp[NDTPA_MCAST_PROBES - 1]);
1786
1787 if (tbp[NDTPA_BASE_REACHABLE_TIME - 1])
1788 p->base_reachable_time =
1789 RTA_GET_MSECS(tbp[NDTPA_BASE_REACHABLE_TIME - 1]);
1790
1791 if (tbp[NDTPA_GC_STALETIME - 1])
1792 p->gc_staletime =
1793 RTA_GET_MSECS(tbp[NDTPA_GC_STALETIME - 1]);
1794
1795 if (tbp[NDTPA_DELAY_PROBE_TIME - 1])
1796 p->delay_probe_time =
1797 RTA_GET_MSECS(tbp[NDTPA_DELAY_PROBE_TIME - 1]);
1798
1799 if (tbp[NDTPA_RETRANS_TIME - 1])
1800 p->retrans_time =
1801 RTA_GET_MSECS(tbp[NDTPA_RETRANS_TIME - 1]);
1802
1803 if (tbp[NDTPA_ANYCAST_DELAY - 1])
1804 p->anycast_delay =
1805 RTA_GET_MSECS(tbp[NDTPA_ANYCAST_DELAY - 1]);
1806
1807 if (tbp[NDTPA_PROXY_DELAY - 1])
1808 p->proxy_delay =
1809 RTA_GET_MSECS(tbp[NDTPA_PROXY_DELAY - 1]);
1810
1811 if (tbp[NDTPA_LOCKTIME - 1])
1812 p->locktime = RTA_GET_MSECS(tbp[NDTPA_LOCKTIME - 1]);
1813 }
1814
1815 err = 0;
1816
1817rtattr_failure:
1818 write_unlock_bh(&tbl->lock);
1819errout:
1820 read_unlock(&neigh_tbl_lock);
1821 return err;
1822}
1823
1824int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1825{
1826 int idx, family;
1827 int s_idx = cb->args[0];
1828 struct neigh_table *tbl;
1829
1830 family = ((struct rtgenmsg *)NLMSG_DATA(cb->nlh))->rtgen_family;
1831
1832 read_lock(&neigh_tbl_lock);
1833 for (tbl = neigh_tables, idx = 0; tbl; tbl = tbl->next) {
1834 struct neigh_parms *p;
1835
1836 if (idx < s_idx || (family && tbl->family != family))
1837 continue;
1838
1839 if (neightbl_fill_info(tbl, skb, cb) <= 0)
1840 break;
1841
1842 for (++idx, p = tbl->parms.next; p; p = p->next, idx++) {
1843 if (idx < s_idx)
1844 continue;
1845
1846 if (neightbl_fill_param_info(tbl, p, skb, cb) <= 0)
1847 goto out;
1848 }
1849
1850 }
1851out:
1852 read_unlock(&neigh_tbl_lock);
1853 cb->args[0] = idx;
1854
1855 return skb->len;
1856}
1da177e4
LT		 1857
1858static int neigh_fill_info(struct sk_buff *skb, struct neighbour *n,
b6544c0b 1859 u32 pid, u32 seq, int event, unsigned int flags)
1da177e4
LT		 1860{
1861 unsigned long now = jiffies;
1862 unsigned char *b = skb->tail;
1863 struct nda_cacheinfo ci;
1864 int locked = 0;
1865 u32 probes;
b6544c0b
JHS		 1866 struct nlmsghdr *nlh = NLMSG_NEW(skb, pid, seq, event,
1867 sizeof(struct ndmsg), flags);
1da177e4
LT		 1868 struct ndmsg *ndm = NLMSG_DATA(nlh);
1869
1da177e4 1870 ndm->ndm_family = n->ops->family;
9ef1d4c7
PM		 1871 ndm->ndm_pad1 = 0;
1872 ndm->ndm_pad2 = 0;
1da177e4
LT		 1873 ndm->ndm_flags = n->flags;
1874 ndm->ndm_type = n->type;
1875 ndm->ndm_ifindex = n->dev->ifindex;
1876 RTA_PUT(skb, NDA_DST, n->tbl->key_len, n->primary_key);
1877 read_lock_bh(&n->lock);
1878 locked = 1;
1879 ndm->ndm_state = n->nud_state;
1880 if (n->nud_state & NUD_VALID)
1881 RTA_PUT(skb, NDA_LLADDR, n->dev->addr_len, n->ha);
1882 ci.ndm_used = now - n->used;
1883 ci.ndm_confirmed = now - n->confirmed;
1884 ci.ndm_updated = now - n->updated;
1885 ci.ndm_refcnt = atomic_read(&n->refcnt) - 1;
1886 probes = atomic_read(&n->probes);
1887 read_unlock_bh(&n->lock);
1888 locked = 0;
1889 RTA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
1890 RTA_PUT(skb, NDA_PROBES, sizeof(probes), &probes);
1891 nlh->nlmsg_len = skb->tail - b;
1892 return skb->len;
1893
1894nlmsg_failure:
1895rtattr_failure:
1896 if (locked)
1897 read_unlock_bh(&n->lock);
1898 skb_trim(skb, b - skb->data);
1899 return -1;
1900}
1901
1902
1903static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
1904 struct netlink_callback *cb)
1905{
1906 struct neighbour *n;
1907 int rc, h, s_h = cb->args[1];
1908 int idx, s_idx = idx = cb->args[2];
1909
1910 for (h = 0; h <= tbl->hash_mask; h++) {
1911 if (h < s_h)
1912 continue;
1913 if (h > s_h)
1914 s_idx = 0;
1915 read_lock_bh(&tbl->lock);
1916 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next, idx++) {
1917 if (idx < s_idx)
1918 continue;
1919 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid,
1920 cb->nlh->nlmsg_seq,
b6544c0b
JHS		 1921 RTM_NEWNEIGH,
1922 NLM_F_MULTI) <= 0) {
1da177e4
LT		 1923 read_unlock_bh(&tbl->lock);
1924 rc = -1;
1925 goto out;
1926 }
1927 }
1928 read_unlock_bh(&tbl->lock);
1929 }
1930 rc = skb->len;
1931out:
1932 cb->args[1] = h;
1933 cb->args[2] = idx;
1934 return rc;
1935}
1936
1937int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1938{
1939 struct neigh_table *tbl;
1940 int t, family, s_t;
1941
1942 read_lock(&neigh_tbl_lock);
1943 family = ((struct rtgenmsg *)NLMSG_DATA(cb->nlh))->rtgen_family;
1944 s_t = cb->args[0];
1945
1946 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
1947 if (t < s_t || (family && tbl->family != family))
1948 continue;
1949 if (t > s_t)
1950 memset(&cb->args[1], 0, sizeof(cb->args) -
1951 sizeof(cb->args[0]));
1952 if (neigh_dump_table(tbl, skb, cb) < 0)
1953 break;
1954 }
1955 read_unlock(&neigh_tbl_lock);
1956
1957 cb->args[0] = t;
1958 return skb->len;
1959}
1960
1961void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
1962{
1963 int chain;
1964
1965 read_lock_bh(&tbl->lock);
1966 for (chain = 0; chain <= tbl->hash_mask; chain++) {
1967 struct neighbour *n;
1968
1969 for (n = tbl->hash_buckets[chain]; n; n = n->next)
1970 cb(n, cookie);
1971 }
1972 read_unlock_bh(&tbl->lock);
1973}
1974EXPORT_SYMBOL(neigh_for_each);
1975
1976/* The tbl->lock must be held as a writer and BH disabled. */
1977void __neigh_for_each_release(struct neigh_table *tbl,
1978 int (*cb)(struct neighbour *))
1979{
1980 int chain;
1981
1982 for (chain = 0; chain <= tbl->hash_mask; chain++) {
1983 struct neighbour *n, **np;
1984
1985 np = &tbl->hash_buckets[chain];
1986 while ((n = *np) != NULL) {
1987 int release;
1988
1989 write_lock(&n->lock);
1990 release = cb(n);
1991 if (release) {
1992 *np = n->next;
1993 n->dead = 1;
1994 } else
1995 np = &n->next;
1996 write_unlock(&n->lock);
1997 if (release)
1998 neigh_release(n);
1999 }
2000 }
2001}
2002EXPORT_SYMBOL(__neigh_for_each_release);
2003
2004#ifdef CONFIG_PROC_FS
2005
2006static struct neighbour *neigh_get_first(struct seq_file *seq)
2007{
2008 struct neigh_seq_state *state = seq->private;
2009 struct neigh_table *tbl = state->tbl;
2010 struct neighbour *n = NULL;
2011 int bucket = state->bucket;
2012
2013 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2014 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) {
2015 n = tbl->hash_buckets[bucket];
2016
2017 while (n) {
2018 if (state->neigh_sub_iter) {
2019 loff_t fakep = 0;
2020 void *v;
2021
2022 v = state->neigh_sub_iter(state, n, &fakep);
2023 if (!v)
2024 goto next;
2025 }
2026 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2027 break;
2028 if (n->nud_state & ~NUD_NOARP)
2029 break;
2030 next:
2031 n = n->next;
2032 }
2033
2034 if (n)
2035 break;
2036 }
2037 state->bucket = bucket;
2038
2039 return n;
2040}
2041
2042static struct neighbour *neigh_get_next(struct seq_file *seq,
2043 struct neighbour *n,
2044 loff_t *pos)
2045{
2046 struct neigh_seq_state *state = seq->private;
2047 struct neigh_table *tbl = state->tbl;
2048
2049 if (state->neigh_sub_iter) {
2050 void *v = state->neigh_sub_iter(state, n, pos);
2051 if (v)
2052 return n;
2053 }
2054 n = n->next;
2055
2056 while (1) {
2057 while (n) {
2058 if (state->neigh_sub_iter) {
2059 void *v = state->neigh_sub_iter(state, n, pos);
2060 if (v)
2061 return n;
2062 goto next;
2063 }
2064 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2065 break;
2066
2067 if (n->nud_state & ~NUD_NOARP)
2068 break;
2069 next:
2070 n = n->next;
2071 }
2072
2073 if (n)
2074 break;
2075
2076 if (++state->bucket > tbl->hash_mask)
2077 break;
2078
2079 n = tbl->hash_buckets[state->bucket];
2080 }
2081
2082 if (n && pos)
2083 --(*pos);
2084 return n;
2085}
2086
2087static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2088{
2089 struct neighbour *n = neigh_get_first(seq);
2090
2091 if (n) {
2092 while (*pos) {
2093 n = neigh_get_next(seq, n, pos);
2094 if (!n)
2095 break;
2096 }
2097 }
2098 return *pos ? NULL : n;
2099}
2100
2101static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2102{
2103 struct neigh_seq_state *state = seq->private;
2104 struct neigh_table *tbl = state->tbl;
2105 struct pneigh_entry *pn = NULL;
2106 int bucket = state->bucket;
2107
2108 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2109 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2110 pn = tbl->phash_buckets[bucket];
2111 if (pn)
2112 break;
2113 }
2114 state->bucket = bucket;
2115
2116 return pn;
2117}
2118
2119static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2120 struct pneigh_entry *pn,
2121 loff_t *pos)
2122{
2123 struct neigh_seq_state *state = seq->private;
2124 struct neigh_table *tbl = state->tbl;
2125
2126 pn = pn->next;
2127 while (!pn) {
2128 if (++state->bucket > PNEIGH_HASHMASK)
2129 break;
2130 pn = tbl->phash_buckets[state->bucket];
2131 if (pn)
2132 break;
2133 }
2134
2135 if (pn && pos)
2136 --(*pos);
2137
2138 return pn;
2139}
2140
2141static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2142{
2143 struct pneigh_entry *pn = pneigh_get_first(seq);
2144
2145 if (pn) {
2146 while (*pos) {
2147 pn = pneigh_get_next(seq, pn, pos);
2148 if (!pn)
2149 break;
2150 }
2151 }
2152 return *pos ? NULL : pn;
2153}
2154
2155static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2156{
2157 struct neigh_seq_state *state = seq->private;
2158 void *rc;
2159
2160 rc = neigh_get_idx(seq, pos);
2161 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2162 rc = pneigh_get_idx(seq, pos);
2163
2164 return rc;
2165}
2166
2167void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
2168{
2169 struct neigh_seq_state *state = seq->private;
2170 loff_t pos_minus_one;
2171
2172 state->tbl = tbl;
2173 state->bucket = 0;
2174 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2175
2176 read_lock_bh(&tbl->lock);
2177
2178 pos_minus_one = *pos - 1;
2179 return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN;
2180}
2181EXPORT_SYMBOL(neigh_seq_start);
2182
2183void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2184{
2185 struct neigh_seq_state *state;
2186 void *rc;
2187
2188 if (v == SEQ_START_TOKEN) {
2189 rc = neigh_get_idx(seq, pos);
2190 goto out;
2191 }
2192
2193 state = seq->private;
2194 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2195 rc = neigh_get_next(seq, v, NULL);
2196 if (rc)
2197 goto out;
2198 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2199 rc = pneigh_get_first(seq);
2200 } else {
2201 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2202 rc = pneigh_get_next(seq, v, NULL);
2203 }
2204out:
2205 ++(*pos);
2206 return rc;
2207}
2208EXPORT_SYMBOL(neigh_seq_next);
2209
2210void neigh_seq_stop(struct seq_file *seq, void *v)
2211{
2212 struct neigh_seq_state *state = seq->private;
2213 struct neigh_table *tbl = state->tbl;
2214
2215 read_unlock_bh(&tbl->lock);
2216}
2217EXPORT_SYMBOL(neigh_seq_stop);
2218
2219/* statistics via seq_file */
2220
2221static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2222{
2223 struct proc_dir_entry *pde = seq->private;
2224 struct neigh_table *tbl = pde->data;
2225 int cpu;
2226
2227 if (*pos == 0)
2228 return SEQ_START_TOKEN;
2229
2230 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
2231 if (!cpu_possible(cpu))
2232 continue;
2233 *pos = cpu+1;
2234 return per_cpu_ptr(tbl->stats, cpu);
2235 }
2236 return NULL;
2237}
2238
2239static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2240{
2241 struct proc_dir_entry *pde = seq->private;
2242 struct neigh_table *tbl = pde->data;
2243 int cpu;
2244
2245 for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
2246 if (!cpu_possible(cpu))
2247 continue;
2248 *pos = cpu+1;
2249 return per_cpu_ptr(tbl->stats, cpu);
2250 }
2251 return NULL;
2252}
2253
2254static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2255{
2256
2257}
2258
2259static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2260{
2261 struct proc_dir_entry *pde = seq->private;
2262 struct neigh_table *tbl = pde->data;
2263 struct neigh_statistics *st = v;
2264
2265 if (v == SEQ_START_TOKEN) {
5bec0039 2266 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");
1da177e4
LT		 2267 return 0;
2268 }
2269
2270 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2271 "%08lx %08lx %08lx %08lx\n",
2272 atomic_read(&tbl->entries),
2273
2274 st->allocs,
2275 st->destroys,
2276 st->hash_grows,
2277
2278 st->lookups,
2279 st->hits,
2280
2281 st->res_failed,
2282
2283 st->rcv_probes_mcast,
2284 st->rcv_probes_ucast,
2285
2286 st->periodic_gc_runs,
2287 st->forced_gc_runs
2288 );
2289
2290 return 0;
2291}
2292
2293static struct seq_operations neigh_stat_seq_ops = {
2294 .start = neigh_stat_seq_start,
2295 .next = neigh_stat_seq_next,
2296 .stop = neigh_stat_seq_stop,
2297 .show = neigh_stat_seq_show,
2298};
2299
2300static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2301{
2302 int ret = seq_open(file, &neigh_stat_seq_ops);
2303
2304 if (!ret) {
2305 struct seq_file *sf = file->private_data;
2306 sf->private = PDE(inode);
2307 }
2308 return ret;
2309};
2310
2311static struct file_operations neigh_stat_seq_fops = {
2312 .owner = THIS_MODULE,
2313 .open = neigh_stat_seq_open,
2314 .read = seq_read,
2315 .llseek = seq_lseek,
2316 .release = seq_release,
2317};
2318
2319#endif /* CONFIG_PROC_FS */
2320
2321#ifdef CONFIG_ARPD
2322void neigh_app_ns(struct neighbour *n)
2323{
2324 struct nlmsghdr *nlh;
2325 int size = NLMSG_SPACE(sizeof(struct ndmsg) + 256);
2326 struct sk_buff *skb = alloc_skb(size, GFP_ATOMIC);
2327
2328 if (!skb)
2329 return;
2330
b6544c0b 2331 if (neigh_fill_info(skb, n, 0, 0, RTM_GETNEIGH, 0) < 0) {
1da177e4
LT		 2332 kfree_skb(skb);
2333 return;
2334 }
2335 nlh = (struct nlmsghdr *)skb->data;
2336 nlh->nlmsg_flags = NLM_F_REQUEST;
ac6d439d
PM		 2337 NETLINK_CB(skb).dst_group = RTNLGRP_NEIGH;
2338 netlink_broadcast(rtnl, skb, 0, RTNLGRP_NEIGH, GFP_ATOMIC);
1da177e4
LT		 2339}
2340
2341static void neigh_app_notify(struct neighbour *n)
2342{
2343 struct nlmsghdr *nlh;
2344 int size = NLMSG_SPACE(sizeof(struct ndmsg) + 256);
2345 struct sk_buff *skb = alloc_skb(size, GFP_ATOMIC);
2346
2347 if (!skb)
2348 return;
2349
b6544c0b 2350 if (neigh_fill_info(skb, n, 0, 0, RTM_NEWNEIGH, 0) < 0) {
1da177e4
LT		 2351 kfree_skb(skb);
2352 return;
2353 }
2354 nlh = (struct nlmsghdr *)skb->data;
ac6d439d
PM		 2355 NETLINK_CB(skb).dst_group = RTNLGRP_NEIGH;
2356 netlink_broadcast(rtnl, skb, 0, RTNLGRP_NEIGH, GFP_ATOMIC);
1da177e4
LT		 2357}
2358
2359#endif /* CONFIG_ARPD */
2360
2361#ifdef CONFIG_SYSCTL
2362
2363static struct neigh_sysctl_table {
2364 struct ctl_table_header *sysctl_header;
2365 ctl_table neigh_vars[__NET_NEIGH_MAX];
2366 ctl_table neigh_dev[2];
2367 ctl_table neigh_neigh_dir[2];
2368 ctl_table neigh_proto_dir[2];
2369 ctl_table neigh_root_dir[2];
2370} neigh_sysctl_template = {
2371 .neigh_vars = {
2372 {
2373 .ctl_name = NET_NEIGH_MCAST_SOLICIT,
2374 .procname = "mcast_solicit",
2375 .maxlen = sizeof(int),
2376 .mode = 0644,
2377 .proc_handler = &proc_dointvec,
2378 },
2379 {
2380 .ctl_name = NET_NEIGH_UCAST_SOLICIT,
2381 .procname = "ucast_solicit",
2382 .maxlen = sizeof(int),
2383 .mode = 0644,
2384 .proc_handler = &proc_dointvec,
2385 },
2386 {
2387 .ctl_name = NET_NEIGH_APP_SOLICIT,
2388 .procname = "app_solicit",
2389 .maxlen = sizeof(int),
2390 .mode = 0644,
2391 .proc_handler = &proc_dointvec,
2392 },
2393 {
2394 .ctl_name = NET_NEIGH_RETRANS_TIME,
2395 .procname = "retrans_time",
2396 .maxlen = sizeof(int),
2397 .mode = 0644,
2398 .proc_handler = &proc_dointvec_userhz_jiffies,
2399 },
2400 {
2401 .ctl_name = NET_NEIGH_REACHABLE_TIME,
2402 .procname = "base_reachable_time",
2403 .maxlen = sizeof(int),
2404 .mode = 0644,
2405 .proc_handler = &proc_dointvec_jiffies,
2406 .strategy = &sysctl_jiffies,
2407 },
2408 {
2409 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME,
2410 .procname = "delay_first_probe_time",
2411 .maxlen = sizeof(int),
2412 .mode = 0644,
2413 .proc_handler = &proc_dointvec_jiffies,
2414 .strategy = &sysctl_jiffies,
2415 },
2416 {
2417 .ctl_name = NET_NEIGH_GC_STALE_TIME,
2418 .procname = "gc_stale_time",
2419 .maxlen = sizeof(int),
2420 .mode = 0644,
2421 .proc_handler = &proc_dointvec_jiffies,
2422 .strategy = &sysctl_jiffies,
2423 },
2424 {
2425 .ctl_name = NET_NEIGH_UNRES_QLEN,
2426 .procname = "unres_qlen",
2427 .maxlen = sizeof(int),
2428 .mode = 0644,
2429 .proc_handler = &proc_dointvec,
2430 },
2431 {
2432 .ctl_name = NET_NEIGH_PROXY_QLEN,
2433 .procname = "proxy_qlen",
2434 .maxlen = sizeof(int),
2435 .mode = 0644,
2436 .proc_handler = &proc_dointvec,
2437 },
2438 {
2439 .ctl_name = NET_NEIGH_ANYCAST_DELAY,
2440 .procname = "anycast_delay",
2441 .maxlen = sizeof(int),
2442 .mode = 0644,
2443 .proc_handler = &proc_dointvec_userhz_jiffies,
2444 },
2445 {
2446 .ctl_name = NET_NEIGH_PROXY_DELAY,
2447 .procname = "proxy_delay",
2448 .maxlen = sizeof(int),
2449 .mode = 0644,
2450 .proc_handler = &proc_dointvec_userhz_jiffies,
2451 },
2452 {
2453 .ctl_name = NET_NEIGH_LOCKTIME,
2454 .procname = "locktime",
2455 .maxlen = sizeof(int),
2456 .mode = 0644,
2457 .proc_handler = &proc_dointvec_userhz_jiffies,
2458 },
2459 {
2460 .ctl_name = NET_NEIGH_GC_INTERVAL,
2461 .procname = "gc_interval",
2462 .maxlen = sizeof(int),
2463 .mode = 0644,
2464 .proc_handler = &proc_dointvec_jiffies,
2465 .strategy = &sysctl_jiffies,
2466 },
2467 {
2468 .ctl_name = NET_NEIGH_GC_THRESH1,
2469 .procname = "gc_thresh1",
2470 .maxlen = sizeof(int),
2471 .mode = 0644,
2472 .proc_handler = &proc_dointvec,
2473 },
2474 {
2475 .ctl_name = NET_NEIGH_GC_THRESH2,
2476 .procname = "gc_thresh2",
2477 .maxlen = sizeof(int),
2478 .mode = 0644,
2479 .proc_handler = &proc_dointvec,
2480 },
2481 {
2482 .ctl_name = NET_NEIGH_GC_THRESH3,
2483 .procname = "gc_thresh3",
2484 .maxlen = sizeof(int),
2485 .mode = 0644,
2486 .proc_handler = &proc_dointvec,
2487 },
2488 {
2489 .ctl_name = NET_NEIGH_RETRANS_TIME_MS,
2490 .procname = "retrans_time_ms",
2491 .maxlen = sizeof(int),
2492 .mode = 0644,
2493 .proc_handler = &proc_dointvec_ms_jiffies,
2494 .strategy = &sysctl_ms_jiffies,
2495 },
2496 {
2497 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS,
2498 .procname = "base_reachable_time_ms",
2499 .maxlen = sizeof(int),
2500 .mode = 0644,
2501 .proc_handler = &proc_dointvec_ms_jiffies,
2502 .strategy = &sysctl_ms_jiffies,
2503 },
2504 },
2505 .neigh_dev = {
2506 {
2507 .ctl_name = NET_PROTO_CONF_DEFAULT,
2508 .procname = "default",
2509 .mode = 0555,
2510 },
2511 },
2512 .neigh_neigh_dir = {
2513 {
2514 .procname = "neigh",
2515 .mode = 0555,
2516 },
2517 },
2518 .neigh_proto_dir = {
2519 {
2520 .mode = 0555,
2521 },
2522 },
2523 .neigh_root_dir = {
2524 {
2525 .ctl_name = CTL_NET,
2526 .procname = "net",
2527 .mode = 0555,
2528 },
2529 },
2530};
2531
2532int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
2533 int p_id, int pdev_id, char *p_name,
2534 proc_handler *handler, ctl_handler *strategy)
2535{
2536 struct neigh_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
2537 const char *dev_name_source = NULL;
2538 char *dev_name = NULL;
2539 int err = 0;
2540
2541 if (!t)
2542 return -ENOBUFS;
2543 memcpy(t, &neigh_sysctl_template, sizeof(*t));
2544 t->neigh_vars[0].data = &p->mcast_probes;
2545 t->neigh_vars[1].data = &p->ucast_probes;
2546 t->neigh_vars[2].data = &p->app_probes;
2547 t->neigh_vars[3].data = &p->retrans_time;
2548 t->neigh_vars[4].data = &p->base_reachable_time;
2549 t->neigh_vars[5].data = &p->delay_probe_time;
2550 t->neigh_vars[6].data = &p->gc_staletime;
2551 t->neigh_vars[7].data = &p->queue_len;
2552 t->neigh_vars[8].data = &p->proxy_qlen;
2553 t->neigh_vars[9].data = &p->anycast_delay;
2554 t->neigh_vars[10].data = &p->proxy_delay;
2555 t->neigh_vars[11].data = &p->locktime;
2556
2557 if (dev) {
2558 dev_name_source = dev->name;
2559 t->neigh_dev[0].ctl_name = dev->ifindex;
2560 t->neigh_vars[12].procname = NULL;
2561 t->neigh_vars[13].procname = NULL;
2562 t->neigh_vars[14].procname = NULL;
2563 t->neigh_vars[15].procname = NULL;
2564 } else {
2565 dev_name_source = t->neigh_dev[0].procname;
2566 t->neigh_vars[12].data = (int *)(p + 1);
2567 t->neigh_vars[13].data = (int *)(p + 1) + 1;
2568 t->neigh_vars[14].data = (int *)(p + 1) + 2;
2569 t->neigh_vars[15].data = (int *)(p + 1) + 3;
2570 }
2571
2572 t->neigh_vars[16].data = &p->retrans_time;
2573 t->neigh_vars[17].data = &p->base_reachable_time;
2574
2575 if (handler || strategy) {
2576 /* RetransTime */
2577 t->neigh_vars[3].proc_handler = handler;
2578 t->neigh_vars[3].strategy = strategy;
2579 t->neigh_vars[3].extra1 = dev;
2580 /* ReachableTime */
2581 t->neigh_vars[4].proc_handler = handler;
2582 t->neigh_vars[4].strategy = strategy;
2583 t->neigh_vars[4].extra1 = dev;
2584 /* RetransTime (in milliseconds)*/
2585 t->neigh_vars[16].proc_handler = handler;
2586 t->neigh_vars[16].strategy = strategy;
2587 t->neigh_vars[16].extra1 = dev;
2588 /* ReachableTime (in milliseconds) */
2589 t->neigh_vars[17].proc_handler = handler;
2590 t->neigh_vars[17].strategy = strategy;
2591 t->neigh_vars[17].extra1 = dev;
2592 }
2593
543537bd 2594 dev_name = kstrdup(dev_name_source, GFP_KERNEL);
1da177e4
LT		 2595 if (!dev_name) {
2596 err = -ENOBUFS;
2597 goto free;
2598 }
2599
2600 t->neigh_dev[0].procname = dev_name;
2601
2602 t->neigh_neigh_dir[0].ctl_name = pdev_id;
2603
2604 t->neigh_proto_dir[0].procname = p_name;
2605 t->neigh_proto_dir[0].ctl_name = p_id;
2606
2607 t->neigh_dev[0].child = t->neigh_vars;
2608 t->neigh_neigh_dir[0].child = t->neigh_dev;
2609 t->neigh_proto_dir[0].child = t->neigh_neigh_dir;
2610 t->neigh_root_dir[0].child = t->neigh_proto_dir;
2611
2612 t->sysctl_header = register_sysctl_table(t->neigh_root_dir, 0);
2613 if (!t->sysctl_header) {
2614 err = -ENOBUFS;
2615 goto free_procname;
2616 }
2617 p->sysctl_table = t;
2618 return 0;
2619
2620 /* error path */
2621 free_procname:
2622 kfree(dev_name);
2623 free:
2624 kfree(t);
2625
2626 return err;
2627}
2628
2629void neigh_sysctl_unregister(struct neigh_parms *p)
2630{
2631 if (p->sysctl_table) {
2632 struct neigh_sysctl_table *t = p->sysctl_table;
2633 p->sysctl_table = NULL;
2634 unregister_sysctl_table(t->sysctl_header);
2635 kfree(t->neigh_dev[0].procname);
2636 kfree(t);
2637 }
2638}
2639
2640#endif /* CONFIG_SYSCTL */
2641
2642EXPORT_SYMBOL(__neigh_event_send);
2643EXPORT_SYMBOL(neigh_add);
2644EXPORT_SYMBOL(neigh_changeaddr);
2645EXPORT_SYMBOL(neigh_compat_output);
2646EXPORT_SYMBOL(neigh_connected_output);
2647EXPORT_SYMBOL(neigh_create);
2648EXPORT_SYMBOL(neigh_delete);
2649EXPORT_SYMBOL(neigh_destroy);
2650EXPORT_SYMBOL(neigh_dump_info);
2651EXPORT_SYMBOL(neigh_event_ns);
2652EXPORT_SYMBOL(neigh_ifdown);
2653EXPORT_SYMBOL(neigh_lookup);
2654EXPORT_SYMBOL(neigh_lookup_nodev);
2655EXPORT_SYMBOL(neigh_parms_alloc);
2656EXPORT_SYMBOL(neigh_parms_release);
2657EXPORT_SYMBOL(neigh_rand_reach_time);
2658EXPORT_SYMBOL(neigh_resolve_output);
2659EXPORT_SYMBOL(neigh_table_clear);
2660EXPORT_SYMBOL(neigh_table_init);
2661EXPORT_SYMBOL(neigh_update);
2662EXPORT_SYMBOL(neigh_update_hhs);
2663EXPORT_SYMBOL(pneigh_enqueue);
2664EXPORT_SYMBOL(pneigh_lookup);
c7fb64db
TG		 2665EXPORT_SYMBOL(neightbl_dump_info);
2666EXPORT_SYMBOL(neightbl_set);
1da177e4
LT		 2667
2668#ifdef CONFIG_ARPD
2669EXPORT_SYMBOL(neigh_app_ns);
2670#endif
2671#ifdef CONFIG_SYSCTL
2672EXPORT_SYMBOL(neigh_sysctl_register);
2673EXPORT_SYMBOL(neigh_sysctl_unregister);
2674#endif
Linux 6.x block layer and io_uring tree(s)