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