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