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