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