projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drivers/net/usb: use USB API functions rather than constants
[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
1997 if (nidx++ < neigh_skip)
c7fb64db
TG		 1998 continue;
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
TG		 2005 goto out;
2006 }
2007
ca860fb3 2008 neigh_skip = 0;
c7fb64db
TG		 2009 }
2010out:
2011 read_unlock(&neigh_tbl_lock);
ca860fb3
TG		 2012 cb->args[0] = tidx;
2013 cb->args[1] = nidx;
c7fb64db
TG		 2014
2015 return skb->len;
2016}
1da177e4 2017
8b8aec50
TG		 2018static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
2019 u32 pid, u32 seq, int type, unsigned int flags)
1da177e4
LT		 2020{
2021 unsigned long now = jiffies;
1da177e4 2022 struct nda_cacheinfo ci;
8b8aec50
TG		 2023 struct nlmsghdr *nlh;
2024 struct ndmsg *ndm;
2025
2026 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2027 if (nlh == NULL)
26932566 2028 return -EMSGSIZE;
1da177e4 2029
8b8aec50
TG		 2030 ndm = nlmsg_data(nlh);
2031 ndm->ndm_family = neigh->ops->family;
9ef1d4c7
PM		 2032 ndm->ndm_pad1 = 0;
2033 ndm->ndm_pad2 = 0;
8b8aec50
TG		 2034 ndm->ndm_flags = neigh->flags;
2035 ndm->ndm_type = neigh->type;
2036 ndm->ndm_ifindex = neigh->dev->ifindex;
1da177e4 2037
8b8aec50
TG		 2038 NLA_PUT(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key);
2039
2040 read_lock_bh(&neigh->lock);
2041 ndm->ndm_state = neigh->nud_state;
2042 if ((neigh->nud_state & NUD_VALID) &&
2043 nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, neigh->ha) < 0) {
2044 read_unlock_bh(&neigh->lock);
2045 goto nla_put_failure;
2046 }
2047
b9f5f52c
SH		 2048 ci.ndm_used = jiffies_to_clock_t(now - neigh->used);
2049 ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
2050 ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated);
8b8aec50
TG		 2051 ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1;
2052 read_unlock_bh(&neigh->lock);
2053
2054 NLA_PUT_U32(skb, NDA_PROBES, atomic_read(&neigh->probes));
2055 NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
2056
2057 return nlmsg_end(skb, nlh);
2058
2059nla_put_failure:
26932566
PM		 2060 nlmsg_cancel(skb, nlh);
2061 return -EMSGSIZE;
1da177e4
LT		 2062}
2063
d961db35
TG		 2064static void neigh_update_notify(struct neighbour *neigh)
2065{
2066 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2067 __neigh_notify(neigh, RTM_NEWNEIGH, 0);
2068}
1da177e4
LT		 2069
2070static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2071 struct netlink_callback *cb)
2072{
3b1e0a65 2073 struct net * net = sock_net(skb->sk);
1da177e4
LT		 2074 struct neighbour *n;
2075 int rc, h, s_h = cb->args[1];
2076 int idx, s_idx = idx = cb->args[2];
2077
c5e29460 2078 read_lock_bh(&tbl->lock);
1da177e4
LT		 2079 for (h = 0; h <= tbl->hash_mask; h++) {
2080 if (h < s_h)
2081 continue;
2082 if (h > s_h)
2083 s_idx = 0;
426b5303
EB		 2084 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next) {
2085 int lidx;
c346dca1 2086 if (dev_net(n->dev) != net)
426b5303
EB		 2087 continue;
2088 lidx = idx++;
2089 if (lidx < s_idx)
1da177e4
LT		 2090 continue;
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 }
2099 }
1da177e4 2100 }
c5e29460 2101 read_unlock_bh(&tbl->lock);
1da177e4
LT		 2102 rc = skb->len;
2103out:
2104 cb->args[1] = h;
2105 cb->args[2] = idx;
2106 return rc;
2107}
2108
c8822a4e 2109static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1da177e4
LT		 2110{
2111 struct neigh_table *tbl;
2112 int t, family, s_t;
2113
2114 read_lock(&neigh_tbl_lock);
8b8aec50 2115 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
1da177e4
LT		 2116 s_t = cb->args[0];
2117
2118 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
2119 if (t < s_t || (family && tbl->family != family))
2120 continue;
2121 if (t > s_t)
2122 memset(&cb->args[1], 0, sizeof(cb->args) -
2123 sizeof(cb->args[0]));
2124 if (neigh_dump_table(tbl, skb, cb) < 0)
2125 break;
2126 }
2127 read_unlock(&neigh_tbl_lock);
2128
2129 cb->args[0] = t;
2130 return skb->len;
2131}
2132
2133void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2134{
2135 int chain;
2136
2137 read_lock_bh(&tbl->lock);
2138 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2139 struct neighbour *n;
2140
2141 for (n = tbl->hash_buckets[chain]; n; n = n->next)
2142 cb(n, cookie);
2143 }
2144 read_unlock_bh(&tbl->lock);
2145}
2146EXPORT_SYMBOL(neigh_for_each);
2147
2148/* The tbl->lock must be held as a writer and BH disabled. */
2149void __neigh_for_each_release(struct neigh_table *tbl,
2150 int (*cb)(struct neighbour *))
2151{
2152 int chain;
2153
2154 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2155 struct neighbour *n, **np;
2156
2157 np = &tbl->hash_buckets[chain];
2158 while ((n = *np) != NULL) {
2159 int release;
2160
2161 write_lock(&n->lock);
2162 release = cb(n);
2163 if (release) {
2164 *np = n->next;
2165 n->dead = 1;
2166 } else
2167 np = &n->next;
2168 write_unlock(&n->lock);
4f494554
TG		 2169 if (release)
2170 neigh_cleanup_and_release(n);
1da177e4
LT		 2171 }
2172 }
2173}
2174EXPORT_SYMBOL(__neigh_for_each_release);
2175
2176#ifdef CONFIG_PROC_FS
2177
2178static struct neighbour *neigh_get_first(struct seq_file *seq)
2179{
2180 struct neigh_seq_state *state = seq->private;
1218854a 2181 struct net *net = seq_file_net(seq);
1da177e4
LT		 2182 struct neigh_table *tbl = state->tbl;
2183 struct neighbour *n = NULL;
2184 int bucket = state->bucket;
2185
2186 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2187 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) {
2188 n = tbl->hash_buckets[bucket];
2189
2190 while (n) {
878628fb 2191 if (!net_eq(dev_net(n->dev), net))
426b5303 2192 goto next;
1da177e4
LT		 2193 if (state->neigh_sub_iter) {
2194 loff_t fakep = 0;
2195 void *v;
2196
2197 v = state->neigh_sub_iter(state, n, &fakep);
2198 if (!v)
2199 goto next;
2200 }
2201 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2202 break;
2203 if (n->nud_state & ~NUD_NOARP)
2204 break;
2205 next:
2206 n = n->next;
2207 }
2208
2209 if (n)
2210 break;
2211 }
2212 state->bucket = bucket;
2213
2214 return n;
2215}
2216
2217static struct neighbour *neigh_get_next(struct seq_file *seq,
2218 struct neighbour *n,
2219 loff_t *pos)
2220{
2221 struct neigh_seq_state *state = seq->private;
1218854a 2222 struct net *net = seq_file_net(seq);
1da177e4
LT		 2223 struct neigh_table *tbl = state->tbl;
2224
2225 if (state->neigh_sub_iter) {
2226 void *v = state->neigh_sub_iter(state, n, pos);
2227 if (v)
2228 return n;
2229 }
2230 n = n->next;
2231
2232 while (1) {
2233 while (n) {
878628fb 2234 if (!net_eq(dev_net(n->dev), net))
426b5303 2235 goto next;
1da177e4
LT		 2236 if (state->neigh_sub_iter) {
2237 void *v = state->neigh_sub_iter(state, n, pos);
2238 if (v)
2239 return n;
2240 goto next;
2241 }
2242 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2243 break;
2244
2245 if (n->nud_state & ~NUD_NOARP)
2246 break;
2247 next:
2248 n = n->next;
2249 }
2250
2251 if (n)
2252 break;
2253
2254 if (++state->bucket > tbl->hash_mask)
2255 break;
2256
2257 n = tbl->hash_buckets[state->bucket];
2258 }
2259
2260 if (n && pos)
2261 --(*pos);
2262 return n;
2263}
2264
2265static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2266{
2267 struct neighbour *n = neigh_get_first(seq);
2268
2269 if (n) {
745e2031 2270 --(*pos);
1da177e4
LT		 2271 while (*pos) {
2272 n = neigh_get_next(seq, n, pos);
2273 if (!n)
2274 break;
2275 }
2276 }
2277 return *pos ? NULL : n;
2278}
2279
2280static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2281{
2282 struct neigh_seq_state *state = seq->private;
1218854a 2283 struct net *net = seq_file_net(seq);
1da177e4
LT		 2284 struct neigh_table *tbl = state->tbl;
2285 struct pneigh_entry *pn = NULL;
2286 int bucket = state->bucket;
2287
2288 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2289 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2290 pn = tbl->phash_buckets[bucket];
878628fb 2291 while (pn && !net_eq(pneigh_net(pn), net))
426b5303 2292 pn = pn->next;
1da177e4
LT		 2293 if (pn)
2294 break;
2295 }
2296 state->bucket = bucket;
2297
2298 return pn;
2299}
2300
2301static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2302 struct pneigh_entry *pn,
2303 loff_t *pos)
2304{
2305 struct neigh_seq_state *state = seq->private;
1218854a 2306 struct net *net = seq_file_net(seq);
1da177e4
LT		 2307 struct neigh_table *tbl = state->tbl;
2308
2309 pn = pn->next;
2310 while (!pn) {
2311 if (++state->bucket > PNEIGH_HASHMASK)
2312 break;
2313 pn = tbl->phash_buckets[state->bucket];
878628fb 2314 while (pn && !net_eq(pneigh_net(pn), net))
426b5303 2315 pn = pn->next;
1da177e4
LT		 2316 if (pn)
2317 break;
2318 }
2319
2320 if (pn && pos)
2321 --(*pos);
2322
2323 return pn;
2324}
2325
2326static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2327{
2328 struct pneigh_entry *pn = pneigh_get_first(seq);
2329
2330 if (pn) {
745e2031 2331 --(*pos);
1da177e4
LT		 2332 while (*pos) {
2333 pn = pneigh_get_next(seq, pn, pos);
2334 if (!pn)
2335 break;
2336 }
2337 }
2338 return *pos ? NULL : pn;
2339}
2340
2341static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2342{
2343 struct neigh_seq_state *state = seq->private;
2344 void *rc;
745e2031 2345 loff_t idxpos = *pos;
1da177e4 2346
745e2031 2347 rc = neigh_get_idx(seq, &idxpos);
1da177e4 2348 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
745e2031 2349 rc = pneigh_get_idx(seq, &idxpos);
1da177e4
LT		 2350
2351 return rc;
2352}
2353
2354void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
9a429c49 2355 __acquires(tbl->lock)
1da177e4
LT		 2356{
2357 struct neigh_seq_state *state = seq->private;
1da177e4
LT		 2358
2359 state->tbl = tbl;
2360 state->bucket = 0;
2361 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2362
2363 read_lock_bh(&tbl->lock);
2364
745e2031 2365 return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN;
1da177e4
LT		 2366}
2367EXPORT_SYMBOL(neigh_seq_start);
2368
2369void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2370{
2371 struct neigh_seq_state *state;
2372 void *rc;
2373
2374 if (v == SEQ_START_TOKEN) {
bff69732 2375 rc = neigh_get_first(seq);
1da177e4
LT		 2376 goto out;
2377 }
2378
2379 state = seq->private;
2380 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2381 rc = neigh_get_next(seq, v, NULL);
2382 if (rc)
2383 goto out;
2384 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2385 rc = pneigh_get_first(seq);
2386 } else {
2387 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2388 rc = pneigh_get_next(seq, v, NULL);
2389 }
2390out:
2391 ++(*pos);
2392 return rc;
2393}
2394EXPORT_SYMBOL(neigh_seq_next);
2395
2396void neigh_seq_stop(struct seq_file *seq, void *v)
9a429c49 2397 __releases(tbl->lock)
1da177e4
LT		 2398{
2399 struct neigh_seq_state *state = seq->private;
2400 struct neigh_table *tbl = state->tbl;
2401
2402 read_unlock_bh(&tbl->lock);
2403}
2404EXPORT_SYMBOL(neigh_seq_stop);
2405
2406/* statistics via seq_file */
2407
2408static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2409{
2410 struct proc_dir_entry *pde = seq->private;
2411 struct neigh_table *tbl = pde->data;
2412 int cpu;
2413
2414 if (*pos == 0)
2415 return SEQ_START_TOKEN;
4ec93edb 2416
1da177e4
LT		 2417 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
2418 if (!cpu_possible(cpu))
2419 continue;
2420 *pos = cpu+1;
2421 return per_cpu_ptr(tbl->stats, cpu);
2422 }
2423 return NULL;
2424}
2425
2426static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2427{
2428 struct proc_dir_entry *pde = seq->private;
2429 struct neigh_table *tbl = pde->data;
2430 int cpu;
2431
2432 for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
2433 if (!cpu_possible(cpu))
2434 continue;
2435 *pos = cpu+1;
2436 return per_cpu_ptr(tbl->stats, cpu);
2437 }
2438 return NULL;
2439}
2440
2441static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2442{
2443
2444}
2445
2446static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2447{
2448 struct proc_dir_entry *pde = seq->private;
2449 struct neigh_table *tbl = pde->data;
2450 struct neigh_statistics *st = v;
2451
2452 if (v == SEQ_START_TOKEN) {
9a6d276e 2453 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		 2454 return 0;
2455 }
2456
2457 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
9a6d276e 2458 "%08lx %08lx %08lx %08lx %08lx\n",
1da177e4
LT		 2459 atomic_read(&tbl->entries),
2460
2461 st->allocs,
2462 st->destroys,
2463 st->hash_grows,
2464
2465 st->lookups,
2466 st->hits,
2467
2468 st->res_failed,
2469
2470 st->rcv_probes_mcast,
2471 st->rcv_probes_ucast,
2472
2473 st->periodic_gc_runs,
9a6d276e
NH		 2474 st->forced_gc_runs,
2475 st->unres_discards
1da177e4
LT		 2476 );
2477
2478 return 0;
2479}
2480
f690808e 2481static const struct seq_operations neigh_stat_seq_ops = {
1da177e4
LT		 2482 .start = neigh_stat_seq_start,
2483 .next = neigh_stat_seq_next,
2484 .stop = neigh_stat_seq_stop,
2485 .show = neigh_stat_seq_show,
2486};
2487
2488static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2489{
2490 int ret = seq_open(file, &neigh_stat_seq_ops);
2491
2492 if (!ret) {
2493 struct seq_file *sf = file->private_data;
2494 sf->private = PDE(inode);
2495 }
2496 return ret;
2497};
2498
9a32144e 2499static const struct file_operations neigh_stat_seq_fops = {
1da177e4
LT		 2500 .owner = THIS_MODULE,
2501 .open = neigh_stat_seq_open,
2502 .read = seq_read,
2503 .llseek = seq_lseek,
2504 .release = seq_release,
2505};
2506
2507#endif /* CONFIG_PROC_FS */
2508
339bf98f
TG		 2509static inline size_t neigh_nlmsg_size(void)
2510{
2511 return NLMSG_ALIGN(sizeof(struct ndmsg))
2512 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2513 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2514 + nla_total_size(sizeof(struct nda_cacheinfo))
2515 + nla_total_size(4); /* NDA_PROBES */
2516}
2517
b8673311 2518static void __neigh_notify(struct neighbour *n, int type, int flags)
1da177e4 2519{
c346dca1 2520 struct net *net = dev_net(n->dev);
8b8aec50 2521 struct sk_buff *skb;
b8673311 2522 int err = -ENOBUFS;
1da177e4 2523
339bf98f 2524 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
8b8aec50 2525 if (skb == NULL)
b8673311 2526 goto errout;
1da177e4 2527
b8673311 2528 err = neigh_fill_info(skb, n, 0, 0, type, flags);
26932566
PM		 2529 if (err < 0) {
2530 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2531 WARN_ON(err == -EMSGSIZE);
2532 kfree_skb(skb);
2533 goto errout;
2534 }
426b5303 2535 err = rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
b8673311
TG		 2536errout:
2537 if (err < 0)
426b5303 2538 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
1da177e4
LT		 2539}
2540
d961db35 2541#ifdef CONFIG_ARPD
b8673311 2542void neigh_app_ns(struct neighbour *n)
1da177e4 2543{
b8673311
TG		 2544 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
2545}
0a204500 2546EXPORT_SYMBOL(neigh_app_ns);
1da177e4
LT		 2547#endif /* CONFIG_ARPD */
2548
2549#ifdef CONFIG_SYSCTL
2550
2551static struct neigh_sysctl_table {
2552 struct ctl_table_header *sysctl_header;
c3bac5a7
PE		 2553 struct ctl_table neigh_vars[__NET_NEIGH_MAX];
2554 char *dev_name;
ab32ea5d 2555} neigh_sysctl_template __read_mostly = {
1da177e4
LT		 2556 .neigh_vars = {
2557 {
2558 .ctl_name = NET_NEIGH_MCAST_SOLICIT,
2559 .procname = "mcast_solicit",
2560 .maxlen = sizeof(int),
2561 .mode = 0644,
6d9f239a 2562 .proc_handler = proc_dointvec,
1da177e4
LT		 2563 },
2564 {
2565 .ctl_name = NET_NEIGH_UCAST_SOLICIT,
2566 .procname = "ucast_solicit",
2567 .maxlen = sizeof(int),
2568 .mode = 0644,
6d9f239a 2569 .proc_handler = proc_dointvec,
1da177e4
LT		 2570 },
2571 {
2572 .ctl_name = NET_NEIGH_APP_SOLICIT,
2573 .procname = "app_solicit",
2574 .maxlen = sizeof(int),
2575 .mode = 0644,
6d9f239a 2576 .proc_handler = proc_dointvec,
1da177e4
LT		 2577 },
2578 {
1da177e4
LT		 2579 .procname = "retrans_time",
2580 .maxlen = sizeof(int),
2581 .mode = 0644,
6d9f239a 2582 .proc_handler = proc_dointvec_userhz_jiffies,
1da177e4
LT		 2583 },
2584 {
2585 .ctl_name = NET_NEIGH_REACHABLE_TIME,
2586 .procname = "base_reachable_time",
2587 .maxlen = sizeof(int),
2588 .mode = 0644,
6d9f239a
AD		 2589 .proc_handler = proc_dointvec_jiffies,
2590 .strategy = sysctl_jiffies,
1da177e4
LT		 2591 },
2592 {
2593 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME,
2594 .procname = "delay_first_probe_time",
2595 .maxlen = sizeof(int),
2596 .mode = 0644,
6d9f239a
AD		 2597 .proc_handler = proc_dointvec_jiffies,
2598 .strategy = sysctl_jiffies,
1da177e4
LT		 2599 },
2600 {
2601 .ctl_name = NET_NEIGH_GC_STALE_TIME,
2602 .procname = "gc_stale_time",
2603 .maxlen = sizeof(int),
2604 .mode = 0644,
6d9f239a
AD		 2605 .proc_handler = proc_dointvec_jiffies,
2606 .strategy = sysctl_jiffies,
1da177e4
LT		 2607 },
2608 {
2609 .ctl_name = NET_NEIGH_UNRES_QLEN,
2610 .procname = "unres_qlen",
2611 .maxlen = sizeof(int),
2612 .mode = 0644,
6d9f239a 2613 .proc_handler = proc_dointvec,
1da177e4
LT		 2614 },
2615 {
2616 .ctl_name = NET_NEIGH_PROXY_QLEN,
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
EB		 2640 {
2641 .ctl_name = NET_NEIGH_RETRANS_TIME_MS,
2642 .procname = "retrans_time_ms",
2643 .maxlen = sizeof(int),
2644 .mode = 0644,
6d9f239a
AD		 2645 .proc_handler = proc_dointvec_ms_jiffies,
2646 .strategy = sysctl_ms_jiffies,
d12af679
EB		 2647 },
2648 {
2649 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS,
2650 .procname = "base_reachable_time_ms",
2651 .maxlen = sizeof(int),
2652 .mode = 0644,
6d9f239a
AD		 2653 .proc_handler = proc_dointvec_ms_jiffies,
2654 .strategy = sysctl_ms_jiffies,
d12af679 2655 },
1da177e4
LT		 2656 {
2657 .ctl_name = NET_NEIGH_GC_INTERVAL,
2658 .procname = "gc_interval",
2659 .maxlen = sizeof(int),
2660 .mode = 0644,
6d9f239a
AD		 2661 .proc_handler = proc_dointvec_jiffies,
2662 .strategy = sysctl_jiffies,
1da177e4
LT		 2663 },
2664 {
2665 .ctl_name = NET_NEIGH_GC_THRESH1,
2666 .procname = "gc_thresh1",
2667 .maxlen = sizeof(int),
2668 .mode = 0644,
6d9f239a 2669 .proc_handler = proc_dointvec,
1da177e4
LT		 2670 },
2671 {
2672 .ctl_name = NET_NEIGH_GC_THRESH2,
2673 .procname = "gc_thresh2",
2674 .maxlen = sizeof(int),
2675 .mode = 0644,
6d9f239a 2676 .proc_handler = proc_dointvec,
1da177e4
LT		 2677 },
2678 {
2679 .ctl_name = NET_NEIGH_GC_THRESH3,
2680 .procname = "gc_thresh3",
2681 .maxlen = sizeof(int),
2682 .mode = 0644,
6d9f239a 2683 .proc_handler = proc_dointvec,
1da177e4 2684 },
c3bac5a7 2685 {},
1da177e4
LT		 2686 },
2687};
2688
2689int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
4ec93edb 2690 int p_id, int pdev_id, char *p_name,
1da177e4
LT		 2691 proc_handler *handler, ctl_handler *strategy)
2692{
3c607bbb 2693 struct neigh_sysctl_table *t;
1da177e4 2694 const char *dev_name_source = NULL;
c3bac5a7
PE		 2695
2696#define NEIGH_CTL_PATH_ROOT 0
2697#define NEIGH_CTL_PATH_PROTO 1
2698#define NEIGH_CTL_PATH_NEIGH 2
2699#define NEIGH_CTL_PATH_DEV 3
2700
2701 struct ctl_path neigh_path[] = {
2702 { .procname = "net", .ctl_name = CTL_NET, },
2703 { .procname = "proto", .ctl_name = 0, },
2704 { .procname = "neigh", .ctl_name = 0, },
2705 { .procname = "default", .ctl_name = NET_PROTO_CONF_DEFAULT, },
2706 { },
2707 };
1da177e4 2708
3c607bbb 2709 t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
1da177e4 2710 if (!t)
3c607bbb
PE		 2711 goto err;
2712
1da177e4
LT		 2713 t->neigh_vars[0].data = &p->mcast_probes;
2714 t->neigh_vars[1].data = &p->ucast_probes;
2715 t->neigh_vars[2].data = &p->app_probes;
2716 t->neigh_vars[3].data = &p->retrans_time;
2717 t->neigh_vars[4].data = &p->base_reachable_time;
2718 t->neigh_vars[5].data = &p->delay_probe_time;
2719 t->neigh_vars[6].data = &p->gc_staletime;
2720 t->neigh_vars[7].data = &p->queue_len;
2721 t->neigh_vars[8].data = &p->proxy_qlen;
2722 t->neigh_vars[9].data = &p->anycast_delay;
2723 t->neigh_vars[10].data = &p->proxy_delay;
2724 t->neigh_vars[11].data = &p->locktime;
d12af679
EB		 2725 t->neigh_vars[12].data = &p->retrans_time;
2726 t->neigh_vars[13].data = &p->base_reachable_time;
1da177e4
LT		 2727
2728 if (dev) {
2729 dev_name_source = dev->name;
c3bac5a7 2730 neigh_path[NEIGH_CTL_PATH_DEV].ctl_name = dev->ifindex;
d12af679
EB		 2731 /* Terminate the table early */
2732 memset(&t->neigh_vars[14], 0, sizeof(t->neigh_vars[14]));
1da177e4 2733 } else {
c3bac5a7 2734 dev_name_source = neigh_path[NEIGH_CTL_PATH_DEV].procname;
d12af679
EB		 2735 t->neigh_vars[14].data = (int *)(p + 1);
2736 t->neigh_vars[15].data = (int *)(p + 1) + 1;
2737 t->neigh_vars[16].data = (int *)(p + 1) + 2;
2738 t->neigh_vars[17].data = (int *)(p + 1) + 3;
1da177e4
LT		 2739 }
2740
1da177e4
LT		 2741
2742 if (handler || strategy) {
2743 /* RetransTime */
2744 t->neigh_vars[3].proc_handler = handler;
2745 t->neigh_vars[3].strategy = strategy;
2746 t->neigh_vars[3].extra1 = dev;
d12af679
EB		 2747 if (!strategy)
2748 t->neigh_vars[3].ctl_name = CTL_UNNUMBERED;
1da177e4
LT		 2749 /* ReachableTime */
2750 t->neigh_vars[4].proc_handler = handler;
2751 t->neigh_vars[4].strategy = strategy;
2752 t->neigh_vars[4].extra1 = dev;
d12af679
EB		 2753 if (!strategy)
2754 t->neigh_vars[4].ctl_name = CTL_UNNUMBERED;
1da177e4 2755 /* RetransTime (in milliseconds)*/
d12af679
EB		 2756 t->neigh_vars[12].proc_handler = handler;
2757 t->neigh_vars[12].strategy = strategy;
2758 t->neigh_vars[12].extra1 = dev;
2759 if (!strategy)
2760 t->neigh_vars[12].ctl_name = CTL_UNNUMBERED;
1da177e4 2761 /* ReachableTime (in milliseconds) */
d12af679
EB		 2762 t->neigh_vars[13].proc_handler = handler;
2763 t->neigh_vars[13].strategy = strategy;
2764 t->neigh_vars[13].extra1 = dev;
2765 if (!strategy)
2766 t->neigh_vars[13].ctl_name = CTL_UNNUMBERED;
1da177e4
LT		 2767 }
2768
c3bac5a7
PE		 2769 t->dev_name = kstrdup(dev_name_source, GFP_KERNEL);
2770 if (!t->dev_name)
1da177e4 2771 goto free;
1da177e4 2772
c3bac5a7
PE		 2773 neigh_path[NEIGH_CTL_PATH_DEV].procname = t->dev_name;
2774 neigh_path[NEIGH_CTL_PATH_NEIGH].ctl_name = pdev_id;
2775 neigh_path[NEIGH_CTL_PATH_PROTO].procname = p_name;
2776 neigh_path[NEIGH_CTL_PATH_PROTO].ctl_name = p_id;
1da177e4 2777
4ab438fc 2778 t->sysctl_header =
57da52c1 2779 register_net_sysctl_table(neigh_parms_net(p), neigh_path, t->neigh_vars);
3c607bbb 2780 if (!t->sysctl_header)
1da177e4 2781 goto free_procname;
3c607bbb 2782
1da177e4
LT		 2783 p->sysctl_table = t;
2784 return 0;
2785
3c607bbb 2786free_procname:
c3bac5a7 2787 kfree(t->dev_name);
3c607bbb 2788free:
1da177e4 2789 kfree(t);
3c607bbb
PE		 2790err:
2791 return -ENOBUFS;
1da177e4 2792}
0a204500 2793EXPORT_SYMBOL(neigh_sysctl_register);
1da177e4
LT		 2794
2795void neigh_sysctl_unregister(struct neigh_parms *p)
2796{
2797 if (p->sysctl_table) {
2798 struct neigh_sysctl_table *t = p->sysctl_table;
2799 p->sysctl_table = NULL;
2800 unregister_sysctl_table(t->sysctl_header);
c3bac5a7 2801 kfree(t->dev_name);
1da177e4
LT		 2802 kfree(t);
2803 }
2804}
0a204500 2805EXPORT_SYMBOL(neigh_sysctl_unregister);
1da177e4
LT		 2806
2807#endif /* CONFIG_SYSCTL */
2808
c8822a4e
TG		 2809static int __init neigh_init(void)
2810{
2811 rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL);
2812 rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL);
2813 rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info);
2814
2815 rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info);
2816 rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL);
2817
2818 return 0;
2819}
2820
2821subsys_initcall(neigh_init);
2822
Linux 6.x block layer and io_uring tree(s)