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