blob: 84195dacb8b63f418cac67d4039842dd72eaecc4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Joe Perchese005d192012-05-16 19:58:40 +000018#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/types.h>
22#include <linux/kernel.h>
23#include <linux/module.h>
24#include <linux/socket.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#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>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020031#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <net/neighbour.h>
33#include <net/dst.h>
34#include <net/sock.h>
Tom Tucker8d717402006-07-30 20:43:36 -070035#include <net/netevent.h>
Thomas Grafa14a49d2006-08-07 17:53:08 -070036#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/rtnetlink.h>
38#include <linux/random.h>
Paulo Marques543537b2005-06-23 00:09:02 -070039#include <linux/string.h>
vignesh babuc3609d52007-08-24 22:27:55 -070040#include <linux/log2.h>
Jiri Pirko1d4c8c22013-12-07 19:26:56 +010041#include <linux/inetdevice.h>
Jiri Pirkobba24892013-12-07 19:26:57 +010042#include <net/addrconf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Joe Perchesd5d427c2013-04-15 15:17:19 +000044#define DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define NEIGH_DEBUG 1
Joe Perchesd5d427c2013-04-15 15:17:19 +000046#define neigh_dbg(level, fmt, ...) \
47do { \
48 if (level <= NEIGH_DEBUG) \
49 pr_debug(fmt, ##__VA_ARGS__); \
50} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52#define PNEIGH_HASHMASK 0xF
53
54static void neigh_timer_handler(unsigned long arg);
Thomas Grafd961db32007-08-08 23:12:56 -070055static void __neigh_notify(struct neighbour *n, int type, int flags);
56static void neigh_update_notify(struct neighbour *neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Amos Waterland45fc3b12005-09-24 16:53:16 -070059#ifdef CONFIG_PROC_FS
Arjan van de Ven9a321442007-02-12 00:55:35 -080060static const struct file_operations neigh_stat_seq_fops;
Amos Waterland45fc3b12005-09-24 16:53:16 -070061#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 */
90
David S. Miller8f40b162011-07-17 13:34:11 -070091static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092{
93 kfree_skb(skb);
94 return -ENETDOWN;
95}
96
Thomas Graf4f494552007-08-08 23:12:36 -070097static void neigh_cleanup_and_release(struct neighbour *neigh)
98{
99 if (neigh->parms->neigh_cleanup)
100 neigh->parms->neigh_cleanup(neigh);
101
Thomas Grafd961db32007-08-08 23:12:56 -0700102 __neigh_notify(neigh, RTM_DELNEIGH, 0);
Thomas Graf4f494552007-08-08 23:12:36 -0700103 neigh_release(neigh);
104}
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106/*
107 * It is random distribution in the interval (1/2)*base...(3/2)*base.
108 * It corresponds to default IPv6 settings and is not overridable,
109 * because it is really reasonable choice.
110 */
111
112unsigned long neigh_rand_reach_time(unsigned long base)
113{
Aruna-Hewapathirane63862b52014-01-11 07:15:59 -0500114 return base ? (prandom_u32() % base) + (base >> 1) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900116EXPORT_SYMBOL(neigh_rand_reach_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118
119static int neigh_forced_gc(struct neigh_table *tbl)
120{
121 int shrunk = 0;
122 int i;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000123 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
125 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
126
127 write_lock_bh(&tbl->lock);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000128 nht = rcu_dereference_protected(tbl->nht,
129 lockdep_is_held(&tbl->lock));
David S. Millercd089332011-07-11 01:28:12 -0700130 for (i = 0; i < (1 << nht->hash_shift); i++) {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700131 struct neighbour *n;
132 struct neighbour __rcu **np;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000134 np = &nht->hash_buckets[i];
Eric Dumazet767e97e2010-10-06 17:49:21 -0700135 while ((n = rcu_dereference_protected(*np,
136 lockdep_is_held(&tbl->lock))) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 /* 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)) {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700144 rcu_assign_pointer(*np,
145 rcu_dereference_protected(n->next,
146 lockdep_is_held(&tbl->lock)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 n->dead = 1;
148 shrunk = 1;
149 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -0700150 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 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
Pavel Emelyanova43d8992007-12-20 15:49:05 -0800165static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175static 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
185static 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
Herbert Xu49636bb2005-10-23 17:18:00 +1000195static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196{
197 int i;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000198 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000200 nht = rcu_dereference_protected(tbl->nht,
201 lockdep_is_held(&tbl->lock));
202
David S. Millercd089332011-07-11 01:28:12 -0700203 for (i = 0; i < (1 << nht->hash_shift); i++) {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700204 struct neighbour *n;
205 struct neighbour __rcu **np = &nht->hash_buckets[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Eric Dumazet767e97e2010-10-06 17:49:21 -0700207 while ((n = rcu_dereference_protected(*np,
208 lockdep_is_held(&tbl->lock))) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 if (dev && n->dev != dev) {
210 np = &n->next;
211 continue;
212 }
Eric Dumazet767e97e2010-10-06 17:49:21 -0700213 rcu_assign_pointer(*np,
214 rcu_dereference_protected(n->next,
215 lockdep_is_held(&tbl->lock)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 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 */
Eric Dumazetc9ab4d82013-06-28 02:37:42 -0700230 __skb_queue_purge(&n->arp_queue);
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000231 n->arp_queue_len_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 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;
Joe Perchesd5d427c2013-04-15 15:17:19 +0000237 neigh_dbg(2, "neigh %p is stray\n", n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 }
239 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -0700240 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 }
242 }
Herbert Xu49636bb2005-10-23 17:18:00 +1000243}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Herbert Xu49636bb2005-10-23 17:18:00 +1000245void 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}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900251EXPORT_SYMBOL(neigh_changeaddr);
Herbert Xu49636bb2005-10-23 17:18:00 +1000252
253int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
254{
255 write_lock_bh(&tbl->lock);
256 neigh_flush_dev(tbl, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 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}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900264EXPORT_SYMBOL(neigh_ifdown);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
David Miller596b9b62011-07-25 00:01:25 +0000266static struct neighbour *neigh_alloc(struct neigh_table *tbl, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267{
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 goto out_entries;
279 }
280
YOSHIFUJI Hideaki / 吉藤英明08433ef2013-01-24 00:44:23 +0000281 n = kzalloc(tbl->entry_size + dev->neigh_priv_len, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 if (!n)
283 goto out_entries;
284
Eric Dumazetc9ab4d82013-06-28 02:37:42 -0700285 __skb_queue_head_init(&n->arp_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 rwlock_init(&n->lock);
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +0000287 seqlock_init(&n->ha_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 n->updated = n->used = now;
289 n->nud_state = NUD_NONE;
290 n->output = neigh_blackhole;
David S. Millerf6b72b62011-07-14 07:53:20 -0700291 seqlock_init(&n->hh.hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 n->parms = neigh_parms_clone(&tbl->parms);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800293 setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
295 NEIGH_CACHE_STAT_INC(tbl, allocs);
296 n->tbl = tbl;
297 atomic_set(&n->refcnt, 1);
298 n->dead = 1;
299out:
300 return n;
301
302out_entries:
303 atomic_dec(&tbl->entries);
304 goto out;
305}
306
David S. Miller2c2aba62011-12-28 15:06:58 -0500307static void neigh_get_hash_rnd(u32 *x)
308{
309 get_random_bytes(x, sizeof(*x));
310 *x |= 1;
311}
312
David S. Millercd089332011-07-11 01:28:12 -0700313static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314{
David S. Millercd089332011-07-11 01:28:12 -0700315 size_t size = (1 << shift) * sizeof(struct neighbour *);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000316 struct neigh_hash_table *ret;
Eric Dumazet6193d2b2011-01-19 22:02:47 +0000317 struct neighbour __rcu **buckets;
David S. Miller2c2aba62011-12-28 15:06:58 -0500318 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000320 ret = kmalloc(sizeof(*ret), GFP_ATOMIC);
321 if (!ret)
322 return NULL;
323 if (size <= PAGE_SIZE)
324 buckets = kzalloc(size, GFP_ATOMIC);
325 else
Eric Dumazet6193d2b2011-01-19 22:02:47 +0000326 buckets = (struct neighbour __rcu **)
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000327 __get_free_pages(GFP_ATOMIC | __GFP_ZERO,
328 get_order(size));
329 if (!buckets) {
330 kfree(ret);
331 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 }
Eric Dumazet6193d2b2011-01-19 22:02:47 +0000333 ret->hash_buckets = buckets;
David S. Millercd089332011-07-11 01:28:12 -0700334 ret->hash_shift = shift;
David S. Miller2c2aba62011-12-28 15:06:58 -0500335 for (i = 0; i < NEIGH_NUM_HASH_RND; i++)
336 neigh_get_hash_rnd(&ret->hash_rnd[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 return ret;
338}
339
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000340static void neigh_hash_free_rcu(struct rcu_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000342 struct neigh_hash_table *nht = container_of(head,
343 struct neigh_hash_table,
344 rcu);
David S. Millercd089332011-07-11 01:28:12 -0700345 size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *);
Eric Dumazet6193d2b2011-01-19 22:02:47 +0000346 struct neighbour __rcu **buckets = nht->hash_buckets;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
348 if (size <= PAGE_SIZE)
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000349 kfree(buckets);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 else
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000351 free_pages((unsigned long)buckets, get_order(size));
352 kfree(nht);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353}
354
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000355static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl,
David S. Millercd089332011-07-11 01:28:12 -0700356 unsigned long new_shift)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357{
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000358 unsigned int i, hash;
359 struct neigh_hash_table *new_nht, *old_nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
361 NEIGH_CACHE_STAT_INC(tbl, hash_grows);
362
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000363 old_nht = rcu_dereference_protected(tbl->nht,
364 lockdep_is_held(&tbl->lock));
David S. Millercd089332011-07-11 01:28:12 -0700365 new_nht = neigh_hash_alloc(new_shift);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000366 if (!new_nht)
367 return old_nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
David S. Millercd089332011-07-11 01:28:12 -0700369 for (i = 0; i < (1 << old_nht->hash_shift); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 struct neighbour *n, *next;
371
Eric Dumazet767e97e2010-10-06 17:49:21 -0700372 for (n = rcu_dereference_protected(old_nht->hash_buckets[i],
373 lockdep_is_held(&tbl->lock));
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000374 n != NULL;
375 n = next) {
376 hash = tbl->hash(n->primary_key, n->dev,
377 new_nht->hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
David S. Millercd089332011-07-11 01:28:12 -0700379 hash >>= (32 - new_nht->hash_shift);
Eric Dumazet767e97e2010-10-06 17:49:21 -0700380 next = rcu_dereference_protected(n->next,
381 lockdep_is_held(&tbl->lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Eric Dumazet767e97e2010-10-06 17:49:21 -0700383 rcu_assign_pointer(n->next,
384 rcu_dereference_protected(
385 new_nht->hash_buckets[hash],
386 lockdep_is_held(&tbl->lock)));
387 rcu_assign_pointer(new_nht->hash_buckets[hash], n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 }
389 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000391 rcu_assign_pointer(tbl->nht, new_nht);
392 call_rcu(&old_nht->rcu, neigh_hash_free_rcu);
393 return new_nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394}
395
396struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
397 struct net_device *dev)
398{
399 struct neighbour *n;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 NEIGH_CACHE_STAT_INC(tbl, lookups);
402
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000403 rcu_read_lock_bh();
Eric W. Biederman60395a22015-03-03 17:10:44 -0600404 n = __neigh_lookup_noref(tbl, pkey, dev);
405 if (n) {
406 if (!atomic_inc_not_zero(&n->refcnt))
407 n = NULL;
408 NEIGH_CACHE_STAT_INC(tbl, hits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 }
Eric Dumazet767e97e2010-10-06 17:49:21 -0700410
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000411 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 return n;
413}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900414EXPORT_SYMBOL(neigh_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
Eric W. Biederman426b5302008-01-24 00:13:18 -0800416struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
417 const void *pkey)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418{
419 struct neighbour *n;
420 int key_len = tbl->key_len;
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800421 u32 hash_val;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000422 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 NEIGH_CACHE_STAT_INC(tbl, lookups);
425
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000426 rcu_read_lock_bh();
427 nht = rcu_dereference_bh(tbl->nht);
David S. Millercd089332011-07-11 01:28:12 -0700428 hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift);
Eric Dumazet767e97e2010-10-06 17:49:21 -0700429
430 for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
431 n != NULL;
432 n = rcu_dereference_bh(n->next)) {
Eric W. Biederman426b5302008-01-24 00:13:18 -0800433 if (!memcmp(n->primary_key, pkey, key_len) &&
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +0900434 net_eq(dev_net(n->dev), net)) {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700435 if (!atomic_inc_not_zero(&n->refcnt))
436 n = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 NEIGH_CACHE_STAT_INC(tbl, hits);
438 break;
439 }
440 }
Eric Dumazet767e97e2010-10-06 17:49:21 -0700441
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000442 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 return n;
444}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900445EXPORT_SYMBOL(neigh_lookup_nodev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
David S. Millera263b302012-07-02 02:02:15 -0700447struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey,
448 struct net_device *dev, bool want_ref)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
450 u32 hash_val;
451 int key_len = tbl->key_len;
452 int error;
David Miller596b9b62011-07-25 00:01:25 +0000453 struct neighbour *n1, *rc, *n = neigh_alloc(tbl, dev);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000454 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
456 if (!n) {
457 rc = ERR_PTR(-ENOBUFS);
458 goto out;
459 }
460
461 memcpy(n->primary_key, pkey, key_len);
462 n->dev = dev;
463 dev_hold(dev);
464
465 /* Protocol specific setup. */
466 if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
467 rc = ERR_PTR(error);
468 goto out_neigh_release;
469 }
470
David Millerda6a8fa2011-07-25 00:01:38 +0000471 if (dev->netdev_ops->ndo_neigh_construct) {
472 error = dev->netdev_ops->ndo_neigh_construct(n);
473 if (error < 0) {
474 rc = ERR_PTR(error);
475 goto out_neigh_release;
476 }
477 }
478
David S. Miller447f2192011-12-19 15:04:41 -0500479 /* Device specific setup. */
480 if (n->parms->neigh_setup &&
481 (error = n->parms->neigh_setup(n)) < 0) {
482 rc = ERR_PTR(error);
483 goto out_neigh_release;
484 }
485
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100486 n->confirmed = jiffies - (NEIGH_VAR(n->parms, BASE_REACHABLE_TIME) << 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
488 write_lock_bh(&tbl->lock);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000489 nht = rcu_dereference_protected(tbl->nht,
490 lockdep_is_held(&tbl->lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
David S. Millercd089332011-07-11 01:28:12 -0700492 if (atomic_read(&tbl->entries) > (1 << nht->hash_shift))
493 nht = neigh_hash_grow(tbl, nht->hash_shift + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
David S. Millercd089332011-07-11 01:28:12 -0700495 hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
497 if (n->parms->dead) {
498 rc = ERR_PTR(-EINVAL);
499 goto out_tbl_unlock;
500 }
501
Eric Dumazet767e97e2010-10-06 17:49:21 -0700502 for (n1 = rcu_dereference_protected(nht->hash_buckets[hash_val],
503 lockdep_is_held(&tbl->lock));
504 n1 != NULL;
505 n1 = rcu_dereference_protected(n1->next,
506 lockdep_is_held(&tbl->lock))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
David S. Millera263b302012-07-02 02:02:15 -0700508 if (want_ref)
509 neigh_hold(n1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 rc = n1;
511 goto out_tbl_unlock;
512 }
513 }
514
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 n->dead = 0;
David S. Millera263b302012-07-02 02:02:15 -0700516 if (want_ref)
517 neigh_hold(n);
Eric Dumazet767e97e2010-10-06 17:49:21 -0700518 rcu_assign_pointer(n->next,
519 rcu_dereference_protected(nht->hash_buckets[hash_val],
520 lockdep_is_held(&tbl->lock)));
521 rcu_assign_pointer(nht->hash_buckets[hash_val], n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 write_unlock_bh(&tbl->lock);
Joe Perchesd5d427c2013-04-15 15:17:19 +0000523 neigh_dbg(2, "neigh %p is created\n", n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 rc = n;
525out:
526 return rc;
527out_tbl_unlock:
528 write_unlock_bh(&tbl->lock);
529out_neigh_release:
530 neigh_release(n);
531 goto out;
532}
David S. Millera263b302012-07-02 02:02:15 -0700533EXPORT_SYMBOL(__neigh_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900535static u32 pneigh_hash(const void *pkey, int key_len)
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700536{
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700537 u32 hash_val = *(u32 *)(pkey + key_len - 4);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700538 hash_val ^= (hash_val >> 16);
539 hash_val ^= hash_val >> 8;
540 hash_val ^= hash_val >> 4;
541 hash_val &= PNEIGH_HASHMASK;
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900542 return hash_val;
543}
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700544
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900545static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n,
546 struct net *net,
547 const void *pkey,
548 int key_len,
549 struct net_device *dev)
550{
551 while (n) {
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700552 if (!memcmp(n->key, pkey, key_len) &&
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900553 net_eq(pneigh_net(n), net) &&
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700554 (n->dev == dev || !n->dev))
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900555 return n;
556 n = n->next;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700557 }
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900558 return NULL;
559}
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700560
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900561struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl,
562 struct net *net, const void *pkey, struct net_device *dev)
563{
564 int key_len = tbl->key_len;
565 u32 hash_val = pneigh_hash(pkey, key_len);
566
567 return __pneigh_lookup_1(tbl->phash_buckets[hash_val],
568 net, pkey, key_len, dev);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700569}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900570EXPORT_SYMBOL_GPL(__pneigh_lookup);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700571
Eric W. Biederman426b5302008-01-24 00:13:18 -0800572struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl,
573 struct net *net, const void *pkey,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 struct net_device *dev, int creat)
575{
576 struct pneigh_entry *n;
577 int key_len = tbl->key_len;
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900578 u32 hash_val = pneigh_hash(pkey, key_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 read_lock_bh(&tbl->lock);
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900581 n = __pneigh_lookup_1(tbl->phash_buckets[hash_val],
582 net, pkey, key_len, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 read_unlock_bh(&tbl->lock);
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900584
585 if (n || !creat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 goto out;
587
Pavel Emelyanov4ae28942007-10-15 12:54:15 -0700588 ASSERT_RTNL();
589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
591 if (!n)
592 goto out;
593
Eric W. Biedermanefd7ef12015-03-11 23:04:08 -0500594 write_pnet(&n->net, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 memcpy(n->key, pkey, key_len);
596 n->dev = dev;
597 if (dev)
598 dev_hold(dev);
599
600 if (tbl->pconstructor && tbl->pconstructor(n)) {
601 if (dev)
602 dev_put(dev);
603 kfree(n);
604 n = NULL;
605 goto out;
606 }
607
608 write_lock_bh(&tbl->lock);
609 n->next = tbl->phash_buckets[hash_val];
610 tbl->phash_buckets[hash_val] = n;
611 write_unlock_bh(&tbl->lock);
612out:
613 return n;
614}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900615EXPORT_SYMBOL(pneigh_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617
Eric W. Biederman426b5302008-01-24 00:13:18 -0800618int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 struct net_device *dev)
620{
621 struct pneigh_entry *n, **np;
622 int key_len = tbl->key_len;
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900623 u32 hash_val = pneigh_hash(pkey, key_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625 write_lock_bh(&tbl->lock);
626 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
627 np = &n->next) {
Eric W. Biederman426b5302008-01-24 00:13:18 -0800628 if (!memcmp(n->key, pkey, key_len) && n->dev == dev &&
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +0900629 net_eq(pneigh_net(n), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 *np = n->next;
631 write_unlock_bh(&tbl->lock);
632 if (tbl->pdestructor)
633 tbl->pdestructor(n);
634 if (n->dev)
635 dev_put(n->dev);
636 kfree(n);
637 return 0;
638 }
639 }
640 write_unlock_bh(&tbl->lock);
641 return -ENOENT;
642}
643
644static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
645{
646 struct pneigh_entry *n, **np;
647 u32 h;
648
649 for (h = 0; h <= PNEIGH_HASHMASK; h++) {
650 np = &tbl->phash_buckets[h];
651 while ((n = *np) != NULL) {
652 if (!dev || n->dev == dev) {
653 *np = n->next;
654 if (tbl->pdestructor)
655 tbl->pdestructor(n);
656 if (n->dev)
657 dev_put(n->dev);
658 kfree(n);
659 continue;
660 }
661 np = &n->next;
662 }
663 }
664 return -ENOENT;
665}
666
Denis V. Lunev06f05112008-01-24 00:30:58 -0800667static void neigh_parms_destroy(struct neigh_parms *parms);
668
669static inline void neigh_parms_put(struct neigh_parms *parms)
670{
671 if (atomic_dec_and_test(&parms->refcnt))
672 neigh_parms_destroy(parms);
673}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
675/*
676 * neighbour must already be out of the table;
677 *
678 */
679void neigh_destroy(struct neighbour *neigh)
680{
David Millerda6a8fa2011-07-25 00:01:38 +0000681 struct net_device *dev = neigh->dev;
682
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
684
685 if (!neigh->dead) {
Joe Perchese005d192012-05-16 19:58:40 +0000686 pr_warn("Destroying alive neighbour %p\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 dump_stack();
688 return;
689 }
690
691 if (neigh_del_timer(neigh))
Joe Perchese005d192012-05-16 19:58:40 +0000692 pr_warn("Impossible event\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Eric Dumazetc9ab4d82013-06-28 02:37:42 -0700694 write_lock_bh(&neigh->lock);
695 __skb_queue_purge(&neigh->arp_queue);
696 write_unlock_bh(&neigh->lock);
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000697 neigh->arp_queue_len_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
David S. Miller447f2192011-12-19 15:04:41 -0500699 if (dev->netdev_ops->ndo_neigh_destroy)
700 dev->netdev_ops->ndo_neigh_destroy(neigh);
701
David Millerda6a8fa2011-07-25 00:01:38 +0000702 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 neigh_parms_put(neigh->parms);
704
Joe Perchesd5d427c2013-04-15 15:17:19 +0000705 neigh_dbg(2, "neigh %p is destroyed\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
707 atomic_dec(&neigh->tbl->entries);
David Miller5b8b0062011-07-25 00:01:22 +0000708 kfree_rcu(neigh, rcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900710EXPORT_SYMBOL(neigh_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
712/* Neighbour state is suspicious;
713 disable fast path.
714
715 Called with write_locked neigh.
716 */
717static void neigh_suspect(struct neighbour *neigh)
718{
Joe Perchesd5d427c2013-04-15 15:17:19 +0000719 neigh_dbg(2, "neigh %p is suspected\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
721 neigh->output = neigh->ops->output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722}
723
724/* Neighbour state is OK;
725 enable fast path.
726
727 Called with write_locked neigh.
728 */
729static void neigh_connect(struct neighbour *neigh)
730{
Joe Perchesd5d427c2013-04-15 15:17:19 +0000731 neigh_dbg(2, "neigh %p is connected\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
733 neigh->output = neigh->ops->connected_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734}
735
Eric Dumazete4c4e442009-07-30 03:15:07 +0000736static void neigh_periodic_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
Eric Dumazete4c4e442009-07-30 03:15:07 +0000738 struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work);
Eric Dumazet767e97e2010-10-06 17:49:21 -0700739 struct neighbour *n;
740 struct neighbour __rcu **np;
Eric Dumazete4c4e442009-07-30 03:15:07 +0000741 unsigned int i;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000742 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
744 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
745
Eric Dumazete4c4e442009-07-30 03:15:07 +0000746 write_lock_bh(&tbl->lock);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000747 nht = rcu_dereference_protected(tbl->nht,
748 lockdep_is_held(&tbl->lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
750 /*
751 * periodically recompute ReachableTime from random function
752 */
753
Eric Dumazete4c4e442009-07-30 03:15:07 +0000754 if (time_after(jiffies, tbl->last_rand + 300 * HZ)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 struct neigh_parms *p;
Eric Dumazete4c4e442009-07-30 03:15:07 +0000756 tbl->last_rand = jiffies;
Nicolas Dichtel75fbfd32014-10-29 19:29:31 +0100757 list_for_each_entry(p, &tbl->parms_list, list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 p->reachable_time =
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100759 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 }
761
Duan Jiongfeff9ab2014-02-27 17:14:41 +0800762 if (atomic_read(&tbl->entries) < tbl->gc_thresh1)
763 goto out;
764
David S. Millercd089332011-07-11 01:28:12 -0700765 for (i = 0 ; i < (1 << nht->hash_shift); i++) {
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000766 np = &nht->hash_buckets[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
Eric Dumazet767e97e2010-10-06 17:49:21 -0700768 while ((n = rcu_dereference_protected(*np,
769 lockdep_is_held(&tbl->lock))) != NULL) {
Eric Dumazete4c4e442009-07-30 03:15:07 +0000770 unsigned int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
Eric Dumazete4c4e442009-07-30 03:15:07 +0000772 write_lock(&n->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Eric Dumazete4c4e442009-07-30 03:15:07 +0000774 state = n->nud_state;
775 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
776 write_unlock(&n->lock);
777 goto next_elt;
778 }
779
780 if (time_before(n->used, n->confirmed))
781 n->used = n->confirmed;
782
783 if (atomic_read(&n->refcnt) == 1 &&
784 (state == NUD_FAILED ||
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100785 time_after(jiffies, n->used + NEIGH_VAR(n->parms, GC_STALETIME)))) {
Eric Dumazete4c4e442009-07-30 03:15:07 +0000786 *np = n->next;
787 n->dead = 1;
788 write_unlock(&n->lock);
789 neigh_cleanup_and_release(n);
790 continue;
791 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 write_unlock(&n->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
794next_elt:
Eric Dumazete4c4e442009-07-30 03:15:07 +0000795 np = &n->next;
796 }
797 /*
798 * It's fine to release lock here, even if hash table
799 * grows while we are preempted.
800 */
801 write_unlock_bh(&tbl->lock);
802 cond_resched();
803 write_lock_bh(&tbl->lock);
Michel Machado84338a62012-02-21 16:04:13 -0500804 nht = rcu_dereference_protected(tbl->nht,
805 lockdep_is_held(&tbl->lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 }
YOSHIFUJI Hideaki / 吉藤英明27246802013-01-22 05:20:05 +0000807out:
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100808 /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks.
809 * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2
810 * BASE_REACHABLE_TIME.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 */
viresh kumarf6180022014-01-22 12:23:33 +0530812 queue_delayed_work(system_power_efficient_wq, &tbl->gc_work,
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100813 NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME) >> 1);
Eric Dumazete4c4e442009-07-30 03:15:07 +0000814 write_unlock_bh(&tbl->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815}
816
817static __inline__ int neigh_max_probes(struct neighbour *n)
818{
819 struct neigh_parms *p = n->parms;
YOSHIFUJI Hideaki/吉藤英明8da86462015-03-19 22:41:46 +0900820 return NEIGH_VAR(p, UCAST_PROBES) + NEIGH_VAR(p, APP_PROBES) +
821 (n->nud_state & NUD_PROBE ? NEIGH_VAR(p, MCAST_REPROBES) :
822 NEIGH_VAR(p, MCAST_PROBES));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823}
824
Timo Teras5ef12d92009-06-11 04:16:28 -0700825static void neigh_invalidate(struct neighbour *neigh)
Eric Dumazet0a141502010-03-09 19:40:54 +0000826 __releases(neigh->lock)
827 __acquires(neigh->lock)
Timo Teras5ef12d92009-06-11 04:16:28 -0700828{
829 struct sk_buff *skb;
830
831 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
Joe Perchesd5d427c2013-04-15 15:17:19 +0000832 neigh_dbg(2, "neigh %p is failed\n", neigh);
Timo Teras5ef12d92009-06-11 04:16:28 -0700833 neigh->updated = jiffies;
834
835 /* It is very thin place. report_unreachable is very complicated
836 routine. Particularly, it can hit the same neighbour entry!
837
838 So that, we try to be accurate and avoid dead loop. --ANK
839 */
840 while (neigh->nud_state == NUD_FAILED &&
841 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
842 write_unlock(&neigh->lock);
843 neigh->ops->error_report(neigh, skb);
844 write_lock(&neigh->lock);
845 }
Eric Dumazetc9ab4d82013-06-28 02:37:42 -0700846 __skb_queue_purge(&neigh->arp_queue);
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000847 neigh->arp_queue_len_bytes = 0;
Timo Teras5ef12d92009-06-11 04:16:28 -0700848}
849
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000850static void neigh_probe(struct neighbour *neigh)
851 __releases(neigh->lock)
852{
Hannes Frederic Sowa4ed377e2013-09-21 06:32:34 +0200853 struct sk_buff *skb = skb_peek_tail(&neigh->arp_queue);
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000854 /* keep skb alive even if arp_queue overflows */
855 if (skb)
856 skb = skb_copy(skb, GFP_ATOMIC);
857 write_unlock(&neigh->lock);
858 neigh->ops->solicit(neigh, skb);
859 atomic_inc(&neigh->probes);
860 kfree_skb(skb);
861}
862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863/* Called when a timer expires for a neighbour entry. */
864
865static void neigh_timer_handler(unsigned long arg)
866{
867 unsigned long now, next;
868 struct neighbour *neigh = (struct neighbour *)arg;
Eric Dumazet95c96172012-04-15 05:58:06 +0000869 unsigned int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 int notify = 0;
871
872 write_lock(&neigh->lock);
873
874 state = neigh->nud_state;
875 now = jiffies;
876 next = now + HZ;
877
David S. Miller045f7b32011-11-01 17:45:55 -0400878 if (!(state & NUD_IN_TIMER))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
881 if (state & NUD_REACHABLE) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900882 if (time_before_eq(now,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 neigh->confirmed + neigh->parms->reachable_time)) {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000884 neigh_dbg(2, "neigh %p is still alive\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 next = neigh->confirmed + neigh->parms->reachable_time;
886 } else if (time_before_eq(now,
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100887 neigh->used +
888 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000889 neigh_dbg(2, "neigh %p is delayed\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 neigh->nud_state = NUD_DELAY;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800891 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 neigh_suspect(neigh);
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100893 next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 } else {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000895 neigh_dbg(2, "neigh %p is suspected\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 neigh->nud_state = NUD_STALE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800897 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 neigh_suspect(neigh);
Tom Tucker8d717402006-07-30 20:43:36 -0700899 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 }
901 } else if (state & NUD_DELAY) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900902 if (time_before_eq(now,
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100903 neigh->confirmed +
904 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000905 neigh_dbg(2, "neigh %p is now reachable\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 neigh->nud_state = NUD_REACHABLE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800907 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 neigh_connect(neigh);
Tom Tucker8d717402006-07-30 20:43:36 -0700909 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 next = neigh->confirmed + neigh->parms->reachable_time;
911 } else {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000912 neigh_dbg(2, "neigh %p is probed\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 neigh->nud_state = NUD_PROBE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800914 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 atomic_set(&neigh->probes, 0);
Erik Kline765c9c62015-05-18 19:44:41 +0900916 notify = 1;
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100917 next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 }
919 } else {
920 /* NUD_PROBE|NUD_INCOMPLETE */
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100921 next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 }
923
924 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
925 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 neigh->nud_state = NUD_FAILED;
927 notify = 1;
Timo Teras5ef12d92009-06-11 04:16:28 -0700928 neigh_invalidate(neigh);
Duan Jiong5e2c21d2014-02-27 17:03:03 +0800929 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 }
931
932 if (neigh->nud_state & NUD_IN_TIMER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 if (time_before(next, jiffies + HZ/2))
934 next = jiffies + HZ/2;
Herbert Xu6fb99742005-10-23 16:37:48 +1000935 if (!mod_timer(&neigh->timer, next))
936 neigh_hold(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 }
938 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000939 neigh_probe(neigh);
David S. Miller9ff56602008-02-17 18:39:54 -0800940 } else {
David S. Miller69cc64d2008-02-11 21:45:44 -0800941out:
David S. Miller9ff56602008-02-17 18:39:54 -0800942 write_unlock(&neigh->lock);
943 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
Thomas Grafd961db32007-08-08 23:12:56 -0700945 if (notify)
946 neigh_update_notify(neigh);
947
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 neigh_release(neigh);
949}
950
951int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
952{
953 int rc;
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000954 bool immediate_probe = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
956 write_lock_bh(&neigh->lock);
957
958 rc = 0;
959 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
960 goto out_unlock_bh;
Julian Anastasov2c51a972015-06-16 22:56:39 +0300961 if (neigh->dead)
962 goto out_dead;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100965 if (NEIGH_VAR(neigh->parms, MCAST_PROBES) +
966 NEIGH_VAR(neigh->parms, APP_PROBES)) {
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000967 unsigned long next, now = jiffies;
968
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100969 atomic_set(&neigh->probes,
970 NEIGH_VAR(neigh->parms, UCAST_PROBES));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 neigh->nud_state = NUD_INCOMPLETE;
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000972 neigh->updated = now;
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100973 next = now + max(NEIGH_VAR(neigh->parms, RETRANS_TIME),
974 HZ/2);
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000975 neigh_add_timer(neigh, next);
976 immediate_probe = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 } else {
978 neigh->nud_state = NUD_FAILED;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800979 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 write_unlock_bh(&neigh->lock);
981
Wei Yongjunf3fbbe02009-02-25 00:37:32 +0000982 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 return 1;
984 }
985 } else if (neigh->nud_state & NUD_STALE) {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000986 neigh_dbg(2, "neigh %p is delayed\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 neigh->nud_state = NUD_DELAY;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800988 neigh->updated = jiffies;
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100989 neigh_add_timer(neigh, jiffies +
990 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 }
992
993 if (neigh->nud_state == NUD_INCOMPLETE) {
994 if (skb) {
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000995 while (neigh->arp_queue_len_bytes + skb->truesize >
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100996 NEIGH_VAR(neigh->parms, QUEUE_LEN_BYTES)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 struct sk_buff *buff;
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000998
David S. Millerf72051b2008-09-23 01:11:18 -0700999 buff = __skb_dequeue(&neigh->arp_queue);
Eric Dumazet8b5c1712011-11-09 12:07:14 +00001000 if (!buff)
1001 break;
1002 neigh->arp_queue_len_bytes -= buff->truesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 kfree_skb(buff);
Neil Horman9a6d2762008-07-16 20:50:49 -07001004 NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 }
Eric Dumazeta4731132010-05-27 16:09:39 -07001006 skb_dst_force(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 __skb_queue_tail(&neigh->arp_queue, skb);
Eric Dumazet8b5c1712011-11-09 12:07:14 +00001008 neigh->arp_queue_len_bytes += skb->truesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 }
1010 rc = 1;
1011 }
1012out_unlock_bh:
Eric Dumazetcd28ca02011-08-09 08:15:58 +00001013 if (immediate_probe)
1014 neigh_probe(neigh);
1015 else
1016 write_unlock(&neigh->lock);
1017 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 return rc;
Julian Anastasov2c51a972015-06-16 22:56:39 +03001019
1020out_dead:
1021 if (neigh->nud_state & NUD_STALE)
1022 goto out_unlock_bh;
1023 write_unlock_bh(&neigh->lock);
1024 kfree_skb(skb);
1025 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001027EXPORT_SYMBOL(__neigh_event_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028
David S. Millerf6b72b62011-07-14 07:53:20 -07001029static void neigh_update_hhs(struct neighbour *neigh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030{
1031 struct hh_cache *hh;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001032 void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
Doug Kehn91a72a72010-07-14 18:02:16 -07001033 = NULL;
1034
1035 if (neigh->dev->header_ops)
1036 update = neigh->dev->header_ops->cache_update;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037
1038 if (update) {
David S. Millerf6b72b62011-07-14 07:53:20 -07001039 hh = &neigh->hh;
1040 if (hh->hh_len) {
Stephen Hemminger3644f0c2006-12-07 15:08:17 -08001041 write_seqlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 update(hh, neigh->dev, neigh->ha);
Stephen Hemminger3644f0c2006-12-07 15:08:17 -08001043 write_sequnlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 }
1045 }
1046}
1047
1048
1049
1050/* Generic update routine.
1051 -- lladdr is new lladdr or NULL, if it is not supplied.
1052 -- new is new state.
1053 -- flags
1054 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
1055 if it is different.
1056 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001057 lladdr instead of overriding it
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 if it is different.
1059 It also allows to retain current state
1060 if lladdr is unchanged.
1061 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
1062
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001063 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 NTF_ROUTER flag.
1065 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1066 a router.
1067
1068 Caller MUST hold reference count on the entry.
1069 */
1070
1071int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
1072 u32 flags)
1073{
1074 u8 old;
1075 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 int notify = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 struct net_device *dev;
1078 int update_isrouter = 0;
1079
1080 write_lock_bh(&neigh->lock);
1081
1082 dev = neigh->dev;
1083 old = neigh->nud_state;
1084 err = -EPERM;
1085
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001086 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 (old & (NUD_NOARP | NUD_PERMANENT)))
1088 goto out;
Julian Anastasov2c51a972015-06-16 22:56:39 +03001089 if (neigh->dead)
1090 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
1092 if (!(new & NUD_VALID)) {
1093 neigh_del_timer(neigh);
1094 if (old & NUD_CONNECTED)
1095 neigh_suspect(neigh);
1096 neigh->nud_state = new;
1097 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 notify = old & NUD_VALID;
Timo Teras5ef12d92009-06-11 04:16:28 -07001099 if ((old & (NUD_INCOMPLETE | NUD_PROBE)) &&
1100 (new & NUD_FAILED)) {
1101 neigh_invalidate(neigh);
1102 notify = 1;
1103 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 goto out;
1105 }
1106
1107 /* Compare new lladdr with cached one */
1108 if (!dev->addr_len) {
1109 /* First case: device needs no address. */
1110 lladdr = neigh->ha;
1111 } else if (lladdr) {
1112 /* The second case: if something is already cached
1113 and a new address is proposed:
1114 - compare new & old
1115 - if they are different, check override flag
1116 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001117 if ((old & NUD_VALID) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 !memcmp(lladdr, neigh->ha, dev->addr_len))
1119 lladdr = neigh->ha;
1120 } else {
1121 /* No address is supplied; if we know something,
1122 use it, otherwise discard the request.
1123 */
1124 err = -EINVAL;
1125 if (!(old & NUD_VALID))
1126 goto out;
1127 lladdr = neigh->ha;
1128 }
1129
1130 if (new & NUD_CONNECTED)
1131 neigh->confirmed = jiffies;
1132 neigh->updated = jiffies;
1133
1134 /* If entry was valid and address is not changed,
1135 do not change entry state, if new one is STALE.
1136 */
1137 err = 0;
1138 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1139 if (old & NUD_VALID) {
1140 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1141 update_isrouter = 0;
1142 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1143 (old & NUD_CONNECTED)) {
1144 lladdr = neigh->ha;
1145 new = NUD_STALE;
1146 } else
1147 goto out;
1148 } else {
1149 if (lladdr == neigh->ha && new == NUD_STALE &&
1150 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1151 (old & NUD_CONNECTED))
1152 )
1153 new = old;
1154 }
1155 }
1156
1157 if (new != old) {
1158 neigh_del_timer(neigh);
Erik Kline765c9c62015-05-18 19:44:41 +09001159 if (new & NUD_PROBE)
1160 atomic_set(&neigh->probes, 0);
Pavel Emelyanova43d8992007-12-20 15:49:05 -08001161 if (new & NUD_IN_TIMER)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001162 neigh_add_timer(neigh, (jiffies +
1163 ((new & NUD_REACHABLE) ?
David S. Miller667347f2005-09-27 12:07:44 -07001164 neigh->parms->reachable_time :
1165 0)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 neigh->nud_state = new;
Bob Gilligan53385d22013-12-15 13:39:56 -08001167 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 }
1169
1170 if (lladdr != neigh->ha) {
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001171 write_seqlock(&neigh->ha_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 memcpy(&neigh->ha, lladdr, dev->addr_len);
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001173 write_sequnlock(&neigh->ha_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 neigh_update_hhs(neigh);
1175 if (!(new & NUD_CONNECTED))
1176 neigh->confirmed = jiffies -
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001177 (NEIGH_VAR(neigh->parms, BASE_REACHABLE_TIME) << 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 }
1180 if (new == old)
1181 goto out;
1182 if (new & NUD_CONNECTED)
1183 neigh_connect(neigh);
1184 else
1185 neigh_suspect(neigh);
1186 if (!(old & NUD_VALID)) {
1187 struct sk_buff *skb;
1188
1189 /* Again: avoid dead loop if something went wrong */
1190
1191 while (neigh->nud_state & NUD_VALID &&
1192 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
David S. Miller69cce1d2011-07-17 23:09:49 -07001193 struct dst_entry *dst = skb_dst(skb);
1194 struct neighbour *n2, *n1 = neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 write_unlock_bh(&neigh->lock);
roy.qing.li@gmail.come049f282011-10-17 22:32:42 +00001196
1197 rcu_read_lock();
David S. Miller13a43d92012-07-02 22:15:37 -07001198
1199 /* Why not just use 'neigh' as-is? The problem is that
1200 * things such as shaper, eql, and sch_teql can end up
1201 * using alternative, different, neigh objects to output
1202 * the packet in the output path. So what we need to do
1203 * here is re-lookup the top-level neigh in the path so
1204 * we can reinject the packet there.
1205 */
1206 n2 = NULL;
1207 if (dst) {
1208 n2 = dst_neigh_lookup_skb(dst, skb);
1209 if (n2)
1210 n1 = n2;
1211 }
David S. Miller8f40b162011-07-17 13:34:11 -07001212 n1->output(n1, skb);
David S. Miller13a43d92012-07-02 22:15:37 -07001213 if (n2)
1214 neigh_release(n2);
roy.qing.li@gmail.come049f282011-10-17 22:32:42 +00001215 rcu_read_unlock();
1216
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 write_lock_bh(&neigh->lock);
1218 }
Eric Dumazetc9ab4d82013-06-28 02:37:42 -07001219 __skb_queue_purge(&neigh->arp_queue);
Eric Dumazet8b5c1712011-11-09 12:07:14 +00001220 neigh->arp_queue_len_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 }
1222out:
1223 if (update_isrouter) {
1224 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1225 (neigh->flags | NTF_ROUTER) :
1226 (neigh->flags & ~NTF_ROUTER);
1227 }
1228 write_unlock_bh(&neigh->lock);
Tom Tucker8d717402006-07-30 20:43:36 -07001229
1230 if (notify)
Thomas Grafd961db32007-08-08 23:12:56 -07001231 neigh_update_notify(neigh);
1232
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 return err;
1234}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001235EXPORT_SYMBOL(neigh_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236
Jiri Benc7e980562013-12-11 13:48:20 +01001237/* Update the neigh to listen temporarily for probe responses, even if it is
1238 * in a NUD_FAILED state. The caller has to hold neigh->lock for writing.
1239 */
1240void __neigh_set_probe_once(struct neighbour *neigh)
1241{
Julian Anastasov2c51a972015-06-16 22:56:39 +03001242 if (neigh->dead)
1243 return;
Jiri Benc7e980562013-12-11 13:48:20 +01001244 neigh->updated = jiffies;
1245 if (!(neigh->nud_state & NUD_FAILED))
1246 return;
Duan Jiong2176d5d2014-05-09 13:16:48 +08001247 neigh->nud_state = NUD_INCOMPLETE;
1248 atomic_set(&neigh->probes, neigh_max_probes(neigh));
Jiri Benc7e980562013-12-11 13:48:20 +01001249 neigh_add_timer(neigh,
1250 jiffies + NEIGH_VAR(neigh->parms, RETRANS_TIME));
1251}
1252EXPORT_SYMBOL(__neigh_set_probe_once);
1253
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1255 u8 *lladdr, void *saddr,
1256 struct net_device *dev)
1257{
1258 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1259 lladdr || !dev->addr_len);
1260 if (neigh)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001261 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 NEIGH_UPDATE_F_OVERRIDE);
1263 return neigh;
1264}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001265EXPORT_SYMBOL(neigh_event_ns);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
Eric Dumazet34d101d2010-10-11 09:16:57 -07001267/* called with read_lock_bh(&n->lock); */
Eric W. Biedermanbdf53c52015-03-02 00:13:22 -06001268static void neigh_hh_init(struct neighbour *n)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269{
Eric W. Biedermanbdf53c52015-03-02 00:13:22 -06001270 struct net_device *dev = n->dev;
1271 __be16 prot = n->tbl->protocol;
David S. Millerf6b72b62011-07-14 07:53:20 -07001272 struct hh_cache *hh = &n->hh;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001273
1274 write_lock_bh(&n->lock);
Eric Dumazet34d101d2010-10-11 09:16:57 -07001275
David S. Millerf6b72b62011-07-14 07:53:20 -07001276 /* Only one thread can come in here and initialize the
1277 * hh_cache entry.
1278 */
David S. Millerb23b5452011-07-16 17:45:02 -07001279 if (!hh->hh_len)
1280 dev->header_ops->cache(n, hh, prot);
David S. Millerf6b72b62011-07-14 07:53:20 -07001281
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001282 write_unlock_bh(&n->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283}
1284
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285/* Slow and careful. */
1286
David S. Miller8f40b162011-07-17 13:34:11 -07001287int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 int rc = 0;
1290
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 if (!neigh_event_send(neigh, skb)) {
1292 int err;
1293 struct net_device *dev = neigh->dev;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001294 unsigned int seq;
Eric Dumazet34d101d2010-10-11 09:16:57 -07001295
David S. Millerf6b72b62011-07-14 07:53:20 -07001296 if (dev->header_ops->cache && !neigh->hh.hh_len)
Eric W. Biedermanbdf53c52015-03-02 00:13:22 -06001297 neigh_hh_init(neigh);
Eric Dumazet34d101d2010-10-11 09:16:57 -07001298
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001299 do {
ramesh.nagappa@gmail.come1f16502012-10-05 19:10:15 +00001300 __skb_pull(skb, skb_network_offset(skb));
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001301 seq = read_seqbegin(&neigh->ha_lock);
1302 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1303 neigh->ha, NULL, skb->len);
1304 } while (read_seqretry(&neigh->ha_lock, seq));
Eric Dumazet34d101d2010-10-11 09:16:57 -07001305
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 if (err >= 0)
David S. Miller542d4d62011-07-16 18:06:24 -07001307 rc = dev_queue_xmit(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 else
1309 goto out_kfree_skb;
1310 }
1311out:
1312 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313out_kfree_skb:
1314 rc = -EINVAL;
1315 kfree_skb(skb);
1316 goto out;
1317}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001318EXPORT_SYMBOL(neigh_resolve_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
1320/* As fast as possible without hh cache */
1321
David S. Miller8f40b162011-07-17 13:34:11 -07001322int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 struct net_device *dev = neigh->dev;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001325 unsigned int seq;
David S. Miller8f40b162011-07-17 13:34:11 -07001326 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001328 do {
ramesh.nagappa@gmail.come1f16502012-10-05 19:10:15 +00001329 __skb_pull(skb, skb_network_offset(skb));
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001330 seq = read_seqbegin(&neigh->ha_lock);
1331 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1332 neigh->ha, NULL, skb->len);
1333 } while (read_seqretry(&neigh->ha_lock, seq));
1334
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 if (err >= 0)
David S. Miller542d4d62011-07-16 18:06:24 -07001336 err = dev_queue_xmit(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 else {
1338 err = -EINVAL;
1339 kfree_skb(skb);
1340 }
1341 return err;
1342}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001343EXPORT_SYMBOL(neigh_connected_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
David S. Miller8f40b162011-07-17 13:34:11 -07001345int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb)
1346{
1347 return dev_queue_xmit(skb);
1348}
1349EXPORT_SYMBOL(neigh_direct_output);
1350
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351static void neigh_proxy_process(unsigned long arg)
1352{
1353 struct neigh_table *tbl = (struct neigh_table *)arg;
1354 long sched_next = 0;
1355 unsigned long now = jiffies;
David S. Millerf72051b2008-09-23 01:11:18 -07001356 struct sk_buff *skb, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357
1358 spin_lock(&tbl->proxy_queue.lock);
1359
David S. Millerf72051b2008-09-23 01:11:18 -07001360 skb_queue_walk_safe(&tbl->proxy_queue, skb, n) {
1361 long tdif = NEIGH_CB(skb)->sched_next - now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 if (tdif <= 0) {
David S. Millerf72051b2008-09-23 01:11:18 -07001364 struct net_device *dev = skb->dev;
Eric Dumazet20e60742011-08-22 19:32:42 +00001365
David S. Millerf72051b2008-09-23 01:11:18 -07001366 __skb_unlink(skb, &tbl->proxy_queue);
Eric Dumazet20e60742011-08-22 19:32:42 +00001367 if (tbl->proxy_redo && netif_running(dev)) {
1368 rcu_read_lock();
David S. Millerf72051b2008-09-23 01:11:18 -07001369 tbl->proxy_redo(skb);
Eric Dumazet20e60742011-08-22 19:32:42 +00001370 rcu_read_unlock();
1371 } else {
David S. Millerf72051b2008-09-23 01:11:18 -07001372 kfree_skb(skb);
Eric Dumazet20e60742011-08-22 19:32:42 +00001373 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374
1375 dev_put(dev);
1376 } else if (!sched_next || tdif < sched_next)
1377 sched_next = tdif;
1378 }
1379 del_timer(&tbl->proxy_timer);
1380 if (sched_next)
1381 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1382 spin_unlock(&tbl->proxy_queue.lock);
1383}
1384
1385void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1386 struct sk_buff *skb)
1387{
1388 unsigned long now = jiffies;
Aruna-Hewapathirane63862b52014-01-11 07:15:59 -05001389
1390 unsigned long sched_next = now + (prandom_u32() %
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001391 NEIGH_VAR(p, PROXY_DELAY));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001393 if (tbl->proxy_queue.qlen > NEIGH_VAR(p, PROXY_QLEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 kfree_skb(skb);
1395 return;
1396 }
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001397
1398 NEIGH_CB(skb)->sched_next = sched_next;
1399 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400
1401 spin_lock(&tbl->proxy_queue.lock);
1402 if (del_timer(&tbl->proxy_timer)) {
1403 if (time_before(tbl->proxy_timer.expires, sched_next))
1404 sched_next = tbl->proxy_timer.expires;
1405 }
Eric Dumazetadf30902009-06-02 05:19:30 +00001406 skb_dst_drop(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 dev_hold(skb->dev);
1408 __skb_queue_tail(&tbl->proxy_queue, skb);
1409 mod_timer(&tbl->proxy_timer, sched_next);
1410 spin_unlock(&tbl->proxy_queue.lock);
1411}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001412EXPORT_SYMBOL(pneigh_enqueue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Tobias Klauser97fd5bc2009-07-13 11:17:49 -07001414static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl,
Eric W. Biederman426b5302008-01-24 00:13:18 -08001415 struct net *net, int ifindex)
1416{
1417 struct neigh_parms *p;
1418
Nicolas Dichtel75fbfd32014-10-29 19:29:31 +01001419 list_for_each_entry(p, &tbl->parms_list, list) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001420 if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) ||
Gao feng170d6f92013-06-20 10:01:33 +08001421 (!p->dev && !ifindex && net_eq(net, &init_net)))
Eric W. Biederman426b5302008-01-24 00:13:18 -08001422 return p;
1423 }
1424
1425 return NULL;
1426}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427
1428struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1429 struct neigh_table *tbl)
1430{
Gao fengcf89d6b2013-06-20 10:01:32 +08001431 struct neigh_parms *p;
Stephen Hemminger00829822008-11-20 20:14:53 -08001432 struct net *net = dev_net(dev);
1433 const struct net_device_ops *ops = dev->netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
Gao fengcf89d6b2013-06-20 10:01:32 +08001435 p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 p->tbl = tbl;
1438 atomic_set(&p->refcnt, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 p->reachable_time =
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001440 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
Denis V. Lunev486b51d2008-01-14 22:59:59 -08001441 dev_hold(dev);
1442 p->dev = dev;
Eric W. Biedermanefd7ef12015-03-11 23:04:08 -05001443 write_pnet(&p->net, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 p->sysctl_table = NULL;
Veaceslav Falico63134802013-08-02 19:07:38 +02001445
1446 if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) {
Veaceslav Falico63134802013-08-02 19:07:38 +02001447 dev_put(dev);
1448 kfree(p);
1449 return NULL;
1450 }
1451
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 write_lock_bh(&tbl->lock);
Nicolas Dichtel75fbfd32014-10-29 19:29:31 +01001453 list_add(&p->list, &tbl->parms.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 write_unlock_bh(&tbl->lock);
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01001455
1456 neigh_parms_data_state_cleanall(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 }
1458 return p;
1459}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001460EXPORT_SYMBOL(neigh_parms_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461
1462static void neigh_rcu_free_parms(struct rcu_head *head)
1463{
1464 struct neigh_parms *parms =
1465 container_of(head, struct neigh_parms, rcu_head);
1466
1467 neigh_parms_put(parms);
1468}
1469
1470void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1471{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 if (!parms || parms == &tbl->parms)
1473 return;
1474 write_lock_bh(&tbl->lock);
Nicolas Dichtel75fbfd32014-10-29 19:29:31 +01001475 list_del(&parms->list);
1476 parms->dead = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 write_unlock_bh(&tbl->lock);
Nicolas Dichtel75fbfd32014-10-29 19:29:31 +01001478 if (parms->dev)
1479 dev_put(parms->dev);
1480 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001482EXPORT_SYMBOL(neigh_parms_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483
Denis V. Lunev06f05112008-01-24 00:30:58 -08001484static void neigh_parms_destroy(struct neigh_parms *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485{
1486 kfree(parms);
1487}
1488
Pavel Emelianovc2ecba72007-04-17 12:45:31 -07001489static struct lock_class_key neigh_table_proxy_queue_class;
1490
WANG Congd7480fd2014-11-10 15:59:36 -08001491static struct neigh_table *neigh_tables[NEIGH_NR_TABLES] __read_mostly;
1492
1493void neigh_table_init(int index, struct neigh_table *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494{
1495 unsigned long now = jiffies;
1496 unsigned long phsize;
1497
Nicolas Dichtel75fbfd32014-10-29 19:29:31 +01001498 INIT_LIST_HEAD(&tbl->parms_list);
1499 list_add(&tbl->parms.list, &tbl->parms_list);
Eric Dumazete42ea982008-11-12 00:54:54 -08001500 write_pnet(&tbl->parms.net, &init_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 atomic_set(&tbl->parms.refcnt, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 tbl->parms.reachable_time =
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001503 neigh_rand_reach_time(NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 tbl->stats = alloc_percpu(struct neigh_statistics);
1506 if (!tbl->stats)
1507 panic("cannot create neighbour cache statistics");
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001508
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509#ifdef CONFIG_PROC_FS
Alexey Dobriyan9b739ba2008-11-11 16:47:44 -08001510 if (!proc_create_data(tbl->id, 0, init_net.proc_net_stat,
1511 &neigh_stat_seq_fops, tbl))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 panic("cannot create neighbour proc dir entry");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513#endif
1514
David S. Millercd089332011-07-11 01:28:12 -07001515 RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
1517 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
Andrew Morton77d04bd2006-04-07 14:52:59 -07001518 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519
Eric Dumazetd6bf7812010-10-04 06:15:44 +00001520 if (!tbl->nht || !tbl->phash_buckets)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 panic("cannot allocate neighbour cache hashes");
1522
YOSHIFUJI Hideaki / 吉藤英明08433ef2013-01-24 00:44:23 +00001523 if (!tbl->entry_size)
1524 tbl->entry_size = ALIGN(offsetof(struct neighbour, primary_key) +
1525 tbl->key_len, NEIGH_PRIV_ALIGN);
1526 else
1527 WARN_ON(tbl->entry_size % NEIGH_PRIV_ALIGN);
1528
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 rwlock_init(&tbl->lock);
Tejun Heo203b42f2012-08-21 13:18:23 -07001530 INIT_DEFERRABLE_WORK(&tbl->gc_work, neigh_periodic_work);
viresh kumarf6180022014-01-22 12:23:33 +05301531 queue_delayed_work(system_power_efficient_wq, &tbl->gc_work,
1532 tbl->parms.reachable_time);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -08001533 setup_timer(&tbl->proxy_timer, neigh_proxy_process, (unsigned long)tbl);
Pavel Emelianovc2ecba72007-04-17 12:45:31 -07001534 skb_queue_head_init_class(&tbl->proxy_queue,
1535 &neigh_table_proxy_queue_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536
1537 tbl->last_flush = now;
1538 tbl->last_rand = now + tbl->parms.reachable_time * 20;
Simon Kelleybd89efc2006-05-12 14:56:08 -07001539
WANG Congd7480fd2014-11-10 15:59:36 -08001540 neigh_tables[index] = tbl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001542EXPORT_SYMBOL(neigh_table_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543
WANG Congd7480fd2014-11-10 15:59:36 -08001544int neigh_table_clear(int index, struct neigh_table *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545{
WANG Congd7480fd2014-11-10 15:59:36 -08001546 neigh_tables[index] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 /* It is not clean... Fix it to unload IPv6 module safely */
Tejun Heoa5c30b32010-10-19 06:04:42 +00001548 cancel_delayed_work_sync(&tbl->gc_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 del_timer_sync(&tbl->proxy_timer);
1550 pneigh_queue_purge(&tbl->proxy_queue);
1551 neigh_ifdown(tbl, NULL);
1552 if (atomic_read(&tbl->entries))
Joe Perchese005d192012-05-16 19:58:40 +00001553 pr_crit("neighbour leakage\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554
Eric Dumazet6193d2b2011-01-19 22:02:47 +00001555 call_rcu(&rcu_dereference_protected(tbl->nht, 1)->rcu,
1556 neigh_hash_free_rcu);
Eric Dumazetd6bf7812010-10-04 06:15:44 +00001557 tbl->nht = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558
1559 kfree(tbl->phash_buckets);
1560 tbl->phash_buckets = NULL;
1561
Alexey Dobriyan3f192b52007-11-05 21:28:13 -08001562 remove_proc_entry(tbl->id, init_net.proc_net_stat);
1563
Kirill Korotaev3fcde742006-09-01 01:34:10 -07001564 free_percpu(tbl->stats);
1565 tbl->stats = NULL;
1566
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 return 0;
1568}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001569EXPORT_SYMBOL(neigh_table_clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
WANG Congd7480fd2014-11-10 15:59:36 -08001571static struct neigh_table *neigh_find_table(int family)
1572{
1573 struct neigh_table *tbl = NULL;
1574
1575 switch (family) {
1576 case AF_INET:
1577 tbl = neigh_tables[NEIGH_ARP_TABLE];
1578 break;
1579 case AF_INET6:
1580 tbl = neigh_tables[NEIGH_ND_TABLE];
1581 break;
1582 case AF_DECnet:
1583 tbl = neigh_tables[NEIGH_DN_TABLE];
1584 break;
1585 }
1586
1587 return tbl;
1588}
1589
Thomas Graf661d2962013-03-21 07:45:29 +00001590static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001592 struct net *net = sock_net(skb->sk);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001593 struct ndmsg *ndm;
1594 struct nlattr *dst_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 struct neigh_table *tbl;
WANG Congd7480fd2014-11-10 15:59:36 -08001596 struct neighbour *neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 struct net_device *dev = NULL;
Thomas Grafa14a49d2006-08-07 17:53:08 -07001598 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
Eric Dumazet110b2492010-10-04 04:27:36 +00001600 ASSERT_RTNL();
Thomas Grafa14a49d2006-08-07 17:53:08 -07001601 if (nlmsg_len(nlh) < sizeof(*ndm))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 goto out;
1603
Thomas Grafa14a49d2006-08-07 17:53:08 -07001604 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1605 if (dst_attr == NULL)
1606 goto out;
1607
1608 ndm = nlmsg_data(nlh);
1609 if (ndm->ndm_ifindex) {
Eric Dumazet110b2492010-10-04 04:27:36 +00001610 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001611 if (dev == NULL) {
1612 err = -ENODEV;
1613 goto out;
1614 }
1615 }
1616
WANG Congd7480fd2014-11-10 15:59:36 -08001617 tbl = neigh_find_table(ndm->ndm_family);
1618 if (tbl == NULL)
1619 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620
WANG Congd7480fd2014-11-10 15:59:36 -08001621 if (nla_len(dst_attr) < tbl->key_len)
1622 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623
WANG Congd7480fd2014-11-10 15:59:36 -08001624 if (ndm->ndm_flags & NTF_PROXY) {
1625 err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
Eric Dumazet110b2492010-10-04 04:27:36 +00001626 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 }
WANG Congd7480fd2014-11-10 15:59:36 -08001628
1629 if (dev == NULL)
1630 goto out;
1631
1632 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1633 if (neigh == NULL) {
1634 err = -ENOENT;
1635 goto out;
1636 }
1637
1638 err = neigh_update(neigh, NULL, NUD_FAILED,
1639 NEIGH_UPDATE_F_OVERRIDE |
1640 NEIGH_UPDATE_F_ADMIN);
1641 neigh_release(neigh);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001642
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643out:
1644 return err;
1645}
1646
Thomas Graf661d2962013-03-21 07:45:29 +00001647static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648{
WANG Congd7480fd2014-11-10 15:59:36 -08001649 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001650 struct net *net = sock_net(skb->sk);
Thomas Graf5208deb2006-08-07 17:55:40 -07001651 struct ndmsg *ndm;
1652 struct nlattr *tb[NDA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 struct neigh_table *tbl;
1654 struct net_device *dev = NULL;
WANG Congd7480fd2014-11-10 15:59:36 -08001655 struct neighbour *neigh;
1656 void *dst, *lladdr;
Thomas Graf5208deb2006-08-07 17:55:40 -07001657 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658
Eric Dumazet110b2492010-10-04 04:27:36 +00001659 ASSERT_RTNL();
Thomas Graf5208deb2006-08-07 17:55:40 -07001660 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
1661 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 goto out;
1663
Thomas Graf5208deb2006-08-07 17:55:40 -07001664 err = -EINVAL;
1665 if (tb[NDA_DST] == NULL)
1666 goto out;
1667
1668 ndm = nlmsg_data(nlh);
1669 if (ndm->ndm_ifindex) {
Eric Dumazet110b2492010-10-04 04:27:36 +00001670 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
Thomas Graf5208deb2006-08-07 17:55:40 -07001671 if (dev == NULL) {
1672 err = -ENODEV;
1673 goto out;
1674 }
1675
1676 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
Eric Dumazet110b2492010-10-04 04:27:36 +00001677 goto out;
Thomas Graf5208deb2006-08-07 17:55:40 -07001678 }
1679
WANG Congd7480fd2014-11-10 15:59:36 -08001680 tbl = neigh_find_table(ndm->ndm_family);
1681 if (tbl == NULL)
1682 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683
WANG Congd7480fd2014-11-10 15:59:36 -08001684 if (nla_len(tb[NDA_DST]) < tbl->key_len)
1685 goto out;
1686 dst = nla_data(tb[NDA_DST]);
1687 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688
WANG Congd7480fd2014-11-10 15:59:36 -08001689 if (ndm->ndm_flags & NTF_PROXY) {
1690 struct pneigh_entry *pn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691
WANG Congd7480fd2014-11-10 15:59:36 -08001692 err = -ENOBUFS;
1693 pn = pneigh_lookup(tbl, net, dst, dev, 1);
1694 if (pn) {
1695 pn->flags = ndm->ndm_flags;
Eric Biederman0c5c2d32009-03-04 00:03:08 -08001696 err = 0;
WANG Congd7480fd2014-11-10 15:59:36 -08001697 }
Eric Dumazet110b2492010-10-04 04:27:36 +00001698 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 }
1700
WANG Congd7480fd2014-11-10 15:59:36 -08001701 if (dev == NULL)
1702 goto out;
1703
1704 neigh = neigh_lookup(tbl, dst, dev);
1705 if (neigh == NULL) {
1706 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1707 err = -ENOENT;
1708 goto out;
1709 }
1710
1711 neigh = __neigh_lookup_errno(tbl, dst, dev);
1712 if (IS_ERR(neigh)) {
1713 err = PTR_ERR(neigh);
1714 goto out;
1715 }
1716 } else {
1717 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1718 err = -EEXIST;
1719 neigh_release(neigh);
1720 goto out;
1721 }
1722
1723 if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
1724 flags &= ~NEIGH_UPDATE_F_OVERRIDE;
1725 }
1726
1727 if (ndm->ndm_flags & NTF_USE) {
1728 neigh_event_send(neigh, NULL);
1729 err = 0;
1730 } else
1731 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
1732 neigh_release(neigh);
1733
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734out:
1735 return err;
1736}
1737
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001738static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1739{
Thomas Grafca860fb2006-08-07 18:00:18 -07001740 struct nlattr *nest;
1741
1742 nest = nla_nest_start(skb, NDTA_PARMS);
1743 if (nest == NULL)
1744 return -ENOBUFS;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001745
David S. Miller9a6308d2012-04-01 20:06:28 -04001746 if ((parms->dev &&
1747 nla_put_u32(skb, NDTPA_IFINDEX, parms->dev->ifindex)) ||
1748 nla_put_u32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt)) ||
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001749 nla_put_u32(skb, NDTPA_QUEUE_LENBYTES,
1750 NEIGH_VAR(parms, QUEUE_LEN_BYTES)) ||
David S. Miller9a6308d2012-04-01 20:06:28 -04001751 /* approximative value for deprecated QUEUE_LEN (in packets) */
1752 nla_put_u32(skb, NDTPA_QUEUE_LEN,
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001753 NEIGH_VAR(parms, QUEUE_LEN_BYTES) / SKB_TRUESIZE(ETH_FRAME_LEN)) ||
1754 nla_put_u32(skb, NDTPA_PROXY_QLEN, NEIGH_VAR(parms, PROXY_QLEN)) ||
1755 nla_put_u32(skb, NDTPA_APP_PROBES, NEIGH_VAR(parms, APP_PROBES)) ||
1756 nla_put_u32(skb, NDTPA_UCAST_PROBES,
1757 NEIGH_VAR(parms, UCAST_PROBES)) ||
1758 nla_put_u32(skb, NDTPA_MCAST_PROBES,
1759 NEIGH_VAR(parms, MCAST_PROBES)) ||
YOSHIFUJI Hideaki/吉藤英明8da86462015-03-19 22:41:46 +09001760 nla_put_u32(skb, NDTPA_MCAST_REPROBES,
1761 NEIGH_VAR(parms, MCAST_REPROBES)) ||
David S. Miller9a6308d2012-04-01 20:06:28 -04001762 nla_put_msecs(skb, NDTPA_REACHABLE_TIME, parms->reachable_time) ||
1763 nla_put_msecs(skb, NDTPA_BASE_REACHABLE_TIME,
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001764 NEIGH_VAR(parms, BASE_REACHABLE_TIME)) ||
1765 nla_put_msecs(skb, NDTPA_GC_STALETIME,
1766 NEIGH_VAR(parms, GC_STALETIME)) ||
David S. Miller9a6308d2012-04-01 20:06:28 -04001767 nla_put_msecs(skb, NDTPA_DELAY_PROBE_TIME,
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001768 NEIGH_VAR(parms, DELAY_PROBE_TIME)) ||
1769 nla_put_msecs(skb, NDTPA_RETRANS_TIME,
1770 NEIGH_VAR(parms, RETRANS_TIME)) ||
1771 nla_put_msecs(skb, NDTPA_ANYCAST_DELAY,
1772 NEIGH_VAR(parms, ANYCAST_DELAY)) ||
1773 nla_put_msecs(skb, NDTPA_PROXY_DELAY,
1774 NEIGH_VAR(parms, PROXY_DELAY)) ||
1775 nla_put_msecs(skb, NDTPA_LOCKTIME,
1776 NEIGH_VAR(parms, LOCKTIME)))
David S. Miller9a6308d2012-04-01 20:06:28 -04001777 goto nla_put_failure;
Thomas Grafca860fb2006-08-07 18:00:18 -07001778 return nla_nest_end(skb, nest);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001779
Thomas Grafca860fb2006-08-07 18:00:18 -07001780nla_put_failure:
Thomas Grafbc3ed282008-06-03 16:36:54 -07001781 nla_nest_cancel(skb, nest);
1782 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001783}
1784
Thomas Grafca860fb2006-08-07 18:00:18 -07001785static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
1786 u32 pid, u32 seq, int type, int flags)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001787{
1788 struct nlmsghdr *nlh;
1789 struct ndtmsg *ndtmsg;
1790
Thomas Grafca860fb2006-08-07 18:00:18 -07001791 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1792 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001793 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001794
Thomas Grafca860fb2006-08-07 18:00:18 -07001795 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001796
1797 read_lock_bh(&tbl->lock);
1798 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001799 ndtmsg->ndtm_pad1 = 0;
1800 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001801
David S. Miller9a6308d2012-04-01 20:06:28 -04001802 if (nla_put_string(skb, NDTA_NAME, tbl->id) ||
1803 nla_put_msecs(skb, NDTA_GC_INTERVAL, tbl->gc_interval) ||
1804 nla_put_u32(skb, NDTA_THRESH1, tbl->gc_thresh1) ||
1805 nla_put_u32(skb, NDTA_THRESH2, tbl->gc_thresh2) ||
1806 nla_put_u32(skb, NDTA_THRESH3, tbl->gc_thresh3))
1807 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001808 {
1809 unsigned long now = jiffies;
1810 unsigned int flush_delta = now - tbl->last_flush;
1811 unsigned int rand_delta = now - tbl->last_rand;
Eric Dumazetd6bf7812010-10-04 06:15:44 +00001812 struct neigh_hash_table *nht;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001813 struct ndt_config ndc = {
1814 .ndtc_key_len = tbl->key_len,
1815 .ndtc_entry_size = tbl->entry_size,
1816 .ndtc_entries = atomic_read(&tbl->entries),
1817 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
1818 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001819 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
1820 };
1821
Eric Dumazetd6bf7812010-10-04 06:15:44 +00001822 rcu_read_lock_bh();
1823 nht = rcu_dereference_bh(tbl->nht);
David S. Miller2c2aba62011-12-28 15:06:58 -05001824 ndc.ndtc_hash_rnd = nht->hash_rnd[0];
David S. Millercd089332011-07-11 01:28:12 -07001825 ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1);
Eric Dumazetd6bf7812010-10-04 06:15:44 +00001826 rcu_read_unlock_bh();
1827
David S. Miller9a6308d2012-04-01 20:06:28 -04001828 if (nla_put(skb, NDTA_CONFIG, sizeof(ndc), &ndc))
1829 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001830 }
1831
1832 {
1833 int cpu;
1834 struct ndt_stats ndst;
1835
1836 memset(&ndst, 0, sizeof(ndst));
1837
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -07001838 for_each_possible_cpu(cpu) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001839 struct neigh_statistics *st;
1840
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001841 st = per_cpu_ptr(tbl->stats, cpu);
1842 ndst.ndts_allocs += st->allocs;
1843 ndst.ndts_destroys += st->destroys;
1844 ndst.ndts_hash_grows += st->hash_grows;
1845 ndst.ndts_res_failed += st->res_failed;
1846 ndst.ndts_lookups += st->lookups;
1847 ndst.ndts_hits += st->hits;
1848 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1849 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1850 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1851 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1852 }
1853
David S. Miller9a6308d2012-04-01 20:06:28 -04001854 if (nla_put(skb, NDTA_STATS, sizeof(ndst), &ndst))
1855 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001856 }
1857
1858 BUG_ON(tbl->parms.dev);
1859 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
Thomas Grafca860fb2006-08-07 18:00:18 -07001860 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001861
1862 read_unlock_bh(&tbl->lock);
Johannes Berg053c0952015-01-16 22:09:00 +01001863 nlmsg_end(skb, nlh);
1864 return 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001865
Thomas Grafca860fb2006-08-07 18:00:18 -07001866nla_put_failure:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001867 read_unlock_bh(&tbl->lock);
Patrick McHardy26932562007-01-31 23:16:40 -08001868 nlmsg_cancel(skb, nlh);
1869 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001870}
1871
Thomas Grafca860fb2006-08-07 18:00:18 -07001872static int neightbl_fill_param_info(struct sk_buff *skb,
1873 struct neigh_table *tbl,
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001874 struct neigh_parms *parms,
Thomas Grafca860fb2006-08-07 18:00:18 -07001875 u32 pid, u32 seq, int type,
1876 unsigned int flags)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001877{
1878 struct ndtmsg *ndtmsg;
1879 struct nlmsghdr *nlh;
1880
Thomas Grafca860fb2006-08-07 18:00:18 -07001881 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1882 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001883 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001884
Thomas Grafca860fb2006-08-07 18:00:18 -07001885 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001886
1887 read_lock_bh(&tbl->lock);
1888 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001889 ndtmsg->ndtm_pad1 = 0;
1890 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001891
Thomas Grafca860fb2006-08-07 18:00:18 -07001892 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
1893 neightbl_fill_parms(skb, parms) < 0)
1894 goto errout;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001895
1896 read_unlock_bh(&tbl->lock);
Johannes Berg053c0952015-01-16 22:09:00 +01001897 nlmsg_end(skb, nlh);
1898 return 0;
Thomas Grafca860fb2006-08-07 18:00:18 -07001899errout:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001900 read_unlock_bh(&tbl->lock);
Patrick McHardy26932562007-01-31 23:16:40 -08001901 nlmsg_cancel(skb, nlh);
1902 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001903}
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001904
Patrick McHardyef7c79e2007-06-05 12:38:30 -07001905static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
Thomas Graf6b3f8672006-08-07 17:58:53 -07001906 [NDTA_NAME] = { .type = NLA_STRING },
1907 [NDTA_THRESH1] = { .type = NLA_U32 },
1908 [NDTA_THRESH2] = { .type = NLA_U32 },
1909 [NDTA_THRESH3] = { .type = NLA_U32 },
1910 [NDTA_GC_INTERVAL] = { .type = NLA_U64 },
1911 [NDTA_PARMS] = { .type = NLA_NESTED },
1912};
1913
Patrick McHardyef7c79e2007-06-05 12:38:30 -07001914static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
Thomas Graf6b3f8672006-08-07 17:58:53 -07001915 [NDTPA_IFINDEX] = { .type = NLA_U32 },
1916 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 },
1917 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 },
1918 [NDTPA_APP_PROBES] = { .type = NLA_U32 },
1919 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 },
1920 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 },
YOSHIFUJI Hideaki/吉藤英明8da86462015-03-19 22:41:46 +09001921 [NDTPA_MCAST_REPROBES] = { .type = NLA_U32 },
Thomas Graf6b3f8672006-08-07 17:58:53 -07001922 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 },
1923 [NDTPA_GC_STALETIME] = { .type = NLA_U64 },
1924 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 },
1925 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 },
1926 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 },
1927 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 },
1928 [NDTPA_LOCKTIME] = { .type = NLA_U64 },
1929};
1930
Thomas Graf661d2962013-03-21 07:45:29 +00001931static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001932{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001933 struct net *net = sock_net(skb->sk);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001934 struct neigh_table *tbl;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001935 struct ndtmsg *ndtmsg;
1936 struct nlattr *tb[NDTA_MAX+1];
WANG Congd7480fd2014-11-10 15:59:36 -08001937 bool found = false;
1938 int err, tidx;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001939
Thomas Graf6b3f8672006-08-07 17:58:53 -07001940 err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
1941 nl_neightbl_policy);
1942 if (err < 0)
1943 goto errout;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001944
Thomas Graf6b3f8672006-08-07 17:58:53 -07001945 if (tb[NDTA_NAME] == NULL) {
1946 err = -EINVAL;
1947 goto errout;
1948 }
1949
1950 ndtmsg = nlmsg_data(nlh);
WANG Congd7480fd2014-11-10 15:59:36 -08001951
1952 for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) {
1953 tbl = neigh_tables[tidx];
1954 if (!tbl)
1955 continue;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001956 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1957 continue;
WANG Congd7480fd2014-11-10 15:59:36 -08001958 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0) {
1959 found = true;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001960 break;
WANG Congd7480fd2014-11-10 15:59:36 -08001961 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001962 }
1963
WANG Congd7480fd2014-11-10 15:59:36 -08001964 if (!found)
1965 return -ENOENT;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001966
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001967 /*
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001968 * We acquire tbl->lock to be nice to the periodic timers and
1969 * make sure they always see a consistent set of values.
1970 */
1971 write_lock_bh(&tbl->lock);
1972
Thomas Graf6b3f8672006-08-07 17:58:53 -07001973 if (tb[NDTA_PARMS]) {
1974 struct nlattr *tbp[NDTPA_MAX+1];
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001975 struct neigh_parms *p;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001976 int i, ifindex = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001977
Thomas Graf6b3f8672006-08-07 17:58:53 -07001978 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
1979 nl_ntbl_parm_policy);
1980 if (err < 0)
1981 goto errout_tbl_lock;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001982
Thomas Graf6b3f8672006-08-07 17:58:53 -07001983 if (tbp[NDTPA_IFINDEX])
1984 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001985
Tobias Klauser97fd5bc2009-07-13 11:17:49 -07001986 p = lookup_neigh_parms(tbl, net, ifindex);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001987 if (p == NULL) {
1988 err = -ENOENT;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001989 goto errout_tbl_lock;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001990 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001991
Thomas Graf6b3f8672006-08-07 17:58:53 -07001992 for (i = 1; i <= NDTPA_MAX; i++) {
1993 if (tbp[i] == NULL)
1994 continue;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001995
Thomas Graf6b3f8672006-08-07 17:58:53 -07001996 switch (i) {
1997 case NDTPA_QUEUE_LEN:
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001998 NEIGH_VAR_SET(p, QUEUE_LEN_BYTES,
1999 nla_get_u32(tbp[i]) *
2000 SKB_TRUESIZE(ETH_FRAME_LEN));
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002001 break;
2002 case NDTPA_QUEUE_LENBYTES:
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002003 NEIGH_VAR_SET(p, QUEUE_LEN_BYTES,
2004 nla_get_u32(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002005 break;
2006 case NDTPA_PROXY_QLEN:
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002007 NEIGH_VAR_SET(p, PROXY_QLEN,
2008 nla_get_u32(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002009 break;
2010 case NDTPA_APP_PROBES:
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002011 NEIGH_VAR_SET(p, APP_PROBES,
2012 nla_get_u32(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002013 break;
2014 case NDTPA_UCAST_PROBES:
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002015 NEIGH_VAR_SET(p, UCAST_PROBES,
2016 nla_get_u32(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002017 break;
2018 case NDTPA_MCAST_PROBES:
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002019 NEIGH_VAR_SET(p, MCAST_PROBES,
2020 nla_get_u32(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002021 break;
YOSHIFUJI Hideaki/吉藤英明8da86462015-03-19 22:41:46 +09002022 case NDTPA_MCAST_REPROBES:
2023 NEIGH_VAR_SET(p, MCAST_REPROBES,
2024 nla_get_u32(tbp[i]));
2025 break;
Thomas Graf6b3f8672006-08-07 17:58:53 -07002026 case NDTPA_BASE_REACHABLE_TIME:
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002027 NEIGH_VAR_SET(p, BASE_REACHABLE_TIME,
2028 nla_get_msecs(tbp[i]));
Jean-Francois Remy4bf69802015-01-14 04:22:39 +01002029 /* update reachable_time as well, otherwise, the change will
2030 * only be effective after the next time neigh_periodic_work
2031 * decides to recompute it (can be multiple minutes)
2032 */
2033 p->reachable_time =
2034 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002035 break;
2036 case NDTPA_GC_STALETIME:
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002037 NEIGH_VAR_SET(p, GC_STALETIME,
2038 nla_get_msecs(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002039 break;
2040 case NDTPA_DELAY_PROBE_TIME:
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002041 NEIGH_VAR_SET(p, DELAY_PROBE_TIME,
2042 nla_get_msecs(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002043 break;
2044 case NDTPA_RETRANS_TIME:
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002045 NEIGH_VAR_SET(p, RETRANS_TIME,
2046 nla_get_msecs(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002047 break;
2048 case NDTPA_ANYCAST_DELAY:
Jiri Pirko39774582014-01-14 15:46:07 +01002049 NEIGH_VAR_SET(p, ANYCAST_DELAY,
2050 nla_get_msecs(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002051 break;
2052 case NDTPA_PROXY_DELAY:
Jiri Pirko39774582014-01-14 15:46:07 +01002053 NEIGH_VAR_SET(p, PROXY_DELAY,
2054 nla_get_msecs(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002055 break;
2056 case NDTPA_LOCKTIME:
Jiri Pirko39774582014-01-14 15:46:07 +01002057 NEIGH_VAR_SET(p, LOCKTIME,
2058 nla_get_msecs(tbp[i]));
Thomas Graf6b3f8672006-08-07 17:58:53 -07002059 break;
2060 }
2061 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002062 }
2063
Gao fengdc25c672013-06-20 10:01:34 +08002064 err = -ENOENT;
2065 if ((tb[NDTA_THRESH1] || tb[NDTA_THRESH2] ||
2066 tb[NDTA_THRESH3] || tb[NDTA_GC_INTERVAL]) &&
2067 !net_eq(net, &init_net))
2068 goto errout_tbl_lock;
2069
Thomas Graf6b3f8672006-08-07 17:58:53 -07002070 if (tb[NDTA_THRESH1])
2071 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
2072
2073 if (tb[NDTA_THRESH2])
2074 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
2075
2076 if (tb[NDTA_THRESH3])
2077 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
2078
2079 if (tb[NDTA_GC_INTERVAL])
2080 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
2081
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002082 err = 0;
2083
Thomas Graf6b3f8672006-08-07 17:58:53 -07002084errout_tbl_lock:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002085 write_unlock_bh(&tbl->lock);
Thomas Graf6b3f8672006-08-07 17:58:53 -07002086errout:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002087 return err;
2088}
2089
Thomas Grafc8822a42007-03-22 11:50:06 -07002090static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002091{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002092 struct net *net = sock_net(skb->sk);
Thomas Grafca860fb2006-08-07 18:00:18 -07002093 int family, tidx, nidx = 0;
2094 int tbl_skip = cb->args[0];
2095 int neigh_skip = cb->args[1];
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002096 struct neigh_table *tbl;
2097
Thomas Grafca860fb2006-08-07 18:00:18 -07002098 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002099
WANG Congd7480fd2014-11-10 15:59:36 -08002100 for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002101 struct neigh_parms *p;
2102
WANG Congd7480fd2014-11-10 15:59:36 -08002103 tbl = neigh_tables[tidx];
2104 if (!tbl)
2105 continue;
2106
Thomas Grafca860fb2006-08-07 18:00:18 -07002107 if (tidx < tbl_skip || (family && tbl->family != family))
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002108 continue;
2109
Eric W. Biederman15e47302012-09-07 20:12:54 +00002110 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).portid,
Thomas Grafca860fb2006-08-07 18:00:18 -07002111 cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
David S. Miller7b46a642015-01-18 23:36:08 -05002112 NLM_F_MULTI) < 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002113 break;
2114
Nicolas Dichtel75fbfd32014-10-29 19:29:31 +01002115 nidx = 0;
2116 p = list_next_entry(&tbl->parms, list);
2117 list_for_each_entry_from(p, &tbl->parms_list, list) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002118 if (!net_eq(neigh_parms_net(p), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002119 continue;
2120
Gautam Kachrooefc683f2009-02-06 00:52:04 -08002121 if (nidx < neigh_skip)
2122 goto next;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002123
Thomas Grafca860fb2006-08-07 18:00:18 -07002124 if (neightbl_fill_param_info(skb, tbl, p,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002125 NETLINK_CB(cb->skb).portid,
Thomas Grafca860fb2006-08-07 18:00:18 -07002126 cb->nlh->nlmsg_seq,
2127 RTM_NEWNEIGHTBL,
David S. Miller7b46a642015-01-18 23:36:08 -05002128 NLM_F_MULTI) < 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002129 goto out;
Gautam Kachrooefc683f2009-02-06 00:52:04 -08002130 next:
2131 nidx++;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002132 }
2133
Thomas Grafca860fb2006-08-07 18:00:18 -07002134 neigh_skip = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002135 }
2136out:
Thomas Grafca860fb2006-08-07 18:00:18 -07002137 cb->args[0] = tidx;
2138 cb->args[1] = nidx;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002139
2140 return skb->len;
2141}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142
Thomas Graf8b8aec52006-08-07 17:56:37 -07002143static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
2144 u32 pid, u32 seq, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145{
2146 unsigned long now = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147 struct nda_cacheinfo ci;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002148 struct nlmsghdr *nlh;
2149 struct ndmsg *ndm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150
Thomas Graf8b8aec52006-08-07 17:56:37 -07002151 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2152 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08002153 return -EMSGSIZE;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002154
2155 ndm = nlmsg_data(nlh);
2156 ndm->ndm_family = neigh->ops->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07002157 ndm->ndm_pad1 = 0;
2158 ndm->ndm_pad2 = 0;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002159 ndm->ndm_flags = neigh->flags;
2160 ndm->ndm_type = neigh->type;
2161 ndm->ndm_ifindex = neigh->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162
David S. Miller9a6308d2012-04-01 20:06:28 -04002163 if (nla_put(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key))
2164 goto nla_put_failure;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002165
2166 read_lock_bh(&neigh->lock);
2167 ndm->ndm_state = neigh->nud_state;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00002168 if (neigh->nud_state & NUD_VALID) {
2169 char haddr[MAX_ADDR_LEN];
2170
2171 neigh_ha_snapshot(haddr, neigh, neigh->dev);
2172 if (nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, haddr) < 0) {
2173 read_unlock_bh(&neigh->lock);
2174 goto nla_put_failure;
2175 }
Thomas Graf8b8aec52006-08-07 17:56:37 -07002176 }
2177
Stephen Hemmingerb9f5f522008-06-03 16:03:15 -07002178 ci.ndm_used = jiffies_to_clock_t(now - neigh->used);
2179 ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
2180 ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002181 ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1;
2182 read_unlock_bh(&neigh->lock);
2183
David S. Miller9a6308d2012-04-01 20:06:28 -04002184 if (nla_put_u32(skb, NDA_PROBES, atomic_read(&neigh->probes)) ||
2185 nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
2186 goto nla_put_failure;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002187
Johannes Berg053c0952015-01-16 22:09:00 +01002188 nlmsg_end(skb, nlh);
2189 return 0;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002190
2191nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002192 nlmsg_cancel(skb, nlh);
2193 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194}
2195
Tony Zelenoff84920c12012-01-26 22:28:58 +00002196static int pneigh_fill_info(struct sk_buff *skb, struct pneigh_entry *pn,
2197 u32 pid, u32 seq, int type, unsigned int flags,
2198 struct neigh_table *tbl)
2199{
2200 struct nlmsghdr *nlh;
2201 struct ndmsg *ndm;
2202
2203 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2204 if (nlh == NULL)
2205 return -EMSGSIZE;
2206
2207 ndm = nlmsg_data(nlh);
2208 ndm->ndm_family = tbl->family;
2209 ndm->ndm_pad1 = 0;
2210 ndm->ndm_pad2 = 0;
2211 ndm->ndm_flags = pn->flags | NTF_PROXY;
Jun Zhao545469f2014-07-26 00:38:59 +08002212 ndm->ndm_type = RTN_UNICAST;
Tony Zelenoff84920c12012-01-26 22:28:58 +00002213 ndm->ndm_ifindex = pn->dev->ifindex;
2214 ndm->ndm_state = NUD_NONE;
2215
David S. Miller9a6308d2012-04-01 20:06:28 -04002216 if (nla_put(skb, NDA_DST, tbl->key_len, pn->key))
2217 goto nla_put_failure;
Tony Zelenoff84920c12012-01-26 22:28:58 +00002218
Johannes Berg053c0952015-01-16 22:09:00 +01002219 nlmsg_end(skb, nlh);
2220 return 0;
Tony Zelenoff84920c12012-01-26 22:28:58 +00002221
2222nla_put_failure:
2223 nlmsg_cancel(skb, nlh);
2224 return -EMSGSIZE;
2225}
2226
Thomas Grafd961db32007-08-08 23:12:56 -07002227static void neigh_update_notify(struct neighbour *neigh)
2228{
2229 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2230 __neigh_notify(neigh, RTM_NEWNEIGH, 0);
2231}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232
2233static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2234 struct netlink_callback *cb)
2235{
Eric Dumazet767e97e2010-10-06 17:49:21 -07002236 struct net *net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237 struct neighbour *n;
2238 int rc, h, s_h = cb->args[1];
2239 int idx, s_idx = idx = cb->args[2];
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002240 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002242 rcu_read_lock_bh();
2243 nht = rcu_dereference_bh(tbl->nht);
2244
Eric Dumazet4bd6683b2012-06-07 04:58:35 +00002245 for (h = s_h; h < (1 << nht->hash_shift); h++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 if (h > s_h)
2247 s_idx = 0;
Eric Dumazet767e97e2010-10-06 17:49:21 -07002248 for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0;
2249 n != NULL;
2250 n = rcu_dereference_bh(n->next)) {
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08002251 if (!net_eq(dev_net(n->dev), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002252 continue;
Gautam Kachrooefc683f2009-02-06 00:52:04 -08002253 if (idx < s_idx)
2254 goto next;
Eric W. Biederman15e47302012-09-07 20:12:54 +00002255 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 cb->nlh->nlmsg_seq,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07002257 RTM_NEWNEIGH,
David S. Miller7b46a642015-01-18 23:36:08 -05002258 NLM_F_MULTI) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 rc = -1;
2260 goto out;
2261 }
Eric Dumazet767e97e2010-10-06 17:49:21 -07002262next:
Gautam Kachrooefc683f2009-02-06 00:52:04 -08002263 idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 }
2266 rc = skb->len;
2267out:
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002268 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269 cb->args[1] = h;
2270 cb->args[2] = idx;
2271 return rc;
2272}
2273
Tony Zelenoff84920c12012-01-26 22:28:58 +00002274static int pneigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2275 struct netlink_callback *cb)
2276{
2277 struct pneigh_entry *n;
2278 struct net *net = sock_net(skb->sk);
2279 int rc, h, s_h = cb->args[3];
2280 int idx, s_idx = idx = cb->args[4];
2281
2282 read_lock_bh(&tbl->lock);
2283
Eric Dumazet4bd6683b2012-06-07 04:58:35 +00002284 for (h = s_h; h <= PNEIGH_HASHMASK; h++) {
Tony Zelenoff84920c12012-01-26 22:28:58 +00002285 if (h > s_h)
2286 s_idx = 0;
2287 for (n = tbl->phash_buckets[h], idx = 0; n; n = n->next) {
2288 if (dev_net(n->dev) != net)
2289 continue;
2290 if (idx < s_idx)
2291 goto next;
Eric W. Biederman15e47302012-09-07 20:12:54 +00002292 if (pneigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
Tony Zelenoff84920c12012-01-26 22:28:58 +00002293 cb->nlh->nlmsg_seq,
2294 RTM_NEWNEIGH,
David S. Miller7b46a642015-01-18 23:36:08 -05002295 NLM_F_MULTI, tbl) < 0) {
Tony Zelenoff84920c12012-01-26 22:28:58 +00002296 read_unlock_bh(&tbl->lock);
2297 rc = -1;
2298 goto out;
2299 }
2300 next:
2301 idx++;
2302 }
2303 }
2304
2305 read_unlock_bh(&tbl->lock);
2306 rc = skb->len;
2307out:
2308 cb->args[3] = h;
2309 cb->args[4] = idx;
2310 return rc;
2311
2312}
2313
Thomas Grafc8822a42007-03-22 11:50:06 -07002314static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315{
2316 struct neigh_table *tbl;
2317 int t, family, s_t;
Tony Zelenoff84920c12012-01-26 22:28:58 +00002318 int proxy = 0;
Eric Dumazet4bd6683b2012-06-07 04:58:35 +00002319 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320
Thomas Graf8b8aec52006-08-07 17:56:37 -07002321 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
Tony Zelenoff84920c12012-01-26 22:28:58 +00002322
2323 /* check for full ndmsg structure presence, family member is
2324 * the same for both structures
2325 */
2326 if (nlmsg_len(cb->nlh) >= sizeof(struct ndmsg) &&
2327 ((struct ndmsg *) nlmsg_data(cb->nlh))->ndm_flags == NTF_PROXY)
2328 proxy = 1;
2329
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 s_t = cb->args[0];
2331
WANG Congd7480fd2014-11-10 15:59:36 -08002332 for (t = 0; t < NEIGH_NR_TABLES; t++) {
2333 tbl = neigh_tables[t];
2334
2335 if (!tbl)
2336 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 if (t < s_t || (family && tbl->family != family))
2338 continue;
2339 if (t > s_t)
2340 memset(&cb->args[1], 0, sizeof(cb->args) -
2341 sizeof(cb->args[0]));
Tony Zelenoff84920c12012-01-26 22:28:58 +00002342 if (proxy)
2343 err = pneigh_dump_table(tbl, skb, cb);
2344 else
2345 err = neigh_dump_table(tbl, skb, cb);
Eric Dumazet4bd6683b2012-06-07 04:58:35 +00002346 if (err < 0)
2347 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349
2350 cb->args[0] = t;
2351 return skb->len;
2352}
2353
2354void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2355{
2356 int chain;
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002357 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002359 rcu_read_lock_bh();
2360 nht = rcu_dereference_bh(tbl->nht);
2361
Eric Dumazet767e97e2010-10-06 17:49:21 -07002362 read_lock(&tbl->lock); /* avoid resizes */
David S. Millercd089332011-07-11 01:28:12 -07002363 for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 struct neighbour *n;
2365
Eric Dumazet767e97e2010-10-06 17:49:21 -07002366 for (n = rcu_dereference_bh(nht->hash_buckets[chain]);
2367 n != NULL;
2368 n = rcu_dereference_bh(n->next))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 cb(n, cookie);
2370 }
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002371 read_unlock(&tbl->lock);
2372 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373}
2374EXPORT_SYMBOL(neigh_for_each);
2375
2376/* The tbl->lock must be held as a writer and BH disabled. */
2377void __neigh_for_each_release(struct neigh_table *tbl,
2378 int (*cb)(struct neighbour *))
2379{
2380 int chain;
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002381 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002383 nht = rcu_dereference_protected(tbl->nht,
2384 lockdep_is_held(&tbl->lock));
David S. Millercd089332011-07-11 01:28:12 -07002385 for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
Eric Dumazet767e97e2010-10-06 17:49:21 -07002386 struct neighbour *n;
2387 struct neighbour __rcu **np;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002389 np = &nht->hash_buckets[chain];
Eric Dumazet767e97e2010-10-06 17:49:21 -07002390 while ((n = rcu_dereference_protected(*np,
2391 lockdep_is_held(&tbl->lock))) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 int release;
2393
2394 write_lock(&n->lock);
2395 release = cb(n);
2396 if (release) {
Eric Dumazet767e97e2010-10-06 17:49:21 -07002397 rcu_assign_pointer(*np,
2398 rcu_dereference_protected(n->next,
2399 lockdep_is_held(&tbl->lock)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400 n->dead = 1;
2401 } else
2402 np = &n->next;
2403 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -07002404 if (release)
2405 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406 }
2407 }
2408}
2409EXPORT_SYMBOL(__neigh_for_each_release);
2410
Eric W. Biedermanb79bda32015-03-07 16:25:56 -06002411int neigh_xmit(int index, struct net_device *dev,
Eric W. Biederman4fd3d7d2015-03-03 17:11:16 -06002412 const void *addr, struct sk_buff *skb)
2413{
Eric W. Biedermanb79bda32015-03-07 16:25:56 -06002414 int err = -EAFNOSUPPORT;
2415 if (likely(index < NEIGH_NR_TABLES)) {
Eric W. Biederman4fd3d7d2015-03-03 17:11:16 -06002416 struct neigh_table *tbl;
2417 struct neighbour *neigh;
2418
Eric W. Biedermanb79bda32015-03-07 16:25:56 -06002419 tbl = neigh_tables[index];
Eric W. Biederman4fd3d7d2015-03-03 17:11:16 -06002420 if (!tbl)
2421 goto out;
2422 neigh = __neigh_lookup_noref(tbl, addr, dev);
2423 if (!neigh)
2424 neigh = __neigh_create(tbl, addr, dev, false);
2425 err = PTR_ERR(neigh);
2426 if (IS_ERR(neigh))
2427 goto out_kfree_skb;
2428 err = neigh->output(neigh, skb);
2429 }
Eric W. Biedermanb79bda32015-03-07 16:25:56 -06002430 else if (index == NEIGH_LINK_TABLE) {
2431 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
2432 addr, NULL, skb->len);
2433 if (err < 0)
2434 goto out_kfree_skb;
2435 err = dev_queue_xmit(skb);
2436 }
Eric W. Biederman4fd3d7d2015-03-03 17:11:16 -06002437out:
2438 return err;
2439out_kfree_skb:
2440 kfree_skb(skb);
2441 goto out;
2442}
2443EXPORT_SYMBOL(neigh_xmit);
2444
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445#ifdef CONFIG_PROC_FS
2446
2447static struct neighbour *neigh_get_first(struct seq_file *seq)
2448{
2449 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002450 struct net *net = seq_file_net(seq);
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002451 struct neigh_hash_table *nht = state->nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 struct neighbour *n = NULL;
2453 int bucket = state->bucket;
2454
2455 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
David S. Millercd089332011-07-11 01:28:12 -07002456 for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) {
Eric Dumazet767e97e2010-10-06 17:49:21 -07002457 n = rcu_dereference_bh(nht->hash_buckets[bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458
2459 while (n) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002460 if (!net_eq(dev_net(n->dev), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002461 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462 if (state->neigh_sub_iter) {
2463 loff_t fakep = 0;
2464 void *v;
2465
2466 v = state->neigh_sub_iter(state, n, &fakep);
2467 if (!v)
2468 goto next;
2469 }
2470 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2471 break;
2472 if (n->nud_state & ~NUD_NOARP)
2473 break;
Eric Dumazet767e97e2010-10-06 17:49:21 -07002474next:
2475 n = rcu_dereference_bh(n->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476 }
2477
2478 if (n)
2479 break;
2480 }
2481 state->bucket = bucket;
2482
2483 return n;
2484}
2485
2486static struct neighbour *neigh_get_next(struct seq_file *seq,
2487 struct neighbour *n,
2488 loff_t *pos)
2489{
2490 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002491 struct net *net = seq_file_net(seq);
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002492 struct neigh_hash_table *nht = state->nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493
2494 if (state->neigh_sub_iter) {
2495 void *v = state->neigh_sub_iter(state, n, pos);
2496 if (v)
2497 return n;
2498 }
Eric Dumazet767e97e2010-10-06 17:49:21 -07002499 n = rcu_dereference_bh(n->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500
2501 while (1) {
2502 while (n) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002503 if (!net_eq(dev_net(n->dev), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002504 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505 if (state->neigh_sub_iter) {
2506 void *v = state->neigh_sub_iter(state, n, pos);
2507 if (v)
2508 return n;
2509 goto next;
2510 }
2511 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2512 break;
2513
2514 if (n->nud_state & ~NUD_NOARP)
2515 break;
Eric Dumazet767e97e2010-10-06 17:49:21 -07002516next:
2517 n = rcu_dereference_bh(n->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518 }
2519
2520 if (n)
2521 break;
2522
David S. Millercd089332011-07-11 01:28:12 -07002523 if (++state->bucket >= (1 << nht->hash_shift))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524 break;
2525
Eric Dumazet767e97e2010-10-06 17:49:21 -07002526 n = rcu_dereference_bh(nht->hash_buckets[state->bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 }
2528
2529 if (n && pos)
2530 --(*pos);
2531 return n;
2532}
2533
2534static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2535{
2536 struct neighbour *n = neigh_get_first(seq);
2537
2538 if (n) {
Chris Larson745e2032008-08-03 01:10:55 -07002539 --(*pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 while (*pos) {
2541 n = neigh_get_next(seq, n, pos);
2542 if (!n)
2543 break;
2544 }
2545 }
2546 return *pos ? NULL : n;
2547}
2548
2549static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2550{
2551 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002552 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553 struct neigh_table *tbl = state->tbl;
2554 struct pneigh_entry *pn = NULL;
2555 int bucket = state->bucket;
2556
2557 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2558 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2559 pn = tbl->phash_buckets[bucket];
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002560 while (pn && !net_eq(pneigh_net(pn), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002561 pn = pn->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 if (pn)
2563 break;
2564 }
2565 state->bucket = bucket;
2566
2567 return pn;
2568}
2569
2570static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2571 struct pneigh_entry *pn,
2572 loff_t *pos)
2573{
2574 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002575 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576 struct neigh_table *tbl = state->tbl;
2577
Jorge Boncompte [DTI2]df07a942011-11-25 13:24:49 -05002578 do {
2579 pn = pn->next;
2580 } while (pn && !net_eq(pneigh_net(pn), net));
2581
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 while (!pn) {
2583 if (++state->bucket > PNEIGH_HASHMASK)
2584 break;
2585 pn = tbl->phash_buckets[state->bucket];
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002586 while (pn && !net_eq(pneigh_net(pn), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002587 pn = pn->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 if (pn)
2589 break;
2590 }
2591
2592 if (pn && pos)
2593 --(*pos);
2594
2595 return pn;
2596}
2597
2598static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2599{
2600 struct pneigh_entry *pn = pneigh_get_first(seq);
2601
2602 if (pn) {
Chris Larson745e2032008-08-03 01:10:55 -07002603 --(*pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 while (*pos) {
2605 pn = pneigh_get_next(seq, pn, pos);
2606 if (!pn)
2607 break;
2608 }
2609 }
2610 return *pos ? NULL : pn;
2611}
2612
2613static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2614{
2615 struct neigh_seq_state *state = seq->private;
2616 void *rc;
Chris Larson745e2032008-08-03 01:10:55 -07002617 loff_t idxpos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618
Chris Larson745e2032008-08-03 01:10:55 -07002619 rc = neigh_get_idx(seq, &idxpos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
Chris Larson745e2032008-08-03 01:10:55 -07002621 rc = pneigh_get_idx(seq, &idxpos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622
2623 return rc;
2624}
2625
2626void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002627 __acquires(rcu_bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628{
2629 struct neigh_seq_state *state = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630
2631 state->tbl = tbl;
2632 state->bucket = 0;
2633 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2634
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002635 rcu_read_lock_bh();
2636 state->nht = rcu_dereference_bh(tbl->nht);
Eric Dumazet767e97e2010-10-06 17:49:21 -07002637
Chris Larson745e2032008-08-03 01:10:55 -07002638 return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639}
2640EXPORT_SYMBOL(neigh_seq_start);
2641
2642void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2643{
2644 struct neigh_seq_state *state;
2645 void *rc;
2646
2647 if (v == SEQ_START_TOKEN) {
Chris Larsonbff69732008-08-03 01:02:41 -07002648 rc = neigh_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649 goto out;
2650 }
2651
2652 state = seq->private;
2653 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2654 rc = neigh_get_next(seq, v, NULL);
2655 if (rc)
2656 goto out;
2657 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2658 rc = pneigh_get_first(seq);
2659 } else {
2660 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2661 rc = pneigh_get_next(seq, v, NULL);
2662 }
2663out:
2664 ++(*pos);
2665 return rc;
2666}
2667EXPORT_SYMBOL(neigh_seq_next);
2668
2669void neigh_seq_stop(struct seq_file *seq, void *v)
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002670 __releases(rcu_bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671{
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002672 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673}
2674EXPORT_SYMBOL(neigh_seq_stop);
2675
2676/* statistics via seq_file */
2677
2678static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2679{
Alexey Dobriyan81c1ebf2010-01-22 10:16:05 +00002680 struct neigh_table *tbl = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002681 int cpu;
2682
2683 if (*pos == 0)
2684 return SEQ_START_TOKEN;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002685
Rusty Russell0f23174a2008-12-29 12:23:42 +00002686 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687 if (!cpu_possible(cpu))
2688 continue;
2689 *pos = cpu+1;
2690 return per_cpu_ptr(tbl->stats, cpu);
2691 }
2692 return NULL;
2693}
2694
2695static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2696{
Alexey Dobriyan81c1ebf2010-01-22 10:16:05 +00002697 struct neigh_table *tbl = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 int cpu;
2699
Rusty Russell0f23174a2008-12-29 12:23:42 +00002700 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701 if (!cpu_possible(cpu))
2702 continue;
2703 *pos = cpu+1;
2704 return per_cpu_ptr(tbl->stats, cpu);
2705 }
2706 return NULL;
2707}
2708
2709static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2710{
2711
2712}
2713
2714static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2715{
Alexey Dobriyan81c1ebf2010-01-22 10:16:05 +00002716 struct neigh_table *tbl = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717 struct neigh_statistics *st = v;
2718
2719 if (v == SEQ_START_TOKEN) {
Neil Horman9a6d2762008-07-16 20:50:49 -07002720 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\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721 return 0;
2722 }
2723
2724 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
Neil Horman9a6d2762008-07-16 20:50:49 -07002725 "%08lx %08lx %08lx %08lx %08lx\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726 atomic_read(&tbl->entries),
2727
2728 st->allocs,
2729 st->destroys,
2730 st->hash_grows,
2731
2732 st->lookups,
2733 st->hits,
2734
2735 st->res_failed,
2736
2737 st->rcv_probes_mcast,
2738 st->rcv_probes_ucast,
2739
2740 st->periodic_gc_runs,
Neil Horman9a6d2762008-07-16 20:50:49 -07002741 st->forced_gc_runs,
2742 st->unres_discards
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 );
2744
2745 return 0;
2746}
2747
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002748static const struct seq_operations neigh_stat_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749 .start = neigh_stat_seq_start,
2750 .next = neigh_stat_seq_next,
2751 .stop = neigh_stat_seq_stop,
2752 .show = neigh_stat_seq_show,
2753};
2754
2755static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2756{
2757 int ret = seq_open(file, &neigh_stat_seq_ops);
2758
2759 if (!ret) {
2760 struct seq_file *sf = file->private_data;
Al Virod9dda782013-03-31 18:16:14 -04002761 sf->private = PDE_DATA(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 }
2763 return ret;
2764};
2765
Arjan van de Ven9a321442007-02-12 00:55:35 -08002766static const struct file_operations neigh_stat_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 .owner = THIS_MODULE,
2768 .open = neigh_stat_seq_open,
2769 .read = seq_read,
2770 .llseek = seq_lseek,
2771 .release = seq_release,
2772};
2773
2774#endif /* CONFIG_PROC_FS */
2775
Thomas Graf339bf982006-11-10 14:10:15 -08002776static inline size_t neigh_nlmsg_size(void)
2777{
2778 return NLMSG_ALIGN(sizeof(struct ndmsg))
2779 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2780 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2781 + nla_total_size(sizeof(struct nda_cacheinfo))
2782 + nla_total_size(4); /* NDA_PROBES */
2783}
2784
Thomas Grafb8673312006-08-15 00:33:14 -07002785static void __neigh_notify(struct neighbour *n, int type, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002787 struct net *net = dev_net(n->dev);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002788 struct sk_buff *skb;
Thomas Grafb8673312006-08-15 00:33:14 -07002789 int err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790
Thomas Graf339bf982006-11-10 14:10:15 -08002791 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002792 if (skb == NULL)
Thomas Grafb8673312006-08-15 00:33:14 -07002793 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794
Thomas Grafb8673312006-08-15 00:33:14 -07002795 err = neigh_fill_info(skb, n, 0, 0, type, flags);
Patrick McHardy26932562007-01-31 23:16:40 -08002796 if (err < 0) {
2797 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2798 WARN_ON(err == -EMSGSIZE);
2799 kfree_skb(skb);
2800 goto errout;
2801 }
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08002802 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
2803 return;
Thomas Grafb8673312006-08-15 00:33:14 -07002804errout:
2805 if (err < 0)
Eric W. Biederman426b5302008-01-24 00:13:18 -08002806 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
Thomas Grafb8673312006-08-15 00:33:14 -07002807}
2808
2809void neigh_app_ns(struct neighbour *n)
2810{
2811 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09002813EXPORT_SYMBOL(neigh_app_ns);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814
2815#ifdef CONFIG_SYSCTL
Cong Wangb93196d2012-12-06 10:04:04 +08002816static int zero;
Francesco Fusco555445c2013-07-24 10:39:06 +02002817static int int_max = INT_MAX;
Cong Wangb93196d2012-12-06 10:04:04 +08002818static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819
Joe Perchesfe2c6332013-06-11 23:04:25 -07002820static int proc_unres_qlen(struct ctl_table *ctl, int write,
2821 void __user *buffer, size_t *lenp, loff_t *ppos)
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002822{
2823 int size, ret;
Joe Perchesfe2c6332013-06-11 23:04:25 -07002824 struct ctl_table tmp = *ctl;
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002825
Shan Weice46cc62012-12-04 18:49:15 +00002826 tmp.extra1 = &zero;
2827 tmp.extra2 = &unres_qlen_max;
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002828 tmp.data = &size;
Shan Weice46cc62012-12-04 18:49:15 +00002829
2830 size = *(int *)ctl->data / SKB_TRUESIZE(ETH_FRAME_LEN);
2831 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
2832
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002833 if (write && !ret)
2834 *(int *)ctl->data = size * SKB_TRUESIZE(ETH_FRAME_LEN);
2835 return ret;
2836}
2837
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002838static struct neigh_parms *neigh_get_dev_parms_rcu(struct net_device *dev,
2839 int family)
2840{
Jiri Pirkobba24892013-12-07 19:26:57 +01002841 switch (family) {
2842 case AF_INET:
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002843 return __in_dev_arp_parms_get_rcu(dev);
Jiri Pirkobba24892013-12-07 19:26:57 +01002844 case AF_INET6:
2845 return __in6_dev_nd_parms_get_rcu(dev);
2846 }
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002847 return NULL;
2848}
2849
2850static void neigh_copy_dflt_parms(struct net *net, struct neigh_parms *p,
2851 int index)
2852{
2853 struct net_device *dev;
2854 int family = neigh_parms_family(p);
2855
2856 rcu_read_lock();
2857 for_each_netdev_rcu(net, dev) {
2858 struct neigh_parms *dst_p =
2859 neigh_get_dev_parms_rcu(dev, family);
2860
2861 if (dst_p && !test_bit(index, dst_p->data_state))
2862 dst_p->data[index] = p->data[index];
2863 }
2864 rcu_read_unlock();
2865}
2866
2867static void neigh_proc_update(struct ctl_table *ctl, int write)
2868{
2869 struct net_device *dev = ctl->extra1;
2870 struct neigh_parms *p = ctl->extra2;
Jiri Pirko77d47af2013-12-10 23:55:07 +01002871 struct net *net = neigh_parms_net(p);
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002872 int index = (int *) ctl->data - p->data;
2873
2874 if (!write)
2875 return;
2876
2877 set_bit(index, p->data_state);
2878 if (!dev) /* NULL dev means this is default value */
2879 neigh_copy_dflt_parms(net, p, index);
2880}
2881
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002882static int neigh_proc_dointvec_zero_intmax(struct ctl_table *ctl, int write,
2883 void __user *buffer,
2884 size_t *lenp, loff_t *ppos)
2885{
2886 struct ctl_table tmp = *ctl;
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002887 int ret;
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002888
2889 tmp.extra1 = &zero;
2890 tmp.extra2 = &int_max;
2891
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002892 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
2893 neigh_proc_update(ctl, write);
2894 return ret;
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002895}
2896
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01002897int neigh_proc_dointvec(struct ctl_table *ctl, int write,
2898 void __user *buffer, size_t *lenp, loff_t *ppos)
2899{
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002900 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2901
2902 neigh_proc_update(ctl, write);
2903 return ret;
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01002904}
2905EXPORT_SYMBOL(neigh_proc_dointvec);
2906
2907int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write,
2908 void __user *buffer,
2909 size_t *lenp, loff_t *ppos)
2910{
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002911 int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
2912
2913 neigh_proc_update(ctl, write);
2914 return ret;
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01002915}
2916EXPORT_SYMBOL(neigh_proc_dointvec_jiffies);
2917
2918static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table *ctl, int write,
2919 void __user *buffer,
2920 size_t *lenp, loff_t *ppos)
2921{
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002922 int ret = proc_dointvec_userhz_jiffies(ctl, write, buffer, lenp, ppos);
2923
2924 neigh_proc_update(ctl, write);
2925 return ret;
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01002926}
2927
2928int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write,
2929 void __user *buffer,
2930 size_t *lenp, loff_t *ppos)
2931{
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002932 int ret = proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
2933
2934 neigh_proc_update(ctl, write);
2935 return ret;
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01002936}
2937EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies);
2938
2939static int neigh_proc_dointvec_unres_qlen(struct ctl_table *ctl, int write,
2940 void __user *buffer,
2941 size_t *lenp, loff_t *ppos)
2942{
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01002943 int ret = proc_unres_qlen(ctl, write, buffer, lenp, ppos);
2944
2945 neigh_proc_update(ctl, write);
2946 return ret;
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01002947}
2948
Jean-Francois Remy4bf69802015-01-14 04:22:39 +01002949static int neigh_proc_base_reachable_time(struct ctl_table *ctl, int write,
2950 void __user *buffer,
2951 size_t *lenp, loff_t *ppos)
2952{
2953 struct neigh_parms *p = ctl->extra2;
2954 int ret;
2955
2956 if (strcmp(ctl->procname, "base_reachable_time") == 0)
2957 ret = neigh_proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
2958 else if (strcmp(ctl->procname, "base_reachable_time_ms") == 0)
2959 ret = neigh_proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
2960 else
2961 ret = -1;
2962
2963 if (write && ret == 0) {
2964 /* update reachable_time as well, otherwise, the change will
2965 * only be effective after the next time neigh_periodic_work
2966 * decides to recompute it
2967 */
2968 p->reachable_time =
2969 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
2970 }
2971 return ret;
2972}
2973
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002974#define NEIGH_PARMS_DATA_OFFSET(index) \
2975 (&((struct neigh_parms *) 0)->data[index])
2976
2977#define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \
2978 [NEIGH_VAR_ ## attr] = { \
2979 .procname = name, \
2980 .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \
2981 .maxlen = sizeof(int), \
2982 .mode = mval, \
2983 .proc_handler = proc, \
2984 }
2985
2986#define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \
2987 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax)
2988
2989#define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01002990 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies)
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002991
2992#define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01002993 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies)
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002994
2995#define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01002996 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
Jiri Pirko1f9248e2013-12-07 19:26:53 +01002997
2998#define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01002999 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
Jiri Pirko1f9248e2013-12-07 19:26:53 +01003000
3001#define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01003002 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen)
Eric W. Biederman54716e32010-02-14 03:27:03 +00003003
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004static struct neigh_sysctl_table {
3005 struct ctl_table_header *sysctl_header;
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003006 struct ctl_table neigh_vars[NEIGH_VAR_MAX + 1];
Brian Haleyab32ea52006-09-22 14:15:41 -07003007} neigh_sysctl_template __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008 .neigh_vars = {
Jiri Pirko1f9248e2013-12-07 19:26:53 +01003009 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES, "mcast_solicit"),
3010 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES, "ucast_solicit"),
3011 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES, "app_solicit"),
YOSHIFUJI Hideaki/吉藤英明8da86462015-03-19 22:41:46 +09003012 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_REPROBES, "mcast_resolicit"),
Jiri Pirko1f9248e2013-12-07 19:26:53 +01003013 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME, "retrans_time"),
3014 NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME, "base_reachable_time"),
3015 NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME, "delay_first_probe_time"),
3016 NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME, "gc_stale_time"),
3017 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES, "unres_qlen_bytes"),
3018 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN, "proxy_qlen"),
3019 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY, "anycast_delay"),
3020 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY, "proxy_delay"),
3021 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME, "locktime"),
3022 NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN, QUEUE_LEN_BYTES, "unres_qlen"),
3023 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS, RETRANS_TIME, "retrans_time_ms"),
3024 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS, BASE_REACHABLE_TIME, "base_reachable_time_ms"),
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003025 [NEIGH_VAR_GC_INTERVAL] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026 .procname = "gc_interval",
3027 .maxlen = sizeof(int),
3028 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003029 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003031 [NEIGH_VAR_GC_THRESH1] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 .procname = "gc_thresh1",
3033 .maxlen = sizeof(int),
3034 .mode = 0644,
Francesco Fusco555445c2013-07-24 10:39:06 +02003035 .extra1 = &zero,
3036 .extra2 = &int_max,
3037 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003038 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003039 [NEIGH_VAR_GC_THRESH2] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040 .procname = "gc_thresh2",
3041 .maxlen = sizeof(int),
3042 .mode = 0644,
Francesco Fusco555445c2013-07-24 10:39:06 +02003043 .extra1 = &zero,
3044 .extra2 = &int_max,
3045 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003047 [NEIGH_VAR_GC_THRESH3] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048 .procname = "gc_thresh3",
3049 .maxlen = sizeof(int),
3050 .mode = 0644,
Francesco Fusco555445c2013-07-24 10:39:06 +02003051 .extra1 = &zero,
3052 .extra2 = &int_max,
3053 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003054 },
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11003055 {},
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056 },
3057};
3058
3059int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
Jiri Pirko73af6142013-12-07 19:26:55 +01003060 proc_handler *handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061{
Jiri Pirko1f9248e2013-12-07 19:26:53 +01003062 int i;
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003063 struct neigh_sysctl_table *t;
Jiri Pirko1f9248e2013-12-07 19:26:53 +01003064 const char *dev_name_source;
Eric W. Biederman8f40a1f2012-04-19 13:38:03 +00003065 char neigh_path[ sizeof("net//neigh/") + IFNAMSIZ + IFNAMSIZ ];
Jiri Pirko73af6142013-12-07 19:26:55 +01003066 char *p_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003068 t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003069 if (!t)
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003070 goto err;
3071
Jiri Pirkob194c1f2014-02-21 14:52:57 +01003072 for (i = 0; i < NEIGH_VAR_GC_INTERVAL; i++) {
Jiri Pirko1f9248e2013-12-07 19:26:53 +01003073 t->neigh_vars[i].data += (long) p;
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01003074 t->neigh_vars[i].extra1 = dev;
Jiri Pirko1d4c8c22013-12-07 19:26:56 +01003075 t->neigh_vars[i].extra2 = p;
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01003076 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077
3078 if (dev) {
3079 dev_name_source = dev->name;
Eric W. Biedermand12af672007-10-18 03:05:25 -07003080 /* Terminate the table early */
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003081 memset(&t->neigh_vars[NEIGH_VAR_GC_INTERVAL], 0,
3082 sizeof(t->neigh_vars[NEIGH_VAR_GC_INTERVAL]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003083 } else {
Mathias Krause9ecf07a2014-07-12 22:36:44 +02003084 struct neigh_table *tbl = p->tbl;
Eric W. Biederman8f40a1f2012-04-19 13:38:03 +00003085 dev_name_source = "default";
Mathias Krause9ecf07a2014-07-12 22:36:44 +02003086 t->neigh_vars[NEIGH_VAR_GC_INTERVAL].data = &tbl->gc_interval;
3087 t->neigh_vars[NEIGH_VAR_GC_THRESH1].data = &tbl->gc_thresh1;
3088 t->neigh_vars[NEIGH_VAR_GC_THRESH2].data = &tbl->gc_thresh2;
3089 t->neigh_vars[NEIGH_VAR_GC_THRESH3].data = &tbl->gc_thresh3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090 }
3091
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08003092 if (handler) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093 /* RetransTime */
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003094 t->neigh_vars[NEIGH_VAR_RETRANS_TIME].proc_handler = handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095 /* ReachableTime */
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003096 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097 /* RetransTime (in milliseconds)*/
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003098 t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].proc_handler = handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099 /* ReachableTime (in milliseconds) */
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003100 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = handler;
Jean-Francois Remy4bf69802015-01-14 04:22:39 +01003101 } else {
3102 /* Those handlers will update p->reachable_time after
3103 * base_reachable_time(_ms) is set to ensure the new timer starts being
3104 * applied after the next neighbour update instead of waiting for
3105 * neigh_periodic_work to update its value (can be multiple minutes)
3106 * So any handler that replaces them should do this as well
3107 */
3108 /* ReachableTime */
3109 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler =
3110 neigh_proc_base_reachable_time;
3111 /* ReachableTime (in milliseconds) */
3112 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler =
3113 neigh_proc_base_reachable_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 }
3115
Eric W. Biederman464dc802012-11-16 03:02:59 +00003116 /* Don't export sysctls to unprivileged users */
3117 if (neigh_parms_net(p)->user_ns != &init_user_ns)
3118 t->neigh_vars[0].procname = NULL;
3119
Jiri Pirko73af6142013-12-07 19:26:55 +01003120 switch (neigh_parms_family(p)) {
3121 case AF_INET:
3122 p_name = "ipv4";
3123 break;
3124 case AF_INET6:
3125 p_name = "ipv6";
3126 break;
3127 default:
3128 BUG();
3129 }
3130
Eric W. Biederman8f40a1f2012-04-19 13:38:03 +00003131 snprintf(neigh_path, sizeof(neigh_path), "net/%s/neigh/%s",
3132 p_name, dev_name_source);
Denis V. Lunev4ab438f2008-02-28 20:48:01 -08003133 t->sysctl_header =
Eric W. Biederman8f40a1f2012-04-19 13:38:03 +00003134 register_net_sysctl(neigh_parms_net(p), neigh_path, t->neigh_vars);
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003135 if (!t->sysctl_header)
Eric W. Biederman8f40a1f2012-04-19 13:38:03 +00003136 goto free;
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003137
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138 p->sysctl_table = t;
3139 return 0;
3140
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003141free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142 kfree(t);
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003143err:
3144 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003145}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09003146EXPORT_SYMBOL(neigh_sysctl_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147
3148void neigh_sysctl_unregister(struct neigh_parms *p)
3149{
3150 if (p->sysctl_table) {
3151 struct neigh_sysctl_table *t = p->sysctl_table;
3152 p->sysctl_table = NULL;
Eric W. Biederman5dd3df12012-04-19 13:24:33 +00003153 unregister_net_sysctl_table(t->sysctl_header);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154 kfree(t);
3155 }
3156}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09003157EXPORT_SYMBOL(neigh_sysctl_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158
3159#endif /* CONFIG_SYSCTL */
3160
Thomas Grafc8822a42007-03-22 11:50:06 -07003161static int __init neigh_init(void)
3162{
Greg Rosec7ac8672011-06-10 01:27:09 +00003163 rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, NULL);
3164 rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, NULL);
3165 rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info, NULL);
Thomas Grafc8822a42007-03-22 11:50:06 -07003166
Greg Rosec7ac8672011-06-10 01:27:09 +00003167 rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info,
3168 NULL);
3169 rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, NULL);
Thomas Grafc8822a42007-03-22 11:50:06 -07003170
3171 return 0;
3172}
3173
3174subsys_initcall(neigh_init);
3175