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