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