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