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