projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mv643xx_eth: set sane default receive coalescing timeout
[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
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);
9ff56607
DM		 874 if (skb)
875 kfree_skb(skb);
876 } else {
69cc64d8 877out:
9ff56607
DM		 878 write_unlock(&neigh->lock);
879 }
d961db35 880
8d71740c 881 if (notify)
d961db35 882 neigh_update_notify(neigh);
1da177e4 883
1da177e4
LT		 884 neigh_release(neigh);
885}
886
887int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
888{
889 int rc;
890 unsigned long now;
891
892 write_lock_bh(&neigh->lock);
893
894 rc = 0;
895 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
896 goto out_unlock_bh;
897
898 now = jiffies;
4ec93edb 899
1da177e4
LT		 900 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
901 if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
902 atomic_set(&neigh->probes, neigh->parms->ucast_probes);
903 neigh->nud_state = NUD_INCOMPLETE;
955aaa2f 904 neigh->updated = jiffies;
667347f1 905 neigh_add_timer(neigh, now + 1);
1da177e4
LT		 906 } else {
907 neigh->nud_state = NUD_FAILED;
955aaa2f 908 neigh->updated = jiffies;
1da177e4
LT		 909 write_unlock_bh(&neigh->lock);
910
911 if (skb)
912 kfree_skb(skb);
913 return 1;
914 }
915 } else if (neigh->nud_state & NUD_STALE) {
916 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
1da177e4 917 neigh->nud_state = NUD_DELAY;
955aaa2f 918 neigh->updated = jiffies;
667347f1
DM		 919 neigh_add_timer(neigh,
920 jiffies + neigh->parms->delay_probe_time);
1da177e4
LT		 921 }
922
923 if (neigh->nud_state == NUD_INCOMPLETE) {
924 if (skb) {
925 if (skb_queue_len(&neigh->arp_queue) >=
926 neigh->parms->queue_len) {
927 struct sk_buff *buff;
f72051b0 928 buff = __skb_dequeue(&neigh->arp_queue);
1da177e4 929 kfree_skb(buff);
9a6d276e 930 NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards);
1da177e4
LT		 931 }
932 __skb_queue_tail(&neigh->arp_queue, skb);
933 }
934 rc = 1;
935 }
936out_unlock_bh:
937 write_unlock_bh(&neigh->lock);
938 return rc;
939}
0a204500 940EXPORT_SYMBOL(__neigh_event_send);
1da177e4 941
e92b43a3 942static void neigh_update_hhs(struct neighbour *neigh)
1da177e4
LT		 943{
944 struct hh_cache *hh;
3b04ddde
SH		 945 void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
946 = neigh->dev->header_ops->cache_update;
1da177e4
LT		 947
948 if (update) {
949 for (hh = neigh->hh; hh; hh = hh->hh_next) {
3644f0ce 950 write_seqlock_bh(&hh->hh_lock);
1da177e4 951 update(hh, neigh->dev, neigh->ha);
3644f0ce 952 write_sequnlock_bh(&hh->hh_lock);
1da177e4
LT		 953 }
954 }
955}
956
957
958
959/* Generic update routine.
960 -- lladdr is new lladdr or NULL, if it is not supplied.
961 -- new is new state.
962 -- flags
963 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
964 if it is different.
965 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
4ec93edb 966 lladdr instead of overriding it
1da177e4
LT		 967 if it is different.
968 It also allows to retain current state
969 if lladdr is unchanged.
970 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
971
4ec93edb 972 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
1da177e4
LT		 973 NTF_ROUTER flag.
974 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
975 a router.
976
977 Caller MUST hold reference count on the entry.
978 */
979
980int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
981 u32 flags)
982{
983 u8 old;
984 int err;
1da177e4 985 int notify = 0;
1da177e4
LT		 986 struct net_device *dev;
987 int update_isrouter = 0;
988
989 write_lock_bh(&neigh->lock);
990
991 dev = neigh->dev;
992 old = neigh->nud_state;
993 err = -EPERM;
994
4ec93edb 995 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
1da177e4
LT		 996 (old & (NUD_NOARP | NUD_PERMANENT)))
997 goto out;
998
999 if (!(new & NUD_VALID)) {
1000 neigh_del_timer(neigh);
1001 if (old & NUD_CONNECTED)
1002 neigh_suspect(neigh);
1003 neigh->nud_state = new;
1004 err = 0;
1da177e4 1005 notify = old & NUD_VALID;
1da177e4
LT		 1006 goto out;
1007 }
1008
1009 /* Compare new lladdr with cached one */
1010 if (!dev->addr_len) {
1011 /* First case: device needs no address. */
1012 lladdr = neigh->ha;
1013 } else if (lladdr) {
1014 /* The second case: if something is already cached
1015 and a new address is proposed:
1016 - compare new & old
1017 - if they are different, check override flag
1018 */
4ec93edb 1019 if ((old & NUD_VALID) &&
1da177e4
LT		 1020 !memcmp(lladdr, neigh->ha, dev->addr_len))
1021 lladdr = neigh->ha;
1022 } else {
1023 /* No address is supplied; if we know something,
1024 use it, otherwise discard the request.
1025 */
1026 err = -EINVAL;
1027 if (!(old & NUD_VALID))
1028 goto out;
1029 lladdr = neigh->ha;
1030 }
1031
1032 if (new & NUD_CONNECTED)
1033 neigh->confirmed = jiffies;
1034 neigh->updated = jiffies;
1035
1036 /* If entry was valid and address is not changed,
1037 do not change entry state, if new one is STALE.
1038 */
1039 err = 0;
1040 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1041 if (old & NUD_VALID) {
1042 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1043 update_isrouter = 0;
1044 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1045 (old & NUD_CONNECTED)) {
1046 lladdr = neigh->ha;
1047 new = NUD_STALE;
1048 } else
1049 goto out;
1050 } else {
1051 if (lladdr == neigh->ha && new == NUD_STALE &&
1052 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1053 (old & NUD_CONNECTED))
1054 )
1055 new = old;
1056 }
1057 }
1058
1059 if (new != old) {
1060 neigh_del_timer(neigh);
a43d8994 1061 if (new & NUD_IN_TIMER)
4ec93edb
YH		 1062 neigh_add_timer(neigh, (jiffies +
1063 ((new & NUD_REACHABLE) ?
667347f1
DM		 1064 neigh->parms->reachable_time :
1065 0)));
1da177e4
LT		 1066 neigh->nud_state = new;
1067 }
1068
1069 if (lladdr != neigh->ha) {
1070 memcpy(&neigh->ha, lladdr, dev->addr_len);
1071 neigh_update_hhs(neigh);
1072 if (!(new & NUD_CONNECTED))
1073 neigh->confirmed = jiffies -
1074 (neigh->parms->base_reachable_time << 1);
1da177e4 1075 notify = 1;
1da177e4
LT		 1076 }
1077 if (new == old)
1078 goto out;
1079 if (new & NUD_CONNECTED)
1080 neigh_connect(neigh);
1081 else
1082 neigh_suspect(neigh);
1083 if (!(old & NUD_VALID)) {
1084 struct sk_buff *skb;
1085
1086 /* Again: avoid dead loop if something went wrong */
1087
1088 while (neigh->nud_state & NUD_VALID &&
1089 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1090 struct neighbour *n1 = neigh;
1091 write_unlock_bh(&neigh->lock);
1092 /* On shaper/eql skb->dst->neighbour != neigh :( */
1093 if (skb->dst && skb->dst->neighbour)
1094 n1 = skb->dst->neighbour;
1095 n1->output(skb);
1096 write_lock_bh(&neigh->lock);
1097 }
1098 skb_queue_purge(&neigh->arp_queue);
1099 }
1100out:
1101 if (update_isrouter) {
1102 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1103 (neigh->flags | NTF_ROUTER) :
1104 (neigh->flags & ~NTF_ROUTER);
1105 }
1106 write_unlock_bh(&neigh->lock);
8d71740c
TT		 1107
1108 if (notify)
d961db35
TG		 1109 neigh_update_notify(neigh);
1110
1da177e4
LT		 1111 return err;
1112}
0a204500 1113EXPORT_SYMBOL(neigh_update);
1da177e4
LT		 1114
1115struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1116 u8 *lladdr, void *saddr,
1117 struct net_device *dev)
1118{
1119 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1120 lladdr || !dev->addr_len);
1121 if (neigh)
4ec93edb 1122 neigh_update(neigh, lladdr, NUD_STALE,
1da177e4
LT		 1123 NEIGH_UPDATE_F_OVERRIDE);
1124 return neigh;
1125}
0a204500 1126EXPORT_SYMBOL(neigh_event_ns);
1da177e4
LT		 1127
1128static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,
d77072ec 1129 __be16 protocol)
1da177e4
LT		 1130{
1131 struct hh_cache *hh;
1132 struct net_device *dev = dst->dev;
1133
1134 for (hh = n->hh; hh; hh = hh->hh_next)
1135 if (hh->hh_type == protocol)
1136 break;
1137
77d04bd9 1138 if (!hh && (hh = kzalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) {
3644f0ce 1139 seqlock_init(&hh->hh_lock);
1da177e4
LT		 1140 hh->hh_type = protocol;
1141 atomic_set(&hh->hh_refcnt, 0);
1142 hh->hh_next = NULL;
3b04ddde
SH		 1143
1144 if (dev->header_ops->cache(n, hh)) {
1da177e4
LT		 1145 kfree(hh);
1146 hh = NULL;
1147 } else {
1148 atomic_inc(&hh->hh_refcnt);
1149 hh->hh_next = n->hh;
1150 n->hh = hh;
1151 if (n->nud_state & NUD_CONNECTED)
1152 hh->hh_output = n->ops->hh_output;
1153 else
1154 hh->hh_output = n->ops->output;
1155 }
1156 }
1157 if (hh) {
1158 atomic_inc(&hh->hh_refcnt);
1159 dst->hh = hh;
1160 }
1161}
1162
1163/* This function can be used in contexts, where only old dev_queue_xmit
1164 worked, f.e. if you want to override normal output path (eql, shaper),
1165 but resolution is not made yet.
1166 */
1167
1168int neigh_compat_output(struct sk_buff *skb)
1169{
1170 struct net_device *dev = skb->dev;
1171
bbe735e4 1172 __skb_pull(skb, skb_network_offset(skb));
1da177e4 1173
0c4e8581
SH		 1174 if (dev_hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
1175 skb->len) < 0 &&
3b04ddde 1176 dev->header_ops->rebuild(skb))
1da177e4
LT		 1177 return 0;
1178
1179 return dev_queue_xmit(skb);
1180}
0a204500 1181EXPORT_SYMBOL(neigh_compat_output);
1da177e4
LT		 1182
1183/* Slow and careful. */
1184
1185int neigh_resolve_output(struct sk_buff *skb)
1186{
1187 struct dst_entry *dst = skb->dst;
1188 struct neighbour *neigh;
1189 int rc = 0;
1190
1191 if (!dst || !(neigh = dst->neighbour))
1192 goto discard;
1193
bbe735e4 1194 __skb_pull(skb, skb_network_offset(skb));
1da177e4
LT		 1195
1196 if (!neigh_event_send(neigh, skb)) {
1197 int err;
1198 struct net_device *dev = neigh->dev;
3b04ddde 1199 if (dev->header_ops->cache && !dst->hh) {
1da177e4
LT		 1200 write_lock_bh(&neigh->lock);
1201 if (!dst->hh)
1202 neigh_hh_init(neigh, dst, dst->ops->protocol);
0c4e8581
SH		 1203 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1204 neigh->ha, NULL, skb->len);
1da177e4
LT		 1205 write_unlock_bh(&neigh->lock);
1206 } else {
1207 read_lock_bh(&neigh->lock);
0c4e8581
SH		 1208 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1209 neigh->ha, NULL, skb->len);
1da177e4
LT		 1210 read_unlock_bh(&neigh->lock);
1211 }
1212 if (err >= 0)
1213 rc = neigh->ops->queue_xmit(skb);
1214 else
1215 goto out_kfree_skb;
1216 }
1217out:
1218 return rc;
1219discard:
1220 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1221 dst, dst ? dst->neighbour : NULL);
1222out_kfree_skb:
1223 rc = -EINVAL;
1224 kfree_skb(skb);
1225 goto out;
1226}
0a204500 1227EXPORT_SYMBOL(neigh_resolve_output);
1da177e4
LT		 1228
1229/* As fast as possible without hh cache */
1230
1231int neigh_connected_output(struct sk_buff *skb)
1232{
1233 int err;
1234 struct dst_entry *dst = skb->dst;
1235 struct neighbour *neigh = dst->neighbour;
1236 struct net_device *dev = neigh->dev;
1237
bbe735e4 1238 __skb_pull(skb, skb_network_offset(skb));
1da177e4
LT		 1239
1240 read_lock_bh(&neigh->lock);
0c4e8581
SH		 1241 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1242 neigh->ha, NULL, skb->len);
1da177e4
LT		 1243 read_unlock_bh(&neigh->lock);
1244 if (err >= 0)
1245 err = neigh->ops->queue_xmit(skb);
1246 else {
1247 err = -EINVAL;
1248 kfree_skb(skb);
1249 }
1250 return err;
1251}
0a204500 1252EXPORT_SYMBOL(neigh_connected_output);
1da177e4
LT		 1253
1254static void neigh_proxy_process(unsigned long arg)
1255{
1256 struct neigh_table *tbl = (struct neigh_table *)arg;
1257 long sched_next = 0;
1258 unsigned long now = jiffies;
f72051b0 1259 struct sk_buff *skb, *n;
1da177e4
LT		 1260
1261 spin_lock(&tbl->proxy_queue.lock);
1262
f72051b0
DM		 1263 skb_queue_walk_safe(&tbl->proxy_queue, skb, n) {
1264 long tdif = NEIGH_CB(skb)->sched_next - now;
1da177e4 1265
1da177e4 1266 if (tdif <= 0) {
f72051b0
DM		 1267 struct net_device *dev = skb->dev;
1268 __skb_unlink(skb, &tbl->proxy_queue);
1da177e4 1269 if (tbl->proxy_redo && netif_running(dev))
f72051b0 1270 tbl->proxy_redo(skb);
1da177e4 1271 else
f72051b0 1272 kfree_skb(skb);
1da177e4
LT		 1273
1274 dev_put(dev);
1275 } else if (!sched_next || tdif < sched_next)
1276 sched_next = tdif;
1277 }
1278 del_timer(&tbl->proxy_timer);
1279 if (sched_next)
1280 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1281 spin_unlock(&tbl->proxy_queue.lock);
1282}
1283
1284void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1285 struct sk_buff *skb)
1286{
1287 unsigned long now = jiffies;
1288 unsigned long sched_next = now + (net_random() % p->proxy_delay);
1289
1290 if (tbl->proxy_queue.qlen > p->proxy_qlen) {
1291 kfree_skb(skb);
1292 return;
1293 }
a61bbcf2
PM		 1294
1295 NEIGH_CB(skb)->sched_next = sched_next;
1296 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
1da177e4
LT		 1297
1298 spin_lock(&tbl->proxy_queue.lock);
1299 if (del_timer(&tbl->proxy_timer)) {
1300 if (time_before(tbl->proxy_timer.expires, sched_next))
1301 sched_next = tbl->proxy_timer.expires;
1302 }
1303 dst_release(skb->dst);
1304 skb->dst = NULL;
1305 dev_hold(skb->dev);
1306 __skb_queue_tail(&tbl->proxy_queue, skb);
1307 mod_timer(&tbl->proxy_timer, sched_next);
1308 spin_unlock(&tbl->proxy_queue.lock);
1309}
0a204500 1310EXPORT_SYMBOL(pneigh_enqueue);
1da177e4 1311
426b5303
EB		 1312static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl,
1313 struct net *net, int ifindex)
1314{
1315 struct neigh_parms *p;
1316
1317 for (p = &tbl->parms; p; p = p->next) {
878628fb 1318 if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) ||
426b5303
EB		 1319 (!p->dev && !ifindex))
1320 return p;
1321 }
1322
1323 return NULL;
1324}
1da177e4
LT		 1325
1326struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1327 struct neigh_table *tbl)
1328{
426b5303 1329 struct neigh_parms *p, *ref;
00829823
SH		 1330 struct net *net = dev_net(dev);
1331 const struct net_device_ops *ops = dev->netdev_ops;
426b5303 1332
426b5303
EB		 1333 ref = lookup_neigh_params(tbl, net, 0);
1334 if (!ref)
1335 return NULL;
1da177e4 1336
426b5303 1337 p = kmemdup(ref, sizeof(*p), GFP_KERNEL);
1da177e4 1338 if (p) {
1da177e4
LT		 1339 p->tbl = tbl;
1340 atomic_set(&p->refcnt, 1);
1da177e4
LT		 1341 p->reachable_time =
1342 neigh_rand_reach_time(p->base_reachable_time);
c7fb64db 1343
00829823 1344 if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) {
486b51d3
DL		 1345 kfree(p);
1346 return NULL;
1da177e4 1347 }
486b51d3
DL		 1348
1349 dev_hold(dev);
1350 p->dev = dev;
e42ea986 1351 write_pnet(&p->net, hold_net(net));
1da177e4
LT		 1352 p->sysctl_table = NULL;
1353 write_lock_bh(&tbl->lock);
1354 p->next = tbl->parms.next;
1355 tbl->parms.next = p;
1356 write_unlock_bh(&tbl->lock);
1357 }
1358 return p;
1359}
0a204500 1360EXPORT_SYMBOL(neigh_parms_alloc);
1da177e4
LT		 1361
1362static void neigh_rcu_free_parms(struct rcu_head *head)
1363{
1364 struct neigh_parms *parms =
1365 container_of(head, struct neigh_parms, rcu_head);
1366
1367 neigh_parms_put(parms);
1368}
1369
1370void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1371{
1372 struct neigh_parms **p;
1373
1374 if (!parms || parms == &tbl->parms)
1375 return;
1376 write_lock_bh(&tbl->lock);
1377 for (p = &tbl->parms.next; *p; p = &(*p)->next) {
1378 if (*p == parms) {
1379 *p = parms->next;
1380 parms->dead = 1;
1381 write_unlock_bh(&tbl->lock);
cecbb639
DM		 1382 if (parms->dev)
1383 dev_put(parms->dev);
1da177e4
LT		 1384 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1385 return;
1386 }
1387 }
1388 write_unlock_bh(&tbl->lock);
1389 NEIGH_PRINTK1("neigh_parms_release: not found\n");
1390}
0a204500 1391EXPORT_SYMBOL(neigh_parms_release);
1da177e4 1392
06f0511d 1393static void neigh_parms_destroy(struct neigh_parms *parms)
1da177e4 1394{
57da52c1 1395 release_net(neigh_parms_net(parms));
1da177e4
LT		 1396 kfree(parms);
1397}
1398
c2ecba71
PE		 1399static struct lock_class_key neigh_table_proxy_queue_class;
1400
bd89efc5 1401void neigh_table_init_no_netlink(struct neigh_table *tbl)
1da177e4
LT		 1402{
1403 unsigned long now = jiffies;
1404 unsigned long phsize;
1405
e42ea986 1406 write_pnet(&tbl->parms.net, &init_net);
1da177e4 1407 atomic_set(&tbl->parms.refcnt, 1);
1da177e4
LT		 1408 tbl->parms.reachable_time =
1409 neigh_rand_reach_time(tbl->parms.base_reachable_time);
1410
1411 if (!tbl->kmem_cachep)
e5d679f3
AD		 1412 tbl->kmem_cachep =
1413 kmem_cache_create(tbl->id, tbl->entry_size, 0,
1414 SLAB_HWCACHE_ALIGN|SLAB_PANIC,
20c2df83 1415 NULL);
1da177e4
LT		 1416 tbl->stats = alloc_percpu(struct neigh_statistics);
1417 if (!tbl->stats)
1418 panic("cannot create neighbour cache statistics");
4ec93edb 1419
1da177e4 1420#ifdef CONFIG_PROC_FS
9b739ba5
AD		 1421 if (!proc_create_data(tbl->id, 0, init_net.proc_net_stat,
1422 &neigh_stat_seq_fops, tbl))
1da177e4 1423 panic("cannot create neighbour proc dir entry");
1da177e4
LT		 1424#endif
1425
1426 tbl->hash_mask = 1;
1427 tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1);
1428
1429 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
77d04bd9 1430 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
1da177e4
LT		 1431
1432 if (!tbl->hash_buckets || !tbl->phash_buckets)
1433 panic("cannot allocate neighbour cache hashes");
1434
1da177e4
LT		 1435 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
1436
1437 rwlock_init(&tbl->lock);
b24b8a24 1438 setup_timer(&tbl->gc_timer, neigh_periodic_timer, (unsigned long)tbl);
1da177e4
LT		 1439 tbl->gc_timer.expires = now + 1;
1440 add_timer(&tbl->gc_timer);
1441
b24b8a24 1442 setup_timer(&tbl->proxy_timer, neigh_proxy_process, (unsigned long)tbl);
c2ecba71
PE		 1443 skb_queue_head_init_class(&tbl->proxy_queue,
1444 &neigh_table_proxy_queue_class);
1da177e4
LT		 1445
1446 tbl->last_flush = now;
1447 tbl->last_rand = now + tbl->parms.reachable_time * 20;
bd89efc5 1448}
0a204500 1449EXPORT_SYMBOL(neigh_table_init_no_netlink);
bd89efc5
SK		 1450
1451void neigh_table_init(struct neigh_table *tbl)
1452{
1453 struct neigh_table *tmp;
1454
1455 neigh_table_init_no_netlink(tbl);
1da177e4 1456 write_lock(&neigh_tbl_lock);
bd89efc5
SK		 1457 for (tmp = neigh_tables; tmp; tmp = tmp->next) {
1458 if (tmp->family == tbl->family)
1459 break;
1460 }
1da177e4
LT		 1461 tbl->next = neigh_tables;
1462 neigh_tables = tbl;
1463 write_unlock(&neigh_tbl_lock);
bd89efc5
SK		 1464
1465 if (unlikely(tmp)) {
1466 printk(KERN_ERR "NEIGH: Registering multiple tables for "
1467 "family %d\n", tbl->family);
1468 dump_stack();
1469 }
1da177e4 1470}
0a204500 1471EXPORT_SYMBOL(neigh_table_init);
1da177e4
LT		 1472
1473int neigh_table_clear(struct neigh_table *tbl)
1474{
1475 struct neigh_table **tp;
1476
1477 /* It is not clean... Fix it to unload IPv6 module safely */
1478 del_timer_sync(&tbl->gc_timer);
1479 del_timer_sync(&tbl->proxy_timer);
1480 pneigh_queue_purge(&tbl->proxy_queue);
1481 neigh_ifdown(tbl, NULL);
1482 if (atomic_read(&tbl->entries))
1483 printk(KERN_CRIT "neighbour leakage\n");
1484 write_lock(&neigh_tbl_lock);
1485 for (tp = &neigh_tables; *tp; tp = &(*tp)->next) {
1486 if (*tp == tbl) {
1487 *tp = tbl->next;
1488 break;
1489 }
1490 }
1491 write_unlock(&neigh_tbl_lock);
1492
1493 neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1);
1494 tbl->hash_buckets = NULL;
1495
1496 kfree(tbl->phash_buckets);
1497 tbl->phash_buckets = NULL;
1498
3f192b5c
AD		 1499 remove_proc_entry(tbl->id, init_net.proc_net_stat);
1500
3fcde74b
KK		 1501 free_percpu(tbl->stats);
1502 tbl->stats = NULL;
1503
bfb85c9f
RD		 1504 kmem_cache_destroy(tbl->kmem_cachep);
1505 tbl->kmem_cachep = NULL;
1506
1da177e4
LT		 1507 return 0;
1508}
0a204500 1509EXPORT_SYMBOL(neigh_table_clear);
1da177e4 1510
c8822a4e 1511static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1da177e4 1512{
3b1e0a65 1513 struct net *net = sock_net(skb->sk);
a14a49d2
TG		 1514 struct ndmsg *ndm;
1515 struct nlattr *dst_attr;
1da177e4
LT		 1516 struct neigh_table *tbl;
1517 struct net_device *dev = NULL;
a14a49d2 1518 int err = -EINVAL;
1da177e4 1519
a14a49d2 1520 if (nlmsg_len(nlh) < sizeof(*ndm))
1da177e4
LT		 1521 goto out;
1522
a14a49d2
TG		 1523 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1524 if (dst_attr == NULL)
1525 goto out;
1526
1527 ndm = nlmsg_data(nlh);
1528 if (ndm->ndm_ifindex) {
881d966b 1529 dev = dev_get_by_index(net, ndm->ndm_ifindex);
a14a49d2
TG		 1530 if (dev == NULL) {
1531 err = -ENODEV;
1532 goto out;
1533 }
1534 }
1535
1da177e4
LT		 1536 read_lock(&neigh_tbl_lock);
1537 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
a14a49d2 1538 struct neighbour *neigh;
1da177e4
LT		 1539
1540 if (tbl->family != ndm->ndm_family)
1541 continue;
1542 read_unlock(&neigh_tbl_lock);
1543
a14a49d2 1544 if (nla_len(dst_attr) < tbl->key_len)
1da177e4
LT		 1545 goto out_dev_put;
1546
1547 if (ndm->ndm_flags & NTF_PROXY) {
426b5303 1548 err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
1da177e4
LT		 1549 goto out_dev_put;
1550 }
1551
a14a49d2
TG		 1552 if (dev == NULL)
1553 goto out_dev_put;
1da177e4 1554
a14a49d2
TG		 1555 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1556 if (neigh == NULL) {
1557 err = -ENOENT;
1558 goto out_dev_put;
1da177e4 1559 }
a14a49d2
TG		 1560
1561 err = neigh_update(neigh, NULL, NUD_FAILED,
1562 NEIGH_UPDATE_F_OVERRIDE |
1563 NEIGH_UPDATE_F_ADMIN);
1564 neigh_release(neigh);
1da177e4
LT		 1565 goto out_dev_put;
1566 }
1567 read_unlock(&neigh_tbl_lock);
a14a49d2
TG		 1568 err = -EAFNOSUPPORT;
1569
1da177e4
LT		 1570out_dev_put:
1571 if (dev)
1572 dev_put(dev);
1573out:
1574 return err;
1575}
1576
c8822a4e 1577static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1da177e4 1578{
3b1e0a65 1579 struct net *net = sock_net(skb->sk);
5208debd
TG		 1580 struct ndmsg *ndm;
1581 struct nlattr *tb[NDA_MAX+1];
1da177e4
LT		 1582 struct neigh_table *tbl;
1583 struct net_device *dev = NULL;
5208debd 1584 int err;
1da177e4 1585
5208debd
TG		 1586 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
1587 if (err < 0)
1da177e4
LT		 1588 goto out;
1589
5208debd
TG		 1590 err = -EINVAL;
1591 if (tb[NDA_DST] == NULL)
1592 goto out;
1593
1594 ndm = nlmsg_data(nlh);
1595 if (ndm->ndm_ifindex) {
881d966b 1596 dev = dev_get_by_index(net, ndm->ndm_ifindex);
5208debd
TG		 1597 if (dev == NULL) {
1598 err = -ENODEV;
1599 goto out;
1600 }
1601
1602 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
1603 goto out_dev_put;
1604 }
1605
1da177e4
LT		 1606 read_lock(&neigh_tbl_lock);
1607 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
5208debd
TG		 1608 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
1609 struct neighbour *neigh;
1610 void *dst, *lladdr;
1da177e4
LT		 1611
1612 if (tbl->family != ndm->ndm_family)
1613 continue;
1614 read_unlock(&neigh_tbl_lock);
1615
5208debd 1616 if (nla_len(tb[NDA_DST]) < tbl->key_len)
1da177e4 1617 goto out_dev_put;
5208debd
TG		 1618 dst = nla_data(tb[NDA_DST]);
1619 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
1da177e4
LT		 1620
1621 if (ndm->ndm_flags & NTF_PROXY) {
62dd9318
VN		 1622 struct pneigh_entry *pn;
1623
1624 err = -ENOBUFS;
426b5303 1625 pn = pneigh_lookup(tbl, net, dst, dev, 1);
62dd9318
VN		 1626 if (pn) {
1627 pn->flags = ndm->ndm_flags;
1628 err = 0;
1629 }
1da177e4
LT		 1630 goto out_dev_put;
1631 }
1632
5208debd 1633 if (dev == NULL)
1da177e4 1634 goto out_dev_put;
5208debd
TG		 1635
1636 neigh = neigh_lookup(tbl, dst, dev);
1637 if (neigh == NULL) {
1638 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1639 err = -ENOENT;
1640 goto out_dev_put;
1641 }
4ec93edb 1642
5208debd
TG		 1643 neigh = __neigh_lookup_errno(tbl, dst, dev);
1644 if (IS_ERR(neigh)) {
1645 err = PTR_ERR(neigh);
1da177e4
LT		 1646 goto out_dev_put;
1647 }
1da177e4 1648 } else {
5208debd
TG		 1649 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1650 err = -EEXIST;
1651 neigh_release(neigh);
1da177e4
LT		 1652 goto out_dev_put;
1653 }
1da177e4 1654
5208debd
TG		 1655 if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
1656 flags &= ~NEIGH_UPDATE_F_OVERRIDE;
1657 }
1da177e4 1658
5208debd
TG		 1659 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
1660 neigh_release(neigh);
1da177e4
LT		 1661 goto out_dev_put;
1662 }
1663
1664 read_unlock(&neigh_tbl_lock);
5208debd
TG		 1665 err = -EAFNOSUPPORT;
1666
1da177e4
LT		 1667out_dev_put:
1668 if (dev)
1669 dev_put(dev);
1670out:
1671 return err;
1672}
1673
c7fb64db
TG		 1674static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1675{
ca860fb3
TG		 1676 struct nlattr *nest;
1677
1678 nest = nla_nest_start(skb, NDTA_PARMS);
1679 if (nest == NULL)
1680 return -ENOBUFS;
c7fb64db
TG		 1681
1682 if (parms->dev)
ca860fb3
TG		 1683 NLA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex);
1684
1685 NLA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt));
1686 NLA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len);
1687 NLA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen);
1688 NLA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes);
1689 NLA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes);
1690 NLA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes);
1691 NLA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time);
1692 NLA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME,
c7fb64db 1693 parms->base_reachable_time);
ca860fb3
TG		 1694 NLA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime);
1695 NLA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time);
1696 NLA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time);
1697 NLA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay);
1698 NLA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay);
1699 NLA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime);
c7fb64db 1700
ca860fb3 1701 return nla_nest_end(skb, nest);
c7fb64db 1702
ca860fb3 1703nla_put_failure:
bc3ed28c
TG		 1704 nla_nest_cancel(skb, nest);
1705 return -EMSGSIZE;
c7fb64db
TG		 1706}
1707
ca860fb3
TG		 1708static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
1709 u32 pid, u32 seq, int type, int flags)
c7fb64db
TG		 1710{
1711 struct nlmsghdr *nlh;
1712 struct ndtmsg *ndtmsg;
1713
ca860fb3
TG		 1714 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1715 if (nlh == NULL)
26932566 1716 return -EMSGSIZE;
c7fb64db 1717
ca860fb3 1718 ndtmsg = nlmsg_data(nlh);
c7fb64db
TG		 1719
1720 read_lock_bh(&tbl->lock);
1721 ndtmsg->ndtm_family = tbl->family;
9ef1d4c7
PM		 1722 ndtmsg->ndtm_pad1 = 0;
1723 ndtmsg->ndtm_pad2 = 0;
c7fb64db 1724
ca860fb3
TG		 1725 NLA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1726 NLA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval);
1727 NLA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1);
1728 NLA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2);
1729 NLA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3);
c7fb64db
TG		 1730
1731 {
1732 unsigned long now = jiffies;
1733 unsigned int flush_delta = now - tbl->last_flush;
1734 unsigned int rand_delta = now - tbl->last_rand;
1735
1736 struct ndt_config ndc = {
1737 .ndtc_key_len = tbl->key_len,
1738 .ndtc_entry_size = tbl->entry_size,
1739 .ndtc_entries = atomic_read(&tbl->entries),
1740 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
1741 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
1742 .ndtc_hash_rnd = tbl->hash_rnd,
1743 .ndtc_hash_mask = tbl->hash_mask,
1744 .ndtc_hash_chain_gc = tbl->hash_chain_gc,
1745 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
1746 };
1747
ca860fb3 1748 NLA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc);
c7fb64db
TG		 1749 }
1750
1751 {
1752 int cpu;
1753 struct ndt_stats ndst;
1754
1755 memset(&ndst, 0, sizeof(ndst));
1756
6f912042 1757 for_each_possible_cpu(cpu) {
c7fb64db
TG		 1758 struct neigh_statistics *st;
1759
c7fb64db
TG		 1760 st = per_cpu_ptr(tbl->stats, cpu);
1761 ndst.ndts_allocs += st->allocs;
1762 ndst.ndts_destroys += st->destroys;
1763 ndst.ndts_hash_grows += st->hash_grows;
1764 ndst.ndts_res_failed += st->res_failed;
1765 ndst.ndts_lookups += st->lookups;
1766 ndst.ndts_hits += st->hits;
1767 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1768 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1769 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1770 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1771 }
1772
ca860fb3 1773 NLA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst);
c7fb64db
TG		 1774 }
1775
1776 BUG_ON(tbl->parms.dev);
1777 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
ca860fb3 1778 goto nla_put_failure;
c7fb64db
TG		 1779
1780 read_unlock_bh(&tbl->lock);
ca860fb3 1781 return nlmsg_end(skb, nlh);
c7fb64db 1782
ca860fb3 1783nla_put_failure:
c7fb64db 1784 read_unlock_bh(&tbl->lock);
26932566
PM		 1785 nlmsg_cancel(skb, nlh);
1786 return -EMSGSIZE;
c7fb64db
TG		 1787}
1788
ca860fb3
TG		 1789static int neightbl_fill_param_info(struct sk_buff *skb,
1790 struct neigh_table *tbl,
c7fb64db 1791 struct neigh_parms *parms,
ca860fb3
TG		 1792 u32 pid, u32 seq, int type,
1793 unsigned int flags)
c7fb64db
TG		 1794{
1795 struct ndtmsg *ndtmsg;
1796 struct nlmsghdr *nlh;
1797
ca860fb3
TG		 1798 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1799 if (nlh == NULL)
26932566 1800 return -EMSGSIZE;
c7fb64db 1801
ca860fb3 1802 ndtmsg = nlmsg_data(nlh);
c7fb64db
TG		 1803
1804 read_lock_bh(&tbl->lock);
1805 ndtmsg->ndtm_family = tbl->family;
9ef1d4c7
PM		 1806 ndtmsg->ndtm_pad1 = 0;
1807 ndtmsg->ndtm_pad2 = 0;
c7fb64db 1808
ca860fb3
TG		 1809 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
1810 neightbl_fill_parms(skb, parms) < 0)
1811 goto errout;
c7fb64db
TG		 1812
1813 read_unlock_bh(&tbl->lock);
ca860fb3
TG		 1814 return nlmsg_end(skb, nlh);
1815errout:
c7fb64db 1816 read_unlock_bh(&tbl->lock);
26932566
PM		 1817 nlmsg_cancel(skb, nlh);
1818 return -EMSGSIZE;
c7fb64db 1819}
4ec93edb 1820
ef7c79ed 1821static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
6b3f8674
TG		 1822 [NDTA_NAME] = { .type = NLA_STRING },
1823 [NDTA_THRESH1] = { .type = NLA_U32 },
1824 [NDTA_THRESH2] = { .type = NLA_U32 },
1825 [NDTA_THRESH3] = { .type = NLA_U32 },
1826 [NDTA_GC_INTERVAL] = { .type = NLA_U64 },
1827 [NDTA_PARMS] = { .type = NLA_NESTED },
1828};
1829
ef7c79ed 1830static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
6b3f8674
TG		 1831 [NDTPA_IFINDEX] = { .type = NLA_U32 },
1832 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 },
1833 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 },
1834 [NDTPA_APP_PROBES] = { .type = NLA_U32 },
1835 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 },
1836 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 },
1837 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 },
1838 [NDTPA_GC_STALETIME] = { .type = NLA_U64 },
1839 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 },
1840 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 },
1841 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 },
1842 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 },
1843 [NDTPA_LOCKTIME] = { .type = NLA_U64 },
1844};
1845
c8822a4e 1846static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
c7fb64db 1847{
3b1e0a65 1848 struct net *net = sock_net(skb->sk);
c7fb64db 1849 struct neigh_table *tbl;
6b3f8674
TG		 1850 struct ndtmsg *ndtmsg;
1851 struct nlattr *tb[NDTA_MAX+1];
1852 int err;
c7fb64db 1853
6b3f8674
TG		 1854 err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
1855 nl_neightbl_policy);
1856 if (err < 0)
1857 goto errout;
c7fb64db 1858
6b3f8674
TG		 1859 if (tb[NDTA_NAME] == NULL) {
1860 err = -EINVAL;
1861 goto errout;
1862 }
1863
1864 ndtmsg = nlmsg_data(nlh);
c7fb64db
TG		 1865 read_lock(&neigh_tbl_lock);
1866 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1867 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1868 continue;
1869
6b3f8674 1870 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0)
c7fb64db
TG		 1871 break;
1872 }
1873
1874 if (tbl == NULL) {
1875 err = -ENOENT;
6b3f8674 1876 goto errout_locked;
c7fb64db
TG		 1877 }
1878
4ec93edb 1879 /*
c7fb64db
TG		 1880 * We acquire tbl->lock to be nice to the periodic timers and
1881 * make sure they always see a consistent set of values.
1882 */
1883 write_lock_bh(&tbl->lock);
1884
6b3f8674
TG		 1885 if (tb[NDTA_PARMS]) {
1886 struct nlattr *tbp[NDTPA_MAX+1];
c7fb64db 1887 struct neigh_parms *p;
6b3f8674 1888 int i, ifindex = 0;
c7fb64db 1889
6b3f8674
TG		 1890 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
1891 nl_ntbl_parm_policy);
1892 if (err < 0)
1893 goto errout_tbl_lock;
c7fb64db 1894
6b3f8674
TG		 1895 if (tbp[NDTPA_IFINDEX])
1896 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
c7fb64db 1897
426b5303 1898 p = lookup_neigh_params(tbl, net, ifindex);
c7fb64db
TG		 1899 if (p == NULL) {
1900 err = -ENOENT;
6b3f8674 1901 goto errout_tbl_lock;
c7fb64db 1902 }
c7fb64db 1903
6b3f8674
TG		 1904 for (i = 1; i <= NDTPA_MAX; i++) {
1905 if (tbp[i] == NULL)
1906 continue;
c7fb64db 1907
6b3f8674
TG		 1908 switch (i) {
1909 case NDTPA_QUEUE_LEN:
1910 p->queue_len = nla_get_u32(tbp[i]);
1911 break;
1912 case NDTPA_PROXY_QLEN:
1913 p->proxy_qlen = nla_get_u32(tbp[i]);
1914 break;
1915 case NDTPA_APP_PROBES:
1916 p->app_probes = nla_get_u32(tbp[i]);
1917 break;
1918 case NDTPA_UCAST_PROBES:
1919 p->ucast_probes = nla_get_u32(tbp[i]);
1920 break;
1921 case NDTPA_MCAST_PROBES:
1922 p->mcast_probes = nla_get_u32(tbp[i]);
1923 break;
1924 case NDTPA_BASE_REACHABLE_TIME:
1925 p->base_reachable_time = nla_get_msecs(tbp[i]);
1926 break;
1927 case NDTPA_GC_STALETIME:
1928 p->gc_staletime = nla_get_msecs(tbp[i]);
1929 break;
1930 case NDTPA_DELAY_PROBE_TIME:
1931 p->delay_probe_time = nla_get_msecs(tbp[i]);
1932 break;
1933 case NDTPA_RETRANS_TIME:
1934 p->retrans_time = nla_get_msecs(tbp[i]);
1935 break;
1936 case NDTPA_ANYCAST_DELAY:
1937 p->anycast_delay = nla_get_msecs(tbp[i]);
1938 break;
1939 case NDTPA_PROXY_DELAY:
1940 p->proxy_delay = nla_get_msecs(tbp[i]);
1941 break;
1942 case NDTPA_LOCKTIME:
1943 p->locktime = nla_get_msecs(tbp[i]);
1944 break;
1945 }
1946 }
1947 }
c7fb64db 1948
6b3f8674
TG		 1949 if (tb[NDTA_THRESH1])
1950 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
c7fb64db 1951
6b3f8674
TG		 1952 if (tb[NDTA_THRESH2])
1953 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
c7fb64db 1954
6b3f8674
TG		 1955 if (tb[NDTA_THRESH3])
1956 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
c7fb64db 1957
6b3f8674
TG		 1958 if (tb[NDTA_GC_INTERVAL])
1959 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
c7fb64db
TG		 1960
1961 err = 0;
1962
6b3f8674 1963errout_tbl_lock:
c7fb64db 1964 write_unlock_bh(&tbl->lock);
6b3f8674 1965errout_locked:
c7fb64db 1966 read_unlock(&neigh_tbl_lock);
6b3f8674 1967errout:
c7fb64db
TG		 1968 return err;
1969}
1970
c8822a4e 1971static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
c7fb64db 1972{
3b1e0a65 1973 struct net *net = sock_net(skb->sk);
ca860fb3
TG		 1974 int family, tidx, nidx = 0;
1975 int tbl_skip = cb->args[0];
1976 int neigh_skip = cb->args[1];
c7fb64db
TG		 1977 struct neigh_table *tbl;
1978
ca860fb3 1979 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
c7fb64db
TG		 1980
1981 read_lock(&neigh_tbl_lock);
ca860fb3 1982 for (tbl = neigh_tables, tidx = 0; tbl; tbl = tbl->next, tidx++) {
c7fb64db
TG		 1983 struct neigh_parms *p;
1984
ca860fb3 1985 if (tidx < tbl_skip || (family && tbl->family != family))
c7fb64db
TG		 1986 continue;
1987
ca860fb3
TG		 1988 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).pid,
1989 cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
1990 NLM_F_MULTI) <= 0)
c7fb64db
TG		 1991 break;
1992
426b5303 1993 for (nidx = 0, p = tbl->parms.next; p; p = p->next) {
878628fb 1994 if (!net_eq(neigh_parms_net(p), net))
426b5303
EB		 1995 continue;
1996
efc683fc
GK		 1997 if (nidx < neigh_skip)
1998 goto next;
c7fb64db 1999
ca860fb3
TG		 2000 if (neightbl_fill_param_info(skb, tbl, p,
2001 NETLINK_CB(cb->skb).pid,
2002 cb->nlh->nlmsg_seq,
2003 RTM_NEWNEIGHTBL,
2004 NLM_F_MULTI) <= 0)
c7fb64db 2005 goto out;
efc683fc
GK		 2006 next:
2007 nidx++;
c7fb64db
TG		 2008 }
2009
ca860fb3 2010 neigh_skip = 0;
c7fb64db
TG		 2011 }
2012out:
2013 read_unlock(&neigh_tbl_lock);
ca860fb3
TG		 2014 cb->args[0] = tidx;
2015 cb->args[1] = nidx;
c7fb64db
TG		 2016
2017 return skb->len;
2018}
1da177e4 2019
8b8aec50
TG		 2020static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
2021 u32 pid, u32 seq, int type, unsigned int flags)
1da177e4
LT		 2022{
2023 unsigned long now = jiffies;
1da177e4 2024 struct nda_cacheinfo ci;
8b8aec50
TG		 2025 struct nlmsghdr *nlh;
2026 struct ndmsg *ndm;
2027
2028 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2029 if (nlh == NULL)
26932566 2030 return -EMSGSIZE;
1da177e4 2031
8b8aec50
TG		 2032 ndm = nlmsg_data(nlh);
2033 ndm->ndm_family = neigh->ops->family;
9ef1d4c7
PM		 2034 ndm->ndm_pad1 = 0;
2035 ndm->ndm_pad2 = 0;
8b8aec50
TG		 2036 ndm->ndm_flags = neigh->flags;
2037 ndm->ndm_type = neigh->type;
2038 ndm->ndm_ifindex = neigh->dev->ifindex;
1da177e4 2039
8b8aec50
TG		 2040 NLA_PUT(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key);
2041
2042 read_lock_bh(&neigh->lock);
2043 ndm->ndm_state = neigh->nud_state;
2044 if ((neigh->nud_state & NUD_VALID) &&
2045 nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, neigh->ha) < 0) {
2046 read_unlock_bh(&neigh->lock);
2047 goto nla_put_failure;
2048 }
2049
b9f5f52c
SH		 2050 ci.ndm_used = jiffies_to_clock_t(now - neigh->used);
2051 ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
2052 ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated);
8b8aec50
TG		 2053 ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1;
2054 read_unlock_bh(&neigh->lock);
2055
2056 NLA_PUT_U32(skb, NDA_PROBES, atomic_read(&neigh->probes));
2057 NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
2058
2059 return nlmsg_end(skb, nlh);
2060
2061nla_put_failure:
26932566
PM		 2062 nlmsg_cancel(skb, nlh);
2063 return -EMSGSIZE;
1da177e4
LT		 2064}
2065
d961db35
TG		 2066static void neigh_update_notify(struct neighbour *neigh)
2067{
2068 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2069 __neigh_notify(neigh, RTM_NEWNEIGH, 0);
2070}
1da177e4
LT		 2071
2072static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2073 struct netlink_callback *cb)
2074{
3b1e0a65 2075 struct net * net = sock_net(skb->sk);
1da177e4
LT		 2076 struct neighbour *n;
2077 int rc, h, s_h = cb->args[1];
2078 int idx, s_idx = idx = cb->args[2];
2079
c5e29460 2080 read_lock_bh(&tbl->lock);
1da177e4
LT		 2081 for (h = 0; h <= tbl->hash_mask; h++) {
2082 if (h < s_h)
2083 continue;
2084 if (h > s_h)
2085 s_idx = 0;
426b5303 2086 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next) {
c346dca1 2087 if (dev_net(n->dev) != net)
426b5303 2088 continue;
efc683fc
GK		 2089 if (idx < s_idx)
2090 goto next;
1da177e4
LT		 2091 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid,
2092 cb->nlh->nlmsg_seq,
b6544c0b
JHS		 2093 RTM_NEWNEIGH,
2094 NLM_F_MULTI) <= 0) {
1da177e4
LT		 2095 read_unlock_bh(&tbl->lock);
2096 rc = -1;
2097 goto out;
2098 }
efc683fc
GK		 2099 next:
2100 idx++;
1da177e4 2101 }
1da177e4 2102 }
c5e29460 2103 read_unlock_bh(&tbl->lock);
1da177e4
LT		 2104 rc = skb->len;
2105out:
2106 cb->args[1] = h;
2107 cb->args[2] = idx;
2108 return rc;
2109}
2110
c8822a4e 2111static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1da177e4
LT		 2112{
2113 struct neigh_table *tbl;
2114 int t, family, s_t;
2115
2116 read_lock(&neigh_tbl_lock);
8b8aec50 2117 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
1da177e4
LT		 2118 s_t = cb->args[0];
2119
2120 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
2121 if (t < s_t || (family && tbl->family != family))
2122 continue;
2123 if (t > s_t)
2124 memset(&cb->args[1], 0, sizeof(cb->args) -
2125 sizeof(cb->args[0]));
2126 if (neigh_dump_table(tbl, skb, cb) < 0)
2127 break;
2128 }
2129 read_unlock(&neigh_tbl_lock);
2130
2131 cb->args[0] = t;
2132 return skb->len;
2133}
2134
2135void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2136{
2137 int chain;
2138
2139 read_lock_bh(&tbl->lock);
2140 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2141 struct neighbour *n;
2142
2143 for (n = tbl->hash_buckets[chain]; n; n = n->next)
2144 cb(n, cookie);
2145 }
2146 read_unlock_bh(&tbl->lock);
2147}
2148EXPORT_SYMBOL(neigh_for_each);
2149
2150/* The tbl->lock must be held as a writer and BH disabled. */
2151void __neigh_for_each_release(struct neigh_table *tbl,
2152 int (*cb)(struct neighbour *))
2153{
2154 int chain;
2155
2156 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2157 struct neighbour *n, **np;
2158
2159 np = &tbl->hash_buckets[chain];
2160 while ((n = *np) != NULL) {
2161 int release;
2162
2163 write_lock(&n->lock);
2164 release = cb(n);
2165 if (release) {
2166 *np = n->next;
2167 n->dead = 1;
2168 } else
2169 np = &n->next;
2170 write_unlock(&n->lock);
4f494554
TG		 2171 if (release)
2172 neigh_cleanup_and_release(n);
1da177e4
LT		 2173 }
2174 }
2175}
2176EXPORT_SYMBOL(__neigh_for_each_release);
2177
2178#ifdef CONFIG_PROC_FS
2179
2180static struct neighbour *neigh_get_first(struct seq_file *seq)
2181{
2182 struct neigh_seq_state *state = seq->private;
1218854a 2183 struct net *net = seq_file_net(seq);
1da177e4
LT		 2184 struct neigh_table *tbl = state->tbl;
2185 struct neighbour *n = NULL;
2186 int bucket = state->bucket;
2187
2188 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2189 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) {
2190 n = tbl->hash_buckets[bucket];
2191
2192 while (n) {
878628fb 2193 if (!net_eq(dev_net(n->dev), net))
426b5303 2194 goto next;
1da177e4
LT		 2195 if (state->neigh_sub_iter) {
2196 loff_t fakep = 0;
2197 void *v;
2198
2199 v = state->neigh_sub_iter(state, n, &fakep);
2200 if (!v)
2201 goto next;
2202 }
2203 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2204 break;
2205 if (n->nud_state & ~NUD_NOARP)
2206 break;
2207 next:
2208 n = n->next;
2209 }
2210
2211 if (n)
2212 break;
2213 }
2214 state->bucket = bucket;
2215
2216 return n;
2217}
2218
2219static struct neighbour *neigh_get_next(struct seq_file *seq,
2220 struct neighbour *n,
2221 loff_t *pos)
2222{
2223 struct neigh_seq_state *state = seq->private;
1218854a 2224 struct net *net = seq_file_net(seq);
1da177e4
LT		 2225 struct neigh_table *tbl = state->tbl;
2226
2227 if (state->neigh_sub_iter) {
2228 void *v = state->neigh_sub_iter(state, n, pos);
2229 if (v)
2230 return n;
2231 }
2232 n = n->next;
2233
2234 while (1) {
2235 while (n) {
878628fb 2236 if (!net_eq(dev_net(n->dev), net))
426b5303 2237 goto next;
1da177e4
LT		 2238 if (state->neigh_sub_iter) {
2239 void *v = state->neigh_sub_iter(state, n, pos);
2240 if (v)
2241 return n;
2242 goto next;
2243 }
2244 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2245 break;
2246
2247 if (n->nud_state & ~NUD_NOARP)
2248 break;
2249 next:
2250 n = n->next;
2251 }
2252
2253 if (n)
2254 break;
2255
2256 if (++state->bucket > tbl->hash_mask)
2257 break;
2258
2259 n = tbl->hash_buckets[state->bucket];
2260 }
2261
2262 if (n && pos)
2263 --(*pos);
2264 return n;
2265}
2266
2267static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2268{
2269 struct neighbour *n = neigh_get_first(seq);
2270
2271 if (n) {
745e2031 2272 --(*pos);
1da177e4
LT		 2273 while (*pos) {
2274 n = neigh_get_next(seq, n, pos);
2275 if (!n)
2276 break;
2277 }
2278 }
2279 return *pos ? NULL : n;
2280}
2281
2282static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2283{
2284 struct neigh_seq_state *state = seq->private;
1218854a 2285 struct net *net = seq_file_net(seq);
1da177e4
LT		 2286 struct neigh_table *tbl = state->tbl;
2287 struct pneigh_entry *pn = NULL;
2288 int bucket = state->bucket;
2289
2290 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2291 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2292 pn = tbl->phash_buckets[bucket];
878628fb 2293 while (pn && !net_eq(pneigh_net(pn), net))
426b5303 2294 pn = pn->next;
1da177e4
LT		 2295 if (pn)
2296 break;
2297 }
2298 state->bucket = bucket;
2299
2300 return pn;
2301}
2302
2303static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2304 struct pneigh_entry *pn,
2305 loff_t *pos)
2306{
2307 struct neigh_seq_state *state = seq->private;
1218854a 2308 struct net *net = seq_file_net(seq);
1da177e4
LT		 2309 struct neigh_table *tbl = state->tbl;
2310
2311 pn = pn->next;
2312 while (!pn) {
2313 if (++state->bucket > PNEIGH_HASHMASK)
2314 break;
2315 pn = tbl->phash_buckets[state->bucket];
878628fb 2316 while (pn && !net_eq(pneigh_net(pn), net))
426b5303 2317 pn = pn->next;
1da177e4
LT		 2318 if (pn)
2319 break;
2320 }
2321
2322 if (pn && pos)
2323 --(*pos);
2324
2325 return pn;
2326}
2327
2328static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2329{
2330 struct pneigh_entry *pn = pneigh_get_first(seq);
2331
2332 if (pn) {
745e2031 2333 --(*pos);
1da177e4
LT		 2334 while (*pos) {
2335 pn = pneigh_get_next(seq, pn, pos);
2336 if (!pn)
2337 break;
2338 }
2339 }
2340 return *pos ? NULL : pn;
2341}
2342
2343static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2344{
2345 struct neigh_seq_state *state = seq->private;
2346 void *rc;
745e2031 2347 loff_t idxpos = *pos;
1da177e4 2348
745e2031 2349 rc = neigh_get_idx(seq, &idxpos);
1da177e4 2350 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
745e2031 2351 rc = pneigh_get_idx(seq, &idxpos);
1da177e4
LT		 2352
2353 return rc;
2354}
2355
2356void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
9a429c49 2357 __acquires(tbl->lock)
1da177e4
LT		 2358{
2359 struct neigh_seq_state *state = seq->private;
1da177e4
LT		 2360
2361 state->tbl = tbl;
2362 state->bucket = 0;
2363 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2364
2365 read_lock_bh(&tbl->lock);
2366
745e2031 2367 return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN;
1da177e4
LT		 2368}
2369EXPORT_SYMBOL(neigh_seq_start);
2370
2371void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2372{
2373 struct neigh_seq_state *state;
2374 void *rc;
2375
2376 if (v == SEQ_START_TOKEN) {
bff69732 2377 rc = neigh_get_first(seq);
1da177e4
LT		 2378 goto out;
2379 }
2380
2381 state = seq->private;
2382 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2383 rc = neigh_get_next(seq, v, NULL);
2384 if (rc)
2385 goto out;
2386 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2387 rc = pneigh_get_first(seq);
2388 } else {
2389 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2390 rc = pneigh_get_next(seq, v, NULL);
2391 }
2392out:
2393 ++(*pos);
2394 return rc;
2395}
2396EXPORT_SYMBOL(neigh_seq_next);
2397
2398void neigh_seq_stop(struct seq_file *seq, void *v)
9a429c49 2399 __releases(tbl->lock)
1da177e4
LT		 2400{
2401 struct neigh_seq_state *state = seq->private;
2402 struct neigh_table *tbl = state->tbl;
2403
2404 read_unlock_bh(&tbl->lock);
2405}
2406EXPORT_SYMBOL(neigh_seq_stop);
2407
2408/* statistics via seq_file */
2409
2410static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2411{
2412 struct proc_dir_entry *pde = seq->private;
2413 struct neigh_table *tbl = pde->data;
2414 int cpu;
2415
2416 if (*pos == 0)
2417 return SEQ_START_TOKEN;
4ec93edb 2418
0f23174a 2419 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
1da177e4
LT		 2420 if (!cpu_possible(cpu))
2421 continue;
2422 *pos = cpu+1;
2423 return per_cpu_ptr(tbl->stats, cpu);
2424 }
2425 return NULL;
2426}
2427
2428static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2429{
2430 struct proc_dir_entry *pde = seq->private;
2431 struct neigh_table *tbl = pde->data;
2432 int cpu;
2433
0f23174a 2434 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
1da177e4
LT		 2435 if (!cpu_possible(cpu))
2436 continue;
2437 *pos = cpu+1;
2438 return per_cpu_ptr(tbl->stats, cpu);
2439 }
2440 return NULL;
2441}
2442
2443static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2444{
2445
2446}
2447
2448static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2449{
2450 struct proc_dir_entry *pde = seq->private;
2451 struct neigh_table *tbl = pde->data;
2452 struct neigh_statistics *st = v;
2453
2454 if (v == SEQ_START_TOKEN) {
9a6d276e 2455 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		 2456 return 0;
2457 }
2458
2459 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
9a6d276e 2460 "%08lx %08lx %08lx %08lx %08lx\n",
1da177e4
LT		 2461 atomic_read(&tbl->entries),
2462
2463 st->allocs,
2464 st->destroys,
2465 st->hash_grows,
2466
2467 st->lookups,
2468 st->hits,
2469
2470 st->res_failed,
2471
2472 st->rcv_probes_mcast,
2473 st->rcv_probes_ucast,
2474
2475 st->periodic_gc_runs,
9a6d276e
NH		 2476 st->forced_gc_runs,
2477 st->unres_discards
1da177e4
LT		 2478 );
2479
2480 return 0;
2481}
2482
f690808e 2483static const struct seq_operations neigh_stat_seq_ops = {
1da177e4
LT		 2484 .start = neigh_stat_seq_start,
2485 .next = neigh_stat_seq_next,
2486 .stop = neigh_stat_seq_stop,
2487 .show = neigh_stat_seq_show,
2488};
2489
2490static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2491{
2492 int ret = seq_open(file, &neigh_stat_seq_ops);
2493
2494 if (!ret) {
2495 struct seq_file *sf = file->private_data;
2496 sf->private = PDE(inode);
2497 }
2498 return ret;
2499};
2500
9a32144e 2501static const struct file_operations neigh_stat_seq_fops = {
1da177e4
LT		 2502 .owner = THIS_MODULE,
2503 .open = neigh_stat_seq_open,
2504 .read = seq_read,
2505 .llseek = seq_lseek,
2506 .release = seq_release,
2507};
2508
2509#endif /* CONFIG_PROC_FS */
2510
339bf98f
TG		 2511static inline size_t neigh_nlmsg_size(void)
2512{
2513 return NLMSG_ALIGN(sizeof(struct ndmsg))
2514 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2515 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2516 + nla_total_size(sizeof(struct nda_cacheinfo))
2517 + nla_total_size(4); /* NDA_PROBES */
2518}
2519
b8673311 2520static void __neigh_notify(struct neighbour *n, int type, int flags)
1da177e4 2521{
c346dca1 2522 struct net *net = dev_net(n->dev);
8b8aec50 2523 struct sk_buff *skb;
b8673311 2524 int err = -ENOBUFS;
1da177e4 2525
339bf98f 2526 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
8b8aec50 2527 if (skb == NULL)
b8673311 2528 goto errout;
1da177e4 2529
b8673311 2530 err = neigh_fill_info(skb, n, 0, 0, type, flags);
26932566
PM		 2531 if (err < 0) {
2532 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2533 WARN_ON(err == -EMSGSIZE);
2534 kfree_skb(skb);
2535 goto errout;
2536 }
426b5303 2537 err = rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
b8673311
TG		 2538errout:
2539 if (err < 0)
426b5303 2540 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
1da177e4
LT		 2541}
2542
d961db35 2543#ifdef CONFIG_ARPD
b8673311 2544void neigh_app_ns(struct neighbour *n)
1da177e4 2545{
b8673311
TG		 2546 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
2547}
0a204500 2548EXPORT_SYMBOL(neigh_app_ns);
1da177e4
LT		 2549#endif /* CONFIG_ARPD */
2550
2551#ifdef CONFIG_SYSCTL
2552
2553static struct neigh_sysctl_table {
2554 struct ctl_table_header *sysctl_header;
c3bac5a7
PE		 2555 struct ctl_table neigh_vars[__NET_NEIGH_MAX];
2556 char *dev_name;
ab32ea5d 2557} neigh_sysctl_template __read_mostly = {
1da177e4
LT		 2558 .neigh_vars = {
2559 {
2560 .ctl_name = NET_NEIGH_MCAST_SOLICIT,
2561 .procname = "mcast_solicit",
2562 .maxlen = sizeof(int),
2563 .mode = 0644,
6d9f239a 2564 .proc_handler = proc_dointvec,
1da177e4
LT		 2565 },
2566 {
2567 .ctl_name = NET_NEIGH_UCAST_SOLICIT,
2568 .procname = "ucast_solicit",
2569 .maxlen = sizeof(int),
2570 .mode = 0644,
6d9f239a 2571 .proc_handler = proc_dointvec,
1da177e4
LT		 2572 },
2573 {
2574 .ctl_name = NET_NEIGH_APP_SOLICIT,
2575 .procname = "app_solicit",
2576 .maxlen = sizeof(int),
2577 .mode = 0644,
6d9f239a 2578 .proc_handler = proc_dointvec,
1da177e4
LT		 2579 },
2580 {
1da177e4
LT		 2581 .procname = "retrans_time",
2582 .maxlen = sizeof(int),
2583 .mode = 0644,
6d9f239a 2584 .proc_handler = proc_dointvec_userhz_jiffies,
1da177e4
LT		 2585 },
2586 {
2587 .ctl_name = NET_NEIGH_REACHABLE_TIME,
2588 .procname = "base_reachable_time",
2589 .maxlen = sizeof(int),
2590 .mode = 0644,
6d9f239a
AD		 2591 .proc_handler = proc_dointvec_jiffies,
2592 .strategy = sysctl_jiffies,
1da177e4
LT		 2593 },
2594 {
2595 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME,
2596 .procname = "delay_first_probe_time",
2597 .maxlen = sizeof(int),
2598 .mode = 0644,
6d9f239a
AD		 2599 .proc_handler = proc_dointvec_jiffies,
2600 .strategy = sysctl_jiffies,
1da177e4
LT		 2601 },
2602 {
2603 .ctl_name = NET_NEIGH_GC_STALE_TIME,
2604 .procname = "gc_stale_time",
2605 .maxlen = sizeof(int),
2606 .mode = 0644,
6d9f239a
AD		 2607 .proc_handler = proc_dointvec_jiffies,
2608 .strategy = sysctl_jiffies,
1da177e4
LT		 2609 },
2610 {
2611 .ctl_name = NET_NEIGH_UNRES_QLEN,
2612 .procname = "unres_qlen",
2613 .maxlen = sizeof(int),
2614 .mode = 0644,
6d9f239a 2615 .proc_handler = proc_dointvec,
1da177e4
LT		 2616 },
2617 {
2618 .ctl_name = NET_NEIGH_PROXY_QLEN,
2619 .procname = "proxy_qlen",
2620 .maxlen = sizeof(int),
2621 .mode = 0644,
6d9f239a 2622 .proc_handler = proc_dointvec,
1da177e4
LT		 2623 },
2624 {
1da177e4
LT		 2625 .procname = "anycast_delay",
2626 .maxlen = sizeof(int),
2627 .mode = 0644,
6d9f239a 2628 .proc_handler = proc_dointvec_userhz_jiffies,
1da177e4
LT		 2629 },
2630 {
1da177e4
LT		 2631 .procname = "proxy_delay",
2632 .maxlen = sizeof(int),
2633 .mode = 0644,
6d9f239a 2634 .proc_handler = proc_dointvec_userhz_jiffies,
1da177e4
LT		 2635 },
2636 {
1da177e4
LT		 2637 .procname = "locktime",
2638 .maxlen = sizeof(int),
2639 .mode = 0644,
6d9f239a 2640 .proc_handler = proc_dointvec_userhz_jiffies,
1da177e4 2641 },
d12af679
EB		 2642 {
2643 .ctl_name = NET_NEIGH_RETRANS_TIME_MS,
2644 .procname = "retrans_time_ms",
2645 .maxlen = sizeof(int),
2646 .mode = 0644,
6d9f239a
AD		 2647 .proc_handler = proc_dointvec_ms_jiffies,
2648 .strategy = sysctl_ms_jiffies,
d12af679
EB		 2649 },
2650 {
2651 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS,
2652 .procname = "base_reachable_time_ms",
2653 .maxlen = sizeof(int),
2654 .mode = 0644,
6d9f239a
AD		 2655 .proc_handler = proc_dointvec_ms_jiffies,
2656 .strategy = sysctl_ms_jiffies,
d12af679 2657 },
1da177e4
LT		 2658 {
2659 .ctl_name = NET_NEIGH_GC_INTERVAL,
2660 .procname = "gc_interval",
2661 .maxlen = sizeof(int),
2662 .mode = 0644,
6d9f239a
AD		 2663 .proc_handler = proc_dointvec_jiffies,
2664 .strategy = sysctl_jiffies,
1da177e4
LT		 2665 },
2666 {
2667 .ctl_name = NET_NEIGH_GC_THRESH1,
2668 .procname = "gc_thresh1",
2669 .maxlen = sizeof(int),
2670 .mode = 0644,
6d9f239a 2671 .proc_handler = proc_dointvec,
1da177e4
LT		 2672 },
2673 {
2674 .ctl_name = NET_NEIGH_GC_THRESH2,
2675 .procname = "gc_thresh2",
2676 .maxlen = sizeof(int),
2677 .mode = 0644,
6d9f239a 2678 .proc_handler = proc_dointvec,
1da177e4
LT		 2679 },
2680 {
2681 .ctl_name = NET_NEIGH_GC_THRESH3,
2682 .procname = "gc_thresh3",
2683 .maxlen = sizeof(int),
2684 .mode = 0644,
6d9f239a 2685 .proc_handler = proc_dointvec,
1da177e4 2686 },
c3bac5a7 2687 {},
1da177e4
LT		 2688 },
2689};
2690
2691int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
4ec93edb 2692 int p_id, int pdev_id, char *p_name,
1da177e4
LT		 2693 proc_handler *handler, ctl_handler *strategy)
2694{
3c607bbb 2695 struct neigh_sysctl_table *t;
1da177e4 2696 const char *dev_name_source = NULL;
c3bac5a7
PE		 2697
2698#define NEIGH_CTL_PATH_ROOT 0
2699#define NEIGH_CTL_PATH_PROTO 1
2700#define NEIGH_CTL_PATH_NEIGH 2
2701#define NEIGH_CTL_PATH_DEV 3
2702
2703 struct ctl_path neigh_path[] = {
2704 { .procname = "net", .ctl_name = CTL_NET, },
2705 { .procname = "proto", .ctl_name = 0, },
2706 { .procname = "neigh", .ctl_name = 0, },
2707 { .procname = "default", .ctl_name = NET_PROTO_CONF_DEFAULT, },
2708 { },
2709 };
1da177e4 2710
3c607bbb 2711 t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
1da177e4 2712 if (!t)
3c607bbb
PE		 2713 goto err;
2714
1da177e4
LT		 2715 t->neigh_vars[0].data = &p->mcast_probes;
2716 t->neigh_vars[1].data = &p->ucast_probes;
2717 t->neigh_vars[2].data = &p->app_probes;
2718 t->neigh_vars[3].data = &p->retrans_time;
2719 t->neigh_vars[4].data = &p->base_reachable_time;
2720 t->neigh_vars[5].data = &p->delay_probe_time;
2721 t->neigh_vars[6].data = &p->gc_staletime;
2722 t->neigh_vars[7].data = &p->queue_len;
2723 t->neigh_vars[8].data = &p->proxy_qlen;
2724 t->neigh_vars[9].data = &p->anycast_delay;
2725 t->neigh_vars[10].data = &p->proxy_delay;
2726 t->neigh_vars[11].data = &p->locktime;
d12af679
EB		 2727 t->neigh_vars[12].data = &p->retrans_time;
2728 t->neigh_vars[13].data = &p->base_reachable_time;
1da177e4
LT		 2729
2730 if (dev) {
2731 dev_name_source = dev->name;
c3bac5a7 2732 neigh_path[NEIGH_CTL_PATH_DEV].ctl_name = dev->ifindex;
d12af679
EB		 2733 /* Terminate the table early */
2734 memset(&t->neigh_vars[14], 0, sizeof(t->neigh_vars[14]));
1da177e4 2735 } else {
c3bac5a7 2736 dev_name_source = neigh_path[NEIGH_CTL_PATH_DEV].procname;
d12af679
EB		 2737 t->neigh_vars[14].data = (int *)(p + 1);
2738 t->neigh_vars[15].data = (int *)(p + 1) + 1;
2739 t->neigh_vars[16].data = (int *)(p + 1) + 2;
2740 t->neigh_vars[17].data = (int *)(p + 1) + 3;
1da177e4
LT		 2741 }
2742
1da177e4
LT		 2743
2744 if (handler || strategy) {
2745 /* RetransTime */
2746 t->neigh_vars[3].proc_handler = handler;
2747 t->neigh_vars[3].strategy = strategy;
2748 t->neigh_vars[3].extra1 = dev;
d12af679
EB		 2749 if (!strategy)
2750 t->neigh_vars[3].ctl_name = CTL_UNNUMBERED;
1da177e4
LT		 2751 /* ReachableTime */
2752 t->neigh_vars[4].proc_handler = handler;
2753 t->neigh_vars[4].strategy = strategy;
2754 t->neigh_vars[4].extra1 = dev;
d12af679
EB		 2755 if (!strategy)
2756 t->neigh_vars[4].ctl_name = CTL_UNNUMBERED;
1da177e4 2757 /* RetransTime (in milliseconds)*/
d12af679
EB		 2758 t->neigh_vars[12].proc_handler = handler;
2759 t->neigh_vars[12].strategy = strategy;
2760 t->neigh_vars[12].extra1 = dev;
2761 if (!strategy)
2762 t->neigh_vars[12].ctl_name = CTL_UNNUMBERED;
1da177e4 2763 /* ReachableTime (in milliseconds) */
d12af679
EB		 2764 t->neigh_vars[13].proc_handler = handler;
2765 t->neigh_vars[13].strategy = strategy;
2766 t->neigh_vars[13].extra1 = dev;
2767 if (!strategy)
2768 t->neigh_vars[13].ctl_name = CTL_UNNUMBERED;
1da177e4
LT		 2769 }
2770
c3bac5a7
PE		 2771 t->dev_name = kstrdup(dev_name_source, GFP_KERNEL);
2772 if (!t->dev_name)
1da177e4 2773 goto free;
1da177e4 2774
c3bac5a7
PE		 2775 neigh_path[NEIGH_CTL_PATH_DEV].procname = t->dev_name;
2776 neigh_path[NEIGH_CTL_PATH_NEIGH].ctl_name = pdev_id;
2777 neigh_path[NEIGH_CTL_PATH_PROTO].procname = p_name;
2778 neigh_path[NEIGH_CTL_PATH_PROTO].ctl_name = p_id;
1da177e4 2779
4ab438fc 2780 t->sysctl_header =
57da52c1 2781 register_net_sysctl_table(neigh_parms_net(p), neigh_path, t->neigh_vars);
3c607bbb 2782 if (!t->sysctl_header)
1da177e4 2783 goto free_procname;
3c607bbb 2784
1da177e4
LT		 2785 p->sysctl_table = t;
2786 return 0;
2787
3c607bbb 2788free_procname:
c3bac5a7 2789 kfree(t->dev_name);
3c607bbb 2790free:
1da177e4 2791 kfree(t);
3c607bbb
PE		 2792err:
2793 return -ENOBUFS;
1da177e4 2794}
0a204500 2795EXPORT_SYMBOL(neigh_sysctl_register);
1da177e4
LT		 2796
2797void neigh_sysctl_unregister(struct neigh_parms *p)
2798{
2799 if (p->sysctl_table) {
2800 struct neigh_sysctl_table *t = p->sysctl_table;
2801 p->sysctl_table = NULL;
2802 unregister_sysctl_table(t->sysctl_header);
c3bac5a7 2803 kfree(t->dev_name);
1da177e4
LT		 2804 kfree(t);
2805 }
2806}
0a204500 2807EXPORT_SYMBOL(neigh_sysctl_unregister);
1da177e4
LT		 2808
2809#endif /* CONFIG_SYSCTL */
2810
c8822a4e
TG		 2811static int __init neigh_init(void)
2812{
2813 rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL);
2814 rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL);
2815 rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info);
2816
2817 rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info);
2818 rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL);
2819
2820 return 0;
2821}
2822
2823subsys_initcall(neigh_init);
2824
Linux 6.x block layer and io_uring tree(s)