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