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