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