blob: 9232c68941abb4b5b5ec23f5d6cd56054d8b4c67 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Joe Perchesd5d427c2013-04-15 15:17:19 +000042#define DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#define NEIGH_DEBUG 1
Joe Perchesd5d427c2013-04-15 15:17:19 +000044#define neigh_dbg(level, fmt, ...) \
45do { \
46 if (level <= NEIGH_DEBUG) \
47 pr_debug(fmt, ##__VA_ARGS__); \
48} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50#define PNEIGH_HASHMASK 0xF
51
52static void neigh_timer_handler(unsigned long arg);
Thomas Grafd961db32007-08-08 23:12:56 -070053static void __neigh_notify(struct neighbour *n, int type, int flags);
54static void neigh_update_notify(struct neighbour *neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57static struct neigh_table *neigh_tables;
Amos Waterland45fc3b12005-09-24 16:53:16 -070058#ifdef CONFIG_PROC_FS
Arjan van de Ven9a321442007-02-12 00:55:35 -080059static const struct file_operations neigh_stat_seq_fops;
Amos Waterland45fc3b12005-09-24 16:53:16 -070060#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62/*
63 Neighbour hash table buckets are protected with rwlock tbl->lock.
64
65 - All the scans/updates to hash buckets MUST be made under this lock.
66 - NOTHING clever should be made under this lock: no callbacks
67 to protocol backends, no attempts to send something to network.
68 It will result in deadlocks, if backend/driver wants to use neighbour
69 cache.
70 - If the entry requires some non-trivial actions, increase
71 its reference count and release table lock.
72
73 Neighbour entries are protected:
74 - with reference count.
75 - with rwlock neigh->lock
76
77 Reference count prevents destruction.
78
79 neigh->lock mainly serializes ll address data and its validity state.
80 However, the same lock is used to protect another entry fields:
81 - timer
82 - resolution queue
83
84 Again, nothing clever shall be made under neigh->lock,
85 the most complicated procedure, which we allow is dev->hard_header.
86 It is supposed, that dev->hard_header is simplistic and does
87 not make callbacks to neighbour tables.
88
89 The last lock is neigh_tbl_lock. It is pure SMP lock, protecting
90 list of neighbour tables. This list is used only in process context,
91 */
92
93static DEFINE_RWLOCK(neigh_tbl_lock);
94
David S. Miller8f40b162011-07-17 13:34:11 -070095static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070096{
97 kfree_skb(skb);
98 return -ENETDOWN;
99}
100
Thomas Graf4f494552007-08-08 23:12:36 -0700101static void neigh_cleanup_and_release(struct neighbour *neigh)
102{
103 if (neigh->parms->neigh_cleanup)
104 neigh->parms->neigh_cleanup(neigh);
105
Thomas Grafd961db32007-08-08 23:12:56 -0700106 __neigh_notify(neigh, RTM_DELNEIGH, 0);
Thomas Graf4f494552007-08-08 23:12:36 -0700107 neigh_release(neigh);
108}
109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110/*
111 * It is random distribution in the interval (1/2)*base...(3/2)*base.
112 * It corresponds to default IPv6 settings and is not overridable,
113 * because it is really reasonable choice.
114 */
115
116unsigned long neigh_rand_reach_time(unsigned long base)
117{
Eric Dumazeta02cec22010-09-22 20:43:57 +0000118 return base ? (net_random() % base) + (base >> 1) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900120EXPORT_SYMBOL(neigh_rand_reach_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
122
123static int neigh_forced_gc(struct neigh_table *tbl)
124{
125 int shrunk = 0;
126 int i;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000127 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
129 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
130
131 write_lock_bh(&tbl->lock);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000132 nht = rcu_dereference_protected(tbl->nht,
133 lockdep_is_held(&tbl->lock));
David S. Millercd089332011-07-11 01:28:12 -0700134 for (i = 0; i < (1 << nht->hash_shift); i++) {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700135 struct neighbour *n;
136 struct neighbour __rcu **np;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000138 np = &nht->hash_buckets[i];
Eric Dumazet767e97e2010-10-06 17:49:21 -0700139 while ((n = rcu_dereference_protected(*np,
140 lockdep_is_held(&tbl->lock))) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 /* Neighbour record may be discarded if:
142 * - nobody refers to it.
143 * - it is not permanent
144 */
145 write_lock(&n->lock);
146 if (atomic_read(&n->refcnt) == 1 &&
147 !(n->nud_state & NUD_PERMANENT)) {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700148 rcu_assign_pointer(*np,
149 rcu_dereference_protected(n->next,
150 lockdep_is_held(&tbl->lock)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 n->dead = 1;
152 shrunk = 1;
153 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -0700154 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 continue;
156 }
157 write_unlock(&n->lock);
158 np = &n->next;
159 }
160 }
161
162 tbl->last_flush = jiffies;
163
164 write_unlock_bh(&tbl->lock);
165
166 return shrunk;
167}
168
Pavel Emelyanova43d8992007-12-20 15:49:05 -0800169static void neigh_add_timer(struct neighbour *n, unsigned long when)
170{
171 neigh_hold(n);
172 if (unlikely(mod_timer(&n->timer, when))) {
173 printk("NEIGH: BUG, double timer add, state is %x\n",
174 n->nud_state);
175 dump_stack();
176 }
177}
178
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179static int neigh_del_timer(struct neighbour *n)
180{
181 if ((n->nud_state & NUD_IN_TIMER) &&
182 del_timer(&n->timer)) {
183 neigh_release(n);
184 return 1;
185 }
186 return 0;
187}
188
189static void pneigh_queue_purge(struct sk_buff_head *list)
190{
191 struct sk_buff *skb;
192
193 while ((skb = skb_dequeue(list)) != NULL) {
194 dev_put(skb->dev);
195 kfree_skb(skb);
196 }
197}
198
Herbert Xu49636bb2005-10-23 17:18:00 +1000199static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
201 int i;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000202 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000204 nht = rcu_dereference_protected(tbl->nht,
205 lockdep_is_held(&tbl->lock));
206
David S. Millercd089332011-07-11 01:28:12 -0700207 for (i = 0; i < (1 << nht->hash_shift); i++) {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700208 struct neighbour *n;
209 struct neighbour __rcu **np = &nht->hash_buckets[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
Eric Dumazet767e97e2010-10-06 17:49:21 -0700211 while ((n = rcu_dereference_protected(*np,
212 lockdep_is_held(&tbl->lock))) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 if (dev && n->dev != dev) {
214 np = &n->next;
215 continue;
216 }
Eric Dumazet767e97e2010-10-06 17:49:21 -0700217 rcu_assign_pointer(*np,
218 rcu_dereference_protected(n->next,
219 lockdep_is_held(&tbl->lock)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 write_lock(&n->lock);
221 neigh_del_timer(n);
222 n->dead = 1;
223
224 if (atomic_read(&n->refcnt) != 1) {
225 /* The most unpleasant situation.
226 We must destroy neighbour entry,
227 but someone still uses it.
228
229 The destroy will be delayed until
230 the last user releases us, but
231 we must kill timers etc. and move
232 it to safe state.
233 */
Eric Dumazetc9ab4d82013-06-28 02:37:42 -0700234 __skb_queue_purge(&n->arp_queue);
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000235 n->arp_queue_len_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 n->output = neigh_blackhole;
237 if (n->nud_state & NUD_VALID)
238 n->nud_state = NUD_NOARP;
239 else
240 n->nud_state = NUD_NONE;
Joe Perchesd5d427c2013-04-15 15:17:19 +0000241 neigh_dbg(2, "neigh %p is stray\n", n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 }
243 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -0700244 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 }
246 }
Herbert Xu49636bb2005-10-23 17:18:00 +1000247}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
Herbert Xu49636bb2005-10-23 17:18:00 +1000249void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
250{
251 write_lock_bh(&tbl->lock);
252 neigh_flush_dev(tbl, dev);
253 write_unlock_bh(&tbl->lock);
254}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900255EXPORT_SYMBOL(neigh_changeaddr);
Herbert Xu49636bb2005-10-23 17:18:00 +1000256
257int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
258{
259 write_lock_bh(&tbl->lock);
260 neigh_flush_dev(tbl, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 pneigh_ifdown(tbl, dev);
262 write_unlock_bh(&tbl->lock);
263
264 del_timer_sync(&tbl->proxy_timer);
265 pneigh_queue_purge(&tbl->proxy_queue);
266 return 0;
267}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900268EXPORT_SYMBOL(neigh_ifdown);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
David Miller596b9b62011-07-25 00:01:25 +0000270static struct neighbour *neigh_alloc(struct neigh_table *tbl, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271{
272 struct neighbour *n = NULL;
273 unsigned long now = jiffies;
274 int entries;
275
276 entries = atomic_inc_return(&tbl->entries) - 1;
277 if (entries >= tbl->gc_thresh3 ||
278 (entries >= tbl->gc_thresh2 &&
279 time_after(now, tbl->last_flush + 5 * HZ))) {
280 if (!neigh_forced_gc(tbl) &&
281 entries >= tbl->gc_thresh3)
282 goto out_entries;
283 }
284
YOSHIFUJI Hideaki / 吉藤英明08433ef2013-01-24 00:44:23 +0000285 n = kzalloc(tbl->entry_size + dev->neigh_priv_len, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 if (!n)
287 goto out_entries;
288
Eric Dumazetc9ab4d82013-06-28 02:37:42 -0700289 __skb_queue_head_init(&n->arp_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 rwlock_init(&n->lock);
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +0000291 seqlock_init(&n->ha_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 n->updated = n->used = now;
293 n->nud_state = NUD_NONE;
294 n->output = neigh_blackhole;
David S. Millerf6b72b62011-07-14 07:53:20 -0700295 seqlock_init(&n->hh.hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 n->parms = neigh_parms_clone(&tbl->parms);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800297 setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
299 NEIGH_CACHE_STAT_INC(tbl, allocs);
300 n->tbl = tbl;
301 atomic_set(&n->refcnt, 1);
302 n->dead = 1;
303out:
304 return n;
305
306out_entries:
307 atomic_dec(&tbl->entries);
308 goto out;
309}
310
David S. Miller2c2aba62011-12-28 15:06:58 -0500311static void neigh_get_hash_rnd(u32 *x)
312{
313 get_random_bytes(x, sizeof(*x));
314 *x |= 1;
315}
316
David S. Millercd089332011-07-11 01:28:12 -0700317static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318{
David S. Millercd089332011-07-11 01:28:12 -0700319 size_t size = (1 << shift) * sizeof(struct neighbour *);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000320 struct neigh_hash_table *ret;
Eric Dumazet6193d2b2011-01-19 22:02:47 +0000321 struct neighbour __rcu **buckets;
David S. Miller2c2aba62011-12-28 15:06:58 -0500322 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000324 ret = kmalloc(sizeof(*ret), GFP_ATOMIC);
325 if (!ret)
326 return NULL;
327 if (size <= PAGE_SIZE)
328 buckets = kzalloc(size, GFP_ATOMIC);
329 else
Eric Dumazet6193d2b2011-01-19 22:02:47 +0000330 buckets = (struct neighbour __rcu **)
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000331 __get_free_pages(GFP_ATOMIC | __GFP_ZERO,
332 get_order(size));
333 if (!buckets) {
334 kfree(ret);
335 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 }
Eric Dumazet6193d2b2011-01-19 22:02:47 +0000337 ret->hash_buckets = buckets;
David S. Millercd089332011-07-11 01:28:12 -0700338 ret->hash_shift = shift;
David S. Miller2c2aba62011-12-28 15:06:58 -0500339 for (i = 0; i < NEIGH_NUM_HASH_RND; i++)
340 neigh_get_hash_rnd(&ret->hash_rnd[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 return ret;
342}
343
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000344static void neigh_hash_free_rcu(struct rcu_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345{
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000346 struct neigh_hash_table *nht = container_of(head,
347 struct neigh_hash_table,
348 rcu);
David S. Millercd089332011-07-11 01:28:12 -0700349 size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *);
Eric Dumazet6193d2b2011-01-19 22:02:47 +0000350 struct neighbour __rcu **buckets = nht->hash_buckets;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 if (size <= PAGE_SIZE)
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000353 kfree(buckets);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 else
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000355 free_pages((unsigned long)buckets, get_order(size));
356 kfree(nht);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357}
358
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000359static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl,
David S. Millercd089332011-07-11 01:28:12 -0700360 unsigned long new_shift)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361{
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000362 unsigned int i, hash;
363 struct neigh_hash_table *new_nht, *old_nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
365 NEIGH_CACHE_STAT_INC(tbl, hash_grows);
366
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000367 old_nht = rcu_dereference_protected(tbl->nht,
368 lockdep_is_held(&tbl->lock));
David S. Millercd089332011-07-11 01:28:12 -0700369 new_nht = neigh_hash_alloc(new_shift);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000370 if (!new_nht)
371 return old_nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
David S. Millercd089332011-07-11 01:28:12 -0700373 for (i = 0; i < (1 << old_nht->hash_shift); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 struct neighbour *n, *next;
375
Eric Dumazet767e97e2010-10-06 17:49:21 -0700376 for (n = rcu_dereference_protected(old_nht->hash_buckets[i],
377 lockdep_is_held(&tbl->lock));
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000378 n != NULL;
379 n = next) {
380 hash = tbl->hash(n->primary_key, n->dev,
381 new_nht->hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
David S. Millercd089332011-07-11 01:28:12 -0700383 hash >>= (32 - new_nht->hash_shift);
Eric Dumazet767e97e2010-10-06 17:49:21 -0700384 next = rcu_dereference_protected(n->next,
385 lockdep_is_held(&tbl->lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
Eric Dumazet767e97e2010-10-06 17:49:21 -0700387 rcu_assign_pointer(n->next,
388 rcu_dereference_protected(
389 new_nht->hash_buckets[hash],
390 lockdep_is_held(&tbl->lock)));
391 rcu_assign_pointer(new_nht->hash_buckets[hash], n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
393 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000395 rcu_assign_pointer(tbl->nht, new_nht);
396 call_rcu(&old_nht->rcu, neigh_hash_free_rcu);
397 return new_nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398}
399
400struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
401 struct net_device *dev)
402{
403 struct neighbour *n;
404 int key_len = tbl->key_len;
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800405 u32 hash_val;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000406 struct neigh_hash_table *nht;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900407
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 NEIGH_CACHE_STAT_INC(tbl, lookups);
409
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000410 rcu_read_lock_bh();
411 nht = rcu_dereference_bh(tbl->nht);
David S. Millercd089332011-07-11 01:28:12 -0700412 hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
Eric Dumazet767e97e2010-10-06 17:49:21 -0700413
414 for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
415 n != NULL;
416 n = rcu_dereference_bh(n->next)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700418 if (!atomic_inc_not_zero(&n->refcnt))
419 n = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 NEIGH_CACHE_STAT_INC(tbl, hits);
421 break;
422 }
423 }
Eric Dumazet767e97e2010-10-06 17:49:21 -0700424
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000425 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 return n;
427}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900428EXPORT_SYMBOL(neigh_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Eric W. Biederman426b5302008-01-24 00:13:18 -0800430struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
431 const void *pkey)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432{
433 struct neighbour *n;
434 int key_len = tbl->key_len;
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800435 u32 hash_val;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000436 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
438 NEIGH_CACHE_STAT_INC(tbl, lookups);
439
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000440 rcu_read_lock_bh();
441 nht = rcu_dereference_bh(tbl->nht);
David S. Millercd089332011-07-11 01:28:12 -0700442 hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift);
Eric Dumazet767e97e2010-10-06 17:49:21 -0700443
444 for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
445 n != NULL;
446 n = rcu_dereference_bh(n->next)) {
Eric W. Biederman426b5302008-01-24 00:13:18 -0800447 if (!memcmp(n->primary_key, pkey, key_len) &&
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +0900448 net_eq(dev_net(n->dev), net)) {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700449 if (!atomic_inc_not_zero(&n->refcnt))
450 n = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 NEIGH_CACHE_STAT_INC(tbl, hits);
452 break;
453 }
454 }
Eric Dumazet767e97e2010-10-06 17:49:21 -0700455
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000456 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 return n;
458}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900459EXPORT_SYMBOL(neigh_lookup_nodev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
David S. Millera263b302012-07-02 02:02:15 -0700461struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey,
462 struct net_device *dev, bool want_ref)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463{
464 u32 hash_val;
465 int key_len = tbl->key_len;
466 int error;
David Miller596b9b62011-07-25 00:01:25 +0000467 struct neighbour *n1, *rc, *n = neigh_alloc(tbl, dev);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000468 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
470 if (!n) {
471 rc = ERR_PTR(-ENOBUFS);
472 goto out;
473 }
474
475 memcpy(n->primary_key, pkey, key_len);
476 n->dev = dev;
477 dev_hold(dev);
478
479 /* Protocol specific setup. */
480 if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
481 rc = ERR_PTR(error);
482 goto out_neigh_release;
483 }
484
David Millerda6a8fa2011-07-25 00:01:38 +0000485 if (dev->netdev_ops->ndo_neigh_construct) {
486 error = dev->netdev_ops->ndo_neigh_construct(n);
487 if (error < 0) {
488 rc = ERR_PTR(error);
489 goto out_neigh_release;
490 }
491 }
492
David S. Miller447f2192011-12-19 15:04:41 -0500493 /* Device specific setup. */
494 if (n->parms->neigh_setup &&
495 (error = n->parms->neigh_setup(n)) < 0) {
496 rc = ERR_PTR(error);
497 goto out_neigh_release;
498 }
499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 n->confirmed = jiffies - (n->parms->base_reachable_time << 1);
501
502 write_lock_bh(&tbl->lock);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000503 nht = rcu_dereference_protected(tbl->nht,
504 lockdep_is_held(&tbl->lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
David S. Millercd089332011-07-11 01:28:12 -0700506 if (atomic_read(&tbl->entries) > (1 << nht->hash_shift))
507 nht = neigh_hash_grow(tbl, nht->hash_shift + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
David S. Millercd089332011-07-11 01:28:12 -0700509 hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
511 if (n->parms->dead) {
512 rc = ERR_PTR(-EINVAL);
513 goto out_tbl_unlock;
514 }
515
Eric Dumazet767e97e2010-10-06 17:49:21 -0700516 for (n1 = rcu_dereference_protected(nht->hash_buckets[hash_val],
517 lockdep_is_held(&tbl->lock));
518 n1 != NULL;
519 n1 = rcu_dereference_protected(n1->next,
520 lockdep_is_held(&tbl->lock))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
David S. Millera263b302012-07-02 02:02:15 -0700522 if (want_ref)
523 neigh_hold(n1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 rc = n1;
525 goto out_tbl_unlock;
526 }
527 }
528
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 n->dead = 0;
David S. Millera263b302012-07-02 02:02:15 -0700530 if (want_ref)
531 neigh_hold(n);
Eric Dumazet767e97e2010-10-06 17:49:21 -0700532 rcu_assign_pointer(n->next,
533 rcu_dereference_protected(nht->hash_buckets[hash_val],
534 lockdep_is_held(&tbl->lock)));
535 rcu_assign_pointer(nht->hash_buckets[hash_val], n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 write_unlock_bh(&tbl->lock);
Joe Perchesd5d427c2013-04-15 15:17:19 +0000537 neigh_dbg(2, "neigh %p is created\n", n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 rc = n;
539out:
540 return rc;
541out_tbl_unlock:
542 write_unlock_bh(&tbl->lock);
543out_neigh_release:
544 neigh_release(n);
545 goto out;
546}
David S. Millera263b302012-07-02 02:02:15 -0700547EXPORT_SYMBOL(__neigh_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900549static u32 pneigh_hash(const void *pkey, int key_len)
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700550{
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700551 u32 hash_val = *(u32 *)(pkey + key_len - 4);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700552 hash_val ^= (hash_val >> 16);
553 hash_val ^= hash_val >> 8;
554 hash_val ^= hash_val >> 4;
555 hash_val &= PNEIGH_HASHMASK;
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900556 return hash_val;
557}
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700558
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900559static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n,
560 struct net *net,
561 const void *pkey,
562 int key_len,
563 struct net_device *dev)
564{
565 while (n) {
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700566 if (!memcmp(n->key, pkey, key_len) &&
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900567 net_eq(pneigh_net(n), net) &&
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700568 (n->dev == dev || !n->dev))
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900569 return n;
570 n = n->next;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700571 }
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900572 return NULL;
573}
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700574
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900575struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl,
576 struct net *net, const void *pkey, struct net_device *dev)
577{
578 int key_len = tbl->key_len;
579 u32 hash_val = pneigh_hash(pkey, key_len);
580
581 return __pneigh_lookup_1(tbl->phash_buckets[hash_val],
582 net, pkey, key_len, dev);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700583}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900584EXPORT_SYMBOL_GPL(__pneigh_lookup);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700585
Eric W. Biederman426b5302008-01-24 00:13:18 -0800586struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl,
587 struct net *net, const void *pkey,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 struct net_device *dev, int creat)
589{
590 struct pneigh_entry *n;
591 int key_len = tbl->key_len;
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900592 u32 hash_val = pneigh_hash(pkey, key_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
594 read_lock_bh(&tbl->lock);
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900595 n = __pneigh_lookup_1(tbl->phash_buckets[hash_val],
596 net, pkey, key_len, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 read_unlock_bh(&tbl->lock);
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900598
599 if (n || !creat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 goto out;
601
Pavel Emelyanov4ae28942007-10-15 12:54:15 -0700602 ASSERT_RTNL();
603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
605 if (!n)
606 goto out;
607
Eric Dumazete42ea982008-11-12 00:54:54 -0800608 write_pnet(&n->net, hold_net(net));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 memcpy(n->key, pkey, key_len);
610 n->dev = dev;
611 if (dev)
612 dev_hold(dev);
613
614 if (tbl->pconstructor && tbl->pconstructor(n)) {
615 if (dev)
616 dev_put(dev);
Denis V. Lunevda12f732008-02-20 00:26:16 -0800617 release_net(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 kfree(n);
619 n = NULL;
620 goto out;
621 }
622
623 write_lock_bh(&tbl->lock);
624 n->next = tbl->phash_buckets[hash_val];
625 tbl->phash_buckets[hash_val] = n;
626 write_unlock_bh(&tbl->lock);
627out:
628 return n;
629}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900630EXPORT_SYMBOL(pneigh_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
632
Eric W. Biederman426b5302008-01-24 00:13:18 -0800633int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 struct net_device *dev)
635{
636 struct pneigh_entry *n, **np;
637 int key_len = tbl->key_len;
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900638 u32 hash_val = pneigh_hash(pkey, key_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
640 write_lock_bh(&tbl->lock);
641 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
642 np = &n->next) {
Eric W. Biederman426b5302008-01-24 00:13:18 -0800643 if (!memcmp(n->key, pkey, key_len) && n->dev == dev &&
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +0900644 net_eq(pneigh_net(n), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 *np = n->next;
646 write_unlock_bh(&tbl->lock);
647 if (tbl->pdestructor)
648 tbl->pdestructor(n);
649 if (n->dev)
650 dev_put(n->dev);
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900651 release_net(pneigh_net(n));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 kfree(n);
653 return 0;
654 }
655 }
656 write_unlock_bh(&tbl->lock);
657 return -ENOENT;
658}
659
660static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
661{
662 struct pneigh_entry *n, **np;
663 u32 h;
664
665 for (h = 0; h <= PNEIGH_HASHMASK; h++) {
666 np = &tbl->phash_buckets[h];
667 while ((n = *np) != NULL) {
668 if (!dev || n->dev == dev) {
669 *np = n->next;
670 if (tbl->pdestructor)
671 tbl->pdestructor(n);
672 if (n->dev)
673 dev_put(n->dev);
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900674 release_net(pneigh_net(n));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 kfree(n);
676 continue;
677 }
678 np = &n->next;
679 }
680 }
681 return -ENOENT;
682}
683
Denis V. Lunev06f05112008-01-24 00:30:58 -0800684static void neigh_parms_destroy(struct neigh_parms *parms);
685
686static inline void neigh_parms_put(struct neigh_parms *parms)
687{
688 if (atomic_dec_and_test(&parms->refcnt))
689 neigh_parms_destroy(parms);
690}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
692/*
693 * neighbour must already be out of the table;
694 *
695 */
696void neigh_destroy(struct neighbour *neigh)
697{
David Millerda6a8fa2011-07-25 00:01:38 +0000698 struct net_device *dev = neigh->dev;
699
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
701
702 if (!neigh->dead) {
Joe Perchese005d192012-05-16 19:58:40 +0000703 pr_warn("Destroying alive neighbour %p\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 dump_stack();
705 return;
706 }
707
708 if (neigh_del_timer(neigh))
Joe Perchese005d192012-05-16 19:58:40 +0000709 pr_warn("Impossible event\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
Eric Dumazetc9ab4d82013-06-28 02:37:42 -0700711 write_lock_bh(&neigh->lock);
712 __skb_queue_purge(&neigh->arp_queue);
713 write_unlock_bh(&neigh->lock);
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000714 neigh->arp_queue_len_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
David S. Miller447f2192011-12-19 15:04:41 -0500716 if (dev->netdev_ops->ndo_neigh_destroy)
717 dev->netdev_ops->ndo_neigh_destroy(neigh);
718
David Millerda6a8fa2011-07-25 00:01:38 +0000719 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 neigh_parms_put(neigh->parms);
721
Joe Perchesd5d427c2013-04-15 15:17:19 +0000722 neigh_dbg(2, "neigh %p is destroyed\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724 atomic_dec(&neigh->tbl->entries);
David Miller5b8b0062011-07-25 00:01:22 +0000725 kfree_rcu(neigh, rcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900727EXPORT_SYMBOL(neigh_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729/* Neighbour state is suspicious;
730 disable fast path.
731
732 Called with write_locked neigh.
733 */
734static void neigh_suspect(struct neighbour *neigh)
735{
Joe Perchesd5d427c2013-04-15 15:17:19 +0000736 neigh_dbg(2, "neigh %p is suspected\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
738 neigh->output = neigh->ops->output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739}
740
741/* Neighbour state is OK;
742 enable fast path.
743
744 Called with write_locked neigh.
745 */
746static void neigh_connect(struct neighbour *neigh)
747{
Joe Perchesd5d427c2013-04-15 15:17:19 +0000748 neigh_dbg(2, "neigh %p is connected\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
750 neigh->output = neigh->ops->connected_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751}
752
Eric Dumazete4c4e442009-07-30 03:15:07 +0000753static void neigh_periodic_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754{
Eric Dumazete4c4e442009-07-30 03:15:07 +0000755 struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work);
Eric Dumazet767e97e2010-10-06 17:49:21 -0700756 struct neighbour *n;
757 struct neighbour __rcu **np;
Eric Dumazete4c4e442009-07-30 03:15:07 +0000758 unsigned int i;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000759 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
761 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
762
Eric Dumazete4c4e442009-07-30 03:15:07 +0000763 write_lock_bh(&tbl->lock);
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000764 nht = rcu_dereference_protected(tbl->nht,
765 lockdep_is_held(&tbl->lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
YOSHIFUJI Hideaki / 吉藤英明27246802013-01-22 05:20:05 +0000767 if (atomic_read(&tbl->entries) < tbl->gc_thresh1)
768 goto out;
769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 /*
771 * periodically recompute ReachableTime from random function
772 */
773
Eric Dumazete4c4e442009-07-30 03:15:07 +0000774 if (time_after(jiffies, tbl->last_rand + 300 * HZ)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 struct neigh_parms *p;
Eric Dumazete4c4e442009-07-30 03:15:07 +0000776 tbl->last_rand = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 for (p = &tbl->parms; p; p = p->next)
778 p->reachable_time =
779 neigh_rand_reach_time(p->base_reachable_time);
780 }
781
David S. Millercd089332011-07-11 01:28:12 -0700782 for (i = 0 ; i < (1 << nht->hash_shift); i++) {
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000783 np = &nht->hash_buckets[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
Eric Dumazet767e97e2010-10-06 17:49:21 -0700785 while ((n = rcu_dereference_protected(*np,
786 lockdep_is_held(&tbl->lock))) != NULL) {
Eric Dumazete4c4e442009-07-30 03:15:07 +0000787 unsigned int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Eric Dumazete4c4e442009-07-30 03:15:07 +0000789 write_lock(&n->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
Eric Dumazete4c4e442009-07-30 03:15:07 +0000791 state = n->nud_state;
792 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
793 write_unlock(&n->lock);
794 goto next_elt;
795 }
796
797 if (time_before(n->used, n->confirmed))
798 n->used = n->confirmed;
799
800 if (atomic_read(&n->refcnt) == 1 &&
801 (state == NUD_FAILED ||
802 time_after(jiffies, n->used + n->parms->gc_staletime))) {
803 *np = n->next;
804 n->dead = 1;
805 write_unlock(&n->lock);
806 neigh_cleanup_and_release(n);
807 continue;
808 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 write_unlock(&n->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
811next_elt:
Eric Dumazete4c4e442009-07-30 03:15:07 +0000812 np = &n->next;
813 }
814 /*
815 * It's fine to release lock here, even if hash table
816 * grows while we are preempted.
817 */
818 write_unlock_bh(&tbl->lock);
819 cond_resched();
820 write_lock_bh(&tbl->lock);
Michel Machado84338a62012-02-21 16:04:13 -0500821 nht = rcu_dereference_protected(tbl->nht,
822 lockdep_is_held(&tbl->lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 }
YOSHIFUJI Hideaki / 吉藤英明27246802013-01-22 05:20:05 +0000824out:
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900825 /* Cycle through all hash buckets every base_reachable_time/2 ticks.
826 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
827 * base_reachable_time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 */
Eric Dumazete4c4e442009-07-30 03:15:07 +0000829 schedule_delayed_work(&tbl->gc_work,
830 tbl->parms.base_reachable_time >> 1);
831 write_unlock_bh(&tbl->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832}
833
834static __inline__ int neigh_max_probes(struct neighbour *n)
835{
836 struct neigh_parms *p = n->parms;
Eric Dumazeta02cec22010-09-22 20:43:57 +0000837 return (n->nud_state & NUD_PROBE) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 p->ucast_probes :
Eric Dumazeta02cec22010-09-22 20:43:57 +0000839 p->ucast_probes + p->app_probes + p->mcast_probes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840}
841
Timo Teras5ef12d92009-06-11 04:16:28 -0700842static void neigh_invalidate(struct neighbour *neigh)
Eric Dumazet0a141502010-03-09 19:40:54 +0000843 __releases(neigh->lock)
844 __acquires(neigh->lock)
Timo Teras5ef12d92009-06-11 04:16:28 -0700845{
846 struct sk_buff *skb;
847
848 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
Joe Perchesd5d427c2013-04-15 15:17:19 +0000849 neigh_dbg(2, "neigh %p is failed\n", neigh);
Timo Teras5ef12d92009-06-11 04:16:28 -0700850 neigh->updated = jiffies;
851
852 /* It is very thin place. report_unreachable is very complicated
853 routine. Particularly, it can hit the same neighbour entry!
854
855 So that, we try to be accurate and avoid dead loop. --ANK
856 */
857 while (neigh->nud_state == NUD_FAILED &&
858 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
859 write_unlock(&neigh->lock);
860 neigh->ops->error_report(neigh, skb);
861 write_lock(&neigh->lock);
862 }
Eric Dumazetc9ab4d82013-06-28 02:37:42 -0700863 __skb_queue_purge(&neigh->arp_queue);
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000864 neigh->arp_queue_len_bytes = 0;
Timo Teras5ef12d92009-06-11 04:16:28 -0700865}
866
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000867static void neigh_probe(struct neighbour *neigh)
868 __releases(neigh->lock)
869{
870 struct sk_buff *skb = skb_peek(&neigh->arp_queue);
871 /* keep skb alive even if arp_queue overflows */
872 if (skb)
873 skb = skb_copy(skb, GFP_ATOMIC);
874 write_unlock(&neigh->lock);
875 neigh->ops->solicit(neigh, skb);
876 atomic_inc(&neigh->probes);
877 kfree_skb(skb);
878}
879
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880/* Called when a timer expires for a neighbour entry. */
881
882static void neigh_timer_handler(unsigned long arg)
883{
884 unsigned long now, next;
885 struct neighbour *neigh = (struct neighbour *)arg;
Eric Dumazet95c96172012-04-15 05:58:06 +0000886 unsigned int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 int notify = 0;
888
889 write_lock(&neigh->lock);
890
891 state = neigh->nud_state;
892 now = jiffies;
893 next = now + HZ;
894
David S. Miller045f7b32011-11-01 17:45:55 -0400895 if (!(state & NUD_IN_TIMER))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
898 if (state & NUD_REACHABLE) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900899 if (time_before_eq(now,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 neigh->confirmed + neigh->parms->reachable_time)) {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000901 neigh_dbg(2, "neigh %p is still alive\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 next = neigh->confirmed + neigh->parms->reachable_time;
903 } else if (time_before_eq(now,
904 neigh->used + neigh->parms->delay_probe_time)) {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000905 neigh_dbg(2, "neigh %p is delayed\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 neigh->nud_state = NUD_DELAY;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800907 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 neigh_suspect(neigh);
909 next = now + neigh->parms->delay_probe_time;
910 } else {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000911 neigh_dbg(2, "neigh %p is suspected\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 neigh->nud_state = NUD_STALE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800913 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 neigh_suspect(neigh);
Tom Tucker8d717402006-07-30 20:43:36 -0700915 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 }
917 } else if (state & NUD_DELAY) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900918 if (time_before_eq(now,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 neigh->confirmed + neigh->parms->delay_probe_time)) {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000920 neigh_dbg(2, "neigh %p is now reachable\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 neigh->nud_state = NUD_REACHABLE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800922 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 neigh_connect(neigh);
Tom Tucker8d717402006-07-30 20:43:36 -0700924 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 next = neigh->confirmed + neigh->parms->reachable_time;
926 } else {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000927 neigh_dbg(2, "neigh %p is probed\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 neigh->nud_state = NUD_PROBE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800929 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 atomic_set(&neigh->probes, 0);
931 next = now + neigh->parms->retrans_time;
932 }
933 } else {
934 /* NUD_PROBE|NUD_INCOMPLETE */
935 next = now + neigh->parms->retrans_time;
936 }
937
938 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
939 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 neigh->nud_state = NUD_FAILED;
941 notify = 1;
Timo Teras5ef12d92009-06-11 04:16:28 -0700942 neigh_invalidate(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 }
944
945 if (neigh->nud_state & NUD_IN_TIMER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 if (time_before(next, jiffies + HZ/2))
947 next = jiffies + HZ/2;
Herbert Xu6fb99742005-10-23 16:37:48 +1000948 if (!mod_timer(&neigh->timer, next))
949 neigh_hold(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 }
951 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000952 neigh_probe(neigh);
David S. Miller9ff56602008-02-17 18:39:54 -0800953 } else {
David S. Miller69cc64d2008-02-11 21:45:44 -0800954out:
David S. Miller9ff56602008-02-17 18:39:54 -0800955 write_unlock(&neigh->lock);
956 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
Thomas Grafd961db32007-08-08 23:12:56 -0700958 if (notify)
959 neigh_update_notify(neigh);
960
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 neigh_release(neigh);
962}
963
964int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
965{
966 int rc;
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000967 bool immediate_probe = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968
969 write_lock_bh(&neigh->lock);
970
971 rc = 0;
972 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
973 goto out_unlock_bh;
974
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
976 if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000977 unsigned long next, now = jiffies;
978
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 atomic_set(&neigh->probes, neigh->parms->ucast_probes);
980 neigh->nud_state = NUD_INCOMPLETE;
Eric Dumazetcd28ca02011-08-09 08:15:58 +0000981 neigh->updated = now;
982 next = now + max(neigh->parms->retrans_time, HZ/2);
983 neigh_add_timer(neigh, next);
984 immediate_probe = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 } else {
986 neigh->nud_state = NUD_FAILED;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800987 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 write_unlock_bh(&neigh->lock);
989
Wei Yongjunf3fbbe02009-02-25 00:37:32 +0000990 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 return 1;
992 }
993 } else if (neigh->nud_state & NUD_STALE) {
Joe Perchesd5d427c2013-04-15 15:17:19 +0000994 neigh_dbg(2, "neigh %p is delayed\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 neigh->nud_state = NUD_DELAY;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800996 neigh->updated = jiffies;
David S. Miller667347f2005-09-27 12:07:44 -0700997 neigh_add_timer(neigh,
998 jiffies + neigh->parms->delay_probe_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 }
1000
1001 if (neigh->nud_state == NUD_INCOMPLETE) {
1002 if (skb) {
Eric Dumazet8b5c1712011-11-09 12:07:14 +00001003 while (neigh->arp_queue_len_bytes + skb->truesize >
1004 neigh->parms->queue_len_bytes) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 struct sk_buff *buff;
Eric Dumazet8b5c1712011-11-09 12:07:14 +00001006
David S. Millerf72051b2008-09-23 01:11:18 -07001007 buff = __skb_dequeue(&neigh->arp_queue);
Eric Dumazet8b5c1712011-11-09 12:07:14 +00001008 if (!buff)
1009 break;
1010 neigh->arp_queue_len_bytes -= buff->truesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 kfree_skb(buff);
Neil Horman9a6d2762008-07-16 20:50:49 -07001012 NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 }
Eric Dumazeta4731132010-05-27 16:09:39 -07001014 skb_dst_force(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 __skb_queue_tail(&neigh->arp_queue, skb);
Eric Dumazet8b5c1712011-11-09 12:07:14 +00001016 neigh->arp_queue_len_bytes += skb->truesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 }
1018 rc = 1;
1019 }
1020out_unlock_bh:
Eric Dumazetcd28ca02011-08-09 08:15:58 +00001021 if (immediate_probe)
1022 neigh_probe(neigh);
1023 else
1024 write_unlock(&neigh->lock);
1025 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 return rc;
1027}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001028EXPORT_SYMBOL(__neigh_event_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
David S. Millerf6b72b62011-07-14 07:53:20 -07001030static void neigh_update_hhs(struct neighbour *neigh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031{
1032 struct hh_cache *hh;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001033 void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
Doug Kehn91a72a72010-07-14 18:02:16 -07001034 = NULL;
1035
1036 if (neigh->dev->header_ops)
1037 update = neigh->dev->header_ops->cache_update;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
1039 if (update) {
David S. Millerf6b72b62011-07-14 07:53:20 -07001040 hh = &neigh->hh;
1041 if (hh->hh_len) {
Stephen Hemminger3644f0c2006-12-07 15:08:17 -08001042 write_seqlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 update(hh, neigh->dev, neigh->ha);
Stephen Hemminger3644f0c2006-12-07 15:08:17 -08001044 write_sequnlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 }
1046 }
1047}
1048
1049
1050
1051/* Generic update routine.
1052 -- lladdr is new lladdr or NULL, if it is not supplied.
1053 -- new is new state.
1054 -- flags
1055 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
1056 if it is different.
1057 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001058 lladdr instead of overriding it
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 if it is different.
1060 It also allows to retain current state
1061 if lladdr is unchanged.
1062 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
1063
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001064 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 NTF_ROUTER flag.
1066 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1067 a router.
1068
1069 Caller MUST hold reference count on the entry.
1070 */
1071
1072int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
1073 u32 flags)
1074{
1075 u8 old;
1076 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 int notify = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 struct net_device *dev;
1079 int update_isrouter = 0;
1080
1081 write_lock_bh(&neigh->lock);
1082
1083 dev = neigh->dev;
1084 old = neigh->nud_state;
1085 err = -EPERM;
1086
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001087 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 (old & (NUD_NOARP | NUD_PERMANENT)))
1089 goto out;
1090
1091 if (!(new & NUD_VALID)) {
1092 neigh_del_timer(neigh);
1093 if (old & NUD_CONNECTED)
1094 neigh_suspect(neigh);
1095 neigh->nud_state = new;
1096 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 notify = old & NUD_VALID;
Timo Teras5ef12d92009-06-11 04:16:28 -07001098 if ((old & (NUD_INCOMPLETE | NUD_PROBE)) &&
1099 (new & NUD_FAILED)) {
1100 neigh_invalidate(neigh);
1101 notify = 1;
1102 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 goto out;
1104 }
1105
1106 /* Compare new lladdr with cached one */
1107 if (!dev->addr_len) {
1108 /* First case: device needs no address. */
1109 lladdr = neigh->ha;
1110 } else if (lladdr) {
1111 /* The second case: if something is already cached
1112 and a new address is proposed:
1113 - compare new & old
1114 - if they are different, check override flag
1115 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001116 if ((old & NUD_VALID) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 !memcmp(lladdr, neigh->ha, dev->addr_len))
1118 lladdr = neigh->ha;
1119 } else {
1120 /* No address is supplied; if we know something,
1121 use it, otherwise discard the request.
1122 */
1123 err = -EINVAL;
1124 if (!(old & NUD_VALID))
1125 goto out;
1126 lladdr = neigh->ha;
1127 }
1128
1129 if (new & NUD_CONNECTED)
1130 neigh->confirmed = jiffies;
1131 neigh->updated = jiffies;
1132
1133 /* If entry was valid and address is not changed,
1134 do not change entry state, if new one is STALE.
1135 */
1136 err = 0;
1137 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1138 if (old & NUD_VALID) {
1139 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1140 update_isrouter = 0;
1141 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1142 (old & NUD_CONNECTED)) {
1143 lladdr = neigh->ha;
1144 new = NUD_STALE;
1145 } else
1146 goto out;
1147 } else {
1148 if (lladdr == neigh->ha && new == NUD_STALE &&
1149 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1150 (old & NUD_CONNECTED))
1151 )
1152 new = old;
1153 }
1154 }
1155
1156 if (new != old) {
1157 neigh_del_timer(neigh);
Pavel Emelyanova43d8992007-12-20 15:49:05 -08001158 if (new & NUD_IN_TIMER)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001159 neigh_add_timer(neigh, (jiffies +
1160 ((new & NUD_REACHABLE) ?
David S. Miller667347f2005-09-27 12:07:44 -07001161 neigh->parms->reachable_time :
1162 0)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 neigh->nud_state = new;
1164 }
1165
1166 if (lladdr != neigh->ha) {
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001167 write_seqlock(&neigh->ha_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 memcpy(&neigh->ha, lladdr, dev->addr_len);
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001169 write_sequnlock(&neigh->ha_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 neigh_update_hhs(neigh);
1171 if (!(new & NUD_CONNECTED))
1172 neigh->confirmed = jiffies -
1173 (neigh->parms->base_reachable_time << 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 }
1176 if (new == old)
1177 goto out;
1178 if (new & NUD_CONNECTED)
1179 neigh_connect(neigh);
1180 else
1181 neigh_suspect(neigh);
1182 if (!(old & NUD_VALID)) {
1183 struct sk_buff *skb;
1184
1185 /* Again: avoid dead loop if something went wrong */
1186
1187 while (neigh->nud_state & NUD_VALID &&
1188 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
David S. Miller69cce1d2011-07-17 23:09:49 -07001189 struct dst_entry *dst = skb_dst(skb);
1190 struct neighbour *n2, *n1 = neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 write_unlock_bh(&neigh->lock);
roy.qing.li@gmail.come049f282011-10-17 22:32:42 +00001192
1193 rcu_read_lock();
David S. Miller13a43d92012-07-02 22:15:37 -07001194
1195 /* Why not just use 'neigh' as-is? The problem is that
1196 * things such as shaper, eql, and sch_teql can end up
1197 * using alternative, different, neigh objects to output
1198 * the packet in the output path. So what we need to do
1199 * here is re-lookup the top-level neigh in the path so
1200 * we can reinject the packet there.
1201 */
1202 n2 = NULL;
1203 if (dst) {
1204 n2 = dst_neigh_lookup_skb(dst, skb);
1205 if (n2)
1206 n1 = n2;
1207 }
David S. Miller8f40b162011-07-17 13:34:11 -07001208 n1->output(n1, skb);
David S. Miller13a43d92012-07-02 22:15:37 -07001209 if (n2)
1210 neigh_release(n2);
roy.qing.li@gmail.come049f282011-10-17 22:32:42 +00001211 rcu_read_unlock();
1212
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 write_lock_bh(&neigh->lock);
1214 }
Eric Dumazetc9ab4d82013-06-28 02:37:42 -07001215 __skb_queue_purge(&neigh->arp_queue);
Eric Dumazet8b5c1712011-11-09 12:07:14 +00001216 neigh->arp_queue_len_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 }
1218out:
1219 if (update_isrouter) {
1220 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1221 (neigh->flags | NTF_ROUTER) :
1222 (neigh->flags & ~NTF_ROUTER);
1223 }
1224 write_unlock_bh(&neigh->lock);
Tom Tucker8d717402006-07-30 20:43:36 -07001225
1226 if (notify)
Thomas Grafd961db32007-08-08 23:12:56 -07001227 neigh_update_notify(neigh);
1228
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 return err;
1230}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001231EXPORT_SYMBOL(neigh_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
1233struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1234 u8 *lladdr, void *saddr,
1235 struct net_device *dev)
1236{
1237 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1238 lladdr || !dev->addr_len);
1239 if (neigh)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001240 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 NEIGH_UPDATE_F_OVERRIDE);
1242 return neigh;
1243}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001244EXPORT_SYMBOL(neigh_event_ns);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
Eric Dumazet34d101d2010-10-11 09:16:57 -07001246/* called with read_lock_bh(&n->lock); */
David S. Millerf6b72b62011-07-14 07:53:20 -07001247static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 struct net_device *dev = dst->dev;
David S. Millerf6b72b62011-07-14 07:53:20 -07001250 __be16 prot = dst->ops->protocol;
1251 struct hh_cache *hh = &n->hh;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001252
1253 write_lock_bh(&n->lock);
Eric Dumazet34d101d2010-10-11 09:16:57 -07001254
David S. Millerf6b72b62011-07-14 07:53:20 -07001255 /* Only one thread can come in here and initialize the
1256 * hh_cache entry.
1257 */
David S. Millerb23b5452011-07-16 17:45:02 -07001258 if (!hh->hh_len)
1259 dev->header_ops->cache(n, hh, prot);
David S. Millerf6b72b62011-07-14 07:53:20 -07001260
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001261 write_unlock_bh(&n->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262}
1263
1264/* This function can be used in contexts, where only old dev_queue_xmit
Eric Dumazet767e97e2010-10-06 17:49:21 -07001265 * worked, f.e. if you want to override normal output path (eql, shaper),
1266 * but resolution is not made yet.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 */
1268
David S. Miller8f40b162011-07-17 13:34:11 -07001269int neigh_compat_output(struct neighbour *neigh, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270{
1271 struct net_device *dev = skb->dev;
1272
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03001273 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001275 if (dev_hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
1276 skb->len) < 0 &&
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001277 dev->header_ops->rebuild(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 return 0;
1279
1280 return dev_queue_xmit(skb);
1281}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001282EXPORT_SYMBOL(neigh_compat_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
1284/* Slow and careful. */
1285
David S. Miller8f40b162011-07-17 13:34:11 -07001286int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287{
Eric Dumazetadf30902009-06-02 05:19:30 +00001288 struct dst_entry *dst = skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 int rc = 0;
1290
David S. Miller8f40b162011-07-17 13:34:11 -07001291 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 goto discard;
1293
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 if (!neigh_event_send(neigh, skb)) {
1295 int err;
1296 struct net_device *dev = neigh->dev;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001297 unsigned int seq;
Eric Dumazet34d101d2010-10-11 09:16:57 -07001298
David S. Millerf6b72b62011-07-14 07:53:20 -07001299 if (dev->header_ops->cache && !neigh->hh.hh_len)
1300 neigh_hh_init(neigh, dst);
Eric Dumazet34d101d2010-10-11 09:16:57 -07001301
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001302 do {
ramesh.nagappa@gmail.come1f16502012-10-05 19:10:15 +00001303 __skb_pull(skb, skb_network_offset(skb));
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001304 seq = read_seqbegin(&neigh->ha_lock);
1305 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1306 neigh->ha, NULL, skb->len);
1307 } while (read_seqretry(&neigh->ha_lock, seq));
Eric Dumazet34d101d2010-10-11 09:16:57 -07001308
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 if (err >= 0)
David S. Miller542d4d62011-07-16 18:06:24 -07001310 rc = dev_queue_xmit(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 else
1312 goto out_kfree_skb;
1313 }
1314out:
1315 return rc;
1316discard:
Joe Perchesd5d427c2013-04-15 15:17:19 +00001317 neigh_dbg(1, "%s: dst=%p neigh=%p\n", __func__, dst, neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318out_kfree_skb:
1319 rc = -EINVAL;
1320 kfree_skb(skb);
1321 goto out;
1322}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001323EXPORT_SYMBOL(neigh_resolve_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
1325/* As fast as possible without hh cache */
1326
David S. Miller8f40b162011-07-17 13:34:11 -07001327int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 struct net_device *dev = neigh->dev;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001330 unsigned int seq;
David S. Miller8f40b162011-07-17 13:34:11 -07001331 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001333 do {
ramesh.nagappa@gmail.come1f16502012-10-05 19:10:15 +00001334 __skb_pull(skb, skb_network_offset(skb));
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00001335 seq = read_seqbegin(&neigh->ha_lock);
1336 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1337 neigh->ha, NULL, skb->len);
1338 } while (read_seqretry(&neigh->ha_lock, seq));
1339
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 if (err >= 0)
David S. Miller542d4d62011-07-16 18:06:24 -07001341 err = dev_queue_xmit(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 else {
1343 err = -EINVAL;
1344 kfree_skb(skb);
1345 }
1346 return err;
1347}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001348EXPORT_SYMBOL(neigh_connected_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349
David S. Miller8f40b162011-07-17 13:34:11 -07001350int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb)
1351{
1352 return dev_queue_xmit(skb);
1353}
1354EXPORT_SYMBOL(neigh_direct_output);
1355
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356static void neigh_proxy_process(unsigned long arg)
1357{
1358 struct neigh_table *tbl = (struct neigh_table *)arg;
1359 long sched_next = 0;
1360 unsigned long now = jiffies;
David S. Millerf72051b2008-09-23 01:11:18 -07001361 struct sk_buff *skb, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
1363 spin_lock(&tbl->proxy_queue.lock);
1364
David S. Millerf72051b2008-09-23 01:11:18 -07001365 skb_queue_walk_safe(&tbl->proxy_queue, skb, n) {
1366 long tdif = NEIGH_CB(skb)->sched_next - now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 if (tdif <= 0) {
David S. Millerf72051b2008-09-23 01:11:18 -07001369 struct net_device *dev = skb->dev;
Eric Dumazet20e60742011-08-22 19:32:42 +00001370
David S. Millerf72051b2008-09-23 01:11:18 -07001371 __skb_unlink(skb, &tbl->proxy_queue);
Eric Dumazet20e60742011-08-22 19:32:42 +00001372 if (tbl->proxy_redo && netif_running(dev)) {
1373 rcu_read_lock();
David S. Millerf72051b2008-09-23 01:11:18 -07001374 tbl->proxy_redo(skb);
Eric Dumazet20e60742011-08-22 19:32:42 +00001375 rcu_read_unlock();
1376 } else {
David S. Millerf72051b2008-09-23 01:11:18 -07001377 kfree_skb(skb);
Eric Dumazet20e60742011-08-22 19:32:42 +00001378 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379
1380 dev_put(dev);
1381 } else if (!sched_next || tdif < sched_next)
1382 sched_next = tdif;
1383 }
1384 del_timer(&tbl->proxy_timer);
1385 if (sched_next)
1386 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1387 spin_unlock(&tbl->proxy_queue.lock);
1388}
1389
1390void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1391 struct sk_buff *skb)
1392{
1393 unsigned long now = jiffies;
1394 unsigned long sched_next = now + (net_random() % p->proxy_delay);
1395
1396 if (tbl->proxy_queue.qlen > p->proxy_qlen) {
1397 kfree_skb(skb);
1398 return;
1399 }
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001400
1401 NEIGH_CB(skb)->sched_next = sched_next;
1402 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403
1404 spin_lock(&tbl->proxy_queue.lock);
1405 if (del_timer(&tbl->proxy_timer)) {
1406 if (time_before(tbl->proxy_timer.expires, sched_next))
1407 sched_next = tbl->proxy_timer.expires;
1408 }
Eric Dumazetadf30902009-06-02 05:19:30 +00001409 skb_dst_drop(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 dev_hold(skb->dev);
1411 __skb_queue_tail(&tbl->proxy_queue, skb);
1412 mod_timer(&tbl->proxy_timer, sched_next);
1413 spin_unlock(&tbl->proxy_queue.lock);
1414}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001415EXPORT_SYMBOL(pneigh_enqueue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416
Tobias Klauser97fd5bc2009-07-13 11:17:49 -07001417static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl,
Eric W. Biederman426b5302008-01-24 00:13:18 -08001418 struct net *net, int ifindex)
1419{
1420 struct neigh_parms *p;
1421
1422 for (p = &tbl->parms; p; p = p->next) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001423 if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) ||
Gao feng170d6f92013-06-20 10:01:33 +08001424 (!p->dev && !ifindex && net_eq(net, &init_net)))
Eric W. Biederman426b5302008-01-24 00:13:18 -08001425 return p;
1426 }
1427
1428 return NULL;
1429}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430
1431struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1432 struct neigh_table *tbl)
1433{
Gao fengcf89d6b2013-06-20 10:01:32 +08001434 struct neigh_parms *p;
Stephen Hemminger00829822008-11-20 20:14:53 -08001435 struct net *net = dev_net(dev);
1436 const struct net_device_ops *ops = dev->netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437
Gao fengcf89d6b2013-06-20 10:01:32 +08001438 p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 p->tbl = tbl;
1441 atomic_set(&p->refcnt, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 p->reachable_time =
1443 neigh_rand_reach_time(p->base_reachable_time);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001444
Stephen Hemminger00829822008-11-20 20:14:53 -08001445 if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) {
Denis V. Lunev486b51d2008-01-14 22:59:59 -08001446 kfree(p);
1447 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 }
Denis V. Lunev486b51d2008-01-14 22:59:59 -08001449
1450 dev_hold(dev);
1451 p->dev = dev;
Eric Dumazete42ea982008-11-12 00:54:54 -08001452 write_pnet(&p->net, hold_net(net));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 p->sysctl_table = NULL;
1454 write_lock_bh(&tbl->lock);
1455 p->next = tbl->parms.next;
1456 tbl->parms.next = p;
1457 write_unlock_bh(&tbl->lock);
1458 }
1459 return p;
1460}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001461EXPORT_SYMBOL(neigh_parms_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
1463static void neigh_rcu_free_parms(struct rcu_head *head)
1464{
1465 struct neigh_parms *parms =
1466 container_of(head, struct neigh_parms, rcu_head);
1467
1468 neigh_parms_put(parms);
1469}
1470
1471void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1472{
1473 struct neigh_parms **p;
1474
1475 if (!parms || parms == &tbl->parms)
1476 return;
1477 write_lock_bh(&tbl->lock);
1478 for (p = &tbl->parms.next; *p; p = &(*p)->next) {
1479 if (*p == parms) {
1480 *p = parms->next;
1481 parms->dead = 1;
1482 write_unlock_bh(&tbl->lock);
David S. Millercecbb632008-01-20 16:39:03 -08001483 if (parms->dev)
1484 dev_put(parms->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1486 return;
1487 }
1488 }
1489 write_unlock_bh(&tbl->lock);
Joe Perchesd5d427c2013-04-15 15:17:19 +00001490 neigh_dbg(1, "%s: not found\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001492EXPORT_SYMBOL(neigh_parms_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493
Denis V. Lunev06f05112008-01-24 00:30:58 -08001494static void neigh_parms_destroy(struct neigh_parms *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495{
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +09001496 release_net(neigh_parms_net(parms));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 kfree(parms);
1498}
1499
Pavel Emelianovc2ecba72007-04-17 12:45:31 -07001500static struct lock_class_key neigh_table_proxy_queue_class;
1501
Hiroaki SHIMODAdcd2ba92012-04-13 07:34:44 +00001502static void neigh_table_init_no_netlink(struct neigh_table *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503{
1504 unsigned long now = jiffies;
1505 unsigned long phsize;
1506
Eric Dumazete42ea982008-11-12 00:54:54 -08001507 write_pnet(&tbl->parms.net, &init_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 atomic_set(&tbl->parms.refcnt, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 tbl->parms.reachable_time =
1510 neigh_rand_reach_time(tbl->parms.base_reachable_time);
1511
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 tbl->stats = alloc_percpu(struct neigh_statistics);
1513 if (!tbl->stats)
1514 panic("cannot create neighbour cache statistics");
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001515
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516#ifdef CONFIG_PROC_FS
Alexey Dobriyan9b739ba2008-11-11 16:47:44 -08001517 if (!proc_create_data(tbl->id, 0, init_net.proc_net_stat,
1518 &neigh_stat_seq_fops, tbl))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 panic("cannot create neighbour proc dir entry");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520#endif
1521
David S. Millercd089332011-07-11 01:28:12 -07001522 RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523
1524 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
Andrew Morton77d04bd2006-04-07 14:52:59 -07001525 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526
Eric Dumazetd6bf7812010-10-04 06:15:44 +00001527 if (!tbl->nht || !tbl->phash_buckets)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 panic("cannot allocate neighbour cache hashes");
1529
YOSHIFUJI Hideaki / 吉藤英明08433ef2013-01-24 00:44:23 +00001530 if (!tbl->entry_size)
1531 tbl->entry_size = ALIGN(offsetof(struct neighbour, primary_key) +
1532 tbl->key_len, NEIGH_PRIV_ALIGN);
1533 else
1534 WARN_ON(tbl->entry_size % NEIGH_PRIV_ALIGN);
1535
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 rwlock_init(&tbl->lock);
Tejun Heo203b42f2012-08-21 13:18:23 -07001537 INIT_DEFERRABLE_WORK(&tbl->gc_work, neigh_periodic_work);
Eric Dumazete4c4e442009-07-30 03:15:07 +00001538 schedule_delayed_work(&tbl->gc_work, tbl->parms.reachable_time);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -08001539 setup_timer(&tbl->proxy_timer, neigh_proxy_process, (unsigned long)tbl);
Pavel Emelianovc2ecba72007-04-17 12:45:31 -07001540 skb_queue_head_init_class(&tbl->proxy_queue,
1541 &neigh_table_proxy_queue_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542
1543 tbl->last_flush = now;
1544 tbl->last_rand = now + tbl->parms.reachable_time * 20;
Simon Kelleybd89efc2006-05-12 14:56:08 -07001545}
1546
1547void neigh_table_init(struct neigh_table *tbl)
1548{
1549 struct neigh_table *tmp;
1550
1551 neigh_table_init_no_netlink(tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 write_lock(&neigh_tbl_lock);
Simon Kelleybd89efc2006-05-12 14:56:08 -07001553 for (tmp = neigh_tables; tmp; tmp = tmp->next) {
1554 if (tmp->family == tbl->family)
1555 break;
1556 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 tbl->next = neigh_tables;
1558 neigh_tables = tbl;
1559 write_unlock(&neigh_tbl_lock);
Simon Kelleybd89efc2006-05-12 14:56:08 -07001560
1561 if (unlikely(tmp)) {
Joe Perchese005d192012-05-16 19:58:40 +00001562 pr_err("Registering multiple tables for family %d\n",
1563 tbl->family);
Simon Kelleybd89efc2006-05-12 14:56:08 -07001564 dump_stack();
1565 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001567EXPORT_SYMBOL(neigh_table_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
1569int neigh_table_clear(struct neigh_table *tbl)
1570{
1571 struct neigh_table **tp;
1572
1573 /* It is not clean... Fix it to unload IPv6 module safely */
Tejun Heoa5c30b32010-10-19 06:04:42 +00001574 cancel_delayed_work_sync(&tbl->gc_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 del_timer_sync(&tbl->proxy_timer);
1576 pneigh_queue_purge(&tbl->proxy_queue);
1577 neigh_ifdown(tbl, NULL);
1578 if (atomic_read(&tbl->entries))
Joe Perchese005d192012-05-16 19:58:40 +00001579 pr_crit("neighbour leakage\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 write_lock(&neigh_tbl_lock);
1581 for (tp = &neigh_tables; *tp; tp = &(*tp)->next) {
1582 if (*tp == tbl) {
1583 *tp = tbl->next;
1584 break;
1585 }
1586 }
1587 write_unlock(&neigh_tbl_lock);
1588
Eric Dumazet6193d2b2011-01-19 22:02:47 +00001589 call_rcu(&rcu_dereference_protected(tbl->nht, 1)->rcu,
1590 neigh_hash_free_rcu);
Eric Dumazetd6bf7812010-10-04 06:15:44 +00001591 tbl->nht = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592
1593 kfree(tbl->phash_buckets);
1594 tbl->phash_buckets = NULL;
1595
Alexey Dobriyan3f192b52007-11-05 21:28:13 -08001596 remove_proc_entry(tbl->id, init_net.proc_net_stat);
1597
Kirill Korotaev3fcde742006-09-01 01:34:10 -07001598 free_percpu(tbl->stats);
1599 tbl->stats = NULL;
1600
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 return 0;
1602}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001603EXPORT_SYMBOL(neigh_table_clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604
Thomas Graf661d2962013-03-21 07:45:29 +00001605static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001607 struct net *net = sock_net(skb->sk);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001608 struct ndmsg *ndm;
1609 struct nlattr *dst_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 struct neigh_table *tbl;
1611 struct net_device *dev = NULL;
Thomas Grafa14a49d2006-08-07 17:53:08 -07001612 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
Eric Dumazet110b2492010-10-04 04:27:36 +00001614 ASSERT_RTNL();
Thomas Grafa14a49d2006-08-07 17:53:08 -07001615 if (nlmsg_len(nlh) < sizeof(*ndm))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 goto out;
1617
Thomas Grafa14a49d2006-08-07 17:53:08 -07001618 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1619 if (dst_attr == NULL)
1620 goto out;
1621
1622 ndm = nlmsg_data(nlh);
1623 if (ndm->ndm_ifindex) {
Eric Dumazet110b2492010-10-04 04:27:36 +00001624 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001625 if (dev == NULL) {
1626 err = -ENODEV;
1627 goto out;
1628 }
1629 }
1630
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 read_lock(&neigh_tbl_lock);
1632 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
Thomas Grafa14a49d2006-08-07 17:53:08 -07001633 struct neighbour *neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634
1635 if (tbl->family != ndm->ndm_family)
1636 continue;
1637 read_unlock(&neigh_tbl_lock);
1638
Thomas Grafa14a49d2006-08-07 17:53:08 -07001639 if (nla_len(dst_attr) < tbl->key_len)
Eric Dumazet110b2492010-10-04 04:27:36 +00001640 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
1642 if (ndm->ndm_flags & NTF_PROXY) {
Eric W. Biederman426b5302008-01-24 00:13:18 -08001643 err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
Eric Dumazet110b2492010-10-04 04:27:36 +00001644 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 }
1646
Thomas Grafa14a49d2006-08-07 17:53:08 -07001647 if (dev == NULL)
Eric Dumazet110b2492010-10-04 04:27:36 +00001648 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
Thomas Grafa14a49d2006-08-07 17:53:08 -07001650 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1651 if (neigh == NULL) {
1652 err = -ENOENT;
Eric Dumazet110b2492010-10-04 04:27:36 +00001653 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 }
Thomas Grafa14a49d2006-08-07 17:53:08 -07001655
1656 err = neigh_update(neigh, NULL, NUD_FAILED,
1657 NEIGH_UPDATE_F_OVERRIDE |
1658 NEIGH_UPDATE_F_ADMIN);
1659 neigh_release(neigh);
Eric Dumazet110b2492010-10-04 04:27:36 +00001660 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 }
1662 read_unlock(&neigh_tbl_lock);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001663 err = -EAFNOSUPPORT;
1664
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665out:
1666 return err;
1667}
1668
Thomas Graf661d2962013-03-21 07:45:29 +00001669static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001671 struct net *net = sock_net(skb->sk);
Thomas Graf5208deb2006-08-07 17:55:40 -07001672 struct ndmsg *ndm;
1673 struct nlattr *tb[NDA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 struct neigh_table *tbl;
1675 struct net_device *dev = NULL;
Thomas Graf5208deb2006-08-07 17:55:40 -07001676 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
Eric Dumazet110b2492010-10-04 04:27:36 +00001678 ASSERT_RTNL();
Thomas Graf5208deb2006-08-07 17:55:40 -07001679 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
1680 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 goto out;
1682
Thomas Graf5208deb2006-08-07 17:55:40 -07001683 err = -EINVAL;
1684 if (tb[NDA_DST] == NULL)
1685 goto out;
1686
1687 ndm = nlmsg_data(nlh);
1688 if (ndm->ndm_ifindex) {
Eric Dumazet110b2492010-10-04 04:27:36 +00001689 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
Thomas Graf5208deb2006-08-07 17:55:40 -07001690 if (dev == NULL) {
1691 err = -ENODEV;
1692 goto out;
1693 }
1694
1695 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
Eric Dumazet110b2492010-10-04 04:27:36 +00001696 goto out;
Thomas Graf5208deb2006-08-07 17:55:40 -07001697 }
1698
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 read_lock(&neigh_tbl_lock);
1700 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
Thomas Graf5208deb2006-08-07 17:55:40 -07001701 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
1702 struct neighbour *neigh;
1703 void *dst, *lladdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704
1705 if (tbl->family != ndm->ndm_family)
1706 continue;
1707 read_unlock(&neigh_tbl_lock);
1708
Thomas Graf5208deb2006-08-07 17:55:40 -07001709 if (nla_len(tb[NDA_DST]) < tbl->key_len)
Eric Dumazet110b2492010-10-04 04:27:36 +00001710 goto out;
Thomas Graf5208deb2006-08-07 17:55:40 -07001711 dst = nla_data(tb[NDA_DST]);
1712 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713
1714 if (ndm->ndm_flags & NTF_PROXY) {
Ville Nuorvala62dd9312006-09-22 14:43:19 -07001715 struct pneigh_entry *pn;
1716
1717 err = -ENOBUFS;
Eric W. Biederman426b5302008-01-24 00:13:18 -08001718 pn = pneigh_lookup(tbl, net, dst, dev, 1);
Ville Nuorvala62dd9312006-09-22 14:43:19 -07001719 if (pn) {
1720 pn->flags = ndm->ndm_flags;
1721 err = 0;
1722 }
Eric Dumazet110b2492010-10-04 04:27:36 +00001723 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 }
1725
Thomas Graf5208deb2006-08-07 17:55:40 -07001726 if (dev == NULL)
Eric Dumazet110b2492010-10-04 04:27:36 +00001727 goto out;
Thomas Graf5208deb2006-08-07 17:55:40 -07001728
1729 neigh = neigh_lookup(tbl, dst, dev);
1730 if (neigh == NULL) {
1731 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1732 err = -ENOENT;
Eric Dumazet110b2492010-10-04 04:27:36 +00001733 goto out;
Thomas Graf5208deb2006-08-07 17:55:40 -07001734 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001735
Thomas Graf5208deb2006-08-07 17:55:40 -07001736 neigh = __neigh_lookup_errno(tbl, dst, dev);
1737 if (IS_ERR(neigh)) {
1738 err = PTR_ERR(neigh);
Eric Dumazet110b2492010-10-04 04:27:36 +00001739 goto out;
Thomas Graf5208deb2006-08-07 17:55:40 -07001740 }
1741 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1743 err = -EEXIST;
Thomas Graf5208deb2006-08-07 17:55:40 -07001744 neigh_release(neigh);
Eric Dumazet110b2492010-10-04 04:27:36 +00001745 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 }
Thomas Graf5208deb2006-08-07 17:55:40 -07001747
1748 if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
1749 flags &= ~NEIGH_UPDATE_F_OVERRIDE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 }
1751
Eric Biederman0c5c2d32009-03-04 00:03:08 -08001752 if (ndm->ndm_flags & NTF_USE) {
1753 neigh_event_send(neigh, NULL);
1754 err = 0;
1755 } else
1756 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
Thomas Graf5208deb2006-08-07 17:55:40 -07001757 neigh_release(neigh);
Eric Dumazet110b2492010-10-04 04:27:36 +00001758 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 }
1760
1761 read_unlock(&neigh_tbl_lock);
Thomas Graf5208deb2006-08-07 17:55:40 -07001762 err = -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763out:
1764 return err;
1765}
1766
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001767static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1768{
Thomas Grafca860fb2006-08-07 18:00:18 -07001769 struct nlattr *nest;
1770
1771 nest = nla_nest_start(skb, NDTA_PARMS);
1772 if (nest == NULL)
1773 return -ENOBUFS;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001774
David S. Miller9a6308d2012-04-01 20:06:28 -04001775 if ((parms->dev &&
1776 nla_put_u32(skb, NDTPA_IFINDEX, parms->dev->ifindex)) ||
1777 nla_put_u32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt)) ||
1778 nla_put_u32(skb, NDTPA_QUEUE_LENBYTES, parms->queue_len_bytes) ||
1779 /* approximative value for deprecated QUEUE_LEN (in packets) */
1780 nla_put_u32(skb, NDTPA_QUEUE_LEN,
Shan Weice46cc62012-12-04 18:49:15 +00001781 parms->queue_len_bytes / SKB_TRUESIZE(ETH_FRAME_LEN)) ||
David S. Miller9a6308d2012-04-01 20:06:28 -04001782 nla_put_u32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen) ||
1783 nla_put_u32(skb, NDTPA_APP_PROBES, parms->app_probes) ||
1784 nla_put_u32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes) ||
1785 nla_put_u32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes) ||
1786 nla_put_msecs(skb, NDTPA_REACHABLE_TIME, parms->reachable_time) ||
1787 nla_put_msecs(skb, NDTPA_BASE_REACHABLE_TIME,
1788 parms->base_reachable_time) ||
1789 nla_put_msecs(skb, NDTPA_GC_STALETIME, parms->gc_staletime) ||
1790 nla_put_msecs(skb, NDTPA_DELAY_PROBE_TIME,
1791 parms->delay_probe_time) ||
1792 nla_put_msecs(skb, NDTPA_RETRANS_TIME, parms->retrans_time) ||
1793 nla_put_msecs(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay) ||
1794 nla_put_msecs(skb, NDTPA_PROXY_DELAY, parms->proxy_delay) ||
1795 nla_put_msecs(skb, NDTPA_LOCKTIME, parms->locktime))
1796 goto nla_put_failure;
Thomas Grafca860fb2006-08-07 18:00:18 -07001797 return nla_nest_end(skb, nest);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001798
Thomas Grafca860fb2006-08-07 18:00:18 -07001799nla_put_failure:
Thomas Grafbc3ed282008-06-03 16:36:54 -07001800 nla_nest_cancel(skb, nest);
1801 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001802}
1803
Thomas Grafca860fb2006-08-07 18:00:18 -07001804static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
1805 u32 pid, u32 seq, int type, int flags)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001806{
1807 struct nlmsghdr *nlh;
1808 struct ndtmsg *ndtmsg;
1809
Thomas Grafca860fb2006-08-07 18:00:18 -07001810 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1811 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001812 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001813
Thomas Grafca860fb2006-08-07 18:00:18 -07001814 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001815
1816 read_lock_bh(&tbl->lock);
1817 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001818 ndtmsg->ndtm_pad1 = 0;
1819 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001820
David S. Miller9a6308d2012-04-01 20:06:28 -04001821 if (nla_put_string(skb, NDTA_NAME, tbl->id) ||
1822 nla_put_msecs(skb, NDTA_GC_INTERVAL, tbl->gc_interval) ||
1823 nla_put_u32(skb, NDTA_THRESH1, tbl->gc_thresh1) ||
1824 nla_put_u32(skb, NDTA_THRESH2, tbl->gc_thresh2) ||
1825 nla_put_u32(skb, NDTA_THRESH3, tbl->gc_thresh3))
1826 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001827 {
1828 unsigned long now = jiffies;
1829 unsigned int flush_delta = now - tbl->last_flush;
1830 unsigned int rand_delta = now - tbl->last_rand;
Eric Dumazetd6bf7812010-10-04 06:15:44 +00001831 struct neigh_hash_table *nht;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001832 struct ndt_config ndc = {
1833 .ndtc_key_len = tbl->key_len,
1834 .ndtc_entry_size = tbl->entry_size,
1835 .ndtc_entries = atomic_read(&tbl->entries),
1836 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
1837 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001838 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
1839 };
1840
Eric Dumazetd6bf7812010-10-04 06:15:44 +00001841 rcu_read_lock_bh();
1842 nht = rcu_dereference_bh(tbl->nht);
David S. Miller2c2aba62011-12-28 15:06:58 -05001843 ndc.ndtc_hash_rnd = nht->hash_rnd[0];
David S. Millercd089332011-07-11 01:28:12 -07001844 ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1);
Eric Dumazetd6bf7812010-10-04 06:15:44 +00001845 rcu_read_unlock_bh();
1846
David S. Miller9a6308d2012-04-01 20:06:28 -04001847 if (nla_put(skb, NDTA_CONFIG, sizeof(ndc), &ndc))
1848 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001849 }
1850
1851 {
1852 int cpu;
1853 struct ndt_stats ndst;
1854
1855 memset(&ndst, 0, sizeof(ndst));
1856
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -07001857 for_each_possible_cpu(cpu) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001858 struct neigh_statistics *st;
1859
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001860 st = per_cpu_ptr(tbl->stats, cpu);
1861 ndst.ndts_allocs += st->allocs;
1862 ndst.ndts_destroys += st->destroys;
1863 ndst.ndts_hash_grows += st->hash_grows;
1864 ndst.ndts_res_failed += st->res_failed;
1865 ndst.ndts_lookups += st->lookups;
1866 ndst.ndts_hits += st->hits;
1867 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1868 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1869 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1870 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1871 }
1872
David S. Miller9a6308d2012-04-01 20:06:28 -04001873 if (nla_put(skb, NDTA_STATS, sizeof(ndst), &ndst))
1874 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001875 }
1876
1877 BUG_ON(tbl->parms.dev);
1878 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
Thomas Grafca860fb2006-08-07 18:00:18 -07001879 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001880
1881 read_unlock_bh(&tbl->lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001882 return nlmsg_end(skb, nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001883
Thomas Grafca860fb2006-08-07 18:00:18 -07001884nla_put_failure:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001885 read_unlock_bh(&tbl->lock);
Patrick McHardy26932562007-01-31 23:16:40 -08001886 nlmsg_cancel(skb, nlh);
1887 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001888}
1889
Thomas Grafca860fb2006-08-07 18:00:18 -07001890static int neightbl_fill_param_info(struct sk_buff *skb,
1891 struct neigh_table *tbl,
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001892 struct neigh_parms *parms,
Thomas Grafca860fb2006-08-07 18:00:18 -07001893 u32 pid, u32 seq, int type,
1894 unsigned int flags)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001895{
1896 struct ndtmsg *ndtmsg;
1897 struct nlmsghdr *nlh;
1898
Thomas Grafca860fb2006-08-07 18:00:18 -07001899 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1900 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001901 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001902
Thomas Grafca860fb2006-08-07 18:00:18 -07001903 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001904
1905 read_lock_bh(&tbl->lock);
1906 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001907 ndtmsg->ndtm_pad1 = 0;
1908 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001909
Thomas Grafca860fb2006-08-07 18:00:18 -07001910 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
1911 neightbl_fill_parms(skb, parms) < 0)
1912 goto errout;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001913
1914 read_unlock_bh(&tbl->lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001915 return nlmsg_end(skb, nlh);
1916errout:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001917 read_unlock_bh(&tbl->lock);
Patrick McHardy26932562007-01-31 23:16:40 -08001918 nlmsg_cancel(skb, nlh);
1919 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001920}
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001921
Patrick McHardyef7c79e2007-06-05 12:38:30 -07001922static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
Thomas Graf6b3f8672006-08-07 17:58:53 -07001923 [NDTA_NAME] = { .type = NLA_STRING },
1924 [NDTA_THRESH1] = { .type = NLA_U32 },
1925 [NDTA_THRESH2] = { .type = NLA_U32 },
1926 [NDTA_THRESH3] = { .type = NLA_U32 },
1927 [NDTA_GC_INTERVAL] = { .type = NLA_U64 },
1928 [NDTA_PARMS] = { .type = NLA_NESTED },
1929};
1930
Patrick McHardyef7c79e2007-06-05 12:38:30 -07001931static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
Thomas Graf6b3f8672006-08-07 17:58:53 -07001932 [NDTPA_IFINDEX] = { .type = NLA_U32 },
1933 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 },
1934 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 },
1935 [NDTPA_APP_PROBES] = { .type = NLA_U32 },
1936 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 },
1937 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 },
1938 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 },
1939 [NDTPA_GC_STALETIME] = { .type = NLA_U64 },
1940 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 },
1941 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 },
1942 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 },
1943 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 },
1944 [NDTPA_LOCKTIME] = { .type = NLA_U64 },
1945};
1946
Thomas Graf661d2962013-03-21 07:45:29 +00001947static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001948{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001949 struct net *net = sock_net(skb->sk);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001950 struct neigh_table *tbl;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001951 struct ndtmsg *ndtmsg;
1952 struct nlattr *tb[NDTA_MAX+1];
1953 int err;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001954
Thomas Graf6b3f8672006-08-07 17:58:53 -07001955 err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
1956 nl_neightbl_policy);
1957 if (err < 0)
1958 goto errout;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001959
Thomas Graf6b3f8672006-08-07 17:58:53 -07001960 if (tb[NDTA_NAME] == NULL) {
1961 err = -EINVAL;
1962 goto errout;
1963 }
1964
1965 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001966 read_lock(&neigh_tbl_lock);
1967 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1968 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1969 continue;
1970
Thomas Graf6b3f8672006-08-07 17:58:53 -07001971 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001972 break;
1973 }
1974
1975 if (tbl == NULL) {
1976 err = -ENOENT;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001977 goto errout_locked;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001978 }
1979
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001980 /*
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001981 * We acquire tbl->lock to be nice to the periodic timers and
1982 * make sure they always see a consistent set of values.
1983 */
1984 write_lock_bh(&tbl->lock);
1985
Thomas Graf6b3f8672006-08-07 17:58:53 -07001986 if (tb[NDTA_PARMS]) {
1987 struct nlattr *tbp[NDTPA_MAX+1];
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001988 struct neigh_parms *p;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001989 int i, ifindex = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001990
Thomas Graf6b3f8672006-08-07 17:58:53 -07001991 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
1992 nl_ntbl_parm_policy);
1993 if (err < 0)
1994 goto errout_tbl_lock;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001995
Thomas Graf6b3f8672006-08-07 17:58:53 -07001996 if (tbp[NDTPA_IFINDEX])
1997 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001998
Tobias Klauser97fd5bc2009-07-13 11:17:49 -07001999 p = lookup_neigh_parms(tbl, net, ifindex);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002000 if (p == NULL) {
2001 err = -ENOENT;
Thomas Graf6b3f8672006-08-07 17:58:53 -07002002 goto errout_tbl_lock;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002003 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002004
Thomas Graf6b3f8672006-08-07 17:58:53 -07002005 for (i = 1; i <= NDTPA_MAX; i++) {
2006 if (tbp[i] == NULL)
2007 continue;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002008
Thomas Graf6b3f8672006-08-07 17:58:53 -07002009 switch (i) {
2010 case NDTPA_QUEUE_LEN:
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002011 p->queue_len_bytes = nla_get_u32(tbp[i]) *
2012 SKB_TRUESIZE(ETH_FRAME_LEN);
2013 break;
2014 case NDTPA_QUEUE_LENBYTES:
2015 p->queue_len_bytes = nla_get_u32(tbp[i]);
Thomas Graf6b3f8672006-08-07 17:58:53 -07002016 break;
2017 case NDTPA_PROXY_QLEN:
2018 p->proxy_qlen = nla_get_u32(tbp[i]);
2019 break;
2020 case NDTPA_APP_PROBES:
2021 p->app_probes = nla_get_u32(tbp[i]);
2022 break;
2023 case NDTPA_UCAST_PROBES:
2024 p->ucast_probes = nla_get_u32(tbp[i]);
2025 break;
2026 case NDTPA_MCAST_PROBES:
2027 p->mcast_probes = nla_get_u32(tbp[i]);
2028 break;
2029 case NDTPA_BASE_REACHABLE_TIME:
2030 p->base_reachable_time = nla_get_msecs(tbp[i]);
2031 break;
2032 case NDTPA_GC_STALETIME:
2033 p->gc_staletime = nla_get_msecs(tbp[i]);
2034 break;
2035 case NDTPA_DELAY_PROBE_TIME:
2036 p->delay_probe_time = nla_get_msecs(tbp[i]);
2037 break;
2038 case NDTPA_RETRANS_TIME:
2039 p->retrans_time = nla_get_msecs(tbp[i]);
2040 break;
2041 case NDTPA_ANYCAST_DELAY:
2042 p->anycast_delay = nla_get_msecs(tbp[i]);
2043 break;
2044 case NDTPA_PROXY_DELAY:
2045 p->proxy_delay = nla_get_msecs(tbp[i]);
2046 break;
2047 case NDTPA_LOCKTIME:
2048 p->locktime = nla_get_msecs(tbp[i]);
2049 break;
2050 }
2051 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002052 }
2053
Gao fengdc25c672013-06-20 10:01:34 +08002054 err = -ENOENT;
2055 if ((tb[NDTA_THRESH1] || tb[NDTA_THRESH2] ||
2056 tb[NDTA_THRESH3] || tb[NDTA_GC_INTERVAL]) &&
2057 !net_eq(net, &init_net))
2058 goto errout_tbl_lock;
2059
Thomas Graf6b3f8672006-08-07 17:58:53 -07002060 if (tb[NDTA_THRESH1])
2061 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
2062
2063 if (tb[NDTA_THRESH2])
2064 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
2065
2066 if (tb[NDTA_THRESH3])
2067 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
2068
2069 if (tb[NDTA_GC_INTERVAL])
2070 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
2071
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002072 err = 0;
2073
Thomas Graf6b3f8672006-08-07 17:58:53 -07002074errout_tbl_lock:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002075 write_unlock_bh(&tbl->lock);
Thomas Graf6b3f8672006-08-07 17:58:53 -07002076errout_locked:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002077 read_unlock(&neigh_tbl_lock);
Thomas Graf6b3f8672006-08-07 17:58:53 -07002078errout:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002079 return err;
2080}
2081
Thomas Grafc8822a42007-03-22 11:50:06 -07002082static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002083{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002084 struct net *net = sock_net(skb->sk);
Thomas Grafca860fb2006-08-07 18:00:18 -07002085 int family, tidx, nidx = 0;
2086 int tbl_skip = cb->args[0];
2087 int neigh_skip = cb->args[1];
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002088 struct neigh_table *tbl;
2089
Thomas Grafca860fb2006-08-07 18:00:18 -07002090 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002091
2092 read_lock(&neigh_tbl_lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07002093 for (tbl = neigh_tables, tidx = 0; tbl; tbl = tbl->next, tidx++) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002094 struct neigh_parms *p;
2095
Thomas Grafca860fb2006-08-07 18:00:18 -07002096 if (tidx < tbl_skip || (family && tbl->family != family))
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002097 continue;
2098
Eric W. Biederman15e47302012-09-07 20:12:54 +00002099 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).portid,
Thomas Grafca860fb2006-08-07 18:00:18 -07002100 cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
2101 NLM_F_MULTI) <= 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002102 break;
2103
Eric W. Biederman426b5302008-01-24 00:13:18 -08002104 for (nidx = 0, p = tbl->parms.next; p; p = p->next) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002105 if (!net_eq(neigh_parms_net(p), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002106 continue;
2107
Gautam Kachrooefc683f2009-02-06 00:52:04 -08002108 if (nidx < neigh_skip)
2109 goto next;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002110
Thomas Grafca860fb2006-08-07 18:00:18 -07002111 if (neightbl_fill_param_info(skb, tbl, p,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002112 NETLINK_CB(cb->skb).portid,
Thomas Grafca860fb2006-08-07 18:00:18 -07002113 cb->nlh->nlmsg_seq,
2114 RTM_NEWNEIGHTBL,
2115 NLM_F_MULTI) <= 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002116 goto out;
Gautam Kachrooefc683f2009-02-06 00:52:04 -08002117 next:
2118 nidx++;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002119 }
2120
Thomas Grafca860fb2006-08-07 18:00:18 -07002121 neigh_skip = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002122 }
2123out:
2124 read_unlock(&neigh_tbl_lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07002125 cb->args[0] = tidx;
2126 cb->args[1] = nidx;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002127
2128 return skb->len;
2129}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130
Thomas Graf8b8aec52006-08-07 17:56:37 -07002131static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
2132 u32 pid, u32 seq, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133{
2134 unsigned long now = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 struct nda_cacheinfo ci;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002136 struct nlmsghdr *nlh;
2137 struct ndmsg *ndm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138
Thomas Graf8b8aec52006-08-07 17:56:37 -07002139 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2140 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08002141 return -EMSGSIZE;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002142
2143 ndm = nlmsg_data(nlh);
2144 ndm->ndm_family = neigh->ops->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07002145 ndm->ndm_pad1 = 0;
2146 ndm->ndm_pad2 = 0;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002147 ndm->ndm_flags = neigh->flags;
2148 ndm->ndm_type = neigh->type;
2149 ndm->ndm_ifindex = neigh->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150
David S. Miller9a6308d2012-04-01 20:06:28 -04002151 if (nla_put(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key))
2152 goto nla_put_failure;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002153
2154 read_lock_bh(&neigh->lock);
2155 ndm->ndm_state = neigh->nud_state;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +00002156 if (neigh->nud_state & NUD_VALID) {
2157 char haddr[MAX_ADDR_LEN];
2158
2159 neigh_ha_snapshot(haddr, neigh, neigh->dev);
2160 if (nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, haddr) < 0) {
2161 read_unlock_bh(&neigh->lock);
2162 goto nla_put_failure;
2163 }
Thomas Graf8b8aec52006-08-07 17:56:37 -07002164 }
2165
Stephen Hemmingerb9f5f522008-06-03 16:03:15 -07002166 ci.ndm_used = jiffies_to_clock_t(now - neigh->used);
2167 ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
2168 ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002169 ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1;
2170 read_unlock_bh(&neigh->lock);
2171
David S. Miller9a6308d2012-04-01 20:06:28 -04002172 if (nla_put_u32(skb, NDA_PROBES, atomic_read(&neigh->probes)) ||
2173 nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
2174 goto nla_put_failure;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002175
2176 return nlmsg_end(skb, nlh);
2177
2178nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002179 nlmsg_cancel(skb, nlh);
2180 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181}
2182
Tony Zelenoff84920c12012-01-26 22:28:58 +00002183static int pneigh_fill_info(struct sk_buff *skb, struct pneigh_entry *pn,
2184 u32 pid, u32 seq, int type, unsigned int flags,
2185 struct neigh_table *tbl)
2186{
2187 struct nlmsghdr *nlh;
2188 struct ndmsg *ndm;
2189
2190 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2191 if (nlh == NULL)
2192 return -EMSGSIZE;
2193
2194 ndm = nlmsg_data(nlh);
2195 ndm->ndm_family = tbl->family;
2196 ndm->ndm_pad1 = 0;
2197 ndm->ndm_pad2 = 0;
2198 ndm->ndm_flags = pn->flags | NTF_PROXY;
2199 ndm->ndm_type = NDA_DST;
2200 ndm->ndm_ifindex = pn->dev->ifindex;
2201 ndm->ndm_state = NUD_NONE;
2202
David S. Miller9a6308d2012-04-01 20:06:28 -04002203 if (nla_put(skb, NDA_DST, tbl->key_len, pn->key))
2204 goto nla_put_failure;
Tony Zelenoff84920c12012-01-26 22:28:58 +00002205
2206 return nlmsg_end(skb, nlh);
2207
2208nla_put_failure:
2209 nlmsg_cancel(skb, nlh);
2210 return -EMSGSIZE;
2211}
2212
Thomas Grafd961db32007-08-08 23:12:56 -07002213static void neigh_update_notify(struct neighbour *neigh)
2214{
2215 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2216 __neigh_notify(neigh, RTM_NEWNEIGH, 0);
2217}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218
2219static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2220 struct netlink_callback *cb)
2221{
Eric Dumazet767e97e2010-10-06 17:49:21 -07002222 struct net *net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 struct neighbour *n;
2224 int rc, h, s_h = cb->args[1];
2225 int idx, s_idx = idx = cb->args[2];
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002226 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002228 rcu_read_lock_bh();
2229 nht = rcu_dereference_bh(tbl->nht);
2230
Eric Dumazet4bd66832012-06-07 04:58:35 +00002231 for (h = s_h; h < (1 << nht->hash_shift); h++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 if (h > s_h)
2233 s_idx = 0;
Eric Dumazet767e97e2010-10-06 17:49:21 -07002234 for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0;
2235 n != NULL;
2236 n = rcu_dereference_bh(n->next)) {
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08002237 if (!net_eq(dev_net(n->dev), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002238 continue;
Gautam Kachrooefc683f2009-02-06 00:52:04 -08002239 if (idx < s_idx)
2240 goto next;
Eric W. Biederman15e47302012-09-07 20:12:54 +00002241 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 cb->nlh->nlmsg_seq,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07002243 RTM_NEWNEIGH,
2244 NLM_F_MULTI) <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 rc = -1;
2246 goto out;
2247 }
Eric Dumazet767e97e2010-10-06 17:49:21 -07002248next:
Gautam Kachrooefc683f2009-02-06 00:52:04 -08002249 idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 }
2252 rc = skb->len;
2253out:
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002254 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 cb->args[1] = h;
2256 cb->args[2] = idx;
2257 return rc;
2258}
2259
Tony Zelenoff84920c12012-01-26 22:28:58 +00002260static int pneigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2261 struct netlink_callback *cb)
2262{
2263 struct pneigh_entry *n;
2264 struct net *net = sock_net(skb->sk);
2265 int rc, h, s_h = cb->args[3];
2266 int idx, s_idx = idx = cb->args[4];
2267
2268 read_lock_bh(&tbl->lock);
2269
Eric Dumazet4bd66832012-06-07 04:58:35 +00002270 for (h = s_h; h <= PNEIGH_HASHMASK; h++) {
Tony Zelenoff84920c12012-01-26 22:28:58 +00002271 if (h > s_h)
2272 s_idx = 0;
2273 for (n = tbl->phash_buckets[h], idx = 0; n; n = n->next) {
2274 if (dev_net(n->dev) != net)
2275 continue;
2276 if (idx < s_idx)
2277 goto next;
Eric W. Biederman15e47302012-09-07 20:12:54 +00002278 if (pneigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
Tony Zelenoff84920c12012-01-26 22:28:58 +00002279 cb->nlh->nlmsg_seq,
2280 RTM_NEWNEIGH,
2281 NLM_F_MULTI, tbl) <= 0) {
2282 read_unlock_bh(&tbl->lock);
2283 rc = -1;
2284 goto out;
2285 }
2286 next:
2287 idx++;
2288 }
2289 }
2290
2291 read_unlock_bh(&tbl->lock);
2292 rc = skb->len;
2293out:
2294 cb->args[3] = h;
2295 cb->args[4] = idx;
2296 return rc;
2297
2298}
2299
Thomas Grafc8822a42007-03-22 11:50:06 -07002300static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301{
2302 struct neigh_table *tbl;
2303 int t, family, s_t;
Tony Zelenoff84920c12012-01-26 22:28:58 +00002304 int proxy = 0;
Eric Dumazet4bd66832012-06-07 04:58:35 +00002305 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306
2307 read_lock(&neigh_tbl_lock);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002308 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
Tony Zelenoff84920c12012-01-26 22:28:58 +00002309
2310 /* check for full ndmsg structure presence, family member is
2311 * the same for both structures
2312 */
2313 if (nlmsg_len(cb->nlh) >= sizeof(struct ndmsg) &&
2314 ((struct ndmsg *) nlmsg_data(cb->nlh))->ndm_flags == NTF_PROXY)
2315 proxy = 1;
2316
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317 s_t = cb->args[0];
2318
Eric Dumazet4bd66832012-06-07 04:58:35 +00002319 for (tbl = neigh_tables, t = 0; tbl;
Tony Zelenoff84920c12012-01-26 22:28:58 +00002320 tbl = tbl->next, t++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 if (t < s_t || (family && tbl->family != family))
2322 continue;
2323 if (t > s_t)
2324 memset(&cb->args[1], 0, sizeof(cb->args) -
2325 sizeof(cb->args[0]));
Tony Zelenoff84920c12012-01-26 22:28:58 +00002326 if (proxy)
2327 err = pneigh_dump_table(tbl, skb, cb);
2328 else
2329 err = neigh_dump_table(tbl, skb, cb);
Eric Dumazet4bd66832012-06-07 04:58:35 +00002330 if (err < 0)
2331 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 }
2333 read_unlock(&neigh_tbl_lock);
2334
2335 cb->args[0] = t;
2336 return skb->len;
2337}
2338
2339void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2340{
2341 int chain;
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002342 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002344 rcu_read_lock_bh();
2345 nht = rcu_dereference_bh(tbl->nht);
2346
Eric Dumazet767e97e2010-10-06 17:49:21 -07002347 read_lock(&tbl->lock); /* avoid resizes */
David S. Millercd089332011-07-11 01:28:12 -07002348 for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 struct neighbour *n;
2350
Eric Dumazet767e97e2010-10-06 17:49:21 -07002351 for (n = rcu_dereference_bh(nht->hash_buckets[chain]);
2352 n != NULL;
2353 n = rcu_dereference_bh(n->next))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 cb(n, cookie);
2355 }
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002356 read_unlock(&tbl->lock);
2357 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358}
2359EXPORT_SYMBOL(neigh_for_each);
2360
2361/* The tbl->lock must be held as a writer and BH disabled. */
2362void __neigh_for_each_release(struct neigh_table *tbl,
2363 int (*cb)(struct neighbour *))
2364{
2365 int chain;
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002366 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002368 nht = rcu_dereference_protected(tbl->nht,
2369 lockdep_is_held(&tbl->lock));
David S. Millercd089332011-07-11 01:28:12 -07002370 for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
Eric Dumazet767e97e2010-10-06 17:49:21 -07002371 struct neighbour *n;
2372 struct neighbour __rcu **np;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002374 np = &nht->hash_buckets[chain];
Eric Dumazet767e97e2010-10-06 17:49:21 -07002375 while ((n = rcu_dereference_protected(*np,
2376 lockdep_is_held(&tbl->lock))) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 int release;
2378
2379 write_lock(&n->lock);
2380 release = cb(n);
2381 if (release) {
Eric Dumazet767e97e2010-10-06 17:49:21 -07002382 rcu_assign_pointer(*np,
2383 rcu_dereference_protected(n->next,
2384 lockdep_is_held(&tbl->lock)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385 n->dead = 1;
2386 } else
2387 np = &n->next;
2388 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -07002389 if (release)
2390 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391 }
2392 }
2393}
2394EXPORT_SYMBOL(__neigh_for_each_release);
2395
2396#ifdef CONFIG_PROC_FS
2397
2398static struct neighbour *neigh_get_first(struct seq_file *seq)
2399{
2400 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002401 struct net *net = seq_file_net(seq);
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002402 struct neigh_hash_table *nht = state->nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 struct neighbour *n = NULL;
2404 int bucket = state->bucket;
2405
2406 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
David S. Millercd089332011-07-11 01:28:12 -07002407 for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) {
Eric Dumazet767e97e2010-10-06 17:49:21 -07002408 n = rcu_dereference_bh(nht->hash_buckets[bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409
2410 while (n) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002411 if (!net_eq(dev_net(n->dev), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002412 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413 if (state->neigh_sub_iter) {
2414 loff_t fakep = 0;
2415 void *v;
2416
2417 v = state->neigh_sub_iter(state, n, &fakep);
2418 if (!v)
2419 goto next;
2420 }
2421 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2422 break;
2423 if (n->nud_state & ~NUD_NOARP)
2424 break;
Eric Dumazet767e97e2010-10-06 17:49:21 -07002425next:
2426 n = rcu_dereference_bh(n->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427 }
2428
2429 if (n)
2430 break;
2431 }
2432 state->bucket = bucket;
2433
2434 return n;
2435}
2436
2437static struct neighbour *neigh_get_next(struct seq_file *seq,
2438 struct neighbour *n,
2439 loff_t *pos)
2440{
2441 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002442 struct net *net = seq_file_net(seq);
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002443 struct neigh_hash_table *nht = state->nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444
2445 if (state->neigh_sub_iter) {
2446 void *v = state->neigh_sub_iter(state, n, pos);
2447 if (v)
2448 return n;
2449 }
Eric Dumazet767e97e2010-10-06 17:49:21 -07002450 n = rcu_dereference_bh(n->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451
2452 while (1) {
2453 while (n) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002454 if (!net_eq(dev_net(n->dev), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002455 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 if (state->neigh_sub_iter) {
2457 void *v = state->neigh_sub_iter(state, n, pos);
2458 if (v)
2459 return n;
2460 goto next;
2461 }
2462 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2463 break;
2464
2465 if (n->nud_state & ~NUD_NOARP)
2466 break;
Eric Dumazet767e97e2010-10-06 17:49:21 -07002467next:
2468 n = rcu_dereference_bh(n->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 }
2470
2471 if (n)
2472 break;
2473
David S. Millercd089332011-07-11 01:28:12 -07002474 if (++state->bucket >= (1 << nht->hash_shift))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 break;
2476
Eric Dumazet767e97e2010-10-06 17:49:21 -07002477 n = rcu_dereference_bh(nht->hash_buckets[state->bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 }
2479
2480 if (n && pos)
2481 --(*pos);
2482 return n;
2483}
2484
2485static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2486{
2487 struct neighbour *n = neigh_get_first(seq);
2488
2489 if (n) {
Chris Larson745e2032008-08-03 01:10:55 -07002490 --(*pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 while (*pos) {
2492 n = neigh_get_next(seq, n, pos);
2493 if (!n)
2494 break;
2495 }
2496 }
2497 return *pos ? NULL : n;
2498}
2499
2500static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2501{
2502 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002503 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 struct neigh_table *tbl = state->tbl;
2505 struct pneigh_entry *pn = NULL;
2506 int bucket = state->bucket;
2507
2508 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2509 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2510 pn = tbl->phash_buckets[bucket];
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002511 while (pn && !net_eq(pneigh_net(pn), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002512 pn = pn->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513 if (pn)
2514 break;
2515 }
2516 state->bucket = bucket;
2517
2518 return pn;
2519}
2520
2521static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2522 struct pneigh_entry *pn,
2523 loff_t *pos)
2524{
2525 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002526 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 struct neigh_table *tbl = state->tbl;
2528
Jorge Boncompte [DTI2]df07a942011-11-25 13:24:49 -05002529 do {
2530 pn = pn->next;
2531 } while (pn && !net_eq(pneigh_net(pn), net));
2532
Linus Torvalds1da177e2005-04-16 15:20:36 -07002533 while (!pn) {
2534 if (++state->bucket > PNEIGH_HASHMASK)
2535 break;
2536 pn = tbl->phash_buckets[state->bucket];
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002537 while (pn && !net_eq(pneigh_net(pn), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002538 pn = pn->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539 if (pn)
2540 break;
2541 }
2542
2543 if (pn && pos)
2544 --(*pos);
2545
2546 return pn;
2547}
2548
2549static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2550{
2551 struct pneigh_entry *pn = pneigh_get_first(seq);
2552
2553 if (pn) {
Chris Larson745e2032008-08-03 01:10:55 -07002554 --(*pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 while (*pos) {
2556 pn = pneigh_get_next(seq, pn, pos);
2557 if (!pn)
2558 break;
2559 }
2560 }
2561 return *pos ? NULL : pn;
2562}
2563
2564static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2565{
2566 struct neigh_seq_state *state = seq->private;
2567 void *rc;
Chris Larson745e2032008-08-03 01:10:55 -07002568 loff_t idxpos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569
Chris Larson745e2032008-08-03 01:10:55 -07002570 rc = neigh_get_idx(seq, &idxpos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
Chris Larson745e2032008-08-03 01:10:55 -07002572 rc = pneigh_get_idx(seq, &idxpos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573
2574 return rc;
2575}
2576
2577void *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 +00002578 __acquires(rcu_bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579{
2580 struct neigh_seq_state *state = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581
2582 state->tbl = tbl;
2583 state->bucket = 0;
2584 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2585
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002586 rcu_read_lock_bh();
2587 state->nht = rcu_dereference_bh(tbl->nht);
Eric Dumazet767e97e2010-10-06 17:49:21 -07002588
Chris Larson745e2032008-08-03 01:10:55 -07002589 return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590}
2591EXPORT_SYMBOL(neigh_seq_start);
2592
2593void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2594{
2595 struct neigh_seq_state *state;
2596 void *rc;
2597
2598 if (v == SEQ_START_TOKEN) {
Chris Larsonbff69732008-08-03 01:02:41 -07002599 rc = neigh_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600 goto out;
2601 }
2602
2603 state = seq->private;
2604 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2605 rc = neigh_get_next(seq, v, NULL);
2606 if (rc)
2607 goto out;
2608 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2609 rc = pneigh_get_first(seq);
2610 } else {
2611 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2612 rc = pneigh_get_next(seq, v, NULL);
2613 }
2614out:
2615 ++(*pos);
2616 return rc;
2617}
2618EXPORT_SYMBOL(neigh_seq_next);
2619
2620void neigh_seq_stop(struct seq_file *seq, void *v)
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002621 __releases(rcu_bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622{
Eric Dumazetd6bf7812010-10-04 06:15:44 +00002623 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624}
2625EXPORT_SYMBOL(neigh_seq_stop);
2626
2627/* statistics via seq_file */
2628
2629static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2630{
Alexey Dobriyan81c1ebf2010-01-22 10:16:05 +00002631 struct neigh_table *tbl = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 int cpu;
2633
2634 if (*pos == 0)
2635 return SEQ_START_TOKEN;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002636
Rusty Russell0f23174a2008-12-29 12:23:42 +00002637 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 if (!cpu_possible(cpu))
2639 continue;
2640 *pos = cpu+1;
2641 return per_cpu_ptr(tbl->stats, cpu);
2642 }
2643 return NULL;
2644}
2645
2646static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2647{
Alexey Dobriyan81c1ebf2010-01-22 10:16:05 +00002648 struct neigh_table *tbl = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649 int cpu;
2650
Rusty Russell0f23174a2008-12-29 12:23:42 +00002651 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 if (!cpu_possible(cpu))
2653 continue;
2654 *pos = cpu+1;
2655 return per_cpu_ptr(tbl->stats, cpu);
2656 }
2657 return NULL;
2658}
2659
2660static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2661{
2662
2663}
2664
2665static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2666{
Alexey Dobriyan81c1ebf2010-01-22 10:16:05 +00002667 struct neigh_table *tbl = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 struct neigh_statistics *st = v;
2669
2670 if (v == SEQ_START_TOKEN) {
Neil Horman9a6d2762008-07-16 20:50:49 -07002671 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 -07002672 return 0;
2673 }
2674
2675 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
Neil Horman9a6d2762008-07-16 20:50:49 -07002676 "%08lx %08lx %08lx %08lx %08lx\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677 atomic_read(&tbl->entries),
2678
2679 st->allocs,
2680 st->destroys,
2681 st->hash_grows,
2682
2683 st->lookups,
2684 st->hits,
2685
2686 st->res_failed,
2687
2688 st->rcv_probes_mcast,
2689 st->rcv_probes_ucast,
2690
2691 st->periodic_gc_runs,
Neil Horman9a6d2762008-07-16 20:50:49 -07002692 st->forced_gc_runs,
2693 st->unres_discards
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 );
2695
2696 return 0;
2697}
2698
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002699static const struct seq_operations neigh_stat_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 .start = neigh_stat_seq_start,
2701 .next = neigh_stat_seq_next,
2702 .stop = neigh_stat_seq_stop,
2703 .show = neigh_stat_seq_show,
2704};
2705
2706static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2707{
2708 int ret = seq_open(file, &neigh_stat_seq_ops);
2709
2710 if (!ret) {
2711 struct seq_file *sf = file->private_data;
Al Virod9dda782013-03-31 18:16:14 -04002712 sf->private = PDE_DATA(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713 }
2714 return ret;
2715};
2716
Arjan van de Ven9a321442007-02-12 00:55:35 -08002717static const struct file_operations neigh_stat_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 .owner = THIS_MODULE,
2719 .open = neigh_stat_seq_open,
2720 .read = seq_read,
2721 .llseek = seq_lseek,
2722 .release = seq_release,
2723};
2724
2725#endif /* CONFIG_PROC_FS */
2726
Thomas Graf339bf982006-11-10 14:10:15 -08002727static inline size_t neigh_nlmsg_size(void)
2728{
2729 return NLMSG_ALIGN(sizeof(struct ndmsg))
2730 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2731 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2732 + nla_total_size(sizeof(struct nda_cacheinfo))
2733 + nla_total_size(4); /* NDA_PROBES */
2734}
2735
Thomas Grafb8673312006-08-15 00:33:14 -07002736static void __neigh_notify(struct neighbour *n, int type, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002738 struct net *net = dev_net(n->dev);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002739 struct sk_buff *skb;
Thomas Grafb8673312006-08-15 00:33:14 -07002740 int err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741
Thomas Graf339bf982006-11-10 14:10:15 -08002742 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002743 if (skb == NULL)
Thomas Grafb8673312006-08-15 00:33:14 -07002744 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745
Thomas Grafb8673312006-08-15 00:33:14 -07002746 err = neigh_fill_info(skb, n, 0, 0, type, flags);
Patrick McHardy26932562007-01-31 23:16:40 -08002747 if (err < 0) {
2748 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2749 WARN_ON(err == -EMSGSIZE);
2750 kfree_skb(skb);
2751 goto errout;
2752 }
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08002753 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
2754 return;
Thomas Grafb8673312006-08-15 00:33:14 -07002755errout:
2756 if (err < 0)
Eric W. Biederman426b5302008-01-24 00:13:18 -08002757 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
Thomas Grafb8673312006-08-15 00:33:14 -07002758}
2759
Thomas Grafd961db32007-08-08 23:12:56 -07002760#ifdef CONFIG_ARPD
Thomas Grafb8673312006-08-15 00:33:14 -07002761void neigh_app_ns(struct neighbour *n)
2762{
2763 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09002765EXPORT_SYMBOL(neigh_app_ns);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766#endif /* CONFIG_ARPD */
2767
2768#ifdef CONFIG_SYSCTL
Cong Wangb93196d2012-12-06 10:04:04 +08002769static int zero;
Francesco Fusco555445c2013-07-24 10:39:06 +02002770static int int_max = INT_MAX;
Cong Wangb93196d2012-12-06 10:04:04 +08002771static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772
Joe Perchesfe2c6332013-06-11 23:04:25 -07002773static int proc_unres_qlen(struct ctl_table *ctl, int write,
2774 void __user *buffer, size_t *lenp, loff_t *ppos)
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002775{
2776 int size, ret;
Joe Perchesfe2c6332013-06-11 23:04:25 -07002777 struct ctl_table tmp = *ctl;
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002778
Shan Weice46cc62012-12-04 18:49:15 +00002779 tmp.extra1 = &zero;
2780 tmp.extra2 = &unres_qlen_max;
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002781 tmp.data = &size;
Shan Weice46cc62012-12-04 18:49:15 +00002782
2783 size = *(int *)ctl->data / SKB_TRUESIZE(ETH_FRAME_LEN);
2784 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
2785
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002786 if (write && !ret)
2787 *(int *)ctl->data = size * SKB_TRUESIZE(ETH_FRAME_LEN);
2788 return ret;
2789}
2790
2791enum {
2792 NEIGH_VAR_MCAST_PROBE,
2793 NEIGH_VAR_UCAST_PROBE,
2794 NEIGH_VAR_APP_PROBE,
2795 NEIGH_VAR_RETRANS_TIME,
2796 NEIGH_VAR_BASE_REACHABLE_TIME,
2797 NEIGH_VAR_DELAY_PROBE_TIME,
2798 NEIGH_VAR_GC_STALETIME,
2799 NEIGH_VAR_QUEUE_LEN,
2800 NEIGH_VAR_QUEUE_LEN_BYTES,
2801 NEIGH_VAR_PROXY_QLEN,
2802 NEIGH_VAR_ANYCAST_DELAY,
2803 NEIGH_VAR_PROXY_DELAY,
2804 NEIGH_VAR_LOCKTIME,
2805 NEIGH_VAR_RETRANS_TIME_MS,
2806 NEIGH_VAR_BASE_REACHABLE_TIME_MS,
2807 NEIGH_VAR_GC_INTERVAL,
2808 NEIGH_VAR_GC_THRESH1,
2809 NEIGH_VAR_GC_THRESH2,
2810 NEIGH_VAR_GC_THRESH3,
2811 NEIGH_VAR_MAX
2812};
Eric W. Biederman54716e32010-02-14 03:27:03 +00002813
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814static struct neigh_sysctl_table {
2815 struct ctl_table_header *sysctl_header;
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002816 struct ctl_table neigh_vars[NEIGH_VAR_MAX + 1];
Brian Haleyab32ea52006-09-22 14:15:41 -07002817} neigh_sysctl_template __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818 .neigh_vars = {
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002819 [NEIGH_VAR_MCAST_PROBE] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820 .procname = "mcast_solicit",
2821 .maxlen = sizeof(int),
2822 .mode = 0644,
Francesco Fusco555445c2013-07-24 10:39:06 +02002823 .extra1 = &zero,
2824 .extra2 = &int_max,
2825 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002827 [NEIGH_VAR_UCAST_PROBE] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 .procname = "ucast_solicit",
2829 .maxlen = sizeof(int),
2830 .mode = 0644,
Francesco Fusco555445c2013-07-24 10:39:06 +02002831 .extra1 = &zero,
2832 .extra2 = &int_max,
2833 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002835 [NEIGH_VAR_APP_PROBE] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002836 .procname = "app_solicit",
2837 .maxlen = sizeof(int),
2838 .mode = 0644,
Francesco Fusco555445c2013-07-24 10:39:06 +02002839 .extra1 = &zero,
2840 .extra2 = &int_max,
2841 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002843 [NEIGH_VAR_RETRANS_TIME] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844 .procname = "retrans_time",
2845 .maxlen = sizeof(int),
2846 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002847 .proc_handler = proc_dointvec_userhz_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002849 [NEIGH_VAR_BASE_REACHABLE_TIME] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 .procname = "base_reachable_time",
2851 .maxlen = sizeof(int),
2852 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002853 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002855 [NEIGH_VAR_DELAY_PROBE_TIME] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 .procname = "delay_first_probe_time",
2857 .maxlen = sizeof(int),
2858 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002859 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002861 [NEIGH_VAR_GC_STALETIME] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862 .procname = "gc_stale_time",
2863 .maxlen = sizeof(int),
2864 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002865 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002867 [NEIGH_VAR_QUEUE_LEN] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868 .procname = "unres_qlen",
2869 .maxlen = sizeof(int),
2870 .mode = 0644,
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002871 .proc_handler = proc_unres_qlen,
2872 },
2873 [NEIGH_VAR_QUEUE_LEN_BYTES] = {
2874 .procname = "unres_qlen_bytes",
2875 .maxlen = sizeof(int),
2876 .mode = 0644,
Shan Weice46cc62012-12-04 18:49:15 +00002877 .extra1 = &zero,
2878 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002880 [NEIGH_VAR_PROXY_QLEN] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 .procname = "proxy_qlen",
2882 .maxlen = sizeof(int),
2883 .mode = 0644,
Francesco Fusco555445c2013-07-24 10:39:06 +02002884 .extra1 = &zero,
2885 .extra2 = &int_max,
2886 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002888 [NEIGH_VAR_ANYCAST_DELAY] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 .procname = "anycast_delay",
2890 .maxlen = sizeof(int),
2891 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002892 .proc_handler = proc_dointvec_userhz_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002893 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002894 [NEIGH_VAR_PROXY_DELAY] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 .procname = "proxy_delay",
2896 .maxlen = sizeof(int),
2897 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002898 .proc_handler = proc_dointvec_userhz_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002900 [NEIGH_VAR_LOCKTIME] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901 .procname = "locktime",
2902 .maxlen = sizeof(int),
2903 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002904 .proc_handler = proc_dointvec_userhz_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002906 [NEIGH_VAR_RETRANS_TIME_MS] = {
Eric W. Biedermand12af672007-10-18 03:05:25 -07002907 .procname = "retrans_time_ms",
2908 .maxlen = sizeof(int),
2909 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002910 .proc_handler = proc_dointvec_ms_jiffies,
Eric W. Biedermand12af672007-10-18 03:05:25 -07002911 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002912 [NEIGH_VAR_BASE_REACHABLE_TIME_MS] = {
Eric W. Biedermand12af672007-10-18 03:05:25 -07002913 .procname = "base_reachable_time_ms",
2914 .maxlen = sizeof(int),
2915 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002916 .proc_handler = proc_dointvec_ms_jiffies,
Eric W. Biedermand12af672007-10-18 03:05:25 -07002917 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002918 [NEIGH_VAR_GC_INTERVAL] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919 .procname = "gc_interval",
2920 .maxlen = sizeof(int),
2921 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002922 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002924 [NEIGH_VAR_GC_THRESH1] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925 .procname = "gc_thresh1",
2926 .maxlen = sizeof(int),
2927 .mode = 0644,
Francesco Fusco555445c2013-07-24 10:39:06 +02002928 .extra1 = &zero,
2929 .extra2 = &int_max,
2930 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002932 [NEIGH_VAR_GC_THRESH2] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933 .procname = "gc_thresh2",
2934 .maxlen = sizeof(int),
2935 .mode = 0644,
Francesco Fusco555445c2013-07-24 10:39:06 +02002936 .extra1 = &zero,
2937 .extra2 = &int_max,
2938 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939 },
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002940 [NEIGH_VAR_GC_THRESH3] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002941 .procname = "gc_thresh3",
2942 .maxlen = sizeof(int),
2943 .mode = 0644,
Francesco Fusco555445c2013-07-24 10:39:06 +02002944 .extra1 = &zero,
2945 .extra2 = &int_max,
2946 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 },
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002948 {},
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 },
2950};
2951
2952int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
Eric W. Biederman54716e32010-02-14 03:27:03 +00002953 char *p_name, proc_handler *handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002954{
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002955 struct neigh_sysctl_table *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 const char *dev_name_source = NULL;
Eric W. Biederman8f40a1f2012-04-19 13:38:03 +00002957 char neigh_path[ sizeof("net//neigh/") + IFNAMSIZ + IFNAMSIZ ];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002959 t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960 if (!t)
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002961 goto err;
2962
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002963 t->neigh_vars[NEIGH_VAR_MCAST_PROBE].data = &p->mcast_probes;
2964 t->neigh_vars[NEIGH_VAR_UCAST_PROBE].data = &p->ucast_probes;
2965 t->neigh_vars[NEIGH_VAR_APP_PROBE].data = &p->app_probes;
2966 t->neigh_vars[NEIGH_VAR_RETRANS_TIME].data = &p->retrans_time;
2967 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].data = &p->base_reachable_time;
2968 t->neigh_vars[NEIGH_VAR_DELAY_PROBE_TIME].data = &p->delay_probe_time;
2969 t->neigh_vars[NEIGH_VAR_GC_STALETIME].data = &p->gc_staletime;
2970 t->neigh_vars[NEIGH_VAR_QUEUE_LEN].data = &p->queue_len_bytes;
2971 t->neigh_vars[NEIGH_VAR_QUEUE_LEN_BYTES].data = &p->queue_len_bytes;
2972 t->neigh_vars[NEIGH_VAR_PROXY_QLEN].data = &p->proxy_qlen;
2973 t->neigh_vars[NEIGH_VAR_ANYCAST_DELAY].data = &p->anycast_delay;
2974 t->neigh_vars[NEIGH_VAR_PROXY_DELAY].data = &p->proxy_delay;
2975 t->neigh_vars[NEIGH_VAR_LOCKTIME].data = &p->locktime;
2976 t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].data = &p->retrans_time;
2977 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].data = &p->base_reachable_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002978
2979 if (dev) {
2980 dev_name_source = dev->name;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002981 /* Terminate the table early */
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002982 memset(&t->neigh_vars[NEIGH_VAR_GC_INTERVAL], 0,
2983 sizeof(t->neigh_vars[NEIGH_VAR_GC_INTERVAL]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 } else {
Eric W. Biederman8f40a1f2012-04-19 13:38:03 +00002985 dev_name_source = "default";
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002986 t->neigh_vars[NEIGH_VAR_GC_INTERVAL].data = (int *)(p + 1);
2987 t->neigh_vars[NEIGH_VAR_GC_THRESH1].data = (int *)(p + 1) + 1;
2988 t->neigh_vars[NEIGH_VAR_GC_THRESH2].data = (int *)(p + 1) + 2;
2989 t->neigh_vars[NEIGH_VAR_GC_THRESH3].data = (int *)(p + 1) + 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002990 }
2991
Linus Torvalds1da177e2005-04-16 15:20:36 -07002992
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002993 if (handler) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002994 /* RetransTime */
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002995 t->neigh_vars[NEIGH_VAR_RETRANS_TIME].proc_handler = handler;
2996 t->neigh_vars[NEIGH_VAR_RETRANS_TIME].extra1 = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997 /* ReachableTime */
Eric Dumazet8b5c1712011-11-09 12:07:14 +00002998 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = handler;
2999 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].extra1 = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003000 /* RetransTime (in milliseconds)*/
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003001 t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].proc_handler = handler;
3002 t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].extra1 = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003003 /* ReachableTime (in milliseconds) */
Eric Dumazet8b5c1712011-11-09 12:07:14 +00003004 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = handler;
3005 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].extra1 = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003006 }
3007
Eric W. Biederman464dc802012-11-16 03:02:59 +00003008 /* Don't export sysctls to unprivileged users */
3009 if (neigh_parms_net(p)->user_ns != &init_user_ns)
3010 t->neigh_vars[0].procname = NULL;
3011
Eric W. Biederman8f40a1f2012-04-19 13:38:03 +00003012 snprintf(neigh_path, sizeof(neigh_path), "net/%s/neigh/%s",
3013 p_name, dev_name_source);
Denis V. Lunev4ab438f2008-02-28 20:48:01 -08003014 t->sysctl_header =
Eric W. Biederman8f40a1f2012-04-19 13:38:03 +00003015 register_net_sysctl(neigh_parms_net(p), neigh_path, t->neigh_vars);
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003016 if (!t->sysctl_header)
Eric W. Biederman8f40a1f2012-04-19 13:38:03 +00003017 goto free;
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003018
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 p->sysctl_table = t;
3020 return 0;
3021
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003022free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023 kfree(t);
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11003024err:
3025 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09003027EXPORT_SYMBOL(neigh_sysctl_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028
3029void neigh_sysctl_unregister(struct neigh_parms *p)
3030{
3031 if (p->sysctl_table) {
3032 struct neigh_sysctl_table *t = p->sysctl_table;
3033 p->sysctl_table = NULL;
Eric W. Biederman5dd3df12012-04-19 13:24:33 +00003034 unregister_net_sysctl_table(t->sysctl_header);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035 kfree(t);
3036 }
3037}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09003038EXPORT_SYMBOL(neigh_sysctl_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039
3040#endif /* CONFIG_SYSCTL */
3041
Thomas Grafc8822a42007-03-22 11:50:06 -07003042static int __init neigh_init(void)
3043{
Greg Rosec7ac8672011-06-10 01:27:09 +00003044 rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, NULL);
3045 rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, NULL);
3046 rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info, NULL);
Thomas Grafc8822a42007-03-22 11:50:06 -07003047
Greg Rosec7ac8672011-06-10 01:27:09 +00003048 rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info,
3049 NULL);
3050 rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, NULL);
Thomas Grafc8822a42007-03-22 11:50:06 -07003051
3052 return 0;
3053}
3054
3055subsys_initcall(neigh_init);
3056