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