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