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