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