blob: e68700f950a55d3cff784a54d655001a7da30dec [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>
Paulo Marques543537b2005-06-23 00:09:02 -070035#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
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;
Amos Waterland45fc3b12005-09-24 16:53:16 -070064#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -070065static struct file_operations neigh_stat_seq_fops;
Amos Waterland45fc3b12005-09-24 16:53:16 -070066#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
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
Herbert Xu49636bb2005-10-23 17:18:00 +1000178static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
180 int i;
181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 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 }
Herbert Xu49636bb2005-10-23 17:18:00 +1000217}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
Herbert Xu49636bb2005-10-23 17:18:00 +1000219void 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 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
David S. Miller667347f2005-09-27 12:07:44 -0700713static 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);
Herbert Xu20375502005-10-23 16:11:39 +1000718 dump_stack();
David S. Miller667347f2005-09-27 12:07:44 -0700719 }
720}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
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) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 if (time_before(next, jiffies + HZ/2))
803 next = jiffies + HZ/2;
Herbert Xu6fb99742005-10-23 16:37:48 +1000804 if (!mod_timer(&neigh->timer, next))
805 neigh_hold(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 }
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);
David S. Miller667347f2005-09-27 12:07:44 -0700847 neigh_add_timer(neigh, now + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 } 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;
David S. Miller667347f2005-09-27 12:07:44 -0700860 neigh_add_timer(neigh,
861 jiffies + neigh->parms->delay_probe_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 }
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);
David S. Miller667347f2005-09-27 12:07:44 -07001007 neigh_add_timer(neigh, (jiffies +
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 ((new & NUD_REACHABLE) ?
David S. Miller667347f2005-09-27 12:07:44 -07001009 neigh->parms->reachable_time :
1010 0)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 }
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;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001211 long tdif = NEIGH_CB(back)->sched_next - now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
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 }
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001242
1243 NEIGH_CB(skb)->sched_next = sched_next;
1244 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
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);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001272 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 }
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);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001310 if (parms->dev)
1311 dev_put(parms->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 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
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001549static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1550{
Thomas Grafe386c6e2005-06-18 22:52:09 -07001551 struct rtattr *nest = NULL;
1552
1553 nest = RTA_NEST(skb, NDTA_PARMS);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001554
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
Thomas Graf17977542005-06-18 22:53:48 -07001586 nlh = NLMSG_NEW_ANSWER(skb, cb, RTM_NEWNEIGHTBL, sizeof(struct ndtmsg),
1587 NLM_F_MULTI);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001588
Thomas Graf4b6ea822005-06-18 22:51:43 -07001589 ndtmsg = NLMSG_DATA(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001590
1591 read_lock_bh(&tbl->lock);
1592 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001593 ndtmsg->ndtm_pad1 = 0;
1594 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001595
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
John Hawkes670c02c2005-10-13 09:30:31 -07001628 for_each_cpu(cpu) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001629 struct neigh_statistics *st;
1630
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001631 st = per_cpu_ptr(tbl->stats, cpu);
1632 ndst.ndts_allocs += st->allocs;
1633 ndst.ndts_destroys += st->destroys;
1634 ndst.ndts_hash_grows += st->hash_grows;
1635 ndst.ndts_res_failed += st->res_failed;
1636 ndst.ndts_lookups += st->lookups;
1637 ndst.ndts_hits += st->hits;
1638 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1639 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1640 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1641 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1642 }
1643
1644 RTA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst);
1645 }
1646
1647 BUG_ON(tbl->parms.dev);
1648 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
1649 goto rtattr_failure;
1650
1651 read_unlock_bh(&tbl->lock);
1652 return NLMSG_END(skb, nlh);
1653
1654rtattr_failure:
1655 read_unlock_bh(&tbl->lock);
1656 return NLMSG_CANCEL(skb, nlh);
1657
1658nlmsg_failure:
1659 return -1;
1660}
1661
1662static int neightbl_fill_param_info(struct neigh_table *tbl,
1663 struct neigh_parms *parms,
1664 struct sk_buff *skb,
1665 struct netlink_callback *cb)
1666{
1667 struct ndtmsg *ndtmsg;
1668 struct nlmsghdr *nlh;
1669
Thomas Graf17977542005-06-18 22:53:48 -07001670 nlh = NLMSG_NEW_ANSWER(skb, cb, RTM_NEWNEIGHTBL, sizeof(struct ndtmsg),
1671 NLM_F_MULTI);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001672
Thomas Graf4b6ea822005-06-18 22:51:43 -07001673 ndtmsg = NLMSG_DATA(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001674
1675 read_lock_bh(&tbl->lock);
1676 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001677 ndtmsg->ndtm_pad1 = 0;
1678 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001679 RTA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1680
1681 if (neightbl_fill_parms(skb, parms) < 0)
1682 goto rtattr_failure;
1683
1684 read_unlock_bh(&tbl->lock);
1685 return NLMSG_END(skb, nlh);
1686
1687rtattr_failure:
1688 read_unlock_bh(&tbl->lock);
1689 return NLMSG_CANCEL(skb, nlh);
1690
1691nlmsg_failure:
1692 return -1;
1693}
1694
1695static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl,
1696 int ifindex)
1697{
1698 struct neigh_parms *p;
1699
1700 for (p = &tbl->parms; p; p = p->next)
1701 if ((p->dev && p->dev->ifindex == ifindex) ||
1702 (!p->dev && !ifindex))
1703 return p;
1704
1705 return NULL;
1706}
1707
1708int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1709{
1710 struct neigh_table *tbl;
1711 struct ndtmsg *ndtmsg = NLMSG_DATA(nlh);
1712 struct rtattr **tb = arg;
1713 int err = -EINVAL;
1714
1715 if (!tb[NDTA_NAME - 1] || !RTA_PAYLOAD(tb[NDTA_NAME - 1]))
1716 return -EINVAL;
1717
1718 read_lock(&neigh_tbl_lock);
1719 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1720 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1721 continue;
1722
1723 if (!rtattr_strcmp(tb[NDTA_NAME - 1], tbl->id))
1724 break;
1725 }
1726
1727 if (tbl == NULL) {
1728 err = -ENOENT;
1729 goto errout;
1730 }
1731
1732 /*
1733 * We acquire tbl->lock to be nice to the periodic timers and
1734 * make sure they always see a consistent set of values.
1735 */
1736 write_lock_bh(&tbl->lock);
1737
1738 if (tb[NDTA_THRESH1 - 1])
1739 tbl->gc_thresh1 = RTA_GET_U32(tb[NDTA_THRESH1 - 1]);
1740
1741 if (tb[NDTA_THRESH2 - 1])
1742 tbl->gc_thresh2 = RTA_GET_U32(tb[NDTA_THRESH2 - 1]);
1743
1744 if (tb[NDTA_THRESH3 - 1])
1745 tbl->gc_thresh3 = RTA_GET_U32(tb[NDTA_THRESH3 - 1]);
1746
1747 if (tb[NDTA_GC_INTERVAL - 1])
1748 tbl->gc_interval = RTA_GET_MSECS(tb[NDTA_GC_INTERVAL - 1]);
1749
1750 if (tb[NDTA_PARMS - 1]) {
1751 struct rtattr *tbp[NDTPA_MAX];
1752 struct neigh_parms *p;
1753 u32 ifindex = 0;
1754
1755 if (rtattr_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS - 1]) < 0)
1756 goto rtattr_failure;
1757
1758 if (tbp[NDTPA_IFINDEX - 1])
1759 ifindex = RTA_GET_U32(tbp[NDTPA_IFINDEX - 1]);
1760
1761 p = lookup_neigh_params(tbl, ifindex);
1762 if (p == NULL) {
1763 err = -ENOENT;
1764 goto rtattr_failure;
1765 }
1766
1767 if (tbp[NDTPA_QUEUE_LEN - 1])
1768 p->queue_len = RTA_GET_U32(tbp[NDTPA_QUEUE_LEN - 1]);
1769
1770 if (tbp[NDTPA_PROXY_QLEN - 1])
1771 p->proxy_qlen = RTA_GET_U32(tbp[NDTPA_PROXY_QLEN - 1]);
1772
1773 if (tbp[NDTPA_APP_PROBES - 1])
1774 p->app_probes = RTA_GET_U32(tbp[NDTPA_APP_PROBES - 1]);
1775
1776 if (tbp[NDTPA_UCAST_PROBES - 1])
1777 p->ucast_probes =
1778 RTA_GET_U32(tbp[NDTPA_UCAST_PROBES - 1]);
1779
1780 if (tbp[NDTPA_MCAST_PROBES - 1])
1781 p->mcast_probes =
1782 RTA_GET_U32(tbp[NDTPA_MCAST_PROBES - 1]);
1783
1784 if (tbp[NDTPA_BASE_REACHABLE_TIME - 1])
1785 p->base_reachable_time =
1786 RTA_GET_MSECS(tbp[NDTPA_BASE_REACHABLE_TIME - 1]);
1787
1788 if (tbp[NDTPA_GC_STALETIME - 1])
1789 p->gc_staletime =
1790 RTA_GET_MSECS(tbp[NDTPA_GC_STALETIME - 1]);
1791
1792 if (tbp[NDTPA_DELAY_PROBE_TIME - 1])
1793 p->delay_probe_time =
1794 RTA_GET_MSECS(tbp[NDTPA_DELAY_PROBE_TIME - 1]);
1795
1796 if (tbp[NDTPA_RETRANS_TIME - 1])
1797 p->retrans_time =
1798 RTA_GET_MSECS(tbp[NDTPA_RETRANS_TIME - 1]);
1799
1800 if (tbp[NDTPA_ANYCAST_DELAY - 1])
1801 p->anycast_delay =
1802 RTA_GET_MSECS(tbp[NDTPA_ANYCAST_DELAY - 1]);
1803
1804 if (tbp[NDTPA_PROXY_DELAY - 1])
1805 p->proxy_delay =
1806 RTA_GET_MSECS(tbp[NDTPA_PROXY_DELAY - 1]);
1807
1808 if (tbp[NDTPA_LOCKTIME - 1])
1809 p->locktime = RTA_GET_MSECS(tbp[NDTPA_LOCKTIME - 1]);
1810 }
1811
1812 err = 0;
1813
1814rtattr_failure:
1815 write_unlock_bh(&tbl->lock);
1816errout:
1817 read_unlock(&neigh_tbl_lock);
1818 return err;
1819}
1820
1821int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1822{
1823 int idx, family;
1824 int s_idx = cb->args[0];
1825 struct neigh_table *tbl;
1826
1827 family = ((struct rtgenmsg *)NLMSG_DATA(cb->nlh))->rtgen_family;
1828
1829 read_lock(&neigh_tbl_lock);
1830 for (tbl = neigh_tables, idx = 0; tbl; tbl = tbl->next) {
1831 struct neigh_parms *p;
1832
1833 if (idx < s_idx || (family && tbl->family != family))
1834 continue;
1835
1836 if (neightbl_fill_info(tbl, skb, cb) <= 0)
1837 break;
1838
1839 for (++idx, p = tbl->parms.next; p; p = p->next, idx++) {
1840 if (idx < s_idx)
1841 continue;
1842
1843 if (neightbl_fill_param_info(tbl, p, skb, cb) <= 0)
1844 goto out;
1845 }
1846
1847 }
1848out:
1849 read_unlock(&neigh_tbl_lock);
1850 cb->args[0] = idx;
1851
1852 return skb->len;
1853}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854
1855static int neigh_fill_info(struct sk_buff *skb, struct neighbour *n,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07001856 u32 pid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857{
1858 unsigned long now = jiffies;
1859 unsigned char *b = skb->tail;
1860 struct nda_cacheinfo ci;
1861 int locked = 0;
1862 u32 probes;
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07001863 struct nlmsghdr *nlh = NLMSG_NEW(skb, pid, seq, event,
1864 sizeof(struct ndmsg), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 struct ndmsg *ndm = NLMSG_DATA(nlh);
1866
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 ndm->ndm_family = n->ops->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001868 ndm->ndm_pad1 = 0;
1869 ndm->ndm_pad2 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 ndm->ndm_flags = n->flags;
1871 ndm->ndm_type = n->type;
1872 ndm->ndm_ifindex = n->dev->ifindex;
1873 RTA_PUT(skb, NDA_DST, n->tbl->key_len, n->primary_key);
1874 read_lock_bh(&n->lock);
1875 locked = 1;
1876 ndm->ndm_state = n->nud_state;
1877 if (n->nud_state & NUD_VALID)
1878 RTA_PUT(skb, NDA_LLADDR, n->dev->addr_len, n->ha);
1879 ci.ndm_used = now - n->used;
1880 ci.ndm_confirmed = now - n->confirmed;
1881 ci.ndm_updated = now - n->updated;
1882 ci.ndm_refcnt = atomic_read(&n->refcnt) - 1;
1883 probes = atomic_read(&n->probes);
1884 read_unlock_bh(&n->lock);
1885 locked = 0;
1886 RTA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
1887 RTA_PUT(skb, NDA_PROBES, sizeof(probes), &probes);
1888 nlh->nlmsg_len = skb->tail - b;
1889 return skb->len;
1890
1891nlmsg_failure:
1892rtattr_failure:
1893 if (locked)
1894 read_unlock_bh(&n->lock);
1895 skb_trim(skb, b - skb->data);
1896 return -1;
1897}
1898
1899
1900static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
1901 struct netlink_callback *cb)
1902{
1903 struct neighbour *n;
1904 int rc, h, s_h = cb->args[1];
1905 int idx, s_idx = idx = cb->args[2];
1906
1907 for (h = 0; h <= tbl->hash_mask; h++) {
1908 if (h < s_h)
1909 continue;
1910 if (h > s_h)
1911 s_idx = 0;
1912 read_lock_bh(&tbl->lock);
1913 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next, idx++) {
1914 if (idx < s_idx)
1915 continue;
1916 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid,
1917 cb->nlh->nlmsg_seq,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07001918 RTM_NEWNEIGH,
1919 NLM_F_MULTI) <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 read_unlock_bh(&tbl->lock);
1921 rc = -1;
1922 goto out;
1923 }
1924 }
1925 read_unlock_bh(&tbl->lock);
1926 }
1927 rc = skb->len;
1928out:
1929 cb->args[1] = h;
1930 cb->args[2] = idx;
1931 return rc;
1932}
1933
1934int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1935{
1936 struct neigh_table *tbl;
1937 int t, family, s_t;
1938
1939 read_lock(&neigh_tbl_lock);
1940 family = ((struct rtgenmsg *)NLMSG_DATA(cb->nlh))->rtgen_family;
1941 s_t = cb->args[0];
1942
1943 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
1944 if (t < s_t || (family && tbl->family != family))
1945 continue;
1946 if (t > s_t)
1947 memset(&cb->args[1], 0, sizeof(cb->args) -
1948 sizeof(cb->args[0]));
1949 if (neigh_dump_table(tbl, skb, cb) < 0)
1950 break;
1951 }
1952 read_unlock(&neigh_tbl_lock);
1953
1954 cb->args[0] = t;
1955 return skb->len;
1956}
1957
1958void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
1959{
1960 int chain;
1961
1962 read_lock_bh(&tbl->lock);
1963 for (chain = 0; chain <= tbl->hash_mask; chain++) {
1964 struct neighbour *n;
1965
1966 for (n = tbl->hash_buckets[chain]; n; n = n->next)
1967 cb(n, cookie);
1968 }
1969 read_unlock_bh(&tbl->lock);
1970}
1971EXPORT_SYMBOL(neigh_for_each);
1972
1973/* The tbl->lock must be held as a writer and BH disabled. */
1974void __neigh_for_each_release(struct neigh_table *tbl,
1975 int (*cb)(struct neighbour *))
1976{
1977 int chain;
1978
1979 for (chain = 0; chain <= tbl->hash_mask; chain++) {
1980 struct neighbour *n, **np;
1981
1982 np = &tbl->hash_buckets[chain];
1983 while ((n = *np) != NULL) {
1984 int release;
1985
1986 write_lock(&n->lock);
1987 release = cb(n);
1988 if (release) {
1989 *np = n->next;
1990 n->dead = 1;
1991 } else
1992 np = &n->next;
1993 write_unlock(&n->lock);
1994 if (release)
1995 neigh_release(n);
1996 }
1997 }
1998}
1999EXPORT_SYMBOL(__neigh_for_each_release);
2000
2001#ifdef CONFIG_PROC_FS
2002
2003static struct neighbour *neigh_get_first(struct seq_file *seq)
2004{
2005 struct neigh_seq_state *state = seq->private;
2006 struct neigh_table *tbl = state->tbl;
2007 struct neighbour *n = NULL;
2008 int bucket = state->bucket;
2009
2010 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2011 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) {
2012 n = tbl->hash_buckets[bucket];
2013
2014 while (n) {
2015 if (state->neigh_sub_iter) {
2016 loff_t fakep = 0;
2017 void *v;
2018
2019 v = state->neigh_sub_iter(state, n, &fakep);
2020 if (!v)
2021 goto next;
2022 }
2023 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2024 break;
2025 if (n->nud_state & ~NUD_NOARP)
2026 break;
2027 next:
2028 n = n->next;
2029 }
2030
2031 if (n)
2032 break;
2033 }
2034 state->bucket = bucket;
2035
2036 return n;
2037}
2038
2039static struct neighbour *neigh_get_next(struct seq_file *seq,
2040 struct neighbour *n,
2041 loff_t *pos)
2042{
2043 struct neigh_seq_state *state = seq->private;
2044 struct neigh_table *tbl = state->tbl;
2045
2046 if (state->neigh_sub_iter) {
2047 void *v = state->neigh_sub_iter(state, n, pos);
2048 if (v)
2049 return n;
2050 }
2051 n = n->next;
2052
2053 while (1) {
2054 while (n) {
2055 if (state->neigh_sub_iter) {
2056 void *v = state->neigh_sub_iter(state, n, pos);
2057 if (v)
2058 return n;
2059 goto next;
2060 }
2061 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2062 break;
2063
2064 if (n->nud_state & ~NUD_NOARP)
2065 break;
2066 next:
2067 n = n->next;
2068 }
2069
2070 if (n)
2071 break;
2072
2073 if (++state->bucket > tbl->hash_mask)
2074 break;
2075
2076 n = tbl->hash_buckets[state->bucket];
2077 }
2078
2079 if (n && pos)
2080 --(*pos);
2081 return n;
2082}
2083
2084static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2085{
2086 struct neighbour *n = neigh_get_first(seq);
2087
2088 if (n) {
2089 while (*pos) {
2090 n = neigh_get_next(seq, n, pos);
2091 if (!n)
2092 break;
2093 }
2094 }
2095 return *pos ? NULL : n;
2096}
2097
2098static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2099{
2100 struct neigh_seq_state *state = seq->private;
2101 struct neigh_table *tbl = state->tbl;
2102 struct pneigh_entry *pn = NULL;
2103 int bucket = state->bucket;
2104
2105 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2106 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2107 pn = tbl->phash_buckets[bucket];
2108 if (pn)
2109 break;
2110 }
2111 state->bucket = bucket;
2112
2113 return pn;
2114}
2115
2116static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2117 struct pneigh_entry *pn,
2118 loff_t *pos)
2119{
2120 struct neigh_seq_state *state = seq->private;
2121 struct neigh_table *tbl = state->tbl;
2122
2123 pn = pn->next;
2124 while (!pn) {
2125 if (++state->bucket > PNEIGH_HASHMASK)
2126 break;
2127 pn = tbl->phash_buckets[state->bucket];
2128 if (pn)
2129 break;
2130 }
2131
2132 if (pn && pos)
2133 --(*pos);
2134
2135 return pn;
2136}
2137
2138static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2139{
2140 struct pneigh_entry *pn = pneigh_get_first(seq);
2141
2142 if (pn) {
2143 while (*pos) {
2144 pn = pneigh_get_next(seq, pn, pos);
2145 if (!pn)
2146 break;
2147 }
2148 }
2149 return *pos ? NULL : pn;
2150}
2151
2152static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2153{
2154 struct neigh_seq_state *state = seq->private;
2155 void *rc;
2156
2157 rc = neigh_get_idx(seq, pos);
2158 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2159 rc = pneigh_get_idx(seq, pos);
2160
2161 return rc;
2162}
2163
2164void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
2165{
2166 struct neigh_seq_state *state = seq->private;
2167 loff_t pos_minus_one;
2168
2169 state->tbl = tbl;
2170 state->bucket = 0;
2171 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2172
2173 read_lock_bh(&tbl->lock);
2174
2175 pos_minus_one = *pos - 1;
2176 return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN;
2177}
2178EXPORT_SYMBOL(neigh_seq_start);
2179
2180void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2181{
2182 struct neigh_seq_state *state;
2183 void *rc;
2184
2185 if (v == SEQ_START_TOKEN) {
2186 rc = neigh_get_idx(seq, pos);
2187 goto out;
2188 }
2189
2190 state = seq->private;
2191 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2192 rc = neigh_get_next(seq, v, NULL);
2193 if (rc)
2194 goto out;
2195 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2196 rc = pneigh_get_first(seq);
2197 } else {
2198 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2199 rc = pneigh_get_next(seq, v, NULL);
2200 }
2201out:
2202 ++(*pos);
2203 return rc;
2204}
2205EXPORT_SYMBOL(neigh_seq_next);
2206
2207void neigh_seq_stop(struct seq_file *seq, void *v)
2208{
2209 struct neigh_seq_state *state = seq->private;
2210 struct neigh_table *tbl = state->tbl;
2211
2212 read_unlock_bh(&tbl->lock);
2213}
2214EXPORT_SYMBOL(neigh_seq_stop);
2215
2216/* statistics via seq_file */
2217
2218static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2219{
2220 struct proc_dir_entry *pde = seq->private;
2221 struct neigh_table *tbl = pde->data;
2222 int cpu;
2223
2224 if (*pos == 0)
2225 return SEQ_START_TOKEN;
2226
2227 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
2228 if (!cpu_possible(cpu))
2229 continue;
2230 *pos = cpu+1;
2231 return per_cpu_ptr(tbl->stats, cpu);
2232 }
2233 return NULL;
2234}
2235
2236static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2237{
2238 struct proc_dir_entry *pde = seq->private;
2239 struct neigh_table *tbl = pde->data;
2240 int cpu;
2241
2242 for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
2243 if (!cpu_possible(cpu))
2244 continue;
2245 *pos = cpu+1;
2246 return per_cpu_ptr(tbl->stats, cpu);
2247 }
2248 return NULL;
2249}
2250
2251static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2252{
2253
2254}
2255
2256static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2257{
2258 struct proc_dir_entry *pde = seq->private;
2259 struct neigh_table *tbl = pde->data;
2260 struct neigh_statistics *st = v;
2261
2262 if (v == SEQ_START_TOKEN) {
Olaf Rempel5bec0032005-04-28 12:16:08 -07002263 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 -07002264 return 0;
2265 }
2266
2267 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2268 "%08lx %08lx %08lx %08lx\n",
2269 atomic_read(&tbl->entries),
2270
2271 st->allocs,
2272 st->destroys,
2273 st->hash_grows,
2274
2275 st->lookups,
2276 st->hits,
2277
2278 st->res_failed,
2279
2280 st->rcv_probes_mcast,
2281 st->rcv_probes_ucast,
2282
2283 st->periodic_gc_runs,
2284 st->forced_gc_runs
2285 );
2286
2287 return 0;
2288}
2289
2290static struct seq_operations neigh_stat_seq_ops = {
2291 .start = neigh_stat_seq_start,
2292 .next = neigh_stat_seq_next,
2293 .stop = neigh_stat_seq_stop,
2294 .show = neigh_stat_seq_show,
2295};
2296
2297static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2298{
2299 int ret = seq_open(file, &neigh_stat_seq_ops);
2300
2301 if (!ret) {
2302 struct seq_file *sf = file->private_data;
2303 sf->private = PDE(inode);
2304 }
2305 return ret;
2306};
2307
2308static struct file_operations neigh_stat_seq_fops = {
2309 .owner = THIS_MODULE,
2310 .open = neigh_stat_seq_open,
2311 .read = seq_read,
2312 .llseek = seq_lseek,
2313 .release = seq_release,
2314};
2315
2316#endif /* CONFIG_PROC_FS */
2317
2318#ifdef CONFIG_ARPD
2319void neigh_app_ns(struct neighbour *n)
2320{
2321 struct nlmsghdr *nlh;
2322 int size = NLMSG_SPACE(sizeof(struct ndmsg) + 256);
2323 struct sk_buff *skb = alloc_skb(size, GFP_ATOMIC);
2324
2325 if (!skb)
2326 return;
2327
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07002328 if (neigh_fill_info(skb, n, 0, 0, RTM_GETNEIGH, 0) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 kfree_skb(skb);
2330 return;
2331 }
2332 nlh = (struct nlmsghdr *)skb->data;
2333 nlh->nlmsg_flags = NLM_F_REQUEST;
Patrick McHardyac6d4392005-08-14 19:29:52 -07002334 NETLINK_CB(skb).dst_group = RTNLGRP_NEIGH;
2335 netlink_broadcast(rtnl, skb, 0, RTNLGRP_NEIGH, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336}
2337
2338static void neigh_app_notify(struct neighbour *n)
2339{
2340 struct nlmsghdr *nlh;
2341 int size = NLMSG_SPACE(sizeof(struct ndmsg) + 256);
2342 struct sk_buff *skb = alloc_skb(size, GFP_ATOMIC);
2343
2344 if (!skb)
2345 return;
2346
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07002347 if (neigh_fill_info(skb, n, 0, 0, RTM_NEWNEIGH, 0) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 kfree_skb(skb);
2349 return;
2350 }
2351 nlh = (struct nlmsghdr *)skb->data;
Patrick McHardyac6d4392005-08-14 19:29:52 -07002352 NETLINK_CB(skb).dst_group = RTNLGRP_NEIGH;
2353 netlink_broadcast(rtnl, skb, 0, RTNLGRP_NEIGH, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354}
2355
2356#endif /* CONFIG_ARPD */
2357
2358#ifdef CONFIG_SYSCTL
2359
2360static struct neigh_sysctl_table {
2361 struct ctl_table_header *sysctl_header;
2362 ctl_table neigh_vars[__NET_NEIGH_MAX];
2363 ctl_table neigh_dev[2];
2364 ctl_table neigh_neigh_dir[2];
2365 ctl_table neigh_proto_dir[2];
2366 ctl_table neigh_root_dir[2];
2367} neigh_sysctl_template = {
2368 .neigh_vars = {
2369 {
2370 .ctl_name = NET_NEIGH_MCAST_SOLICIT,
2371 .procname = "mcast_solicit",
2372 .maxlen = sizeof(int),
2373 .mode = 0644,
2374 .proc_handler = &proc_dointvec,
2375 },
2376 {
2377 .ctl_name = NET_NEIGH_UCAST_SOLICIT,
2378 .procname = "ucast_solicit",
2379 .maxlen = sizeof(int),
2380 .mode = 0644,
2381 .proc_handler = &proc_dointvec,
2382 },
2383 {
2384 .ctl_name = NET_NEIGH_APP_SOLICIT,
2385 .procname = "app_solicit",
2386 .maxlen = sizeof(int),
2387 .mode = 0644,
2388 .proc_handler = &proc_dointvec,
2389 },
2390 {
2391 .ctl_name = NET_NEIGH_RETRANS_TIME,
2392 .procname = "retrans_time",
2393 .maxlen = sizeof(int),
2394 .mode = 0644,
2395 .proc_handler = &proc_dointvec_userhz_jiffies,
2396 },
2397 {
2398 .ctl_name = NET_NEIGH_REACHABLE_TIME,
2399 .procname = "base_reachable_time",
2400 .maxlen = sizeof(int),
2401 .mode = 0644,
2402 .proc_handler = &proc_dointvec_jiffies,
2403 .strategy = &sysctl_jiffies,
2404 },
2405 {
2406 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME,
2407 .procname = "delay_first_probe_time",
2408 .maxlen = sizeof(int),
2409 .mode = 0644,
2410 .proc_handler = &proc_dointvec_jiffies,
2411 .strategy = &sysctl_jiffies,
2412 },
2413 {
2414 .ctl_name = NET_NEIGH_GC_STALE_TIME,
2415 .procname = "gc_stale_time",
2416 .maxlen = sizeof(int),
2417 .mode = 0644,
2418 .proc_handler = &proc_dointvec_jiffies,
2419 .strategy = &sysctl_jiffies,
2420 },
2421 {
2422 .ctl_name = NET_NEIGH_UNRES_QLEN,
2423 .procname = "unres_qlen",
2424 .maxlen = sizeof(int),
2425 .mode = 0644,
2426 .proc_handler = &proc_dointvec,
2427 },
2428 {
2429 .ctl_name = NET_NEIGH_PROXY_QLEN,
2430 .procname = "proxy_qlen",
2431 .maxlen = sizeof(int),
2432 .mode = 0644,
2433 .proc_handler = &proc_dointvec,
2434 },
2435 {
2436 .ctl_name = NET_NEIGH_ANYCAST_DELAY,
2437 .procname = "anycast_delay",
2438 .maxlen = sizeof(int),
2439 .mode = 0644,
2440 .proc_handler = &proc_dointvec_userhz_jiffies,
2441 },
2442 {
2443 .ctl_name = NET_NEIGH_PROXY_DELAY,
2444 .procname = "proxy_delay",
2445 .maxlen = sizeof(int),
2446 .mode = 0644,
2447 .proc_handler = &proc_dointvec_userhz_jiffies,
2448 },
2449 {
2450 .ctl_name = NET_NEIGH_LOCKTIME,
2451 .procname = "locktime",
2452 .maxlen = sizeof(int),
2453 .mode = 0644,
2454 .proc_handler = &proc_dointvec_userhz_jiffies,
2455 },
2456 {
2457 .ctl_name = NET_NEIGH_GC_INTERVAL,
2458 .procname = "gc_interval",
2459 .maxlen = sizeof(int),
2460 .mode = 0644,
2461 .proc_handler = &proc_dointvec_jiffies,
2462 .strategy = &sysctl_jiffies,
2463 },
2464 {
2465 .ctl_name = NET_NEIGH_GC_THRESH1,
2466 .procname = "gc_thresh1",
2467 .maxlen = sizeof(int),
2468 .mode = 0644,
2469 .proc_handler = &proc_dointvec,
2470 },
2471 {
2472 .ctl_name = NET_NEIGH_GC_THRESH2,
2473 .procname = "gc_thresh2",
2474 .maxlen = sizeof(int),
2475 .mode = 0644,
2476 .proc_handler = &proc_dointvec,
2477 },
2478 {
2479 .ctl_name = NET_NEIGH_GC_THRESH3,
2480 .procname = "gc_thresh3",
2481 .maxlen = sizeof(int),
2482 .mode = 0644,
2483 .proc_handler = &proc_dointvec,
2484 },
2485 {
2486 .ctl_name = NET_NEIGH_RETRANS_TIME_MS,
2487 .procname = "retrans_time_ms",
2488 .maxlen = sizeof(int),
2489 .mode = 0644,
2490 .proc_handler = &proc_dointvec_ms_jiffies,
2491 .strategy = &sysctl_ms_jiffies,
2492 },
2493 {
2494 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS,
2495 .procname = "base_reachable_time_ms",
2496 .maxlen = sizeof(int),
2497 .mode = 0644,
2498 .proc_handler = &proc_dointvec_ms_jiffies,
2499 .strategy = &sysctl_ms_jiffies,
2500 },
2501 },
2502 .neigh_dev = {
2503 {
2504 .ctl_name = NET_PROTO_CONF_DEFAULT,
2505 .procname = "default",
2506 .mode = 0555,
2507 },
2508 },
2509 .neigh_neigh_dir = {
2510 {
2511 .procname = "neigh",
2512 .mode = 0555,
2513 },
2514 },
2515 .neigh_proto_dir = {
2516 {
2517 .mode = 0555,
2518 },
2519 },
2520 .neigh_root_dir = {
2521 {
2522 .ctl_name = CTL_NET,
2523 .procname = "net",
2524 .mode = 0555,
2525 },
2526 },
2527};
2528
2529int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
2530 int p_id, int pdev_id, char *p_name,
2531 proc_handler *handler, ctl_handler *strategy)
2532{
2533 struct neigh_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
2534 const char *dev_name_source = NULL;
2535 char *dev_name = NULL;
2536 int err = 0;
2537
2538 if (!t)
2539 return -ENOBUFS;
2540 memcpy(t, &neigh_sysctl_template, sizeof(*t));
2541 t->neigh_vars[0].data = &p->mcast_probes;
2542 t->neigh_vars[1].data = &p->ucast_probes;
2543 t->neigh_vars[2].data = &p->app_probes;
2544 t->neigh_vars[3].data = &p->retrans_time;
2545 t->neigh_vars[4].data = &p->base_reachable_time;
2546 t->neigh_vars[5].data = &p->delay_probe_time;
2547 t->neigh_vars[6].data = &p->gc_staletime;
2548 t->neigh_vars[7].data = &p->queue_len;
2549 t->neigh_vars[8].data = &p->proxy_qlen;
2550 t->neigh_vars[9].data = &p->anycast_delay;
2551 t->neigh_vars[10].data = &p->proxy_delay;
2552 t->neigh_vars[11].data = &p->locktime;
2553
2554 if (dev) {
2555 dev_name_source = dev->name;
2556 t->neigh_dev[0].ctl_name = dev->ifindex;
2557 t->neigh_vars[12].procname = NULL;
2558 t->neigh_vars[13].procname = NULL;
2559 t->neigh_vars[14].procname = NULL;
2560 t->neigh_vars[15].procname = NULL;
2561 } else {
2562 dev_name_source = t->neigh_dev[0].procname;
2563 t->neigh_vars[12].data = (int *)(p + 1);
2564 t->neigh_vars[13].data = (int *)(p + 1) + 1;
2565 t->neigh_vars[14].data = (int *)(p + 1) + 2;
2566 t->neigh_vars[15].data = (int *)(p + 1) + 3;
2567 }
2568
2569 t->neigh_vars[16].data = &p->retrans_time;
2570 t->neigh_vars[17].data = &p->base_reachable_time;
2571
2572 if (handler || strategy) {
2573 /* RetransTime */
2574 t->neigh_vars[3].proc_handler = handler;
2575 t->neigh_vars[3].strategy = strategy;
2576 t->neigh_vars[3].extra1 = dev;
2577 /* ReachableTime */
2578 t->neigh_vars[4].proc_handler = handler;
2579 t->neigh_vars[4].strategy = strategy;
2580 t->neigh_vars[4].extra1 = dev;
2581 /* RetransTime (in milliseconds)*/
2582 t->neigh_vars[16].proc_handler = handler;
2583 t->neigh_vars[16].strategy = strategy;
2584 t->neigh_vars[16].extra1 = dev;
2585 /* ReachableTime (in milliseconds) */
2586 t->neigh_vars[17].proc_handler = handler;
2587 t->neigh_vars[17].strategy = strategy;
2588 t->neigh_vars[17].extra1 = dev;
2589 }
2590
Paulo Marques543537b2005-06-23 00:09:02 -07002591 dev_name = kstrdup(dev_name_source, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002592 if (!dev_name) {
2593 err = -ENOBUFS;
2594 goto free;
2595 }
2596
2597 t->neigh_dev[0].procname = dev_name;
2598
2599 t->neigh_neigh_dir[0].ctl_name = pdev_id;
2600
2601 t->neigh_proto_dir[0].procname = p_name;
2602 t->neigh_proto_dir[0].ctl_name = p_id;
2603
2604 t->neigh_dev[0].child = t->neigh_vars;
2605 t->neigh_neigh_dir[0].child = t->neigh_dev;
2606 t->neigh_proto_dir[0].child = t->neigh_neigh_dir;
2607 t->neigh_root_dir[0].child = t->neigh_proto_dir;
2608
2609 t->sysctl_header = register_sysctl_table(t->neigh_root_dir, 0);
2610 if (!t->sysctl_header) {
2611 err = -ENOBUFS;
2612 goto free_procname;
2613 }
2614 p->sysctl_table = t;
2615 return 0;
2616
2617 /* error path */
2618 free_procname:
2619 kfree(dev_name);
2620 free:
2621 kfree(t);
2622
2623 return err;
2624}
2625
2626void neigh_sysctl_unregister(struct neigh_parms *p)
2627{
2628 if (p->sysctl_table) {
2629 struct neigh_sysctl_table *t = p->sysctl_table;
2630 p->sysctl_table = NULL;
2631 unregister_sysctl_table(t->sysctl_header);
2632 kfree(t->neigh_dev[0].procname);
2633 kfree(t);
2634 }
2635}
2636
2637#endif /* CONFIG_SYSCTL */
2638
2639EXPORT_SYMBOL(__neigh_event_send);
2640EXPORT_SYMBOL(neigh_add);
2641EXPORT_SYMBOL(neigh_changeaddr);
2642EXPORT_SYMBOL(neigh_compat_output);
2643EXPORT_SYMBOL(neigh_connected_output);
2644EXPORT_SYMBOL(neigh_create);
2645EXPORT_SYMBOL(neigh_delete);
2646EXPORT_SYMBOL(neigh_destroy);
2647EXPORT_SYMBOL(neigh_dump_info);
2648EXPORT_SYMBOL(neigh_event_ns);
2649EXPORT_SYMBOL(neigh_ifdown);
2650EXPORT_SYMBOL(neigh_lookup);
2651EXPORT_SYMBOL(neigh_lookup_nodev);
2652EXPORT_SYMBOL(neigh_parms_alloc);
2653EXPORT_SYMBOL(neigh_parms_release);
2654EXPORT_SYMBOL(neigh_rand_reach_time);
2655EXPORT_SYMBOL(neigh_resolve_output);
2656EXPORT_SYMBOL(neigh_table_clear);
2657EXPORT_SYMBOL(neigh_table_init);
2658EXPORT_SYMBOL(neigh_update);
2659EXPORT_SYMBOL(neigh_update_hhs);
2660EXPORT_SYMBOL(pneigh_enqueue);
2661EXPORT_SYMBOL(pneigh_lookup);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002662EXPORT_SYMBOL(neightbl_dump_info);
2663EXPORT_SYMBOL(neightbl_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664
2665#ifdef CONFIG_ARPD
2666EXPORT_SYMBOL(neigh_app_ns);
2667#endif
2668#ifdef CONFIG_SYSCTL
2669EXPORT_SYMBOL(neigh_sysctl_register);
2670EXPORT_SYMBOL(neigh_sysctl_unregister);
2671#endif