blob: 3183142c6044000b93829b4e340a3675a0c7d146 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/types.h>
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/socket.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/netdevice.h>
23#include <linux/proc_fs.h>
24#ifdef CONFIG_SYSCTL
25#include <linux/sysctl.h>
26#endif
27#include <linux/times.h>
28#include <net/neighbour.h>
29#include <net/dst.h>
30#include <net/sock.h>
Tom Tucker8d717402006-07-30 20:43:36 -070031#include <net/netevent.h>
Thomas Grafa14a49d2006-08-07 17:53:08 -070032#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#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
Arjan van de Ven9a321442007-02-12 00:55:35 -080065static const 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
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800253 n = kmem_cache_zalloc(tbl->kmem_cachep, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 if (!n)
255 goto out_entries;
256
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 skb_queue_head_init(&n->arp_queue);
258 rwlock_init(&n->lock);
259 n->updated = n->used = now;
260 n->nud_state = NUD_NONE;
261 n->output = neigh_blackhole;
262 n->parms = neigh_parms_clone(&tbl->parms);
263 init_timer(&n->timer);
264 n->timer.function = neigh_timer_handler;
265 n->timer.data = (unsigned long)n;
266
267 NEIGH_CACHE_STAT_INC(tbl, allocs);
268 n->tbl = tbl;
269 atomic_set(&n->refcnt, 1);
270 n->dead = 1;
271out:
272 return n;
273
274out_entries:
275 atomic_dec(&tbl->entries);
276 goto out;
277}
278
279static struct neighbour **neigh_hash_alloc(unsigned int entries)
280{
281 unsigned long size = entries * sizeof(struct neighbour *);
282 struct neighbour **ret;
283
284 if (size <= PAGE_SIZE) {
Andrew Morton77d04bd2006-04-07 14:52:59 -0700285 ret = kzalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 } else {
287 ret = (struct neighbour **)
Andrew Morton77d04bd2006-04-07 14:52:59 -0700288 __get_free_pages(GFP_ATOMIC|__GFP_ZERO, get_order(size));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 return ret;
291}
292
293static void neigh_hash_free(struct neighbour **hash, unsigned int entries)
294{
295 unsigned long size = entries * sizeof(struct neighbour *);
296
297 if (size <= PAGE_SIZE)
298 kfree(hash);
299 else
300 free_pages((unsigned long)hash, get_order(size));
301}
302
303static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries)
304{
305 struct neighbour **new_hash, **old_hash;
306 unsigned int i, new_hash_mask, old_entries;
307
308 NEIGH_CACHE_STAT_INC(tbl, hash_grows);
309
310 BUG_ON(new_entries & (new_entries - 1));
311 new_hash = neigh_hash_alloc(new_entries);
312 if (!new_hash)
313 return;
314
315 old_entries = tbl->hash_mask + 1;
316 new_hash_mask = new_entries - 1;
317 old_hash = tbl->hash_buckets;
318
319 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
320 for (i = 0; i < old_entries; i++) {
321 struct neighbour *n, *next;
322
323 for (n = old_hash[i]; n; n = next) {
324 unsigned int hash_val = tbl->hash(n->primary_key, n->dev);
325
326 hash_val &= new_hash_mask;
327 next = n->next;
328
329 n->next = new_hash[hash_val];
330 new_hash[hash_val] = n;
331 }
332 }
333 tbl->hash_buckets = new_hash;
334 tbl->hash_mask = new_hash_mask;
335
336 neigh_hash_free(old_hash, old_entries);
337}
338
339struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
340 struct net_device *dev)
341{
342 struct neighbour *n;
343 int key_len = tbl->key_len;
Julian Anastasovc5e29462006-10-03 15:49:46 -0700344 u32 hash_val = tbl->hash(pkey, dev);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900345
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 NEIGH_CACHE_STAT_INC(tbl, lookups);
347
348 read_lock_bh(&tbl->lock);
Julian Anastasovc5e29462006-10-03 15:49:46 -0700349 for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
351 neigh_hold(n);
352 NEIGH_CACHE_STAT_INC(tbl, hits);
353 break;
354 }
355 }
356 read_unlock_bh(&tbl->lock);
357 return n;
358}
359
360struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, const void *pkey)
361{
362 struct neighbour *n;
363 int key_len = tbl->key_len;
Julian Anastasovc5e29462006-10-03 15:49:46 -0700364 u32 hash_val = tbl->hash(pkey, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
366 NEIGH_CACHE_STAT_INC(tbl, lookups);
367
368 read_lock_bh(&tbl->lock);
Julian Anastasovc5e29462006-10-03 15:49:46 -0700369 for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 if (!memcmp(n->primary_key, pkey, key_len)) {
371 neigh_hold(n);
372 NEIGH_CACHE_STAT_INC(tbl, hits);
373 break;
374 }
375 }
376 read_unlock_bh(&tbl->lock);
377 return n;
378}
379
380struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey,
381 struct net_device *dev)
382{
383 u32 hash_val;
384 int key_len = tbl->key_len;
385 int error;
386 struct neighbour *n1, *rc, *n = neigh_alloc(tbl);
387
388 if (!n) {
389 rc = ERR_PTR(-ENOBUFS);
390 goto out;
391 }
392
393 memcpy(n->primary_key, pkey, key_len);
394 n->dev = dev;
395 dev_hold(dev);
396
397 /* Protocol specific setup. */
398 if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
399 rc = ERR_PTR(error);
400 goto out_neigh_release;
401 }
402
403 /* Device specific setup. */
404 if (n->parms->neigh_setup &&
405 (error = n->parms->neigh_setup(n)) < 0) {
406 rc = ERR_PTR(error);
407 goto out_neigh_release;
408 }
409
410 n->confirmed = jiffies - (n->parms->base_reachable_time << 1);
411
412 write_lock_bh(&tbl->lock);
413
414 if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1))
415 neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1);
416
417 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;
418
419 if (n->parms->dead) {
420 rc = ERR_PTR(-EINVAL);
421 goto out_tbl_unlock;
422 }
423
424 for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) {
425 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
426 neigh_hold(n1);
427 rc = n1;
428 goto out_tbl_unlock;
429 }
430 }
431
432 n->next = tbl->hash_buckets[hash_val];
433 tbl->hash_buckets[hash_val] = n;
434 n->dead = 0;
435 neigh_hold(n);
436 write_unlock_bh(&tbl->lock);
437 NEIGH_PRINTK2("neigh %p is created.\n", n);
438 rc = n;
439out:
440 return rc;
441out_tbl_unlock:
442 write_unlock_bh(&tbl->lock);
443out_neigh_release:
444 neigh_release(n);
445 goto out;
446}
447
448struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, const void *pkey,
449 struct net_device *dev, int creat)
450{
451 struct pneigh_entry *n;
452 int key_len = tbl->key_len;
453 u32 hash_val = *(u32 *)(pkey + key_len - 4);
454
455 hash_val ^= (hash_val >> 16);
456 hash_val ^= hash_val >> 8;
457 hash_val ^= hash_val >> 4;
458 hash_val &= PNEIGH_HASHMASK;
459
460 read_lock_bh(&tbl->lock);
461
462 for (n = tbl->phash_buckets[hash_val]; n; n = n->next) {
463 if (!memcmp(n->key, pkey, key_len) &&
464 (n->dev == dev || !n->dev)) {
465 read_unlock_bh(&tbl->lock);
466 goto out;
467 }
468 }
469 read_unlock_bh(&tbl->lock);
470 n = NULL;
471 if (!creat)
472 goto out;
473
474 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
475 if (!n)
476 goto out;
477
478 memcpy(n->key, pkey, key_len);
479 n->dev = dev;
480 if (dev)
481 dev_hold(dev);
482
483 if (tbl->pconstructor && tbl->pconstructor(n)) {
484 if (dev)
485 dev_put(dev);
486 kfree(n);
487 n = NULL;
488 goto out;
489 }
490
491 write_lock_bh(&tbl->lock);
492 n->next = tbl->phash_buckets[hash_val];
493 tbl->phash_buckets[hash_val] = n;
494 write_unlock_bh(&tbl->lock);
495out:
496 return n;
497}
498
499
500int pneigh_delete(struct neigh_table *tbl, const void *pkey,
501 struct net_device *dev)
502{
503 struct pneigh_entry *n, **np;
504 int key_len = tbl->key_len;
505 u32 hash_val = *(u32 *)(pkey + key_len - 4);
506
507 hash_val ^= (hash_val >> 16);
508 hash_val ^= hash_val >> 8;
509 hash_val ^= hash_val >> 4;
510 hash_val &= PNEIGH_HASHMASK;
511
512 write_lock_bh(&tbl->lock);
513 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
514 np = &n->next) {
515 if (!memcmp(n->key, pkey, key_len) && n->dev == dev) {
516 *np = n->next;
517 write_unlock_bh(&tbl->lock);
518 if (tbl->pdestructor)
519 tbl->pdestructor(n);
520 if (n->dev)
521 dev_put(n->dev);
522 kfree(n);
523 return 0;
524 }
525 }
526 write_unlock_bh(&tbl->lock);
527 return -ENOENT;
528}
529
530static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
531{
532 struct pneigh_entry *n, **np;
533 u32 h;
534
535 for (h = 0; h <= PNEIGH_HASHMASK; h++) {
536 np = &tbl->phash_buckets[h];
537 while ((n = *np) != NULL) {
538 if (!dev || n->dev == dev) {
539 *np = n->next;
540 if (tbl->pdestructor)
541 tbl->pdestructor(n);
542 if (n->dev)
543 dev_put(n->dev);
544 kfree(n);
545 continue;
546 }
547 np = &n->next;
548 }
549 }
550 return -ENOENT;
551}
552
553
554/*
555 * neighbour must already be out of the table;
556 *
557 */
558void neigh_destroy(struct neighbour *neigh)
559{
560 struct hh_cache *hh;
561
562 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
563
564 if (!neigh->dead) {
565 printk(KERN_WARNING
566 "Destroying alive neighbour %p\n", neigh);
567 dump_stack();
568 return;
569 }
570
571 if (neigh_del_timer(neigh))
572 printk(KERN_WARNING "Impossible event.\n");
573
574 while ((hh = neigh->hh) != NULL) {
575 neigh->hh = hh->hh_next;
576 hh->hh_next = NULL;
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800577
578 write_seqlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 hh->hh_output = neigh_blackhole;
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800580 write_sequnlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 if (atomic_dec_and_test(&hh->hh_refcnt))
582 kfree(hh);
583 }
584
Michael S. Tsirkinc5ecd622006-03-20 22:25:41 -0800585 if (neigh->parms->neigh_destructor)
586 (neigh->parms->neigh_destructor)(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 skb_queue_purge(&neigh->arp_queue);
589
590 dev_put(neigh->dev);
591 neigh_parms_put(neigh->parms);
592
593 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh);
594
595 atomic_dec(&neigh->tbl->entries);
596 kmem_cache_free(neigh->tbl->kmem_cachep, neigh);
597}
598
599/* Neighbour state is suspicious;
600 disable fast path.
601
602 Called with write_locked neigh.
603 */
604static void neigh_suspect(struct neighbour *neigh)
605{
606 struct hh_cache *hh;
607
608 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
609
610 neigh->output = neigh->ops->output;
611
612 for (hh = neigh->hh; hh; hh = hh->hh_next)
613 hh->hh_output = neigh->ops->output;
614}
615
616/* Neighbour state is OK;
617 enable fast path.
618
619 Called with write_locked neigh.
620 */
621static void neigh_connect(struct neighbour *neigh)
622{
623 struct hh_cache *hh;
624
625 NEIGH_PRINTK2("neigh %p is connected.\n", neigh);
626
627 neigh->output = neigh->ops->connected_output;
628
629 for (hh = neigh->hh; hh; hh = hh->hh_next)
630 hh->hh_output = neigh->ops->hh_output;
631}
632
633static void neigh_periodic_timer(unsigned long arg)
634{
635 struct neigh_table *tbl = (struct neigh_table *)arg;
636 struct neighbour *n, **np;
637 unsigned long expire, now = jiffies;
638
639 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
640
641 write_lock(&tbl->lock);
642
643 /*
644 * periodically recompute ReachableTime from random function
645 */
646
647 if (time_after(now, tbl->last_rand + 300 * HZ)) {
648 struct neigh_parms *p;
649 tbl->last_rand = now;
650 for (p = &tbl->parms; p; p = p->next)
651 p->reachable_time =
652 neigh_rand_reach_time(p->base_reachable_time);
653 }
654
655 np = &tbl->hash_buckets[tbl->hash_chain_gc];
656 tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask);
657
658 while ((n = *np) != NULL) {
659 unsigned int state;
660
661 write_lock(&n->lock);
662
663 state = n->nud_state;
664 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
665 write_unlock(&n->lock);
666 goto next_elt;
667 }
668
669 if (time_before(n->used, n->confirmed))
670 n->used = n->confirmed;
671
672 if (atomic_read(&n->refcnt) == 1 &&
673 (state == NUD_FAILED ||
674 time_after(now, n->used + n->parms->gc_staletime))) {
675 *np = n->next;
676 n->dead = 1;
677 write_unlock(&n->lock);
678 neigh_release(n);
679 continue;
680 }
681 write_unlock(&n->lock);
682
683next_elt:
684 np = &n->next;
685 }
686
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900687 /* Cycle through all hash buckets every base_reachable_time/2 ticks.
688 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
689 * base_reachable_time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 */
691 expire = tbl->parms.base_reachable_time >> 1;
692 expire /= (tbl->hash_mask + 1);
693 if (!expire)
694 expire = 1;
695
Arjan van de Venf5a6e012007-02-05 17:59:51 -0800696 if (expire>HZ)
697 mod_timer(&tbl->gc_timer, round_jiffies(now + expire));
698 else
699 mod_timer(&tbl->gc_timer, now + expire);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
701 write_unlock(&tbl->lock);
702}
703
704static __inline__ int neigh_max_probes(struct neighbour *n)
705{
706 struct neigh_parms *p = n->parms;
707 return (n->nud_state & NUD_PROBE ?
708 p->ucast_probes :
709 p->ucast_probes + p->app_probes + p->mcast_probes);
710}
711
David S. Miller667347f2005-09-27 12:07:44 -0700712static inline void neigh_add_timer(struct neighbour *n, unsigned long when)
713{
714 if (unlikely(mod_timer(&n->timer, when))) {
715 printk("NEIGH: BUG, double timer add, state is %x\n",
716 n->nud_state);
Herbert Xu20375502005-10-23 16:11:39 +1000717 dump_stack();
David S. Miller667347f2005-09-27 12:07:44 -0700718 }
719}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
721/* Called when a timer expires for a neighbour entry. */
722
723static void neigh_timer_handler(unsigned long arg)
724{
725 unsigned long now, next;
726 struct neighbour *neigh = (struct neighbour *)arg;
727 unsigned state;
728 int notify = 0;
729
730 write_lock(&neigh->lock);
731
732 state = neigh->nud_state;
733 now = jiffies;
734 next = now + HZ;
735
736 if (!(state & NUD_IN_TIMER)) {
737#ifndef CONFIG_SMP
738 printk(KERN_WARNING "neigh: timer & !nud_in_timer\n");
739#endif
740 goto out;
741 }
742
743 if (state & NUD_REACHABLE) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900744 if (time_before_eq(now,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 neigh->confirmed + neigh->parms->reachable_time)) {
746 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh);
747 next = neigh->confirmed + neigh->parms->reachable_time;
748 } else if (time_before_eq(now,
749 neigh->used + neigh->parms->delay_probe_time)) {
750 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
751 neigh->nud_state = NUD_DELAY;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800752 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 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;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800758 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 neigh_suspect(neigh);
Tom Tucker8d717402006-07-30 20:43:36 -0700760 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 }
762 } else if (state & NUD_DELAY) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900763 if (time_before_eq(now,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 neigh->confirmed + neigh->parms->delay_probe_time)) {
765 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh);
766 neigh->nud_state = NUD_REACHABLE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800767 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 neigh_connect(neigh);
Tom Tucker8d717402006-07-30 20:43:36 -0700769 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 next = neigh->confirmed + neigh->parms->reachable_time;
771 } else {
772 NEIGH_PRINTK2("neigh %p is probed.\n", neigh);
773 neigh->nud_state = NUD_PROBE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800774 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 atomic_set(&neigh->probes, 0);
776 next = now + neigh->parms->retrans_time;
777 }
778 } else {
779 /* NUD_PROBE|NUD_INCOMPLETE */
780 next = now + neigh->parms->retrans_time;
781 }
782
783 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
784 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
785 struct sk_buff *skb;
786
787 neigh->nud_state = NUD_FAILED;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800788 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 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) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 if (time_before(next, jiffies + HZ/2))
809 next = jiffies + HZ/2;
Herbert Xu6fb99742005-10-23 16:37:48 +1000810 if (!mod_timer(&neigh->timer, next))
811 neigh_hold(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 }
813 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
814 struct sk_buff *skb = skb_peek(&neigh->arp_queue);
815 /* keep skb alive even if arp_queue overflows */
816 if (skb)
817 skb_get(skb);
818 write_unlock(&neigh->lock);
819 neigh->ops->solicit(neigh, skb);
820 atomic_inc(&neigh->probes);
821 if (skb)
822 kfree_skb(skb);
823 } else {
824out:
825 write_unlock(&neigh->lock);
826 }
Tom Tucker8d717402006-07-30 20:43:36 -0700827 if (notify)
828 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
830#ifdef CONFIG_ARPD
831 if (notify && neigh->parms->app_probes)
832 neigh_app_notify(neigh);
833#endif
834 neigh_release(neigh);
835}
836
837int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
838{
839 int rc;
840 unsigned long now;
841
842 write_lock_bh(&neigh->lock);
843
844 rc = 0;
845 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
846 goto out_unlock_bh;
847
848 now = jiffies;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
851 if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
852 atomic_set(&neigh->probes, neigh->parms->ucast_probes);
853 neigh->nud_state = NUD_INCOMPLETE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800854 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 neigh_hold(neigh);
David S. Miller667347f2005-09-27 12:07:44 -0700856 neigh_add_timer(neigh, now + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 } else {
858 neigh->nud_state = NUD_FAILED;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800859 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 write_unlock_bh(&neigh->lock);
861
862 if (skb)
863 kfree_skb(skb);
864 return 1;
865 }
866 } else if (neigh->nud_state & NUD_STALE) {
867 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
868 neigh_hold(neigh);
869 neigh->nud_state = NUD_DELAY;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800870 neigh->updated = jiffies;
David S. Miller667347f2005-09-27 12:07:44 -0700871 neigh_add_timer(neigh,
872 jiffies + neigh->parms->delay_probe_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 }
874
875 if (neigh->nud_state == NUD_INCOMPLETE) {
876 if (skb) {
877 if (skb_queue_len(&neigh->arp_queue) >=
878 neigh->parms->queue_len) {
879 struct sk_buff *buff;
880 buff = neigh->arp_queue.next;
881 __skb_unlink(buff, &neigh->arp_queue);
882 kfree_skb(buff);
883 }
884 __skb_queue_tail(&neigh->arp_queue, skb);
885 }
886 rc = 1;
887 }
888out_unlock_bh:
889 write_unlock_bh(&neigh->lock);
890 return rc;
891}
892
Stephen Hemmingere92b43a2006-08-17 18:17:37 -0700893static void neigh_update_hhs(struct neighbour *neigh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894{
895 struct hh_cache *hh;
896 void (*update)(struct hh_cache*, struct net_device*, unsigned char *) =
897 neigh->dev->header_cache_update;
898
899 if (update) {
900 for (hh = neigh->hh; hh; hh = hh->hh_next) {
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800901 write_seqlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 update(hh, neigh->dev, neigh->ha);
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800903 write_sequnlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 }
905 }
906}
907
908
909
910/* Generic update routine.
911 -- lladdr is new lladdr or NULL, if it is not supplied.
912 -- new is new state.
913 -- flags
914 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
915 if it is different.
916 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900917 lladdr instead of overriding it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 if it is different.
919 It also allows to retain current state
920 if lladdr is unchanged.
921 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
922
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900923 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 NTF_ROUTER flag.
925 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
926 a router.
927
928 Caller MUST hold reference count on the entry.
929 */
930
931int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
932 u32 flags)
933{
934 u8 old;
935 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 int notify = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 struct net_device *dev;
938 int update_isrouter = 0;
939
940 write_lock_bh(&neigh->lock);
941
942 dev = neigh->dev;
943 old = neigh->nud_state;
944 err = -EPERM;
945
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900946 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 (old & (NUD_NOARP | NUD_PERMANENT)))
948 goto out;
949
950 if (!(new & NUD_VALID)) {
951 neigh_del_timer(neigh);
952 if (old & NUD_CONNECTED)
953 neigh_suspect(neigh);
954 neigh->nud_state = new;
955 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 notify = old & NUD_VALID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 goto out;
958 }
959
960 /* Compare new lladdr with cached one */
961 if (!dev->addr_len) {
962 /* First case: device needs no address. */
963 lladdr = neigh->ha;
964 } else if (lladdr) {
965 /* The second case: if something is already cached
966 and a new address is proposed:
967 - compare new & old
968 - if they are different, check override flag
969 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900970 if ((old & NUD_VALID) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 !memcmp(lladdr, neigh->ha, dev->addr_len))
972 lladdr = neigh->ha;
973 } else {
974 /* No address is supplied; if we know something,
975 use it, otherwise discard the request.
976 */
977 err = -EINVAL;
978 if (!(old & NUD_VALID))
979 goto out;
980 lladdr = neigh->ha;
981 }
982
983 if (new & NUD_CONNECTED)
984 neigh->confirmed = jiffies;
985 neigh->updated = jiffies;
986
987 /* If entry was valid and address is not changed,
988 do not change entry state, if new one is STALE.
989 */
990 err = 0;
991 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
992 if (old & NUD_VALID) {
993 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
994 update_isrouter = 0;
995 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
996 (old & NUD_CONNECTED)) {
997 lladdr = neigh->ha;
998 new = NUD_STALE;
999 } else
1000 goto out;
1001 } else {
1002 if (lladdr == neigh->ha && new == NUD_STALE &&
1003 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1004 (old & NUD_CONNECTED))
1005 )
1006 new = old;
1007 }
1008 }
1009
1010 if (new != old) {
1011 neigh_del_timer(neigh);
1012 if (new & NUD_IN_TIMER) {
1013 neigh_hold(neigh);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001014 neigh_add_timer(neigh, (jiffies +
1015 ((new & NUD_REACHABLE) ?
David S. Miller667347f2005-09-27 12:07:44 -07001016 neigh->parms->reachable_time :
1017 0)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 }
1019 neigh->nud_state = new;
1020 }
1021
1022 if (lladdr != neigh->ha) {
1023 memcpy(&neigh->ha, lladdr, dev->addr_len);
1024 neigh_update_hhs(neigh);
1025 if (!(new & NUD_CONNECTED))
1026 neigh->confirmed = jiffies -
1027 (neigh->parms->base_reachable_time << 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 }
1030 if (new == old)
1031 goto out;
1032 if (new & NUD_CONNECTED)
1033 neigh_connect(neigh);
1034 else
1035 neigh_suspect(neigh);
1036 if (!(old & NUD_VALID)) {
1037 struct sk_buff *skb;
1038
1039 /* Again: avoid dead loop if something went wrong */
1040
1041 while (neigh->nud_state & NUD_VALID &&
1042 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1043 struct neighbour *n1 = neigh;
1044 write_unlock_bh(&neigh->lock);
1045 /* On shaper/eql skb->dst->neighbour != neigh :( */
1046 if (skb->dst && skb->dst->neighbour)
1047 n1 = skb->dst->neighbour;
1048 n1->output(skb);
1049 write_lock_bh(&neigh->lock);
1050 }
1051 skb_queue_purge(&neigh->arp_queue);
1052 }
1053out:
1054 if (update_isrouter) {
1055 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1056 (neigh->flags | NTF_ROUTER) :
1057 (neigh->flags & ~NTF_ROUTER);
1058 }
1059 write_unlock_bh(&neigh->lock);
Tom Tucker8d717402006-07-30 20:43:36 -07001060
1061 if (notify)
1062 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063#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)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001077 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 NEIGH_UPDATE_F_OVERRIDE);
1079 return neigh;
1080}
1081
1082static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,
Al Virod77072e2006-09-28 14:20:34 -07001083 __be16 protocol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084{
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
Andrew Morton77d04bd2006-04-07 14:52:59 -07001092 if (!hh && (hh = kzalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) {
Stephen Hemminger3644f0c2006-12-07 15:08:17 -08001093 seqlock_init(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 hh->hh_type = protocol;
1095 atomic_set(&hh->hh_refcnt, 0);
1096 hh->hh_next = NULL;
1097 if (dev->hard_header_cache(n, hh)) {
1098 kfree(hh);
1099 hh = NULL;
1100 } else {
1101 atomic_inc(&hh->hh_refcnt);
1102 hh->hh_next = n->hh;
1103 n->hh = hh;
1104 if (n->nud_state & NUD_CONNECTED)
1105 hh->hh_output = n->ops->hh_output;
1106 else
1107 hh->hh_output = n->ops->output;
1108 }
1109 }
1110 if (hh) {
1111 atomic_inc(&hh->hh_refcnt);
1112 dst->hh = hh;
1113 }
1114}
1115
1116/* This function can be used in contexts, where only old dev_queue_xmit
1117 worked, f.e. if you want to override normal output path (eql, shaper),
1118 but resolution is not made yet.
1119 */
1120
1121int neigh_compat_output(struct sk_buff *skb)
1122{
1123 struct net_device *dev = skb->dev;
1124
1125 __skb_pull(skb, skb->nh.raw - skb->data);
1126
1127 if (dev->hard_header &&
1128 dev->hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001129 skb->len) < 0 &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 dev->rebuild_header(skb))
1131 return 0;
1132
1133 return dev_queue_xmit(skb);
1134}
1135
1136/* Slow and careful. */
1137
1138int neigh_resolve_output(struct sk_buff *skb)
1139{
1140 struct dst_entry *dst = skb->dst;
1141 struct neighbour *neigh;
1142 int rc = 0;
1143
1144 if (!dst || !(neigh = dst->neighbour))
1145 goto discard;
1146
1147 __skb_pull(skb, skb->nh.raw - skb->data);
1148
1149 if (!neigh_event_send(neigh, skb)) {
1150 int err;
1151 struct net_device *dev = neigh->dev;
1152 if (dev->hard_header_cache && !dst->hh) {
1153 write_lock_bh(&neigh->lock);
1154 if (!dst->hh)
1155 neigh_hh_init(neigh, dst, dst->ops->protocol);
1156 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1157 neigh->ha, NULL, skb->len);
1158 write_unlock_bh(&neigh->lock);
1159 } else {
1160 read_lock_bh(&neigh->lock);
1161 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1162 neigh->ha, NULL, skb->len);
1163 read_unlock_bh(&neigh->lock);
1164 }
1165 if (err >= 0)
1166 rc = neigh->ops->queue_xmit(skb);
1167 else
1168 goto out_kfree_skb;
1169 }
1170out:
1171 return rc;
1172discard:
1173 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1174 dst, dst ? dst->neighbour : NULL);
1175out_kfree_skb:
1176 rc = -EINVAL;
1177 kfree_skb(skb);
1178 goto out;
1179}
1180
1181/* As fast as possible without hh cache */
1182
1183int neigh_connected_output(struct sk_buff *skb)
1184{
1185 int err;
1186 struct dst_entry *dst = skb->dst;
1187 struct neighbour *neigh = dst->neighbour;
1188 struct net_device *dev = neigh->dev;
1189
1190 __skb_pull(skb, skb->nh.raw - skb->data);
1191
1192 read_lock_bh(&neigh->lock);
1193 err = dev->hard_header(skb, dev, ntohs(skb->protocol),
1194 neigh->ha, NULL, skb->len);
1195 read_unlock_bh(&neigh->lock);
1196 if (err >= 0)
1197 err = neigh->ops->queue_xmit(skb);
1198 else {
1199 err = -EINVAL;
1200 kfree_skb(skb);
1201 }
1202 return err;
1203}
1204
1205static void neigh_proxy_process(unsigned long arg)
1206{
1207 struct neigh_table *tbl = (struct neigh_table *)arg;
1208 long sched_next = 0;
1209 unsigned long now = jiffies;
1210 struct sk_buff *skb;
1211
1212 spin_lock(&tbl->proxy_queue.lock);
1213
1214 skb = tbl->proxy_queue.next;
1215
1216 while (skb != (struct sk_buff *)&tbl->proxy_queue) {
1217 struct sk_buff *back = skb;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001218 long tdif = NEIGH_CB(back)->sched_next - now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
1220 skb = skb->next;
1221 if (tdif <= 0) {
1222 struct net_device *dev = back->dev;
1223 __skb_unlink(back, &tbl->proxy_queue);
1224 if (tbl->proxy_redo && netif_running(dev))
1225 tbl->proxy_redo(back);
1226 else
1227 kfree_skb(back);
1228
1229 dev_put(dev);
1230 } else if (!sched_next || tdif < sched_next)
1231 sched_next = tdif;
1232 }
1233 del_timer(&tbl->proxy_timer);
1234 if (sched_next)
1235 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1236 spin_unlock(&tbl->proxy_queue.lock);
1237}
1238
1239void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1240 struct sk_buff *skb)
1241{
1242 unsigned long now = jiffies;
1243 unsigned long sched_next = now + (net_random() % p->proxy_delay);
1244
1245 if (tbl->proxy_queue.qlen > p->proxy_qlen) {
1246 kfree_skb(skb);
1247 return;
1248 }
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001249
1250 NEIGH_CB(skb)->sched_next = sched_next;
1251 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252
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{
Arnaldo Carvalho de Melob1a98bf2006-11-21 01:15:32 -02001270 struct neigh_parms *p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
1272 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 p->tbl = tbl;
1274 atomic_set(&p->refcnt, 1);
1275 INIT_RCU_HEAD(&p->rcu_head);
1276 p->reachable_time =
1277 neigh_rand_reach_time(p->base_reachable_time);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001278 if (dev) {
1279 if (dev->neigh_setup && dev->neigh_setup(dev, p)) {
1280 kfree(p);
1281 return NULL;
1282 }
1283
1284 dev_hold(dev);
1285 p->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 }
1287 p->sysctl_table = NULL;
1288 write_lock_bh(&tbl->lock);
1289 p->next = tbl->parms.next;
1290 tbl->parms.next = p;
1291 write_unlock_bh(&tbl->lock);
1292 }
1293 return p;
1294}
1295
1296static void neigh_rcu_free_parms(struct rcu_head *head)
1297{
1298 struct neigh_parms *parms =
1299 container_of(head, struct neigh_parms, rcu_head);
1300
1301 neigh_parms_put(parms);
1302}
1303
1304void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1305{
1306 struct neigh_parms **p;
1307
1308 if (!parms || parms == &tbl->parms)
1309 return;
1310 write_lock_bh(&tbl->lock);
1311 for (p = &tbl->parms.next; *p; p = &(*p)->next) {
1312 if (*p == parms) {
1313 *p = parms->next;
1314 parms->dead = 1;
1315 write_unlock_bh(&tbl->lock);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001316 if (parms->dev)
1317 dev_put(parms->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1319 return;
1320 }
1321 }
1322 write_unlock_bh(&tbl->lock);
1323 NEIGH_PRINTK1("neigh_parms_release: not found\n");
1324}
1325
1326void neigh_parms_destroy(struct neigh_parms *parms)
1327{
1328 kfree(parms);
1329}
1330
Simon Kelleybd89efc2006-05-12 14:56:08 -07001331void neigh_table_init_no_netlink(struct neigh_table *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332{
1333 unsigned long now = jiffies;
1334 unsigned long phsize;
1335
1336 atomic_set(&tbl->parms.refcnt, 1);
1337 INIT_RCU_HEAD(&tbl->parms.rcu_head);
1338 tbl->parms.reachable_time =
1339 neigh_rand_reach_time(tbl->parms.base_reachable_time);
1340
1341 if (!tbl->kmem_cachep)
Alexey Dobriyane5d679f332006-08-26 19:25:52 -07001342 tbl->kmem_cachep =
1343 kmem_cache_create(tbl->id, tbl->entry_size, 0,
1344 SLAB_HWCACHE_ALIGN|SLAB_PANIC,
1345 NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 tbl->stats = alloc_percpu(struct neigh_statistics);
1347 if (!tbl->stats)
1348 panic("cannot create neighbour cache statistics");
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001349
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350#ifdef CONFIG_PROC_FS
1351 tbl->pde = create_proc_entry(tbl->id, 0, proc_net_stat);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001352 if (!tbl->pde)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 panic("cannot create neighbour proc dir entry");
1354 tbl->pde->proc_fops = &neigh_stat_seq_fops;
1355 tbl->pde->data = tbl;
1356#endif
1357
1358 tbl->hash_mask = 1;
1359 tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1);
1360
1361 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
Andrew Morton77d04bd2006-04-07 14:52:59 -07001362 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
1364 if (!tbl->hash_buckets || !tbl->phash_buckets)
1365 panic("cannot allocate neighbour cache hashes");
1366
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
1368
1369 rwlock_init(&tbl->lock);
1370 init_timer(&tbl->gc_timer);
1371 tbl->gc_timer.data = (unsigned long)tbl;
1372 tbl->gc_timer.function = neigh_periodic_timer;
1373 tbl->gc_timer.expires = now + 1;
1374 add_timer(&tbl->gc_timer);
1375
1376 init_timer(&tbl->proxy_timer);
1377 tbl->proxy_timer.data = (unsigned long)tbl;
1378 tbl->proxy_timer.function = neigh_proxy_process;
1379 skb_queue_head_init(&tbl->proxy_queue);
1380
1381 tbl->last_flush = now;
1382 tbl->last_rand = now + tbl->parms.reachable_time * 20;
Simon Kelleybd89efc2006-05-12 14:56:08 -07001383}
1384
1385void neigh_table_init(struct neigh_table *tbl)
1386{
1387 struct neigh_table *tmp;
1388
1389 neigh_table_init_no_netlink(tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 write_lock(&neigh_tbl_lock);
Simon Kelleybd89efc2006-05-12 14:56:08 -07001391 for (tmp = neigh_tables; tmp; tmp = tmp->next) {
1392 if (tmp->family == tbl->family)
1393 break;
1394 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 tbl->next = neigh_tables;
1396 neigh_tables = tbl;
1397 write_unlock(&neigh_tbl_lock);
Simon Kelleybd89efc2006-05-12 14:56:08 -07001398
1399 if (unlikely(tmp)) {
1400 printk(KERN_ERR "NEIGH: Registering multiple tables for "
1401 "family %d\n", tbl->family);
1402 dump_stack();
1403 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404}
1405
1406int neigh_table_clear(struct neigh_table *tbl)
1407{
1408 struct neigh_table **tp;
1409
1410 /* It is not clean... Fix it to unload IPv6 module safely */
1411 del_timer_sync(&tbl->gc_timer);
1412 del_timer_sync(&tbl->proxy_timer);
1413 pneigh_queue_purge(&tbl->proxy_queue);
1414 neigh_ifdown(tbl, NULL);
1415 if (atomic_read(&tbl->entries))
1416 printk(KERN_CRIT "neighbour leakage\n");
1417 write_lock(&neigh_tbl_lock);
1418 for (tp = &neigh_tables; *tp; tp = &(*tp)->next) {
1419 if (*tp == tbl) {
1420 *tp = tbl->next;
1421 break;
1422 }
1423 }
1424 write_unlock(&neigh_tbl_lock);
1425
1426 neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1);
1427 tbl->hash_buckets = NULL;
1428
1429 kfree(tbl->phash_buckets);
1430 tbl->phash_buckets = NULL;
1431
Kirill Korotaev3fcde742006-09-01 01:34:10 -07001432 free_percpu(tbl->stats);
1433 tbl->stats = NULL;
1434
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 return 0;
1436}
1437
1438int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1439{
Thomas Grafa14a49d2006-08-07 17:53:08 -07001440 struct ndmsg *ndm;
1441 struct nlattr *dst_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 struct neigh_table *tbl;
1443 struct net_device *dev = NULL;
Thomas Grafa14a49d2006-08-07 17:53:08 -07001444 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
Thomas Grafa14a49d2006-08-07 17:53:08 -07001446 if (nlmsg_len(nlh) < sizeof(*ndm))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 goto out;
1448
Thomas Grafa14a49d2006-08-07 17:53:08 -07001449 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1450 if (dst_attr == NULL)
1451 goto out;
1452
1453 ndm = nlmsg_data(nlh);
1454 if (ndm->ndm_ifindex) {
1455 dev = dev_get_by_index(ndm->ndm_ifindex);
1456 if (dev == NULL) {
1457 err = -ENODEV;
1458 goto out;
1459 }
1460 }
1461
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 read_lock(&neigh_tbl_lock);
1463 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
Thomas Grafa14a49d2006-08-07 17:53:08 -07001464 struct neighbour *neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465
1466 if (tbl->family != ndm->ndm_family)
1467 continue;
1468 read_unlock(&neigh_tbl_lock);
1469
Thomas Grafa14a49d2006-08-07 17:53:08 -07001470 if (nla_len(dst_attr) < tbl->key_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 goto out_dev_put;
1472
1473 if (ndm->ndm_flags & NTF_PROXY) {
Thomas Grafa14a49d2006-08-07 17:53:08 -07001474 err = pneigh_delete(tbl, nla_data(dst_attr), dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 goto out_dev_put;
1476 }
1477
Thomas Grafa14a49d2006-08-07 17:53:08 -07001478 if (dev == NULL)
1479 goto out_dev_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480
Thomas Grafa14a49d2006-08-07 17:53:08 -07001481 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1482 if (neigh == NULL) {
1483 err = -ENOENT;
1484 goto out_dev_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 }
Thomas Grafa14a49d2006-08-07 17:53:08 -07001486
1487 err = neigh_update(neigh, NULL, NUD_FAILED,
1488 NEIGH_UPDATE_F_OVERRIDE |
1489 NEIGH_UPDATE_F_ADMIN);
1490 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 goto out_dev_put;
1492 }
1493 read_unlock(&neigh_tbl_lock);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001494 err = -EAFNOSUPPORT;
1495
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496out_dev_put:
1497 if (dev)
1498 dev_put(dev);
1499out:
1500 return err;
1501}
1502
1503int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1504{
Thomas Graf5208deb2006-08-07 17:55:40 -07001505 struct ndmsg *ndm;
1506 struct nlattr *tb[NDA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 struct neigh_table *tbl;
1508 struct net_device *dev = NULL;
Thomas Graf5208deb2006-08-07 17:55:40 -07001509 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510
Thomas Graf5208deb2006-08-07 17:55:40 -07001511 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
1512 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 goto out;
1514
Thomas Graf5208deb2006-08-07 17:55:40 -07001515 err = -EINVAL;
1516 if (tb[NDA_DST] == NULL)
1517 goto out;
1518
1519 ndm = nlmsg_data(nlh);
1520 if (ndm->ndm_ifindex) {
1521 dev = dev_get_by_index(ndm->ndm_ifindex);
1522 if (dev == NULL) {
1523 err = -ENODEV;
1524 goto out;
1525 }
1526
1527 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
1528 goto out_dev_put;
1529 }
1530
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 read_lock(&neigh_tbl_lock);
1532 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
Thomas Graf5208deb2006-08-07 17:55:40 -07001533 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
1534 struct neighbour *neigh;
1535 void *dst, *lladdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536
1537 if (tbl->family != ndm->ndm_family)
1538 continue;
1539 read_unlock(&neigh_tbl_lock);
1540
Thomas Graf5208deb2006-08-07 17:55:40 -07001541 if (nla_len(tb[NDA_DST]) < tbl->key_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 goto out_dev_put;
Thomas Graf5208deb2006-08-07 17:55:40 -07001543 dst = nla_data(tb[NDA_DST]);
1544 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545
1546 if (ndm->ndm_flags & NTF_PROXY) {
Ville Nuorvala62dd9312006-09-22 14:43:19 -07001547 struct pneigh_entry *pn;
1548
1549 err = -ENOBUFS;
1550 pn = pneigh_lookup(tbl, dst, dev, 1);
1551 if (pn) {
1552 pn->flags = ndm->ndm_flags;
1553 err = 0;
1554 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 goto out_dev_put;
1556 }
1557
Thomas Graf5208deb2006-08-07 17:55:40 -07001558 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 goto out_dev_put;
Thomas Graf5208deb2006-08-07 17:55:40 -07001560
1561 neigh = neigh_lookup(tbl, dst, dev);
1562 if (neigh == NULL) {
1563 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1564 err = -ENOENT;
1565 goto out_dev_put;
1566 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001567
Thomas Graf5208deb2006-08-07 17:55:40 -07001568 neigh = __neigh_lookup_errno(tbl, dst, dev);
1569 if (IS_ERR(neigh)) {
1570 err = PTR_ERR(neigh);
1571 goto out_dev_put;
1572 }
1573 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1575 err = -EEXIST;
Thomas Graf5208deb2006-08-07 17:55:40 -07001576 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 goto out_dev_put;
1578 }
Thomas Graf5208deb2006-08-07 17:55:40 -07001579
1580 if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
1581 flags &= ~NEIGH_UPDATE_F_OVERRIDE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 }
1583
Thomas Graf5208deb2006-08-07 17:55:40 -07001584 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
1585 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 goto out_dev_put;
1587 }
1588
1589 read_unlock(&neigh_tbl_lock);
Thomas Graf5208deb2006-08-07 17:55:40 -07001590 err = -EAFNOSUPPORT;
1591
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592out_dev_put:
1593 if (dev)
1594 dev_put(dev);
1595out:
1596 return err;
1597}
1598
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001599static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1600{
Thomas Grafca860fb2006-08-07 18:00:18 -07001601 struct nlattr *nest;
1602
1603 nest = nla_nest_start(skb, NDTA_PARMS);
1604 if (nest == NULL)
1605 return -ENOBUFS;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001606
1607 if (parms->dev)
Thomas Grafca860fb2006-08-07 18:00:18 -07001608 NLA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001609
Thomas Grafca860fb2006-08-07 18:00:18 -07001610 NLA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt));
1611 NLA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len);
1612 NLA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen);
1613 NLA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes);
1614 NLA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes);
1615 NLA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes);
1616 NLA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time);
1617 NLA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME,
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001618 parms->base_reachable_time);
Thomas Grafca860fb2006-08-07 18:00:18 -07001619 NLA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime);
1620 NLA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time);
1621 NLA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time);
1622 NLA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay);
1623 NLA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay);
1624 NLA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001625
Thomas Grafca860fb2006-08-07 18:00:18 -07001626 return nla_nest_end(skb, nest);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001627
Thomas Grafca860fb2006-08-07 18:00:18 -07001628nla_put_failure:
1629 return nla_nest_cancel(skb, nest);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001630}
1631
Thomas Grafca860fb2006-08-07 18:00:18 -07001632static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
1633 u32 pid, u32 seq, int type, int flags)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001634{
1635 struct nlmsghdr *nlh;
1636 struct ndtmsg *ndtmsg;
1637
Thomas Grafca860fb2006-08-07 18:00:18 -07001638 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1639 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001640 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001641
Thomas Grafca860fb2006-08-07 18:00:18 -07001642 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001643
1644 read_lock_bh(&tbl->lock);
1645 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001646 ndtmsg->ndtm_pad1 = 0;
1647 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001648
Thomas Grafca860fb2006-08-07 18:00:18 -07001649 NLA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1650 NLA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval);
1651 NLA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1);
1652 NLA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2);
1653 NLA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001654
1655 {
1656 unsigned long now = jiffies;
1657 unsigned int flush_delta = now - tbl->last_flush;
1658 unsigned int rand_delta = now - tbl->last_rand;
1659
1660 struct ndt_config ndc = {
1661 .ndtc_key_len = tbl->key_len,
1662 .ndtc_entry_size = tbl->entry_size,
1663 .ndtc_entries = atomic_read(&tbl->entries),
1664 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
1665 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
1666 .ndtc_hash_rnd = tbl->hash_rnd,
1667 .ndtc_hash_mask = tbl->hash_mask,
1668 .ndtc_hash_chain_gc = tbl->hash_chain_gc,
1669 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
1670 };
1671
Thomas Grafca860fb2006-08-07 18:00:18 -07001672 NLA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001673 }
1674
1675 {
1676 int cpu;
1677 struct ndt_stats ndst;
1678
1679 memset(&ndst, 0, sizeof(ndst));
1680
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -07001681 for_each_possible_cpu(cpu) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001682 struct neigh_statistics *st;
1683
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001684 st = per_cpu_ptr(tbl->stats, cpu);
1685 ndst.ndts_allocs += st->allocs;
1686 ndst.ndts_destroys += st->destroys;
1687 ndst.ndts_hash_grows += st->hash_grows;
1688 ndst.ndts_res_failed += st->res_failed;
1689 ndst.ndts_lookups += st->lookups;
1690 ndst.ndts_hits += st->hits;
1691 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1692 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1693 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1694 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1695 }
1696
Thomas Grafca860fb2006-08-07 18:00:18 -07001697 NLA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001698 }
1699
1700 BUG_ON(tbl->parms.dev);
1701 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
Thomas Grafca860fb2006-08-07 18:00:18 -07001702 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001703
1704 read_unlock_bh(&tbl->lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001705 return nlmsg_end(skb, nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001706
Thomas Grafca860fb2006-08-07 18:00:18 -07001707nla_put_failure:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001708 read_unlock_bh(&tbl->lock);
Patrick McHardy26932562007-01-31 23:16:40 -08001709 nlmsg_cancel(skb, nlh);
1710 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001711}
1712
Thomas Grafca860fb2006-08-07 18:00:18 -07001713static int neightbl_fill_param_info(struct sk_buff *skb,
1714 struct neigh_table *tbl,
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001715 struct neigh_parms *parms,
Thomas Grafca860fb2006-08-07 18:00:18 -07001716 u32 pid, u32 seq, int type,
1717 unsigned int flags)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001718{
1719 struct ndtmsg *ndtmsg;
1720 struct nlmsghdr *nlh;
1721
Thomas Grafca860fb2006-08-07 18:00:18 -07001722 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1723 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001724 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001725
Thomas Grafca860fb2006-08-07 18:00:18 -07001726 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001727
1728 read_lock_bh(&tbl->lock);
1729 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001730 ndtmsg->ndtm_pad1 = 0;
1731 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001732
Thomas Grafca860fb2006-08-07 18:00:18 -07001733 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
1734 neightbl_fill_parms(skb, parms) < 0)
1735 goto errout;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001736
1737 read_unlock_bh(&tbl->lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001738 return nlmsg_end(skb, nlh);
1739errout:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001740 read_unlock_bh(&tbl->lock);
Patrick McHardy26932562007-01-31 23:16:40 -08001741 nlmsg_cancel(skb, nlh);
1742 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001743}
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001744
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001745static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl,
1746 int ifindex)
1747{
1748 struct neigh_parms *p;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001749
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001750 for (p = &tbl->parms; p; p = p->next)
1751 if ((p->dev && p->dev->ifindex == ifindex) ||
1752 (!p->dev && !ifindex))
1753 return p;
1754
1755 return NULL;
1756}
1757
Thomas Graf6b3f8672006-08-07 17:58:53 -07001758static struct nla_policy nl_neightbl_policy[NDTA_MAX+1] __read_mostly = {
1759 [NDTA_NAME] = { .type = NLA_STRING },
1760 [NDTA_THRESH1] = { .type = NLA_U32 },
1761 [NDTA_THRESH2] = { .type = NLA_U32 },
1762 [NDTA_THRESH3] = { .type = NLA_U32 },
1763 [NDTA_GC_INTERVAL] = { .type = NLA_U64 },
1764 [NDTA_PARMS] = { .type = NLA_NESTED },
1765};
1766
1767static struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] __read_mostly = {
1768 [NDTPA_IFINDEX] = { .type = NLA_U32 },
1769 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 },
1770 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 },
1771 [NDTPA_APP_PROBES] = { .type = NLA_U32 },
1772 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 },
1773 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 },
1774 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 },
1775 [NDTPA_GC_STALETIME] = { .type = NLA_U64 },
1776 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 },
1777 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 },
1778 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 },
1779 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 },
1780 [NDTPA_LOCKTIME] = { .type = NLA_U64 },
1781};
1782
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001783int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1784{
1785 struct neigh_table *tbl;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001786 struct ndtmsg *ndtmsg;
1787 struct nlattr *tb[NDTA_MAX+1];
1788 int err;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001789
Thomas Graf6b3f8672006-08-07 17:58:53 -07001790 err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
1791 nl_neightbl_policy);
1792 if (err < 0)
1793 goto errout;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001794
Thomas Graf6b3f8672006-08-07 17:58:53 -07001795 if (tb[NDTA_NAME] == NULL) {
1796 err = -EINVAL;
1797 goto errout;
1798 }
1799
1800 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001801 read_lock(&neigh_tbl_lock);
1802 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1803 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1804 continue;
1805
Thomas Graf6b3f8672006-08-07 17:58:53 -07001806 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001807 break;
1808 }
1809
1810 if (tbl == NULL) {
1811 err = -ENOENT;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001812 goto errout_locked;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001813 }
1814
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001815 /*
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001816 * We acquire tbl->lock to be nice to the periodic timers and
1817 * make sure they always see a consistent set of values.
1818 */
1819 write_lock_bh(&tbl->lock);
1820
Thomas Graf6b3f8672006-08-07 17:58:53 -07001821 if (tb[NDTA_PARMS]) {
1822 struct nlattr *tbp[NDTPA_MAX+1];
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001823 struct neigh_parms *p;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001824 int i, ifindex = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001825
Thomas Graf6b3f8672006-08-07 17:58:53 -07001826 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
1827 nl_ntbl_parm_policy);
1828 if (err < 0)
1829 goto errout_tbl_lock;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001830
Thomas Graf6b3f8672006-08-07 17:58:53 -07001831 if (tbp[NDTPA_IFINDEX])
1832 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001833
1834 p = lookup_neigh_params(tbl, ifindex);
1835 if (p == NULL) {
1836 err = -ENOENT;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001837 goto errout_tbl_lock;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001838 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001839
Thomas Graf6b3f8672006-08-07 17:58:53 -07001840 for (i = 1; i <= NDTPA_MAX; i++) {
1841 if (tbp[i] == NULL)
1842 continue;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001843
Thomas Graf6b3f8672006-08-07 17:58:53 -07001844 switch (i) {
1845 case NDTPA_QUEUE_LEN:
1846 p->queue_len = nla_get_u32(tbp[i]);
1847 break;
1848 case NDTPA_PROXY_QLEN:
1849 p->proxy_qlen = nla_get_u32(tbp[i]);
1850 break;
1851 case NDTPA_APP_PROBES:
1852 p->app_probes = nla_get_u32(tbp[i]);
1853 break;
1854 case NDTPA_UCAST_PROBES:
1855 p->ucast_probes = nla_get_u32(tbp[i]);
1856 break;
1857 case NDTPA_MCAST_PROBES:
1858 p->mcast_probes = nla_get_u32(tbp[i]);
1859 break;
1860 case NDTPA_BASE_REACHABLE_TIME:
1861 p->base_reachable_time = nla_get_msecs(tbp[i]);
1862 break;
1863 case NDTPA_GC_STALETIME:
1864 p->gc_staletime = nla_get_msecs(tbp[i]);
1865 break;
1866 case NDTPA_DELAY_PROBE_TIME:
1867 p->delay_probe_time = nla_get_msecs(tbp[i]);
1868 break;
1869 case NDTPA_RETRANS_TIME:
1870 p->retrans_time = nla_get_msecs(tbp[i]);
1871 break;
1872 case NDTPA_ANYCAST_DELAY:
1873 p->anycast_delay = nla_get_msecs(tbp[i]);
1874 break;
1875 case NDTPA_PROXY_DELAY:
1876 p->proxy_delay = nla_get_msecs(tbp[i]);
1877 break;
1878 case NDTPA_LOCKTIME:
1879 p->locktime = nla_get_msecs(tbp[i]);
1880 break;
1881 }
1882 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001883 }
1884
Thomas Graf6b3f8672006-08-07 17:58:53 -07001885 if (tb[NDTA_THRESH1])
1886 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
1887
1888 if (tb[NDTA_THRESH2])
1889 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
1890
1891 if (tb[NDTA_THRESH3])
1892 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
1893
1894 if (tb[NDTA_GC_INTERVAL])
1895 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
1896
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001897 err = 0;
1898
Thomas Graf6b3f8672006-08-07 17:58:53 -07001899errout_tbl_lock:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001900 write_unlock_bh(&tbl->lock);
Thomas Graf6b3f8672006-08-07 17:58:53 -07001901errout_locked:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001902 read_unlock(&neigh_tbl_lock);
Thomas Graf6b3f8672006-08-07 17:58:53 -07001903errout:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001904 return err;
1905}
1906
1907int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1908{
Thomas Grafca860fb2006-08-07 18:00:18 -07001909 int family, tidx, nidx = 0;
1910 int tbl_skip = cb->args[0];
1911 int neigh_skip = cb->args[1];
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001912 struct neigh_table *tbl;
1913
Thomas Grafca860fb2006-08-07 18:00:18 -07001914 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001915
1916 read_lock(&neigh_tbl_lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001917 for (tbl = neigh_tables, tidx = 0; tbl; tbl = tbl->next, tidx++) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001918 struct neigh_parms *p;
1919
Thomas Grafca860fb2006-08-07 18:00:18 -07001920 if (tidx < tbl_skip || (family && tbl->family != family))
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001921 continue;
1922
Thomas Grafca860fb2006-08-07 18:00:18 -07001923 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).pid,
1924 cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
1925 NLM_F_MULTI) <= 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001926 break;
1927
Thomas Grafca860fb2006-08-07 18:00:18 -07001928 for (nidx = 0, p = tbl->parms.next; p; p = p->next, nidx++) {
1929 if (nidx < neigh_skip)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001930 continue;
1931
Thomas Grafca860fb2006-08-07 18:00:18 -07001932 if (neightbl_fill_param_info(skb, tbl, p,
1933 NETLINK_CB(cb->skb).pid,
1934 cb->nlh->nlmsg_seq,
1935 RTM_NEWNEIGHTBL,
1936 NLM_F_MULTI) <= 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001937 goto out;
1938 }
1939
Thomas Grafca860fb2006-08-07 18:00:18 -07001940 neigh_skip = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001941 }
1942out:
1943 read_unlock(&neigh_tbl_lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001944 cb->args[0] = tidx;
1945 cb->args[1] = nidx;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001946
1947 return skb->len;
1948}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949
Thomas Graf8b8aec52006-08-07 17:56:37 -07001950static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
1951 u32 pid, u32 seq, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952{
1953 unsigned long now = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 struct nda_cacheinfo ci;
Thomas Graf8b8aec52006-08-07 17:56:37 -07001955 struct nlmsghdr *nlh;
1956 struct ndmsg *ndm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957
Thomas Graf8b8aec52006-08-07 17:56:37 -07001958 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
1959 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001960 return -EMSGSIZE;
Thomas Graf8b8aec52006-08-07 17:56:37 -07001961
1962 ndm = nlmsg_data(nlh);
1963 ndm->ndm_family = neigh->ops->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001964 ndm->ndm_pad1 = 0;
1965 ndm->ndm_pad2 = 0;
Thomas Graf8b8aec52006-08-07 17:56:37 -07001966 ndm->ndm_flags = neigh->flags;
1967 ndm->ndm_type = neigh->type;
1968 ndm->ndm_ifindex = neigh->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969
Thomas Graf8b8aec52006-08-07 17:56:37 -07001970 NLA_PUT(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key);
1971
1972 read_lock_bh(&neigh->lock);
1973 ndm->ndm_state = neigh->nud_state;
1974 if ((neigh->nud_state & NUD_VALID) &&
1975 nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, neigh->ha) < 0) {
1976 read_unlock_bh(&neigh->lock);
1977 goto nla_put_failure;
1978 }
1979
1980 ci.ndm_used = now - neigh->used;
1981 ci.ndm_confirmed = now - neigh->confirmed;
1982 ci.ndm_updated = now - neigh->updated;
1983 ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1;
1984 read_unlock_bh(&neigh->lock);
1985
1986 NLA_PUT_U32(skb, NDA_PROBES, atomic_read(&neigh->probes));
1987 NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
1988
1989 return nlmsg_end(skb, nlh);
1990
1991nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001992 nlmsg_cancel(skb, nlh);
1993 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994}
1995
1996
1997static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
1998 struct netlink_callback *cb)
1999{
2000 struct neighbour *n;
2001 int rc, h, s_h = cb->args[1];
2002 int idx, s_idx = idx = cb->args[2];
2003
Julian Anastasovc5e29462006-10-03 15:49:46 -07002004 read_lock_bh(&tbl->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 for (h = 0; h <= tbl->hash_mask; h++) {
2006 if (h < s_h)
2007 continue;
2008 if (h > s_h)
2009 s_idx = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next, idx++) {
2011 if (idx < s_idx)
2012 continue;
2013 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid,
2014 cb->nlh->nlmsg_seq,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07002015 RTM_NEWNEIGH,
2016 NLM_F_MULTI) <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 read_unlock_bh(&tbl->lock);
2018 rc = -1;
2019 goto out;
2020 }
2021 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 }
Julian Anastasovc5e29462006-10-03 15:49:46 -07002023 read_unlock_bh(&tbl->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 rc = skb->len;
2025out:
2026 cb->args[1] = h;
2027 cb->args[2] = idx;
2028 return rc;
2029}
2030
2031int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
2032{
2033 struct neigh_table *tbl;
2034 int t, family, s_t;
2035
2036 read_lock(&neigh_tbl_lock);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002037 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 s_t = cb->args[0];
2039
2040 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
2041 if (t < s_t || (family && tbl->family != family))
2042 continue;
2043 if (t > s_t)
2044 memset(&cb->args[1], 0, sizeof(cb->args) -
2045 sizeof(cb->args[0]));
2046 if (neigh_dump_table(tbl, skb, cb) < 0)
2047 break;
2048 }
2049 read_unlock(&neigh_tbl_lock);
2050
2051 cb->args[0] = t;
2052 return skb->len;
2053}
2054
2055void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2056{
2057 int chain;
2058
2059 read_lock_bh(&tbl->lock);
2060 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2061 struct neighbour *n;
2062
2063 for (n = tbl->hash_buckets[chain]; n; n = n->next)
2064 cb(n, cookie);
2065 }
2066 read_unlock_bh(&tbl->lock);
2067}
2068EXPORT_SYMBOL(neigh_for_each);
2069
2070/* The tbl->lock must be held as a writer and BH disabled. */
2071void __neigh_for_each_release(struct neigh_table *tbl,
2072 int (*cb)(struct neighbour *))
2073{
2074 int chain;
2075
2076 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2077 struct neighbour *n, **np;
2078
2079 np = &tbl->hash_buckets[chain];
2080 while ((n = *np) != NULL) {
2081 int release;
2082
2083 write_lock(&n->lock);
2084 release = cb(n);
2085 if (release) {
2086 *np = n->next;
2087 n->dead = 1;
2088 } else
2089 np = &n->next;
2090 write_unlock(&n->lock);
2091 if (release)
2092 neigh_release(n);
2093 }
2094 }
2095}
2096EXPORT_SYMBOL(__neigh_for_each_release);
2097
2098#ifdef CONFIG_PROC_FS
2099
2100static struct neighbour *neigh_get_first(struct seq_file *seq)
2101{
2102 struct neigh_seq_state *state = seq->private;
2103 struct neigh_table *tbl = state->tbl;
2104 struct neighbour *n = NULL;
2105 int bucket = state->bucket;
2106
2107 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2108 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) {
2109 n = tbl->hash_buckets[bucket];
2110
2111 while (n) {
2112 if (state->neigh_sub_iter) {
2113 loff_t fakep = 0;
2114 void *v;
2115
2116 v = state->neigh_sub_iter(state, n, &fakep);
2117 if (!v)
2118 goto next;
2119 }
2120 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2121 break;
2122 if (n->nud_state & ~NUD_NOARP)
2123 break;
2124 next:
2125 n = n->next;
2126 }
2127
2128 if (n)
2129 break;
2130 }
2131 state->bucket = bucket;
2132
2133 return n;
2134}
2135
2136static struct neighbour *neigh_get_next(struct seq_file *seq,
2137 struct neighbour *n,
2138 loff_t *pos)
2139{
2140 struct neigh_seq_state *state = seq->private;
2141 struct neigh_table *tbl = state->tbl;
2142
2143 if (state->neigh_sub_iter) {
2144 void *v = state->neigh_sub_iter(state, n, pos);
2145 if (v)
2146 return n;
2147 }
2148 n = n->next;
2149
2150 while (1) {
2151 while (n) {
2152 if (state->neigh_sub_iter) {
2153 void *v = state->neigh_sub_iter(state, n, pos);
2154 if (v)
2155 return n;
2156 goto next;
2157 }
2158 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2159 break;
2160
2161 if (n->nud_state & ~NUD_NOARP)
2162 break;
2163 next:
2164 n = n->next;
2165 }
2166
2167 if (n)
2168 break;
2169
2170 if (++state->bucket > tbl->hash_mask)
2171 break;
2172
2173 n = tbl->hash_buckets[state->bucket];
2174 }
2175
2176 if (n && pos)
2177 --(*pos);
2178 return n;
2179}
2180
2181static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2182{
2183 struct neighbour *n = neigh_get_first(seq);
2184
2185 if (n) {
2186 while (*pos) {
2187 n = neigh_get_next(seq, n, pos);
2188 if (!n)
2189 break;
2190 }
2191 }
2192 return *pos ? NULL : n;
2193}
2194
2195static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2196{
2197 struct neigh_seq_state *state = seq->private;
2198 struct neigh_table *tbl = state->tbl;
2199 struct pneigh_entry *pn = NULL;
2200 int bucket = state->bucket;
2201
2202 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2203 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2204 pn = tbl->phash_buckets[bucket];
2205 if (pn)
2206 break;
2207 }
2208 state->bucket = bucket;
2209
2210 return pn;
2211}
2212
2213static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2214 struct pneigh_entry *pn,
2215 loff_t *pos)
2216{
2217 struct neigh_seq_state *state = seq->private;
2218 struct neigh_table *tbl = state->tbl;
2219
2220 pn = pn->next;
2221 while (!pn) {
2222 if (++state->bucket > PNEIGH_HASHMASK)
2223 break;
2224 pn = tbl->phash_buckets[state->bucket];
2225 if (pn)
2226 break;
2227 }
2228
2229 if (pn && pos)
2230 --(*pos);
2231
2232 return pn;
2233}
2234
2235static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2236{
2237 struct pneigh_entry *pn = pneigh_get_first(seq);
2238
2239 if (pn) {
2240 while (*pos) {
2241 pn = pneigh_get_next(seq, pn, pos);
2242 if (!pn)
2243 break;
2244 }
2245 }
2246 return *pos ? NULL : pn;
2247}
2248
2249static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2250{
2251 struct neigh_seq_state *state = seq->private;
2252 void *rc;
2253
2254 rc = neigh_get_idx(seq, pos);
2255 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2256 rc = pneigh_get_idx(seq, pos);
2257
2258 return rc;
2259}
2260
2261void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
2262{
2263 struct neigh_seq_state *state = seq->private;
2264 loff_t pos_minus_one;
2265
2266 state->tbl = tbl;
2267 state->bucket = 0;
2268 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2269
2270 read_lock_bh(&tbl->lock);
2271
2272 pos_minus_one = *pos - 1;
2273 return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN;
2274}
2275EXPORT_SYMBOL(neigh_seq_start);
2276
2277void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2278{
2279 struct neigh_seq_state *state;
2280 void *rc;
2281
2282 if (v == SEQ_START_TOKEN) {
2283 rc = neigh_get_idx(seq, pos);
2284 goto out;
2285 }
2286
2287 state = seq->private;
2288 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2289 rc = neigh_get_next(seq, v, NULL);
2290 if (rc)
2291 goto out;
2292 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2293 rc = pneigh_get_first(seq);
2294 } else {
2295 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2296 rc = pneigh_get_next(seq, v, NULL);
2297 }
2298out:
2299 ++(*pos);
2300 return rc;
2301}
2302EXPORT_SYMBOL(neigh_seq_next);
2303
2304void neigh_seq_stop(struct seq_file *seq, void *v)
2305{
2306 struct neigh_seq_state *state = seq->private;
2307 struct neigh_table *tbl = state->tbl;
2308
2309 read_unlock_bh(&tbl->lock);
2310}
2311EXPORT_SYMBOL(neigh_seq_stop);
2312
2313/* statistics via seq_file */
2314
2315static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2316{
2317 struct proc_dir_entry *pde = seq->private;
2318 struct neigh_table *tbl = pde->data;
2319 int cpu;
2320
2321 if (*pos == 0)
2322 return SEQ_START_TOKEN;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002323
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
2325 if (!cpu_possible(cpu))
2326 continue;
2327 *pos = cpu+1;
2328 return per_cpu_ptr(tbl->stats, cpu);
2329 }
2330 return NULL;
2331}
2332
2333static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2334{
2335 struct proc_dir_entry *pde = seq->private;
2336 struct neigh_table *tbl = pde->data;
2337 int cpu;
2338
2339 for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
2340 if (!cpu_possible(cpu))
2341 continue;
2342 *pos = cpu+1;
2343 return per_cpu_ptr(tbl->stats, cpu);
2344 }
2345 return NULL;
2346}
2347
2348static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2349{
2350
2351}
2352
2353static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2354{
2355 struct proc_dir_entry *pde = seq->private;
2356 struct neigh_table *tbl = pde->data;
2357 struct neigh_statistics *st = v;
2358
2359 if (v == SEQ_START_TOKEN) {
Olaf Rempel5bec0032005-04-28 12:16:08 -07002360 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 -07002361 return 0;
2362 }
2363
2364 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2365 "%08lx %08lx %08lx %08lx\n",
2366 atomic_read(&tbl->entries),
2367
2368 st->allocs,
2369 st->destroys,
2370 st->hash_grows,
2371
2372 st->lookups,
2373 st->hits,
2374
2375 st->res_failed,
2376
2377 st->rcv_probes_mcast,
2378 st->rcv_probes_ucast,
2379
2380 st->periodic_gc_runs,
2381 st->forced_gc_runs
2382 );
2383
2384 return 0;
2385}
2386
2387static struct seq_operations neigh_stat_seq_ops = {
2388 .start = neigh_stat_seq_start,
2389 .next = neigh_stat_seq_next,
2390 .stop = neigh_stat_seq_stop,
2391 .show = neigh_stat_seq_show,
2392};
2393
2394static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2395{
2396 int ret = seq_open(file, &neigh_stat_seq_ops);
2397
2398 if (!ret) {
2399 struct seq_file *sf = file->private_data;
2400 sf->private = PDE(inode);
2401 }
2402 return ret;
2403};
2404
Arjan van de Ven9a321442007-02-12 00:55:35 -08002405static const struct file_operations neigh_stat_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406 .owner = THIS_MODULE,
2407 .open = neigh_stat_seq_open,
2408 .read = seq_read,
2409 .llseek = seq_lseek,
2410 .release = seq_release,
2411};
2412
2413#endif /* CONFIG_PROC_FS */
2414
2415#ifdef CONFIG_ARPD
Thomas Graf339bf982006-11-10 14:10:15 -08002416static inline size_t neigh_nlmsg_size(void)
2417{
2418 return NLMSG_ALIGN(sizeof(struct ndmsg))
2419 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2420 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2421 + nla_total_size(sizeof(struct nda_cacheinfo))
2422 + nla_total_size(4); /* NDA_PROBES */
2423}
2424
Thomas Grafb8673312006-08-15 00:33:14 -07002425static void __neigh_notify(struct neighbour *n, int type, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426{
Thomas Graf8b8aec52006-08-07 17:56:37 -07002427 struct sk_buff *skb;
Thomas Grafb8673312006-08-15 00:33:14 -07002428 int err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429
Thomas Graf339bf982006-11-10 14:10:15 -08002430 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002431 if (skb == NULL)
Thomas Grafb8673312006-08-15 00:33:14 -07002432 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433
Thomas Grafb8673312006-08-15 00:33:14 -07002434 err = neigh_fill_info(skb, n, 0, 0, type, flags);
Patrick McHardy26932562007-01-31 23:16:40 -08002435 if (err < 0) {
2436 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2437 WARN_ON(err == -EMSGSIZE);
2438 kfree_skb(skb);
2439 goto errout;
2440 }
Thomas Grafb8673312006-08-15 00:33:14 -07002441 err = rtnl_notify(skb, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
2442errout:
2443 if (err < 0)
2444 rtnl_set_sk_err(RTNLGRP_NEIGH, err);
2445}
2446
2447void neigh_app_ns(struct neighbour *n)
2448{
2449 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450}
2451
2452static void neigh_app_notify(struct neighbour *n)
2453{
Thomas Grafb8673312006-08-15 00:33:14 -07002454 __neigh_notify(n, RTM_NEWNEIGH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455}
2456
2457#endif /* CONFIG_ARPD */
2458
2459#ifdef CONFIG_SYSCTL
2460
2461static struct neigh_sysctl_table {
2462 struct ctl_table_header *sysctl_header;
2463 ctl_table neigh_vars[__NET_NEIGH_MAX];
2464 ctl_table neigh_dev[2];
2465 ctl_table neigh_neigh_dir[2];
2466 ctl_table neigh_proto_dir[2];
2467 ctl_table neigh_root_dir[2];
Brian Haleyab32ea52006-09-22 14:15:41 -07002468} neigh_sysctl_template __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 .neigh_vars = {
2470 {
2471 .ctl_name = NET_NEIGH_MCAST_SOLICIT,
2472 .procname = "mcast_solicit",
2473 .maxlen = sizeof(int),
2474 .mode = 0644,
2475 .proc_handler = &proc_dointvec,
2476 },
2477 {
2478 .ctl_name = NET_NEIGH_UCAST_SOLICIT,
2479 .procname = "ucast_solicit",
2480 .maxlen = sizeof(int),
2481 .mode = 0644,
2482 .proc_handler = &proc_dointvec,
2483 },
2484 {
2485 .ctl_name = NET_NEIGH_APP_SOLICIT,
2486 .procname = "app_solicit",
2487 .maxlen = sizeof(int),
2488 .mode = 0644,
2489 .proc_handler = &proc_dointvec,
2490 },
2491 {
2492 .ctl_name = NET_NEIGH_RETRANS_TIME,
2493 .procname = "retrans_time",
2494 .maxlen = sizeof(int),
2495 .mode = 0644,
2496 .proc_handler = &proc_dointvec_userhz_jiffies,
2497 },
2498 {
2499 .ctl_name = NET_NEIGH_REACHABLE_TIME,
2500 .procname = "base_reachable_time",
2501 .maxlen = sizeof(int),
2502 .mode = 0644,
2503 .proc_handler = &proc_dointvec_jiffies,
2504 .strategy = &sysctl_jiffies,
2505 },
2506 {
2507 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME,
2508 .procname = "delay_first_probe_time",
2509 .maxlen = sizeof(int),
2510 .mode = 0644,
2511 .proc_handler = &proc_dointvec_jiffies,
2512 .strategy = &sysctl_jiffies,
2513 },
2514 {
2515 .ctl_name = NET_NEIGH_GC_STALE_TIME,
2516 .procname = "gc_stale_time",
2517 .maxlen = sizeof(int),
2518 .mode = 0644,
2519 .proc_handler = &proc_dointvec_jiffies,
2520 .strategy = &sysctl_jiffies,
2521 },
2522 {
2523 .ctl_name = NET_NEIGH_UNRES_QLEN,
2524 .procname = "unres_qlen",
2525 .maxlen = sizeof(int),
2526 .mode = 0644,
2527 .proc_handler = &proc_dointvec,
2528 },
2529 {
2530 .ctl_name = NET_NEIGH_PROXY_QLEN,
2531 .procname = "proxy_qlen",
2532 .maxlen = sizeof(int),
2533 .mode = 0644,
2534 .proc_handler = &proc_dointvec,
2535 },
2536 {
2537 .ctl_name = NET_NEIGH_ANYCAST_DELAY,
2538 .procname = "anycast_delay",
2539 .maxlen = sizeof(int),
2540 .mode = 0644,
2541 .proc_handler = &proc_dointvec_userhz_jiffies,
2542 },
2543 {
2544 .ctl_name = NET_NEIGH_PROXY_DELAY,
2545 .procname = "proxy_delay",
2546 .maxlen = sizeof(int),
2547 .mode = 0644,
2548 .proc_handler = &proc_dointvec_userhz_jiffies,
2549 },
2550 {
2551 .ctl_name = NET_NEIGH_LOCKTIME,
2552 .procname = "locktime",
2553 .maxlen = sizeof(int),
2554 .mode = 0644,
2555 .proc_handler = &proc_dointvec_userhz_jiffies,
2556 },
2557 {
2558 .ctl_name = NET_NEIGH_GC_INTERVAL,
2559 .procname = "gc_interval",
2560 .maxlen = sizeof(int),
2561 .mode = 0644,
2562 .proc_handler = &proc_dointvec_jiffies,
2563 .strategy = &sysctl_jiffies,
2564 },
2565 {
2566 .ctl_name = NET_NEIGH_GC_THRESH1,
2567 .procname = "gc_thresh1",
2568 .maxlen = sizeof(int),
2569 .mode = 0644,
2570 .proc_handler = &proc_dointvec,
2571 },
2572 {
2573 .ctl_name = NET_NEIGH_GC_THRESH2,
2574 .procname = "gc_thresh2",
2575 .maxlen = sizeof(int),
2576 .mode = 0644,
2577 .proc_handler = &proc_dointvec,
2578 },
2579 {
2580 .ctl_name = NET_NEIGH_GC_THRESH3,
2581 .procname = "gc_thresh3",
2582 .maxlen = sizeof(int),
2583 .mode = 0644,
2584 .proc_handler = &proc_dointvec,
2585 },
2586 {
2587 .ctl_name = NET_NEIGH_RETRANS_TIME_MS,
2588 .procname = "retrans_time_ms",
2589 .maxlen = sizeof(int),
2590 .mode = 0644,
2591 .proc_handler = &proc_dointvec_ms_jiffies,
2592 .strategy = &sysctl_ms_jiffies,
2593 },
2594 {
2595 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS,
2596 .procname = "base_reachable_time_ms",
2597 .maxlen = sizeof(int),
2598 .mode = 0644,
2599 .proc_handler = &proc_dointvec_ms_jiffies,
2600 .strategy = &sysctl_ms_jiffies,
2601 },
2602 },
2603 .neigh_dev = {
2604 {
2605 .ctl_name = NET_PROTO_CONF_DEFAULT,
2606 .procname = "default",
2607 .mode = 0555,
2608 },
2609 },
2610 .neigh_neigh_dir = {
2611 {
2612 .procname = "neigh",
2613 .mode = 0555,
2614 },
2615 },
2616 .neigh_proto_dir = {
2617 {
2618 .mode = 0555,
2619 },
2620 },
2621 .neigh_root_dir = {
2622 {
2623 .ctl_name = CTL_NET,
2624 .procname = "net",
2625 .mode = 0555,
2626 },
2627 },
2628};
2629
2630int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002631 int p_id, int pdev_id, char *p_name,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 proc_handler *handler, ctl_handler *strategy)
2633{
Arnaldo Carvalho de Melob1a98bf2006-11-21 01:15:32 -02002634 struct neigh_sysctl_table *t = kmemdup(&neigh_sysctl_template,
2635 sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 const char *dev_name_source = NULL;
2637 char *dev_name = NULL;
2638 int err = 0;
2639
2640 if (!t)
2641 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642 t->neigh_vars[0].data = &p->mcast_probes;
2643 t->neigh_vars[1].data = &p->ucast_probes;
2644 t->neigh_vars[2].data = &p->app_probes;
2645 t->neigh_vars[3].data = &p->retrans_time;
2646 t->neigh_vars[4].data = &p->base_reachable_time;
2647 t->neigh_vars[5].data = &p->delay_probe_time;
2648 t->neigh_vars[6].data = &p->gc_staletime;
2649 t->neigh_vars[7].data = &p->queue_len;
2650 t->neigh_vars[8].data = &p->proxy_qlen;
2651 t->neigh_vars[9].data = &p->anycast_delay;
2652 t->neigh_vars[10].data = &p->proxy_delay;
2653 t->neigh_vars[11].data = &p->locktime;
2654
2655 if (dev) {
2656 dev_name_source = dev->name;
2657 t->neigh_dev[0].ctl_name = dev->ifindex;
2658 t->neigh_vars[12].procname = NULL;
2659 t->neigh_vars[13].procname = NULL;
2660 t->neigh_vars[14].procname = NULL;
2661 t->neigh_vars[15].procname = NULL;
2662 } else {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002663 dev_name_source = t->neigh_dev[0].procname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 t->neigh_vars[12].data = (int *)(p + 1);
2665 t->neigh_vars[13].data = (int *)(p + 1) + 1;
2666 t->neigh_vars[14].data = (int *)(p + 1) + 2;
2667 t->neigh_vars[15].data = (int *)(p + 1) + 3;
2668 }
2669
2670 t->neigh_vars[16].data = &p->retrans_time;
2671 t->neigh_vars[17].data = &p->base_reachable_time;
2672
2673 if (handler || strategy) {
2674 /* RetransTime */
2675 t->neigh_vars[3].proc_handler = handler;
2676 t->neigh_vars[3].strategy = strategy;
2677 t->neigh_vars[3].extra1 = dev;
2678 /* ReachableTime */
2679 t->neigh_vars[4].proc_handler = handler;
2680 t->neigh_vars[4].strategy = strategy;
2681 t->neigh_vars[4].extra1 = dev;
2682 /* RetransTime (in milliseconds)*/
2683 t->neigh_vars[16].proc_handler = handler;
2684 t->neigh_vars[16].strategy = strategy;
2685 t->neigh_vars[16].extra1 = dev;
2686 /* ReachableTime (in milliseconds) */
2687 t->neigh_vars[17].proc_handler = handler;
2688 t->neigh_vars[17].strategy = strategy;
2689 t->neigh_vars[17].extra1 = dev;
2690 }
2691
Paulo Marques543537b2005-06-23 00:09:02 -07002692 dev_name = kstrdup(dev_name_source, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693 if (!dev_name) {
2694 err = -ENOBUFS;
2695 goto free;
2696 }
2697
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002698 t->neigh_dev[0].procname = dev_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699
2700 t->neigh_neigh_dir[0].ctl_name = pdev_id;
2701
2702 t->neigh_proto_dir[0].procname = p_name;
2703 t->neigh_proto_dir[0].ctl_name = p_id;
2704
2705 t->neigh_dev[0].child = t->neigh_vars;
2706 t->neigh_neigh_dir[0].child = t->neigh_dev;
2707 t->neigh_proto_dir[0].child = t->neigh_neigh_dir;
2708 t->neigh_root_dir[0].child = t->neigh_proto_dir;
2709
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08002710 t->sysctl_header = register_sysctl_table(t->neigh_root_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711 if (!t->sysctl_header) {
2712 err = -ENOBUFS;
2713 goto free_procname;
2714 }
2715 p->sysctl_table = t;
2716 return 0;
2717
2718 /* error path */
2719 free_procname:
2720 kfree(dev_name);
2721 free:
2722 kfree(t);
2723
2724 return err;
2725}
2726
2727void neigh_sysctl_unregister(struct neigh_parms *p)
2728{
2729 if (p->sysctl_table) {
2730 struct neigh_sysctl_table *t = p->sysctl_table;
2731 p->sysctl_table = NULL;
2732 unregister_sysctl_table(t->sysctl_header);
2733 kfree(t->neigh_dev[0].procname);
2734 kfree(t);
2735 }
2736}
2737
2738#endif /* CONFIG_SYSCTL */
2739
2740EXPORT_SYMBOL(__neigh_event_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741EXPORT_SYMBOL(neigh_changeaddr);
2742EXPORT_SYMBOL(neigh_compat_output);
2743EXPORT_SYMBOL(neigh_connected_output);
2744EXPORT_SYMBOL(neigh_create);
2745EXPORT_SYMBOL(neigh_delete);
2746EXPORT_SYMBOL(neigh_destroy);
2747EXPORT_SYMBOL(neigh_dump_info);
2748EXPORT_SYMBOL(neigh_event_ns);
2749EXPORT_SYMBOL(neigh_ifdown);
2750EXPORT_SYMBOL(neigh_lookup);
2751EXPORT_SYMBOL(neigh_lookup_nodev);
2752EXPORT_SYMBOL(neigh_parms_alloc);
2753EXPORT_SYMBOL(neigh_parms_release);
2754EXPORT_SYMBOL(neigh_rand_reach_time);
2755EXPORT_SYMBOL(neigh_resolve_output);
2756EXPORT_SYMBOL(neigh_table_clear);
2757EXPORT_SYMBOL(neigh_table_init);
Simon Kelleybd89efc2006-05-12 14:56:08 -07002758EXPORT_SYMBOL(neigh_table_init_no_netlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759EXPORT_SYMBOL(neigh_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760EXPORT_SYMBOL(pneigh_enqueue);
2761EXPORT_SYMBOL(pneigh_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762
2763#ifdef CONFIG_ARPD
2764EXPORT_SYMBOL(neigh_app_ns);
2765#endif
2766#ifdef CONFIG_SYSCTL
2767EXPORT_SYMBOL(neigh_sysctl_register);
2768EXPORT_SYMBOL(neigh_sysctl_unregister);
2769#endif