blob: 19b8e003f15084821aee62374a74038514800d80 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/types.h>
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/socket.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/netdevice.h>
23#include <linux/proc_fs.h>
24#ifdef CONFIG_SYSCTL
25#include <linux/sysctl.h>
26#endif
27#include <linux/times.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020028#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <net/neighbour.h>
30#include <net/dst.h>
31#include <net/sock.h>
Tom Tucker8d717402006-07-30 20:43:36 -070032#include <net/netevent.h>
Thomas Grafa14a49d2006-08-07 17:53:08 -070033#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/rtnetlink.h>
35#include <linux/random.h>
Paulo Marques543537b2005-06-23 00:09:02 -070036#include <linux/string.h>
vignesh babuc3609d52007-08-24 22:27:55 -070037#include <linux/log2.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#define NEIGH_DEBUG 1
40
41#define NEIGH_PRINTK(x...) printk(x)
42#define NEIGH_NOPRINTK(x...) do { ; } while(0)
43#define NEIGH_PRINTK0 NEIGH_PRINTK
44#define NEIGH_PRINTK1 NEIGH_NOPRINTK
45#define NEIGH_PRINTK2 NEIGH_NOPRINTK
46
47#if NEIGH_DEBUG >= 1
48#undef NEIGH_PRINTK1
49#define NEIGH_PRINTK1 NEIGH_PRINTK
50#endif
51#if NEIGH_DEBUG >= 2
52#undef NEIGH_PRINTK2
53#define NEIGH_PRINTK2 NEIGH_PRINTK
54#endif
55
56#define PNEIGH_HASHMASK 0xF
57
58static void neigh_timer_handler(unsigned long arg);
Thomas Grafd961db32007-08-08 23:12:56 -070059static void __neigh_notify(struct neighbour *n, int type, int flags);
60static void neigh_update_notify(struct neighbour *neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63static struct neigh_table *neigh_tables;
Amos Waterland45fc3b12005-09-24 16:53:16 -070064#ifdef CONFIG_PROC_FS
Arjan van de Ven9a321442007-02-12 00:55:35 -080065static const struct file_operations neigh_stat_seq_fops;
Amos Waterland45fc3b12005-09-24 16:53:16 -070066#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68/*
69 Neighbour hash table buckets are protected with rwlock tbl->lock.
70
71 - All the scans/updates to hash buckets MUST be made under this lock.
72 - NOTHING clever should be made under this lock: no callbacks
73 to protocol backends, no attempts to send something to network.
74 It will result in deadlocks, if backend/driver wants to use neighbour
75 cache.
76 - If the entry requires some non-trivial actions, increase
77 its reference count and release table lock.
78
79 Neighbour entries are protected:
80 - with reference count.
81 - with rwlock neigh->lock
82
83 Reference count prevents destruction.
84
85 neigh->lock mainly serializes ll address data and its validity state.
86 However, the same lock is used to protect another entry fields:
87 - timer
88 - resolution queue
89
90 Again, nothing clever shall be made under neigh->lock,
91 the most complicated procedure, which we allow is dev->hard_header.
92 It is supposed, that dev->hard_header is simplistic and does
93 not make callbacks to neighbour tables.
94
95 The last lock is neigh_tbl_lock. It is pure SMP lock, protecting
96 list of neighbour tables. This list is used only in process context,
97 */
98
99static DEFINE_RWLOCK(neigh_tbl_lock);
100
101static int neigh_blackhole(struct sk_buff *skb)
102{
103 kfree_skb(skb);
104 return -ENETDOWN;
105}
106
Thomas Graf4f494552007-08-08 23:12:36 -0700107static void neigh_cleanup_and_release(struct neighbour *neigh)
108{
109 if (neigh->parms->neigh_cleanup)
110 neigh->parms->neigh_cleanup(neigh);
111
Thomas Grafd961db32007-08-08 23:12:56 -0700112 __neigh_notify(neigh, RTM_DELNEIGH, 0);
Thomas Graf4f494552007-08-08 23:12:36 -0700113 neigh_release(neigh);
114}
115
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116/*
117 * It is random distribution in the interval (1/2)*base...(3/2)*base.
118 * It corresponds to default IPv6 settings and is not overridable,
119 * because it is really reasonable choice.
120 */
121
122unsigned long neigh_rand_reach_time(unsigned long base)
123{
124 return (base ? (net_random() % base) + (base >> 1) : 0);
125}
126
127
128static int neigh_forced_gc(struct neigh_table *tbl)
129{
130 int shrunk = 0;
131 int i;
132
133 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
134
135 write_lock_bh(&tbl->lock);
136 for (i = 0; i <= tbl->hash_mask; i++) {
137 struct neighbour *n, **np;
138
139 np = &tbl->hash_buckets[i];
140 while ((n = *np) != NULL) {
141 /* 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)) {
148 *np = n->next;
149 n->dead = 1;
150 shrunk = 1;
151 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -0700152 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 continue;
154 }
155 write_unlock(&n->lock);
156 np = &n->next;
157 }
158 }
159
160 tbl->last_flush = jiffies;
161
162 write_unlock_bh(&tbl->lock);
163
164 return shrunk;
165}
166
Pavel Emelyanova43d8992007-12-20 15:49:05 -0800167static void neigh_add_timer(struct neighbour *n, unsigned long when)
168{
169 neigh_hold(n);
170 if (unlikely(mod_timer(&n->timer, when))) {
171 printk("NEIGH: BUG, double timer add, state is %x\n",
172 n->nud_state);
173 dump_stack();
174 }
175}
176
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177static int neigh_del_timer(struct neighbour *n)
178{
179 if ((n->nud_state & NUD_IN_TIMER) &&
180 del_timer(&n->timer)) {
181 neigh_release(n);
182 return 1;
183 }
184 return 0;
185}
186
187static void pneigh_queue_purge(struct sk_buff_head *list)
188{
189 struct sk_buff *skb;
190
191 while ((skb = skb_dequeue(list)) != NULL) {
192 dev_put(skb->dev);
193 kfree_skb(skb);
194 }
195}
196
Herbert Xu49636bb2005-10-23 17:18:00 +1000197static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
199 int i;
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 for (i = 0; i <= tbl->hash_mask; i++) {
202 struct neighbour *n, **np = &tbl->hash_buckets[i];
203
204 while ((n = *np) != NULL) {
205 if (dev && n->dev != dev) {
206 np = &n->next;
207 continue;
208 }
209 *np = n->next;
210 write_lock(&n->lock);
211 neigh_del_timer(n);
212 n->dead = 1;
213
214 if (atomic_read(&n->refcnt) != 1) {
215 /* The most unpleasant situation.
216 We must destroy neighbour entry,
217 but someone still uses it.
218
219 The destroy will be delayed until
220 the last user releases us, but
221 we must kill timers etc. and move
222 it to safe state.
223 */
224 skb_queue_purge(&n->arp_queue);
225 n->output = neigh_blackhole;
226 if (n->nud_state & NUD_VALID)
227 n->nud_state = NUD_NOARP;
228 else
229 n->nud_state = NUD_NONE;
230 NEIGH_PRINTK2("neigh %p is stray.\n", n);
231 }
232 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -0700233 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 }
235 }
Herbert Xu49636bb2005-10-23 17:18:00 +1000236}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
Herbert Xu49636bb2005-10-23 17:18:00 +1000238void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
239{
240 write_lock_bh(&tbl->lock);
241 neigh_flush_dev(tbl, dev);
242 write_unlock_bh(&tbl->lock);
243}
244
245int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
246{
247 write_lock_bh(&tbl->lock);
248 neigh_flush_dev(tbl, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 pneigh_ifdown(tbl, dev);
250 write_unlock_bh(&tbl->lock);
251
252 del_timer_sync(&tbl->proxy_timer);
253 pneigh_queue_purge(&tbl->proxy_queue);
254 return 0;
255}
256
257static struct neighbour *neigh_alloc(struct neigh_table *tbl)
258{
259 struct neighbour *n = NULL;
260 unsigned long now = jiffies;
261 int entries;
262
263 entries = atomic_inc_return(&tbl->entries) - 1;
264 if (entries >= tbl->gc_thresh3 ||
265 (entries >= tbl->gc_thresh2 &&
266 time_after(now, tbl->last_flush + 5 * HZ))) {
267 if (!neigh_forced_gc(tbl) &&
268 entries >= tbl->gc_thresh3)
269 goto out_entries;
270 }
271
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800272 n = kmem_cache_zalloc(tbl->kmem_cachep, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 if (!n)
274 goto out_entries;
275
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 skb_queue_head_init(&n->arp_queue);
277 rwlock_init(&n->lock);
278 n->updated = n->used = now;
279 n->nud_state = NUD_NONE;
280 n->output = neigh_blackhole;
281 n->parms = neigh_parms_clone(&tbl->parms);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800282 setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
284 NEIGH_CACHE_STAT_INC(tbl, allocs);
285 n->tbl = tbl;
286 atomic_set(&n->refcnt, 1);
287 n->dead = 1;
288out:
289 return n;
290
291out_entries:
292 atomic_dec(&tbl->entries);
293 goto out;
294}
295
296static struct neighbour **neigh_hash_alloc(unsigned int entries)
297{
298 unsigned long size = entries * sizeof(struct neighbour *);
299 struct neighbour **ret;
300
301 if (size <= PAGE_SIZE) {
Andrew Morton77d04bd2006-04-07 14:52:59 -0700302 ret = kzalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 } else {
304 ret = (struct neighbour **)
Andrew Morton77d04bd2006-04-07 14:52:59 -0700305 __get_free_pages(GFP_ATOMIC|__GFP_ZERO, get_order(size));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 return ret;
308}
309
310static void neigh_hash_free(struct neighbour **hash, unsigned int entries)
311{
312 unsigned long size = entries * sizeof(struct neighbour *);
313
314 if (size <= PAGE_SIZE)
315 kfree(hash);
316 else
317 free_pages((unsigned long)hash, get_order(size));
318}
319
320static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries)
321{
322 struct neighbour **new_hash, **old_hash;
323 unsigned int i, new_hash_mask, old_entries;
324
325 NEIGH_CACHE_STAT_INC(tbl, hash_grows);
326
vignesh babuc3609d52007-08-24 22:27:55 -0700327 BUG_ON(!is_power_of_2(new_entries));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 new_hash = neigh_hash_alloc(new_entries);
329 if (!new_hash)
330 return;
331
332 old_entries = tbl->hash_mask + 1;
333 new_hash_mask = new_entries - 1;
334 old_hash = tbl->hash_buckets;
335
336 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
337 for (i = 0; i < old_entries; i++) {
338 struct neighbour *n, *next;
339
340 for (n = old_hash[i]; n; n = next) {
341 unsigned int hash_val = tbl->hash(n->primary_key, n->dev);
342
343 hash_val &= new_hash_mask;
344 next = n->next;
345
346 n->next = new_hash[hash_val];
347 new_hash[hash_val] = n;
348 }
349 }
350 tbl->hash_buckets = new_hash;
351 tbl->hash_mask = new_hash_mask;
352
353 neigh_hash_free(old_hash, old_entries);
354}
355
356struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
357 struct net_device *dev)
358{
359 struct neighbour *n;
360 int key_len = tbl->key_len;
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800361 u32 hash_val;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900362
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 NEIGH_CACHE_STAT_INC(tbl, lookups);
364
365 read_lock_bh(&tbl->lock);
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800366 hash_val = tbl->hash(pkey, dev);
Julian Anastasovc5e29462006-10-03 15:49:46 -0700367 for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
369 neigh_hold(n);
370 NEIGH_CACHE_STAT_INC(tbl, hits);
371 break;
372 }
373 }
374 read_unlock_bh(&tbl->lock);
375 return n;
376}
377
Eric W. Biederman426b5302008-01-24 00:13:18 -0800378struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
379 const void *pkey)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
381 struct neighbour *n;
382 int key_len = tbl->key_len;
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800383 u32 hash_val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385 NEIGH_CACHE_STAT_INC(tbl, lookups);
386
387 read_lock_bh(&tbl->lock);
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800388 hash_val = tbl->hash(pkey, NULL);
Julian Anastasovc5e29462006-10-03 15:49:46 -0700389 for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) {
Eric W. Biederman426b5302008-01-24 00:13:18 -0800390 if (!memcmp(n->primary_key, pkey, key_len) &&
391 (net == n->dev->nd_net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 neigh_hold(n);
393 NEIGH_CACHE_STAT_INC(tbl, hits);
394 break;
395 }
396 }
397 read_unlock_bh(&tbl->lock);
398 return n;
399}
400
401struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey,
402 struct net_device *dev)
403{
404 u32 hash_val;
405 int key_len = tbl->key_len;
406 int error;
407 struct neighbour *n1, *rc, *n = neigh_alloc(tbl);
408
409 if (!n) {
410 rc = ERR_PTR(-ENOBUFS);
411 goto out;
412 }
413
414 memcpy(n->primary_key, pkey, key_len);
415 n->dev = dev;
416 dev_hold(dev);
417
418 /* Protocol specific setup. */
419 if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
420 rc = ERR_PTR(error);
421 goto out_neigh_release;
422 }
423
424 /* Device specific setup. */
425 if (n->parms->neigh_setup &&
426 (error = n->parms->neigh_setup(n)) < 0) {
427 rc = ERR_PTR(error);
428 goto out_neigh_release;
429 }
430
431 n->confirmed = jiffies - (n->parms->base_reachable_time << 1);
432
433 write_lock_bh(&tbl->lock);
434
435 if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1))
436 neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1);
437
438 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;
439
440 if (n->parms->dead) {
441 rc = ERR_PTR(-EINVAL);
442 goto out_tbl_unlock;
443 }
444
445 for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) {
446 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
447 neigh_hold(n1);
448 rc = n1;
449 goto out_tbl_unlock;
450 }
451 }
452
453 n->next = tbl->hash_buckets[hash_val];
454 tbl->hash_buckets[hash_val] = n;
455 n->dead = 0;
456 neigh_hold(n);
457 write_unlock_bh(&tbl->lock);
458 NEIGH_PRINTK2("neigh %p is created.\n", n);
459 rc = n;
460out:
461 return rc;
462out_tbl_unlock:
463 write_unlock_bh(&tbl->lock);
464out_neigh_release:
465 neigh_release(n);
466 goto out;
467}
468
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700469struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl,
470 struct net *net, const void *pkey, struct net_device *dev)
471{
472 struct pneigh_entry *n;
473 int key_len = tbl->key_len;
474 u32 hash_val = *(u32 *)(pkey + key_len - 4);
475
476 hash_val ^= (hash_val >> 16);
477 hash_val ^= hash_val >> 8;
478 hash_val ^= hash_val >> 4;
479 hash_val &= PNEIGH_HASHMASK;
480
481 for (n = tbl->phash_buckets[hash_val]; n; n = n->next) {
482 if (!memcmp(n->key, pkey, key_len) &&
483 (n->net == net) &&
484 (n->dev == dev || !n->dev))
485 break;
486 }
487
488 return n;
489}
490
Eric W. Biederman426b5302008-01-24 00:13:18 -0800491struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl,
492 struct net *net, const void *pkey,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 struct net_device *dev, int creat)
494{
495 struct pneigh_entry *n;
496 int key_len = tbl->key_len;
497 u32 hash_val = *(u32 *)(pkey + key_len - 4);
498
499 hash_val ^= (hash_val >> 16);
500 hash_val ^= hash_val >> 8;
501 hash_val ^= hash_val >> 4;
502 hash_val &= PNEIGH_HASHMASK;
503
504 read_lock_bh(&tbl->lock);
505
506 for (n = tbl->phash_buckets[hash_val]; n; n = n->next) {
507 if (!memcmp(n->key, pkey, key_len) &&
Eric W. Biederman426b5302008-01-24 00:13:18 -0800508 (n->net == net) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 (n->dev == dev || !n->dev)) {
510 read_unlock_bh(&tbl->lock);
511 goto out;
512 }
513 }
514 read_unlock_bh(&tbl->lock);
515 n = NULL;
516 if (!creat)
517 goto out;
518
Pavel Emelyanov4ae28942007-10-15 12:54:15 -0700519 ASSERT_RTNL();
520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
522 if (!n)
523 goto out;
524
Eric W. Biederman426b5302008-01-24 00:13:18 -0800525 n->net = hold_net(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 memcpy(n->key, pkey, key_len);
527 n->dev = dev;
528 if (dev)
529 dev_hold(dev);
530
531 if (tbl->pconstructor && tbl->pconstructor(n)) {
532 if (dev)
533 dev_put(dev);
Denis V. Lunevda12f732008-02-20 00:26:16 -0800534 release_net(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 kfree(n);
536 n = NULL;
537 goto out;
538 }
539
540 write_lock_bh(&tbl->lock);
541 n->next = tbl->phash_buckets[hash_val];
542 tbl->phash_buckets[hash_val] = n;
543 write_unlock_bh(&tbl->lock);
544out:
545 return n;
546}
547
548
Eric W. Biederman426b5302008-01-24 00:13:18 -0800549int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 struct net_device *dev)
551{
552 struct pneigh_entry *n, **np;
553 int key_len = tbl->key_len;
554 u32 hash_val = *(u32 *)(pkey + key_len - 4);
555
556 hash_val ^= (hash_val >> 16);
557 hash_val ^= hash_val >> 8;
558 hash_val ^= hash_val >> 4;
559 hash_val &= PNEIGH_HASHMASK;
560
561 write_lock_bh(&tbl->lock);
562 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
563 np = &n->next) {
Eric W. Biederman426b5302008-01-24 00:13:18 -0800564 if (!memcmp(n->key, pkey, key_len) && n->dev == dev &&
565 (n->net == net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 *np = n->next;
567 write_unlock_bh(&tbl->lock);
568 if (tbl->pdestructor)
569 tbl->pdestructor(n);
570 if (n->dev)
571 dev_put(n->dev);
Eric W. Biederman426b5302008-01-24 00:13:18 -0800572 release_net(n->net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 kfree(n);
574 return 0;
575 }
576 }
577 write_unlock_bh(&tbl->lock);
578 return -ENOENT;
579}
580
581static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
582{
583 struct pneigh_entry *n, **np;
584 u32 h;
585
586 for (h = 0; h <= PNEIGH_HASHMASK; h++) {
587 np = &tbl->phash_buckets[h];
588 while ((n = *np) != NULL) {
589 if (!dev || n->dev == dev) {
590 *np = n->next;
591 if (tbl->pdestructor)
592 tbl->pdestructor(n);
593 if (n->dev)
594 dev_put(n->dev);
Eric W. Biederman426b5302008-01-24 00:13:18 -0800595 release_net(n->net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 kfree(n);
597 continue;
598 }
599 np = &n->next;
600 }
601 }
602 return -ENOENT;
603}
604
Denis V. Lunev06f05112008-01-24 00:30:58 -0800605static void neigh_parms_destroy(struct neigh_parms *parms);
606
607static inline void neigh_parms_put(struct neigh_parms *parms)
608{
609 if (atomic_dec_and_test(&parms->refcnt))
610 neigh_parms_destroy(parms);
611}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612
613/*
614 * neighbour must already be out of the table;
615 *
616 */
617void neigh_destroy(struct neighbour *neigh)
618{
619 struct hh_cache *hh;
620
621 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
622
623 if (!neigh->dead) {
624 printk(KERN_WARNING
625 "Destroying alive neighbour %p\n", neigh);
626 dump_stack();
627 return;
628 }
629
630 if (neigh_del_timer(neigh))
631 printk(KERN_WARNING "Impossible event.\n");
632
633 while ((hh = neigh->hh) != NULL) {
634 neigh->hh = hh->hh_next;
635 hh->hh_next = NULL;
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800636
637 write_seqlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 hh->hh_output = neigh_blackhole;
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800639 write_sequnlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 if (atomic_dec_and_test(&hh->hh_refcnt))
641 kfree(hh);
642 }
643
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 skb_queue_purge(&neigh->arp_queue);
645
646 dev_put(neigh->dev);
647 neigh_parms_put(neigh->parms);
648
649 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh);
650
651 atomic_dec(&neigh->tbl->entries);
652 kmem_cache_free(neigh->tbl->kmem_cachep, neigh);
653}
654
655/* Neighbour state is suspicious;
656 disable fast path.
657
658 Called with write_locked neigh.
659 */
660static void neigh_suspect(struct neighbour *neigh)
661{
662 struct hh_cache *hh;
663
664 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
665
666 neigh->output = neigh->ops->output;
667
668 for (hh = neigh->hh; hh; hh = hh->hh_next)
669 hh->hh_output = neigh->ops->output;
670}
671
672/* Neighbour state is OK;
673 enable fast path.
674
675 Called with write_locked neigh.
676 */
677static void neigh_connect(struct neighbour *neigh)
678{
679 struct hh_cache *hh;
680
681 NEIGH_PRINTK2("neigh %p is connected.\n", neigh);
682
683 neigh->output = neigh->ops->connected_output;
684
685 for (hh = neigh->hh; hh; hh = hh->hh_next)
686 hh->hh_output = neigh->ops->hh_output;
687}
688
689static void neigh_periodic_timer(unsigned long arg)
690{
691 struct neigh_table *tbl = (struct neigh_table *)arg;
692 struct neighbour *n, **np;
693 unsigned long expire, now = jiffies;
694
695 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
696
697 write_lock(&tbl->lock);
698
699 /*
700 * periodically recompute ReachableTime from random function
701 */
702
703 if (time_after(now, tbl->last_rand + 300 * HZ)) {
704 struct neigh_parms *p;
705 tbl->last_rand = now;
706 for (p = &tbl->parms; p; p = p->next)
707 p->reachable_time =
708 neigh_rand_reach_time(p->base_reachable_time);
709 }
710
711 np = &tbl->hash_buckets[tbl->hash_chain_gc];
712 tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask);
713
714 while ((n = *np) != NULL) {
715 unsigned int state;
716
717 write_lock(&n->lock);
718
719 state = n->nud_state;
720 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
721 write_unlock(&n->lock);
722 goto next_elt;
723 }
724
725 if (time_before(n->used, n->confirmed))
726 n->used = n->confirmed;
727
728 if (atomic_read(&n->refcnt) == 1 &&
729 (state == NUD_FAILED ||
730 time_after(now, n->used + n->parms->gc_staletime))) {
731 *np = n->next;
732 n->dead = 1;
733 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -0700734 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 continue;
736 }
737 write_unlock(&n->lock);
738
739next_elt:
740 np = &n->next;
741 }
742
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900743 /* Cycle through all hash buckets every base_reachable_time/2 ticks.
744 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
745 * base_reachable_time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 */
747 expire = tbl->parms.base_reachable_time >> 1;
748 expire /= (tbl->hash_mask + 1);
749 if (!expire)
750 expire = 1;
751
Arjan van de Venf5a6e012007-02-05 17:59:51 -0800752 if (expire>HZ)
753 mod_timer(&tbl->gc_timer, round_jiffies(now + expire));
754 else
755 mod_timer(&tbl->gc_timer, now + expire);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
757 write_unlock(&tbl->lock);
758}
759
760static __inline__ int neigh_max_probes(struct neighbour *n)
761{
762 struct neigh_parms *p = n->parms;
763 return (n->nud_state & NUD_PROBE ?
764 p->ucast_probes :
765 p->ucast_probes + p->app_probes + p->mcast_probes);
766}
767
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768/* Called when a timer expires for a neighbour entry. */
769
770static void neigh_timer_handler(unsigned long arg)
771{
772 unsigned long now, next;
773 struct neighbour *neigh = (struct neighbour *)arg;
774 unsigned state;
775 int notify = 0;
776
777 write_lock(&neigh->lock);
778
779 state = neigh->nud_state;
780 now = jiffies;
781 next = now + HZ;
782
783 if (!(state & NUD_IN_TIMER)) {
784#ifndef CONFIG_SMP
785 printk(KERN_WARNING "neigh: timer & !nud_in_timer\n");
786#endif
787 goto out;
788 }
789
790 if (state & NUD_REACHABLE) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900791 if (time_before_eq(now,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 neigh->confirmed + neigh->parms->reachable_time)) {
793 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh);
794 next = neigh->confirmed + neigh->parms->reachable_time;
795 } else if (time_before_eq(now,
796 neigh->used + neigh->parms->delay_probe_time)) {
797 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
798 neigh->nud_state = NUD_DELAY;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800799 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 neigh_suspect(neigh);
801 next = now + neigh->parms->delay_probe_time;
802 } else {
803 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
804 neigh->nud_state = NUD_STALE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800805 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 neigh_suspect(neigh);
Tom Tucker8d717402006-07-30 20:43:36 -0700807 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 }
809 } else if (state & NUD_DELAY) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900810 if (time_before_eq(now,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 neigh->confirmed + neigh->parms->delay_probe_time)) {
812 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh);
813 neigh->nud_state = NUD_REACHABLE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800814 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 neigh_connect(neigh);
Tom Tucker8d717402006-07-30 20:43:36 -0700816 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 next = neigh->confirmed + neigh->parms->reachable_time;
818 } else {
819 NEIGH_PRINTK2("neigh %p is probed.\n", neigh);
820 neigh->nud_state = NUD_PROBE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800821 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 atomic_set(&neigh->probes, 0);
823 next = now + neigh->parms->retrans_time;
824 }
825 } else {
826 /* NUD_PROBE|NUD_INCOMPLETE */
827 next = now + neigh->parms->retrans_time;
828 }
829
830 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
831 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
832 struct sk_buff *skb;
833
834 neigh->nud_state = NUD_FAILED;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800835 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 notify = 1;
837 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
838 NEIGH_PRINTK2("neigh %p is failed.\n", neigh);
839
840 /* It is very thin place. report_unreachable is very complicated
841 routine. Particularly, it can hit the same neighbour entry!
842
843 So that, we try to be accurate and avoid dead loop. --ANK
844 */
845 while (neigh->nud_state == NUD_FAILED &&
846 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
847 write_unlock(&neigh->lock);
848 neigh->ops->error_report(neigh, skb);
849 write_lock(&neigh->lock);
850 }
851 skb_queue_purge(&neigh->arp_queue);
852 }
853
854 if (neigh->nud_state & NUD_IN_TIMER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 if (time_before(next, jiffies + HZ/2))
856 next = jiffies + HZ/2;
Herbert Xu6fb99742005-10-23 16:37:48 +1000857 if (!mod_timer(&neigh->timer, next))
858 neigh_hold(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 }
860 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
861 struct sk_buff *skb = skb_peek(&neigh->arp_queue);
David S. Miller9ff56602008-02-17 18:39:54 -0800862 /* keep skb alive even if arp_queue overflows */
863 if (skb)
Frank Blaschka7e367632008-03-03 12:16:04 -0800864 skb = skb_copy(skb, GFP_ATOMIC);
David S. Miller9ff56602008-02-17 18:39:54 -0800865 write_unlock(&neigh->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 neigh->ops->solicit(neigh, skb);
867 atomic_inc(&neigh->probes);
David S. Miller9ff56602008-02-17 18:39:54 -0800868 if (skb)
869 kfree_skb(skb);
870 } else {
David S. Miller69cc64d2008-02-11 21:45:44 -0800871out:
David S. Miller9ff56602008-02-17 18:39:54 -0800872 write_unlock(&neigh->lock);
873 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
Thomas Grafd961db32007-08-08 23:12:56 -0700875 if (notify)
876 neigh_update_notify(neigh);
877
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 neigh_release(neigh);
879}
880
881int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
882{
883 int rc;
884 unsigned long now;
885
886 write_lock_bh(&neigh->lock);
887
888 rc = 0;
889 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
890 goto out_unlock_bh;
891
892 now = jiffies;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900893
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
895 if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
896 atomic_set(&neigh->probes, neigh->parms->ucast_probes);
897 neigh->nud_state = NUD_INCOMPLETE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800898 neigh->updated = jiffies;
David S. Miller667347f2005-09-27 12:07:44 -0700899 neigh_add_timer(neigh, now + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 } else {
901 neigh->nud_state = NUD_FAILED;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800902 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 write_unlock_bh(&neigh->lock);
904
905 if (skb)
906 kfree_skb(skb);
907 return 1;
908 }
909 } else if (neigh->nud_state & NUD_STALE) {
910 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 neigh->nud_state = NUD_DELAY;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800912 neigh->updated = jiffies;
David S. Miller667347f2005-09-27 12:07:44 -0700913 neigh_add_timer(neigh,
914 jiffies + neigh->parms->delay_probe_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 }
916
917 if (neigh->nud_state == NUD_INCOMPLETE) {
918 if (skb) {
919 if (skb_queue_len(&neigh->arp_queue) >=
920 neigh->parms->queue_len) {
921 struct sk_buff *buff;
922 buff = neigh->arp_queue.next;
923 __skb_unlink(buff, &neigh->arp_queue);
924 kfree_skb(buff);
925 }
926 __skb_queue_tail(&neigh->arp_queue, skb);
927 }
928 rc = 1;
929 }
930out_unlock_bh:
931 write_unlock_bh(&neigh->lock);
932 return rc;
933}
934
Stephen Hemmingere92b43a2006-08-17 18:17:37 -0700935static void neigh_update_hhs(struct neighbour *neigh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936{
937 struct hh_cache *hh;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700938 void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
939 = neigh->dev->header_ops->cache_update;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
941 if (update) {
942 for (hh = neigh->hh; hh; hh = hh->hh_next) {
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800943 write_seqlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 update(hh, neigh->dev, neigh->ha);
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800945 write_sequnlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 }
947 }
948}
949
950
951
952/* Generic update routine.
953 -- lladdr is new lladdr or NULL, if it is not supplied.
954 -- new is new state.
955 -- flags
956 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
957 if it is different.
958 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900959 lladdr instead of overriding it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 if it is different.
961 It also allows to retain current state
962 if lladdr is unchanged.
963 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
964
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900965 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 NTF_ROUTER flag.
967 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
968 a router.
969
970 Caller MUST hold reference count on the entry.
971 */
972
973int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
974 u32 flags)
975{
976 u8 old;
977 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 int notify = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 struct net_device *dev;
980 int update_isrouter = 0;
981
982 write_lock_bh(&neigh->lock);
983
984 dev = neigh->dev;
985 old = neigh->nud_state;
986 err = -EPERM;
987
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900988 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 (old & (NUD_NOARP | NUD_PERMANENT)))
990 goto out;
991
992 if (!(new & NUD_VALID)) {
993 neigh_del_timer(neigh);
994 if (old & NUD_CONNECTED)
995 neigh_suspect(neigh);
996 neigh->nud_state = new;
997 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 notify = old & NUD_VALID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 goto out;
1000 }
1001
1002 /* Compare new lladdr with cached one */
1003 if (!dev->addr_len) {
1004 /* First case: device needs no address. */
1005 lladdr = neigh->ha;
1006 } else if (lladdr) {
1007 /* The second case: if something is already cached
1008 and a new address is proposed:
1009 - compare new & old
1010 - if they are different, check override flag
1011 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001012 if ((old & NUD_VALID) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 !memcmp(lladdr, neigh->ha, dev->addr_len))
1014 lladdr = neigh->ha;
1015 } else {
1016 /* No address is supplied; if we know something,
1017 use it, otherwise discard the request.
1018 */
1019 err = -EINVAL;
1020 if (!(old & NUD_VALID))
1021 goto out;
1022 lladdr = neigh->ha;
1023 }
1024
1025 if (new & NUD_CONNECTED)
1026 neigh->confirmed = jiffies;
1027 neigh->updated = jiffies;
1028
1029 /* If entry was valid and address is not changed,
1030 do not change entry state, if new one is STALE.
1031 */
1032 err = 0;
1033 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1034 if (old & NUD_VALID) {
1035 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1036 update_isrouter = 0;
1037 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1038 (old & NUD_CONNECTED)) {
1039 lladdr = neigh->ha;
1040 new = NUD_STALE;
1041 } else
1042 goto out;
1043 } else {
1044 if (lladdr == neigh->ha && new == NUD_STALE &&
1045 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1046 (old & NUD_CONNECTED))
1047 )
1048 new = old;
1049 }
1050 }
1051
1052 if (new != old) {
1053 neigh_del_timer(neigh);
Pavel Emelyanova43d8992007-12-20 15:49:05 -08001054 if (new & NUD_IN_TIMER)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001055 neigh_add_timer(neigh, (jiffies +
1056 ((new & NUD_REACHABLE) ?
David S. Miller667347f2005-09-27 12:07:44 -07001057 neigh->parms->reachable_time :
1058 0)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 neigh->nud_state = new;
1060 }
1061
1062 if (lladdr != neigh->ha) {
1063 memcpy(&neigh->ha, lladdr, dev->addr_len);
1064 neigh_update_hhs(neigh);
1065 if (!(new & NUD_CONNECTED))
1066 neigh->confirmed = jiffies -
1067 (neigh->parms->base_reachable_time << 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 }
1070 if (new == old)
1071 goto out;
1072 if (new & NUD_CONNECTED)
1073 neigh_connect(neigh);
1074 else
1075 neigh_suspect(neigh);
1076 if (!(old & NUD_VALID)) {
1077 struct sk_buff *skb;
1078
1079 /* Again: avoid dead loop if something went wrong */
1080
1081 while (neigh->nud_state & NUD_VALID &&
1082 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1083 struct neighbour *n1 = neigh;
1084 write_unlock_bh(&neigh->lock);
1085 /* On shaper/eql skb->dst->neighbour != neigh :( */
1086 if (skb->dst && skb->dst->neighbour)
1087 n1 = skb->dst->neighbour;
1088 n1->output(skb);
1089 write_lock_bh(&neigh->lock);
1090 }
1091 skb_queue_purge(&neigh->arp_queue);
1092 }
1093out:
1094 if (update_isrouter) {
1095 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1096 (neigh->flags | NTF_ROUTER) :
1097 (neigh->flags & ~NTF_ROUTER);
1098 }
1099 write_unlock_bh(&neigh->lock);
Tom Tucker8d717402006-07-30 20:43:36 -07001100
1101 if (notify)
Thomas Grafd961db32007-08-08 23:12:56 -07001102 neigh_update_notify(neigh);
1103
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 return err;
1105}
1106
1107struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1108 u8 *lladdr, void *saddr,
1109 struct net_device *dev)
1110{
1111 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1112 lladdr || !dev->addr_len);
1113 if (neigh)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001114 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 NEIGH_UPDATE_F_OVERRIDE);
1116 return neigh;
1117}
1118
1119static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,
Al Virod77072e2006-09-28 14:20:34 -07001120 __be16 protocol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121{
1122 struct hh_cache *hh;
1123 struct net_device *dev = dst->dev;
1124
1125 for (hh = n->hh; hh; hh = hh->hh_next)
1126 if (hh->hh_type == protocol)
1127 break;
1128
Andrew Morton77d04bd2006-04-07 14:52:59 -07001129 if (!hh && (hh = kzalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) {
Stephen Hemminger3644f0c2006-12-07 15:08:17 -08001130 seqlock_init(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 hh->hh_type = protocol;
1132 atomic_set(&hh->hh_refcnt, 0);
1133 hh->hh_next = NULL;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001134
1135 if (dev->header_ops->cache(n, hh)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 kfree(hh);
1137 hh = NULL;
1138 } else {
1139 atomic_inc(&hh->hh_refcnt);
1140 hh->hh_next = n->hh;
1141 n->hh = hh;
1142 if (n->nud_state & NUD_CONNECTED)
1143 hh->hh_output = n->ops->hh_output;
1144 else
1145 hh->hh_output = n->ops->output;
1146 }
1147 }
1148 if (hh) {
1149 atomic_inc(&hh->hh_refcnt);
1150 dst->hh = hh;
1151 }
1152}
1153
1154/* This function can be used in contexts, where only old dev_queue_xmit
1155 worked, f.e. if you want to override normal output path (eql, shaper),
1156 but resolution is not made yet.
1157 */
1158
1159int neigh_compat_output(struct sk_buff *skb)
1160{
1161 struct net_device *dev = skb->dev;
1162
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03001163 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001165 if (dev_hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
1166 skb->len) < 0 &&
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001167 dev->header_ops->rebuild(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 return 0;
1169
1170 return dev_queue_xmit(skb);
1171}
1172
1173/* Slow and careful. */
1174
1175int neigh_resolve_output(struct sk_buff *skb)
1176{
1177 struct dst_entry *dst = skb->dst;
1178 struct neighbour *neigh;
1179 int rc = 0;
1180
1181 if (!dst || !(neigh = dst->neighbour))
1182 goto discard;
1183
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03001184 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
1186 if (!neigh_event_send(neigh, skb)) {
1187 int err;
1188 struct net_device *dev = neigh->dev;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001189 if (dev->header_ops->cache && !dst->hh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 write_lock_bh(&neigh->lock);
1191 if (!dst->hh)
1192 neigh_hh_init(neigh, dst, dst->ops->protocol);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001193 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1194 neigh->ha, NULL, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 write_unlock_bh(&neigh->lock);
1196 } else {
1197 read_lock_bh(&neigh->lock);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001198 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1199 neigh->ha, NULL, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 read_unlock_bh(&neigh->lock);
1201 }
1202 if (err >= 0)
1203 rc = neigh->ops->queue_xmit(skb);
1204 else
1205 goto out_kfree_skb;
1206 }
1207out:
1208 return rc;
1209discard:
1210 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1211 dst, dst ? dst->neighbour : NULL);
1212out_kfree_skb:
1213 rc = -EINVAL;
1214 kfree_skb(skb);
1215 goto out;
1216}
1217
1218/* As fast as possible without hh cache */
1219
1220int neigh_connected_output(struct sk_buff *skb)
1221{
1222 int err;
1223 struct dst_entry *dst = skb->dst;
1224 struct neighbour *neigh = dst->neighbour;
1225 struct net_device *dev = neigh->dev;
1226
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03001227 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228
1229 read_lock_bh(&neigh->lock);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001230 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1231 neigh->ha, NULL, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 read_unlock_bh(&neigh->lock);
1233 if (err >= 0)
1234 err = neigh->ops->queue_xmit(skb);
1235 else {
1236 err = -EINVAL;
1237 kfree_skb(skb);
1238 }
1239 return err;
1240}
1241
1242static void neigh_proxy_process(unsigned long arg)
1243{
1244 struct neigh_table *tbl = (struct neigh_table *)arg;
1245 long sched_next = 0;
1246 unsigned long now = jiffies;
1247 struct sk_buff *skb;
1248
1249 spin_lock(&tbl->proxy_queue.lock);
1250
1251 skb = tbl->proxy_queue.next;
1252
1253 while (skb != (struct sk_buff *)&tbl->proxy_queue) {
1254 struct sk_buff *back = skb;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001255 long tdif = NEIGH_CB(back)->sched_next - now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
1257 skb = skb->next;
1258 if (tdif <= 0) {
1259 struct net_device *dev = back->dev;
1260 __skb_unlink(back, &tbl->proxy_queue);
1261 if (tbl->proxy_redo && netif_running(dev))
1262 tbl->proxy_redo(back);
1263 else
1264 kfree_skb(back);
1265
1266 dev_put(dev);
1267 } else if (!sched_next || tdif < sched_next)
1268 sched_next = tdif;
1269 }
1270 del_timer(&tbl->proxy_timer);
1271 if (sched_next)
1272 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1273 spin_unlock(&tbl->proxy_queue.lock);
1274}
1275
1276void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1277 struct sk_buff *skb)
1278{
1279 unsigned long now = jiffies;
1280 unsigned long sched_next = now + (net_random() % p->proxy_delay);
1281
1282 if (tbl->proxy_queue.qlen > p->proxy_qlen) {
1283 kfree_skb(skb);
1284 return;
1285 }
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001286
1287 NEIGH_CB(skb)->sched_next = sched_next;
1288 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289
1290 spin_lock(&tbl->proxy_queue.lock);
1291 if (del_timer(&tbl->proxy_timer)) {
1292 if (time_before(tbl->proxy_timer.expires, sched_next))
1293 sched_next = tbl->proxy_timer.expires;
1294 }
1295 dst_release(skb->dst);
1296 skb->dst = NULL;
1297 dev_hold(skb->dev);
1298 __skb_queue_tail(&tbl->proxy_queue, skb);
1299 mod_timer(&tbl->proxy_timer, sched_next);
1300 spin_unlock(&tbl->proxy_queue.lock);
1301}
1302
Eric W. Biederman426b5302008-01-24 00:13:18 -08001303static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl,
1304 struct net *net, int ifindex)
1305{
1306 struct neigh_parms *p;
1307
1308 for (p = &tbl->parms; p; p = p->next) {
1309 if (p->net != net)
1310 continue;
1311 if ((p->dev && p->dev->ifindex == ifindex) ||
1312 (!p->dev && !ifindex))
1313 return p;
1314 }
1315
1316 return NULL;
1317}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
1319struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1320 struct neigh_table *tbl)
1321{
Eric W. Biederman426b5302008-01-24 00:13:18 -08001322 struct neigh_parms *p, *ref;
1323 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
Denis V. Lunev486b51d2008-01-14 22:59:59 -08001325 net = dev->nd_net;
Eric W. Biederman426b5302008-01-24 00:13:18 -08001326 ref = lookup_neigh_params(tbl, net, 0);
1327 if (!ref)
1328 return NULL;
1329
1330 p = kmemdup(ref, sizeof(*p), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 p->tbl = tbl;
1333 atomic_set(&p->refcnt, 1);
1334 INIT_RCU_HEAD(&p->rcu_head);
1335 p->reachable_time =
1336 neigh_rand_reach_time(p->base_reachable_time);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001337
Denis V. Lunev486b51d2008-01-14 22:59:59 -08001338 if (dev->neigh_setup && dev->neigh_setup(dev, p)) {
1339 kfree(p);
1340 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 }
Denis V. Lunev486b51d2008-01-14 22:59:59 -08001342
1343 dev_hold(dev);
1344 p->dev = dev;
Eric W. Biederman426b5302008-01-24 00:13:18 -08001345 p->net = hold_net(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 p->sysctl_table = NULL;
1347 write_lock_bh(&tbl->lock);
1348 p->next = tbl->parms.next;
1349 tbl->parms.next = p;
1350 write_unlock_bh(&tbl->lock);
1351 }
1352 return p;
1353}
1354
1355static void neigh_rcu_free_parms(struct rcu_head *head)
1356{
1357 struct neigh_parms *parms =
1358 container_of(head, struct neigh_parms, rcu_head);
1359
1360 neigh_parms_put(parms);
1361}
1362
1363void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1364{
1365 struct neigh_parms **p;
1366
1367 if (!parms || parms == &tbl->parms)
1368 return;
1369 write_lock_bh(&tbl->lock);
1370 for (p = &tbl->parms.next; *p; p = &(*p)->next) {
1371 if (*p == parms) {
1372 *p = parms->next;
1373 parms->dead = 1;
1374 write_unlock_bh(&tbl->lock);
David S. Millercecbb632008-01-20 16:39:03 -08001375 if (parms->dev)
1376 dev_put(parms->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1378 return;
1379 }
1380 }
1381 write_unlock_bh(&tbl->lock);
1382 NEIGH_PRINTK1("neigh_parms_release: not found\n");
1383}
1384
Denis V. Lunev06f05112008-01-24 00:30:58 -08001385static void neigh_parms_destroy(struct neigh_parms *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386{
Eric W. Biederman426b5302008-01-24 00:13:18 -08001387 release_net(parms->net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 kfree(parms);
1389}
1390
Pavel Emelianovc2ecba72007-04-17 12:45:31 -07001391static struct lock_class_key neigh_table_proxy_queue_class;
1392
Simon Kelleybd89efc2006-05-12 14:56:08 -07001393void neigh_table_init_no_netlink(struct neigh_table *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394{
1395 unsigned long now = jiffies;
1396 unsigned long phsize;
1397
Eric W. Biederman426b5302008-01-24 00:13:18 -08001398 tbl->parms.net = &init_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 atomic_set(&tbl->parms.refcnt, 1);
1400 INIT_RCU_HEAD(&tbl->parms.rcu_head);
1401 tbl->parms.reachable_time =
1402 neigh_rand_reach_time(tbl->parms.base_reachable_time);
1403
1404 if (!tbl->kmem_cachep)
Alexey Dobriyane5d679f332006-08-26 19:25:52 -07001405 tbl->kmem_cachep =
1406 kmem_cache_create(tbl->id, tbl->entry_size, 0,
1407 SLAB_HWCACHE_ALIGN|SLAB_PANIC,
Paul Mundt20c2df82007-07-20 10:11:58 +09001408 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 tbl->stats = alloc_percpu(struct neigh_statistics);
1410 if (!tbl->stats)
1411 panic("cannot create neighbour cache statistics");
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001412
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413#ifdef CONFIG_PROC_FS
Wang Chen46ecf0b2008-02-28 14:10:51 -08001414 tbl->pde = proc_create(tbl->id, 0, init_net.proc_net_stat,
1415 &neigh_stat_seq_fops);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001416 if (!tbl->pde)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 panic("cannot create neighbour proc dir entry");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 tbl->pde->data = tbl;
1419#endif
1420
1421 tbl->hash_mask = 1;
1422 tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1);
1423
1424 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
Andrew Morton77d04bd2006-04-07 14:52:59 -07001425 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426
1427 if (!tbl->hash_buckets || !tbl->phash_buckets)
1428 panic("cannot allocate neighbour cache hashes");
1429
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
1431
1432 rwlock_init(&tbl->lock);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -08001433 setup_timer(&tbl->gc_timer, neigh_periodic_timer, (unsigned long)tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 tbl->gc_timer.expires = now + 1;
1435 add_timer(&tbl->gc_timer);
1436
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -08001437 setup_timer(&tbl->proxy_timer, neigh_proxy_process, (unsigned long)tbl);
Pavel Emelianovc2ecba72007-04-17 12:45:31 -07001438 skb_queue_head_init_class(&tbl->proxy_queue,
1439 &neigh_table_proxy_queue_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
1441 tbl->last_flush = now;
1442 tbl->last_rand = now + tbl->parms.reachable_time * 20;
Simon Kelleybd89efc2006-05-12 14:56:08 -07001443}
1444
1445void neigh_table_init(struct neigh_table *tbl)
1446{
1447 struct neigh_table *tmp;
1448
1449 neigh_table_init_no_netlink(tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 write_lock(&neigh_tbl_lock);
Simon Kelleybd89efc2006-05-12 14:56:08 -07001451 for (tmp = neigh_tables; tmp; tmp = tmp->next) {
1452 if (tmp->family == tbl->family)
1453 break;
1454 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 tbl->next = neigh_tables;
1456 neigh_tables = tbl;
1457 write_unlock(&neigh_tbl_lock);
Simon Kelleybd89efc2006-05-12 14:56:08 -07001458
1459 if (unlikely(tmp)) {
1460 printk(KERN_ERR "NEIGH: Registering multiple tables for "
1461 "family %d\n", tbl->family);
1462 dump_stack();
1463 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464}
1465
1466int neigh_table_clear(struct neigh_table *tbl)
1467{
1468 struct neigh_table **tp;
1469
1470 /* It is not clean... Fix it to unload IPv6 module safely */
1471 del_timer_sync(&tbl->gc_timer);
1472 del_timer_sync(&tbl->proxy_timer);
1473 pneigh_queue_purge(&tbl->proxy_queue);
1474 neigh_ifdown(tbl, NULL);
1475 if (atomic_read(&tbl->entries))
1476 printk(KERN_CRIT "neighbour leakage\n");
1477 write_lock(&neigh_tbl_lock);
1478 for (tp = &neigh_tables; *tp; tp = &(*tp)->next) {
1479 if (*tp == tbl) {
1480 *tp = tbl->next;
1481 break;
1482 }
1483 }
1484 write_unlock(&neigh_tbl_lock);
1485
1486 neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1);
1487 tbl->hash_buckets = NULL;
1488
1489 kfree(tbl->phash_buckets);
1490 tbl->phash_buckets = NULL;
1491
Alexey Dobriyan3f192b52007-11-05 21:28:13 -08001492 remove_proc_entry(tbl->id, init_net.proc_net_stat);
1493
Kirill Korotaev3fcde742006-09-01 01:34:10 -07001494 free_percpu(tbl->stats);
1495 tbl->stats = NULL;
1496
Randy Dunlapbfb85c92007-10-21 16:24:27 -07001497 kmem_cache_destroy(tbl->kmem_cachep);
1498 tbl->kmem_cachep = NULL;
1499
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 return 0;
1501}
1502
Thomas Grafc8822a42007-03-22 11:50:06 -07001503static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504{
Eric W. Biederman881d9662007-09-17 11:56:21 -07001505 struct net *net = skb->sk->sk_net;
Thomas Grafa14a49d2006-08-07 17:53:08 -07001506 struct ndmsg *ndm;
1507 struct nlattr *dst_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 struct neigh_table *tbl;
1509 struct net_device *dev = NULL;
Thomas Grafa14a49d2006-08-07 17:53:08 -07001510 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511
Thomas Grafa14a49d2006-08-07 17:53:08 -07001512 if (nlmsg_len(nlh) < sizeof(*ndm))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 goto out;
1514
Thomas Grafa14a49d2006-08-07 17:53:08 -07001515 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1516 if (dst_attr == NULL)
1517 goto out;
1518
1519 ndm = nlmsg_data(nlh);
1520 if (ndm->ndm_ifindex) {
Eric W. Biederman881d9662007-09-17 11:56:21 -07001521 dev = dev_get_by_index(net, ndm->ndm_ifindex);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001522 if (dev == NULL) {
1523 err = -ENODEV;
1524 goto out;
1525 }
1526 }
1527
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 read_lock(&neigh_tbl_lock);
1529 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
Thomas Grafa14a49d2006-08-07 17:53:08 -07001530 struct neighbour *neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
1532 if (tbl->family != ndm->ndm_family)
1533 continue;
1534 read_unlock(&neigh_tbl_lock);
1535
Thomas Grafa14a49d2006-08-07 17:53:08 -07001536 if (nla_len(dst_attr) < tbl->key_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 goto out_dev_put;
1538
1539 if (ndm->ndm_flags & NTF_PROXY) {
Eric W. Biederman426b5302008-01-24 00:13:18 -08001540 err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 goto out_dev_put;
1542 }
1543
Thomas Grafa14a49d2006-08-07 17:53:08 -07001544 if (dev == NULL)
1545 goto out_dev_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546
Thomas Grafa14a49d2006-08-07 17:53:08 -07001547 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1548 if (neigh == NULL) {
1549 err = -ENOENT;
1550 goto out_dev_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 }
Thomas Grafa14a49d2006-08-07 17:53:08 -07001552
1553 err = neigh_update(neigh, NULL, NUD_FAILED,
1554 NEIGH_UPDATE_F_OVERRIDE |
1555 NEIGH_UPDATE_F_ADMIN);
1556 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 goto out_dev_put;
1558 }
1559 read_unlock(&neigh_tbl_lock);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001560 err = -EAFNOSUPPORT;
1561
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562out_dev_put:
1563 if (dev)
1564 dev_put(dev);
1565out:
1566 return err;
1567}
1568
Thomas Grafc8822a42007-03-22 11:50:06 -07001569static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570{
Eric W. Biederman881d9662007-09-17 11:56:21 -07001571 struct net *net = skb->sk->sk_net;
Thomas Graf5208deb2006-08-07 17:55:40 -07001572 struct ndmsg *ndm;
1573 struct nlattr *tb[NDA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 struct neigh_table *tbl;
1575 struct net_device *dev = NULL;
Thomas Graf5208deb2006-08-07 17:55:40 -07001576 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
Thomas Graf5208deb2006-08-07 17:55:40 -07001578 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
1579 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 goto out;
1581
Thomas Graf5208deb2006-08-07 17:55:40 -07001582 err = -EINVAL;
1583 if (tb[NDA_DST] == NULL)
1584 goto out;
1585
1586 ndm = nlmsg_data(nlh);
1587 if (ndm->ndm_ifindex) {
Eric W. Biederman881d9662007-09-17 11:56:21 -07001588 dev = dev_get_by_index(net, ndm->ndm_ifindex);
Thomas Graf5208deb2006-08-07 17:55:40 -07001589 if (dev == NULL) {
1590 err = -ENODEV;
1591 goto out;
1592 }
1593
1594 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
1595 goto out_dev_put;
1596 }
1597
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 read_lock(&neigh_tbl_lock);
1599 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
Thomas Graf5208deb2006-08-07 17:55:40 -07001600 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
1601 struct neighbour *neigh;
1602 void *dst, *lladdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603
1604 if (tbl->family != ndm->ndm_family)
1605 continue;
1606 read_unlock(&neigh_tbl_lock);
1607
Thomas Graf5208deb2006-08-07 17:55:40 -07001608 if (nla_len(tb[NDA_DST]) < tbl->key_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 goto out_dev_put;
Thomas Graf5208deb2006-08-07 17:55:40 -07001610 dst = nla_data(tb[NDA_DST]);
1611 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612
1613 if (ndm->ndm_flags & NTF_PROXY) {
Ville Nuorvala62dd9312006-09-22 14:43:19 -07001614 struct pneigh_entry *pn;
1615
1616 err = -ENOBUFS;
Eric W. Biederman426b5302008-01-24 00:13:18 -08001617 pn = pneigh_lookup(tbl, net, dst, dev, 1);
Ville Nuorvala62dd9312006-09-22 14:43:19 -07001618 if (pn) {
1619 pn->flags = ndm->ndm_flags;
1620 err = 0;
1621 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 goto out_dev_put;
1623 }
1624
Thomas Graf5208deb2006-08-07 17:55:40 -07001625 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 goto out_dev_put;
Thomas Graf5208deb2006-08-07 17:55:40 -07001627
1628 neigh = neigh_lookup(tbl, dst, dev);
1629 if (neigh == NULL) {
1630 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1631 err = -ENOENT;
1632 goto out_dev_put;
1633 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001634
Thomas Graf5208deb2006-08-07 17:55:40 -07001635 neigh = __neigh_lookup_errno(tbl, dst, dev);
1636 if (IS_ERR(neigh)) {
1637 err = PTR_ERR(neigh);
1638 goto out_dev_put;
1639 }
1640 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1642 err = -EEXIST;
Thomas Graf5208deb2006-08-07 17:55:40 -07001643 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 goto out_dev_put;
1645 }
Thomas Graf5208deb2006-08-07 17:55:40 -07001646
1647 if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
1648 flags &= ~NEIGH_UPDATE_F_OVERRIDE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 }
1650
Thomas Graf5208deb2006-08-07 17:55:40 -07001651 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
1652 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 goto out_dev_put;
1654 }
1655
1656 read_unlock(&neigh_tbl_lock);
Thomas Graf5208deb2006-08-07 17:55:40 -07001657 err = -EAFNOSUPPORT;
1658
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659out_dev_put:
1660 if (dev)
1661 dev_put(dev);
1662out:
1663 return err;
1664}
1665
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001666static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1667{
Thomas Grafca860fb2006-08-07 18:00:18 -07001668 struct nlattr *nest;
1669
1670 nest = nla_nest_start(skb, NDTA_PARMS);
1671 if (nest == NULL)
1672 return -ENOBUFS;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001673
1674 if (parms->dev)
Thomas Grafca860fb2006-08-07 18:00:18 -07001675 NLA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001676
Thomas Grafca860fb2006-08-07 18:00:18 -07001677 NLA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt));
1678 NLA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len);
1679 NLA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen);
1680 NLA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes);
1681 NLA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes);
1682 NLA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes);
1683 NLA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time);
1684 NLA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME,
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001685 parms->base_reachable_time);
Thomas Grafca860fb2006-08-07 18:00:18 -07001686 NLA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime);
1687 NLA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time);
1688 NLA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time);
1689 NLA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay);
1690 NLA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay);
1691 NLA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001692
Thomas Grafca860fb2006-08-07 18:00:18 -07001693 return nla_nest_end(skb, nest);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001694
Thomas Grafca860fb2006-08-07 18:00:18 -07001695nla_put_failure:
1696 return nla_nest_cancel(skb, nest);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001697}
1698
Thomas Grafca860fb2006-08-07 18:00:18 -07001699static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
1700 u32 pid, u32 seq, int type, int flags)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001701{
1702 struct nlmsghdr *nlh;
1703 struct ndtmsg *ndtmsg;
1704
Thomas Grafca860fb2006-08-07 18:00:18 -07001705 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1706 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001707 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001708
Thomas Grafca860fb2006-08-07 18:00:18 -07001709 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001710
1711 read_lock_bh(&tbl->lock);
1712 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001713 ndtmsg->ndtm_pad1 = 0;
1714 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001715
Thomas Grafca860fb2006-08-07 18:00:18 -07001716 NLA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1717 NLA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval);
1718 NLA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1);
1719 NLA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2);
1720 NLA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001721
1722 {
1723 unsigned long now = jiffies;
1724 unsigned int flush_delta = now - tbl->last_flush;
1725 unsigned int rand_delta = now - tbl->last_rand;
1726
1727 struct ndt_config ndc = {
1728 .ndtc_key_len = tbl->key_len,
1729 .ndtc_entry_size = tbl->entry_size,
1730 .ndtc_entries = atomic_read(&tbl->entries),
1731 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
1732 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
1733 .ndtc_hash_rnd = tbl->hash_rnd,
1734 .ndtc_hash_mask = tbl->hash_mask,
1735 .ndtc_hash_chain_gc = tbl->hash_chain_gc,
1736 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
1737 };
1738
Thomas Grafca860fb2006-08-07 18:00:18 -07001739 NLA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001740 }
1741
1742 {
1743 int cpu;
1744 struct ndt_stats ndst;
1745
1746 memset(&ndst, 0, sizeof(ndst));
1747
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -07001748 for_each_possible_cpu(cpu) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001749 struct neigh_statistics *st;
1750
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001751 st = per_cpu_ptr(tbl->stats, cpu);
1752 ndst.ndts_allocs += st->allocs;
1753 ndst.ndts_destroys += st->destroys;
1754 ndst.ndts_hash_grows += st->hash_grows;
1755 ndst.ndts_res_failed += st->res_failed;
1756 ndst.ndts_lookups += st->lookups;
1757 ndst.ndts_hits += st->hits;
1758 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1759 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1760 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1761 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1762 }
1763
Thomas Grafca860fb2006-08-07 18:00:18 -07001764 NLA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001765 }
1766
1767 BUG_ON(tbl->parms.dev);
1768 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
Thomas Grafca860fb2006-08-07 18:00:18 -07001769 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001770
1771 read_unlock_bh(&tbl->lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001772 return nlmsg_end(skb, nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001773
Thomas Grafca860fb2006-08-07 18:00:18 -07001774nla_put_failure:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001775 read_unlock_bh(&tbl->lock);
Patrick McHardy26932562007-01-31 23:16:40 -08001776 nlmsg_cancel(skb, nlh);
1777 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001778}
1779
Thomas Grafca860fb2006-08-07 18:00:18 -07001780static int neightbl_fill_param_info(struct sk_buff *skb,
1781 struct neigh_table *tbl,
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001782 struct neigh_parms *parms,
Thomas Grafca860fb2006-08-07 18:00:18 -07001783 u32 pid, u32 seq, int type,
1784 unsigned int flags)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001785{
1786 struct ndtmsg *ndtmsg;
1787 struct nlmsghdr *nlh;
1788
Thomas Grafca860fb2006-08-07 18:00:18 -07001789 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1790 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001791 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001792
Thomas Grafca860fb2006-08-07 18:00:18 -07001793 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001794
1795 read_lock_bh(&tbl->lock);
1796 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001797 ndtmsg->ndtm_pad1 = 0;
1798 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001799
Thomas Grafca860fb2006-08-07 18:00:18 -07001800 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
1801 neightbl_fill_parms(skb, parms) < 0)
1802 goto errout;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001803
1804 read_unlock_bh(&tbl->lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001805 return nlmsg_end(skb, nlh);
1806errout:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001807 read_unlock_bh(&tbl->lock);
Patrick McHardy26932562007-01-31 23:16:40 -08001808 nlmsg_cancel(skb, nlh);
1809 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001810}
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001811
Patrick McHardyef7c79e2007-06-05 12:38:30 -07001812static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
Thomas Graf6b3f8672006-08-07 17:58:53 -07001813 [NDTA_NAME] = { .type = NLA_STRING },
1814 [NDTA_THRESH1] = { .type = NLA_U32 },
1815 [NDTA_THRESH2] = { .type = NLA_U32 },
1816 [NDTA_THRESH3] = { .type = NLA_U32 },
1817 [NDTA_GC_INTERVAL] = { .type = NLA_U64 },
1818 [NDTA_PARMS] = { .type = NLA_NESTED },
1819};
1820
Patrick McHardyef7c79e2007-06-05 12:38:30 -07001821static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
Thomas Graf6b3f8672006-08-07 17:58:53 -07001822 [NDTPA_IFINDEX] = { .type = NLA_U32 },
1823 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 },
1824 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 },
1825 [NDTPA_APP_PROBES] = { .type = NLA_U32 },
1826 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 },
1827 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 },
1828 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 },
1829 [NDTPA_GC_STALETIME] = { .type = NLA_U64 },
1830 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 },
1831 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 },
1832 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 },
1833 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 },
1834 [NDTPA_LOCKTIME] = { .type = NLA_U64 },
1835};
1836
Thomas Grafc8822a42007-03-22 11:50:06 -07001837static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001838{
Denis V. Lunevb8542722007-12-01 00:21:31 +11001839 struct net *net = skb->sk->sk_net;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001840 struct neigh_table *tbl;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001841 struct ndtmsg *ndtmsg;
1842 struct nlattr *tb[NDTA_MAX+1];
1843 int err;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001844
Thomas Graf6b3f8672006-08-07 17:58:53 -07001845 err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
1846 nl_neightbl_policy);
1847 if (err < 0)
1848 goto errout;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001849
Thomas Graf6b3f8672006-08-07 17:58:53 -07001850 if (tb[NDTA_NAME] == NULL) {
1851 err = -EINVAL;
1852 goto errout;
1853 }
1854
1855 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001856 read_lock(&neigh_tbl_lock);
1857 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1858 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1859 continue;
1860
Thomas Graf6b3f8672006-08-07 17:58:53 -07001861 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001862 break;
1863 }
1864
1865 if (tbl == NULL) {
1866 err = -ENOENT;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001867 goto errout_locked;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001868 }
1869
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001870 /*
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001871 * We acquire tbl->lock to be nice to the periodic timers and
1872 * make sure they always see a consistent set of values.
1873 */
1874 write_lock_bh(&tbl->lock);
1875
Thomas Graf6b3f8672006-08-07 17:58:53 -07001876 if (tb[NDTA_PARMS]) {
1877 struct nlattr *tbp[NDTPA_MAX+1];
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001878 struct neigh_parms *p;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001879 int i, ifindex = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001880
Thomas Graf6b3f8672006-08-07 17:58:53 -07001881 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
1882 nl_ntbl_parm_policy);
1883 if (err < 0)
1884 goto errout_tbl_lock;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001885
Thomas Graf6b3f8672006-08-07 17:58:53 -07001886 if (tbp[NDTPA_IFINDEX])
1887 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001888
Eric W. Biederman426b5302008-01-24 00:13:18 -08001889 p = lookup_neigh_params(tbl, net, ifindex);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001890 if (p == NULL) {
1891 err = -ENOENT;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001892 goto errout_tbl_lock;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001893 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001894
Thomas Graf6b3f8672006-08-07 17:58:53 -07001895 for (i = 1; i <= NDTPA_MAX; i++) {
1896 if (tbp[i] == NULL)
1897 continue;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001898
Thomas Graf6b3f8672006-08-07 17:58:53 -07001899 switch (i) {
1900 case NDTPA_QUEUE_LEN:
1901 p->queue_len = nla_get_u32(tbp[i]);
1902 break;
1903 case NDTPA_PROXY_QLEN:
1904 p->proxy_qlen = nla_get_u32(tbp[i]);
1905 break;
1906 case NDTPA_APP_PROBES:
1907 p->app_probes = nla_get_u32(tbp[i]);
1908 break;
1909 case NDTPA_UCAST_PROBES:
1910 p->ucast_probes = nla_get_u32(tbp[i]);
1911 break;
1912 case NDTPA_MCAST_PROBES:
1913 p->mcast_probes = nla_get_u32(tbp[i]);
1914 break;
1915 case NDTPA_BASE_REACHABLE_TIME:
1916 p->base_reachable_time = nla_get_msecs(tbp[i]);
1917 break;
1918 case NDTPA_GC_STALETIME:
1919 p->gc_staletime = nla_get_msecs(tbp[i]);
1920 break;
1921 case NDTPA_DELAY_PROBE_TIME:
1922 p->delay_probe_time = nla_get_msecs(tbp[i]);
1923 break;
1924 case NDTPA_RETRANS_TIME:
1925 p->retrans_time = nla_get_msecs(tbp[i]);
1926 break;
1927 case NDTPA_ANYCAST_DELAY:
1928 p->anycast_delay = nla_get_msecs(tbp[i]);
1929 break;
1930 case NDTPA_PROXY_DELAY:
1931 p->proxy_delay = nla_get_msecs(tbp[i]);
1932 break;
1933 case NDTPA_LOCKTIME:
1934 p->locktime = nla_get_msecs(tbp[i]);
1935 break;
1936 }
1937 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001938 }
1939
Thomas Graf6b3f8672006-08-07 17:58:53 -07001940 if (tb[NDTA_THRESH1])
1941 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
1942
1943 if (tb[NDTA_THRESH2])
1944 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
1945
1946 if (tb[NDTA_THRESH3])
1947 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
1948
1949 if (tb[NDTA_GC_INTERVAL])
1950 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
1951
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001952 err = 0;
1953
Thomas Graf6b3f8672006-08-07 17:58:53 -07001954errout_tbl_lock:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001955 write_unlock_bh(&tbl->lock);
Thomas Graf6b3f8672006-08-07 17:58:53 -07001956errout_locked:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001957 read_unlock(&neigh_tbl_lock);
Thomas Graf6b3f8672006-08-07 17:58:53 -07001958errout:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001959 return err;
1960}
1961
Thomas Grafc8822a42007-03-22 11:50:06 -07001962static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001963{
Denis V. Lunevb8542722007-12-01 00:21:31 +11001964 struct net *net = skb->sk->sk_net;
Thomas Grafca860fb2006-08-07 18:00:18 -07001965 int family, tidx, nidx = 0;
1966 int tbl_skip = cb->args[0];
1967 int neigh_skip = cb->args[1];
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001968 struct neigh_table *tbl;
1969
Thomas Grafca860fb2006-08-07 18:00:18 -07001970 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001971
1972 read_lock(&neigh_tbl_lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001973 for (tbl = neigh_tables, tidx = 0; tbl; tbl = tbl->next, tidx++) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001974 struct neigh_parms *p;
1975
Thomas Grafca860fb2006-08-07 18:00:18 -07001976 if (tidx < tbl_skip || (family && tbl->family != family))
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001977 continue;
1978
Thomas Grafca860fb2006-08-07 18:00:18 -07001979 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).pid,
1980 cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
1981 NLM_F_MULTI) <= 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001982 break;
1983
Eric W. Biederman426b5302008-01-24 00:13:18 -08001984 for (nidx = 0, p = tbl->parms.next; p; p = p->next) {
1985 if (net != p->net)
1986 continue;
1987
1988 if (nidx++ < neigh_skip)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001989 continue;
1990
Thomas Grafca860fb2006-08-07 18:00:18 -07001991 if (neightbl_fill_param_info(skb, tbl, p,
1992 NETLINK_CB(cb->skb).pid,
1993 cb->nlh->nlmsg_seq,
1994 RTM_NEWNEIGHTBL,
1995 NLM_F_MULTI) <= 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001996 goto out;
1997 }
1998
Thomas Grafca860fb2006-08-07 18:00:18 -07001999 neigh_skip = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002000 }
2001out:
2002 read_unlock(&neigh_tbl_lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07002003 cb->args[0] = tidx;
2004 cb->args[1] = nidx;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002005
2006 return skb->len;
2007}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008
Thomas Graf8b8aec52006-08-07 17:56:37 -07002009static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
2010 u32 pid, u32 seq, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011{
2012 unsigned long now = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 struct nda_cacheinfo ci;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002014 struct nlmsghdr *nlh;
2015 struct ndmsg *ndm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016
Thomas Graf8b8aec52006-08-07 17:56:37 -07002017 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2018 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08002019 return -EMSGSIZE;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002020
2021 ndm = nlmsg_data(nlh);
2022 ndm->ndm_family = neigh->ops->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07002023 ndm->ndm_pad1 = 0;
2024 ndm->ndm_pad2 = 0;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002025 ndm->ndm_flags = neigh->flags;
2026 ndm->ndm_type = neigh->type;
2027 ndm->ndm_ifindex = neigh->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028
Thomas Graf8b8aec52006-08-07 17:56:37 -07002029 NLA_PUT(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key);
2030
2031 read_lock_bh(&neigh->lock);
2032 ndm->ndm_state = neigh->nud_state;
2033 if ((neigh->nud_state & NUD_VALID) &&
2034 nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, neigh->ha) < 0) {
2035 read_unlock_bh(&neigh->lock);
2036 goto nla_put_failure;
2037 }
2038
2039 ci.ndm_used = now - neigh->used;
2040 ci.ndm_confirmed = now - neigh->confirmed;
2041 ci.ndm_updated = now - neigh->updated;
2042 ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1;
2043 read_unlock_bh(&neigh->lock);
2044
2045 NLA_PUT_U32(skb, NDA_PROBES, atomic_read(&neigh->probes));
2046 NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
2047
2048 return nlmsg_end(skb, nlh);
2049
2050nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002051 nlmsg_cancel(skb, nlh);
2052 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053}
2054
Thomas Grafd961db32007-08-08 23:12:56 -07002055static void neigh_update_notify(struct neighbour *neigh)
2056{
2057 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2058 __neigh_notify(neigh, RTM_NEWNEIGH, 0);
2059}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060
2061static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2062 struct netlink_callback *cb)
2063{
Eric W. Biederman426b5302008-01-24 00:13:18 -08002064 struct net * net = skb->sk->sk_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 struct neighbour *n;
2066 int rc, h, s_h = cb->args[1];
2067 int idx, s_idx = idx = cb->args[2];
2068
Julian Anastasovc5e29462006-10-03 15:49:46 -07002069 read_lock_bh(&tbl->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 for (h = 0; h <= tbl->hash_mask; h++) {
2071 if (h < s_h)
2072 continue;
2073 if (h > s_h)
2074 s_idx = 0;
Eric W. Biederman426b5302008-01-24 00:13:18 -08002075 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next) {
2076 int lidx;
2077 if (n->dev->nd_net != net)
2078 continue;
2079 lidx = idx++;
2080 if (lidx < s_idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 continue;
2082 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid,
2083 cb->nlh->nlmsg_seq,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07002084 RTM_NEWNEIGH,
2085 NLM_F_MULTI) <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 read_unlock_bh(&tbl->lock);
2087 rc = -1;
2088 goto out;
2089 }
2090 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 }
Julian Anastasovc5e29462006-10-03 15:49:46 -07002092 read_unlock_bh(&tbl->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 rc = skb->len;
2094out:
2095 cb->args[1] = h;
2096 cb->args[2] = idx;
2097 return rc;
2098}
2099
Thomas Grafc8822a42007-03-22 11:50:06 -07002100static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101{
2102 struct neigh_table *tbl;
2103 int t, family, s_t;
2104
2105 read_lock(&neigh_tbl_lock);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002106 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 s_t = cb->args[0];
2108
2109 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
2110 if (t < s_t || (family && tbl->family != family))
2111 continue;
2112 if (t > s_t)
2113 memset(&cb->args[1], 0, sizeof(cb->args) -
2114 sizeof(cb->args[0]));
2115 if (neigh_dump_table(tbl, skb, cb) < 0)
2116 break;
2117 }
2118 read_unlock(&neigh_tbl_lock);
2119
2120 cb->args[0] = t;
2121 return skb->len;
2122}
2123
2124void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2125{
2126 int chain;
2127
2128 read_lock_bh(&tbl->lock);
2129 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2130 struct neighbour *n;
2131
2132 for (n = tbl->hash_buckets[chain]; n; n = n->next)
2133 cb(n, cookie);
2134 }
2135 read_unlock_bh(&tbl->lock);
2136}
2137EXPORT_SYMBOL(neigh_for_each);
2138
2139/* The tbl->lock must be held as a writer and BH disabled. */
2140void __neigh_for_each_release(struct neigh_table *tbl,
2141 int (*cb)(struct neighbour *))
2142{
2143 int chain;
2144
2145 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2146 struct neighbour *n, **np;
2147
2148 np = &tbl->hash_buckets[chain];
2149 while ((n = *np) != NULL) {
2150 int release;
2151
2152 write_lock(&n->lock);
2153 release = cb(n);
2154 if (release) {
2155 *np = n->next;
2156 n->dead = 1;
2157 } else
2158 np = &n->next;
2159 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -07002160 if (release)
2161 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 }
2163 }
2164}
2165EXPORT_SYMBOL(__neigh_for_each_release);
2166
2167#ifdef CONFIG_PROC_FS
2168
2169static struct neighbour *neigh_get_first(struct seq_file *seq)
2170{
2171 struct neigh_seq_state *state = seq->private;
Denis V. Lunev42508462008-01-10 03:53:12 -08002172 struct net *net = state->p.net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 struct neigh_table *tbl = state->tbl;
2174 struct neighbour *n = NULL;
2175 int bucket = state->bucket;
2176
2177 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2178 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) {
2179 n = tbl->hash_buckets[bucket];
2180
2181 while (n) {
Eric W. Biederman426b5302008-01-24 00:13:18 -08002182 if (n->dev->nd_net != net)
2183 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 if (state->neigh_sub_iter) {
2185 loff_t fakep = 0;
2186 void *v;
2187
2188 v = state->neigh_sub_iter(state, n, &fakep);
2189 if (!v)
2190 goto next;
2191 }
2192 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2193 break;
2194 if (n->nud_state & ~NUD_NOARP)
2195 break;
2196 next:
2197 n = n->next;
2198 }
2199
2200 if (n)
2201 break;
2202 }
2203 state->bucket = bucket;
2204
2205 return n;
2206}
2207
2208static struct neighbour *neigh_get_next(struct seq_file *seq,
2209 struct neighbour *n,
2210 loff_t *pos)
2211{
2212 struct neigh_seq_state *state = seq->private;
Denis V. Lunev42508462008-01-10 03:53:12 -08002213 struct net *net = state->p.net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 struct neigh_table *tbl = state->tbl;
2215
2216 if (state->neigh_sub_iter) {
2217 void *v = state->neigh_sub_iter(state, n, pos);
2218 if (v)
2219 return n;
2220 }
2221 n = n->next;
2222
2223 while (1) {
2224 while (n) {
Eric W. Biederman426b5302008-01-24 00:13:18 -08002225 if (n->dev->nd_net != net)
2226 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 if (state->neigh_sub_iter) {
2228 void *v = state->neigh_sub_iter(state, n, pos);
2229 if (v)
2230 return n;
2231 goto next;
2232 }
2233 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2234 break;
2235
2236 if (n->nud_state & ~NUD_NOARP)
2237 break;
2238 next:
2239 n = n->next;
2240 }
2241
2242 if (n)
2243 break;
2244
2245 if (++state->bucket > tbl->hash_mask)
2246 break;
2247
2248 n = tbl->hash_buckets[state->bucket];
2249 }
2250
2251 if (n && pos)
2252 --(*pos);
2253 return n;
2254}
2255
2256static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2257{
2258 struct neighbour *n = neigh_get_first(seq);
2259
2260 if (n) {
2261 while (*pos) {
2262 n = neigh_get_next(seq, n, pos);
2263 if (!n)
2264 break;
2265 }
2266 }
2267 return *pos ? NULL : n;
2268}
2269
2270static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2271{
2272 struct neigh_seq_state *state = seq->private;
Denis V. Lunev42508462008-01-10 03:53:12 -08002273 struct net * net = state->p.net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 struct neigh_table *tbl = state->tbl;
2275 struct pneigh_entry *pn = NULL;
2276 int bucket = state->bucket;
2277
2278 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2279 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2280 pn = tbl->phash_buckets[bucket];
Eric W. Biederman426b5302008-01-24 00:13:18 -08002281 while (pn && (pn->net != net))
2282 pn = pn->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 if (pn)
2284 break;
2285 }
2286 state->bucket = bucket;
2287
2288 return pn;
2289}
2290
2291static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2292 struct pneigh_entry *pn,
2293 loff_t *pos)
2294{
2295 struct neigh_seq_state *state = seq->private;
Denis V. Lunev42508462008-01-10 03:53:12 -08002296 struct net * net = state->p.net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 struct neigh_table *tbl = state->tbl;
2298
2299 pn = pn->next;
2300 while (!pn) {
2301 if (++state->bucket > PNEIGH_HASHMASK)
2302 break;
2303 pn = tbl->phash_buckets[state->bucket];
Eric W. Biederman426b5302008-01-24 00:13:18 -08002304 while (pn && (pn->net != net))
2305 pn = pn->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 if (pn)
2307 break;
2308 }
2309
2310 if (pn && pos)
2311 --(*pos);
2312
2313 return pn;
2314}
2315
2316static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2317{
2318 struct pneigh_entry *pn = pneigh_get_first(seq);
2319
2320 if (pn) {
2321 while (*pos) {
2322 pn = pneigh_get_next(seq, pn, pos);
2323 if (!pn)
2324 break;
2325 }
2326 }
2327 return *pos ? NULL : pn;
2328}
2329
2330static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2331{
2332 struct neigh_seq_state *state = seq->private;
2333 void *rc;
2334
2335 rc = neigh_get_idx(seq, pos);
2336 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2337 rc = pneigh_get_idx(seq, pos);
2338
2339 return rc;
2340}
2341
2342void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002343 __acquires(tbl->lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344{
2345 struct neigh_seq_state *state = seq->private;
2346 loff_t pos_minus_one;
2347
2348 state->tbl = tbl;
2349 state->bucket = 0;
2350 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2351
2352 read_lock_bh(&tbl->lock);
2353
2354 pos_minus_one = *pos - 1;
2355 return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN;
2356}
2357EXPORT_SYMBOL(neigh_seq_start);
2358
2359void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2360{
2361 struct neigh_seq_state *state;
2362 void *rc;
2363
2364 if (v == SEQ_START_TOKEN) {
2365 rc = neigh_get_idx(seq, pos);
2366 goto out;
2367 }
2368
2369 state = seq->private;
2370 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2371 rc = neigh_get_next(seq, v, NULL);
2372 if (rc)
2373 goto out;
2374 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2375 rc = pneigh_get_first(seq);
2376 } else {
2377 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2378 rc = pneigh_get_next(seq, v, NULL);
2379 }
2380out:
2381 ++(*pos);
2382 return rc;
2383}
2384EXPORT_SYMBOL(neigh_seq_next);
2385
2386void neigh_seq_stop(struct seq_file *seq, void *v)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002387 __releases(tbl->lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388{
2389 struct neigh_seq_state *state = seq->private;
2390 struct neigh_table *tbl = state->tbl;
2391
2392 read_unlock_bh(&tbl->lock);
2393}
2394EXPORT_SYMBOL(neigh_seq_stop);
2395
2396/* statistics via seq_file */
2397
2398static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2399{
2400 struct proc_dir_entry *pde = seq->private;
2401 struct neigh_table *tbl = pde->data;
2402 int cpu;
2403
2404 if (*pos == 0)
2405 return SEQ_START_TOKEN;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002406
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
2408 if (!cpu_possible(cpu))
2409 continue;
2410 *pos = cpu+1;
2411 return per_cpu_ptr(tbl->stats, cpu);
2412 }
2413 return NULL;
2414}
2415
2416static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2417{
2418 struct proc_dir_entry *pde = seq->private;
2419 struct neigh_table *tbl = pde->data;
2420 int cpu;
2421
2422 for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
2423 if (!cpu_possible(cpu))
2424 continue;
2425 *pos = cpu+1;
2426 return per_cpu_ptr(tbl->stats, cpu);
2427 }
2428 return NULL;
2429}
2430
2431static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2432{
2433
2434}
2435
2436static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2437{
2438 struct proc_dir_entry *pde = seq->private;
2439 struct neigh_table *tbl = pde->data;
2440 struct neigh_statistics *st = v;
2441
2442 if (v == SEQ_START_TOKEN) {
Olaf Rempel5bec0032005-04-28 12:16:08 -07002443 seq_printf(seq, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444 return 0;
2445 }
2446
2447 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
2448 "%08lx %08lx %08lx %08lx\n",
2449 atomic_read(&tbl->entries),
2450
2451 st->allocs,
2452 st->destroys,
2453 st->hash_grows,
2454
2455 st->lookups,
2456 st->hits,
2457
2458 st->res_failed,
2459
2460 st->rcv_probes_mcast,
2461 st->rcv_probes_ucast,
2462
2463 st->periodic_gc_runs,
2464 st->forced_gc_runs
2465 );
2466
2467 return 0;
2468}
2469
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002470static const struct seq_operations neigh_stat_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 .start = neigh_stat_seq_start,
2472 .next = neigh_stat_seq_next,
2473 .stop = neigh_stat_seq_stop,
2474 .show = neigh_stat_seq_show,
2475};
2476
2477static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2478{
2479 int ret = seq_open(file, &neigh_stat_seq_ops);
2480
2481 if (!ret) {
2482 struct seq_file *sf = file->private_data;
2483 sf->private = PDE(inode);
2484 }
2485 return ret;
2486};
2487
Arjan van de Ven9a321442007-02-12 00:55:35 -08002488static const struct file_operations neigh_stat_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 .owner = THIS_MODULE,
2490 .open = neigh_stat_seq_open,
2491 .read = seq_read,
2492 .llseek = seq_lseek,
2493 .release = seq_release,
2494};
2495
2496#endif /* CONFIG_PROC_FS */
2497
Thomas Graf339bf982006-11-10 14:10:15 -08002498static inline size_t neigh_nlmsg_size(void)
2499{
2500 return NLMSG_ALIGN(sizeof(struct ndmsg))
2501 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2502 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2503 + nla_total_size(sizeof(struct nda_cacheinfo))
2504 + nla_total_size(4); /* NDA_PROBES */
2505}
2506
Thomas Grafb8673312006-08-15 00:33:14 -07002507static void __neigh_notify(struct neighbour *n, int type, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508{
Eric W. Biederman426b5302008-01-24 00:13:18 -08002509 struct net *net = n->dev->nd_net;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002510 struct sk_buff *skb;
Thomas Grafb8673312006-08-15 00:33:14 -07002511 int err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512
Thomas Graf339bf982006-11-10 14:10:15 -08002513 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002514 if (skb == NULL)
Thomas Grafb8673312006-08-15 00:33:14 -07002515 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516
Thomas Grafb8673312006-08-15 00:33:14 -07002517 err = neigh_fill_info(skb, n, 0, 0, type, flags);
Patrick McHardy26932562007-01-31 23:16:40 -08002518 if (err < 0) {
2519 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2520 WARN_ON(err == -EMSGSIZE);
2521 kfree_skb(skb);
2522 goto errout;
2523 }
Eric W. Biederman426b5302008-01-24 00:13:18 -08002524 err = rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
Thomas Grafb8673312006-08-15 00:33:14 -07002525errout:
2526 if (err < 0)
Eric W. Biederman426b5302008-01-24 00:13:18 -08002527 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
Thomas Grafb8673312006-08-15 00:33:14 -07002528}
2529
Thomas Grafd961db32007-08-08 23:12:56 -07002530#ifdef CONFIG_ARPD
Thomas Grafb8673312006-08-15 00:33:14 -07002531void neigh_app_ns(struct neighbour *n)
2532{
2533 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535#endif /* CONFIG_ARPD */
2536
2537#ifdef CONFIG_SYSCTL
2538
2539static struct neigh_sysctl_table {
2540 struct ctl_table_header *sysctl_header;
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002541 struct ctl_table neigh_vars[__NET_NEIGH_MAX];
2542 char *dev_name;
Brian Haleyab32ea52006-09-22 14:15:41 -07002543} neigh_sysctl_template __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 .neigh_vars = {
2545 {
2546 .ctl_name = NET_NEIGH_MCAST_SOLICIT,
2547 .procname = "mcast_solicit",
2548 .maxlen = sizeof(int),
2549 .mode = 0644,
2550 .proc_handler = &proc_dointvec,
2551 },
2552 {
2553 .ctl_name = NET_NEIGH_UCAST_SOLICIT,
2554 .procname = "ucast_solicit",
2555 .maxlen = sizeof(int),
2556 .mode = 0644,
2557 .proc_handler = &proc_dointvec,
2558 },
2559 {
2560 .ctl_name = NET_NEIGH_APP_SOLICIT,
2561 .procname = "app_solicit",
2562 .maxlen = sizeof(int),
2563 .mode = 0644,
2564 .proc_handler = &proc_dointvec,
2565 },
2566 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567 .procname = "retrans_time",
2568 .maxlen = sizeof(int),
2569 .mode = 0644,
2570 .proc_handler = &proc_dointvec_userhz_jiffies,
2571 },
2572 {
2573 .ctl_name = NET_NEIGH_REACHABLE_TIME,
2574 .procname = "base_reachable_time",
2575 .maxlen = sizeof(int),
2576 .mode = 0644,
2577 .proc_handler = &proc_dointvec_jiffies,
2578 .strategy = &sysctl_jiffies,
2579 },
2580 {
2581 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME,
2582 .procname = "delay_first_probe_time",
2583 .maxlen = sizeof(int),
2584 .mode = 0644,
2585 .proc_handler = &proc_dointvec_jiffies,
2586 .strategy = &sysctl_jiffies,
2587 },
2588 {
2589 .ctl_name = NET_NEIGH_GC_STALE_TIME,
2590 .procname = "gc_stale_time",
2591 .maxlen = sizeof(int),
2592 .mode = 0644,
2593 .proc_handler = &proc_dointvec_jiffies,
2594 .strategy = &sysctl_jiffies,
2595 },
2596 {
2597 .ctl_name = NET_NEIGH_UNRES_QLEN,
2598 .procname = "unres_qlen",
2599 .maxlen = sizeof(int),
2600 .mode = 0644,
2601 .proc_handler = &proc_dointvec,
2602 },
2603 {
2604 .ctl_name = NET_NEIGH_PROXY_QLEN,
2605 .procname = "proxy_qlen",
2606 .maxlen = sizeof(int),
2607 .mode = 0644,
2608 .proc_handler = &proc_dointvec,
2609 },
2610 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611 .procname = "anycast_delay",
2612 .maxlen = sizeof(int),
2613 .mode = 0644,
2614 .proc_handler = &proc_dointvec_userhz_jiffies,
2615 },
2616 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 .procname = "proxy_delay",
2618 .maxlen = sizeof(int),
2619 .mode = 0644,
2620 .proc_handler = &proc_dointvec_userhz_jiffies,
2621 },
2622 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623 .procname = "locktime",
2624 .maxlen = sizeof(int),
2625 .mode = 0644,
2626 .proc_handler = &proc_dointvec_userhz_jiffies,
2627 },
2628 {
Eric W. Biedermand12af672007-10-18 03:05:25 -07002629 .ctl_name = NET_NEIGH_RETRANS_TIME_MS,
2630 .procname = "retrans_time_ms",
2631 .maxlen = sizeof(int),
2632 .mode = 0644,
2633 .proc_handler = &proc_dointvec_ms_jiffies,
2634 .strategy = &sysctl_ms_jiffies,
2635 },
2636 {
2637 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS,
2638 .procname = "base_reachable_time_ms",
2639 .maxlen = sizeof(int),
2640 .mode = 0644,
2641 .proc_handler = &proc_dointvec_ms_jiffies,
2642 .strategy = &sysctl_ms_jiffies,
2643 },
2644 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 .ctl_name = NET_NEIGH_GC_INTERVAL,
2646 .procname = "gc_interval",
2647 .maxlen = sizeof(int),
2648 .mode = 0644,
2649 .proc_handler = &proc_dointvec_jiffies,
2650 .strategy = &sysctl_jiffies,
2651 },
2652 {
2653 .ctl_name = NET_NEIGH_GC_THRESH1,
2654 .procname = "gc_thresh1",
2655 .maxlen = sizeof(int),
2656 .mode = 0644,
2657 .proc_handler = &proc_dointvec,
2658 },
2659 {
2660 .ctl_name = NET_NEIGH_GC_THRESH2,
2661 .procname = "gc_thresh2",
2662 .maxlen = sizeof(int),
2663 .mode = 0644,
2664 .proc_handler = &proc_dointvec,
2665 },
2666 {
2667 .ctl_name = NET_NEIGH_GC_THRESH3,
2668 .procname = "gc_thresh3",
2669 .maxlen = sizeof(int),
2670 .mode = 0644,
2671 .proc_handler = &proc_dointvec,
2672 },
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002673 {},
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674 },
2675};
2676
2677int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002678 int p_id, int pdev_id, char *p_name,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679 proc_handler *handler, ctl_handler *strategy)
2680{
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002681 struct neigh_sysctl_table *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 const char *dev_name_source = NULL;
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002683
2684#define NEIGH_CTL_PATH_ROOT 0
2685#define NEIGH_CTL_PATH_PROTO 1
2686#define NEIGH_CTL_PATH_NEIGH 2
2687#define NEIGH_CTL_PATH_DEV 3
2688
2689 struct ctl_path neigh_path[] = {
2690 { .procname = "net", .ctl_name = CTL_NET, },
2691 { .procname = "proto", .ctl_name = 0, },
2692 { .procname = "neigh", .ctl_name = 0, },
2693 { .procname = "default", .ctl_name = NET_PROTO_CONF_DEFAULT, },
2694 { },
2695 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002697 t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 if (!t)
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002699 goto err;
2700
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701 t->neigh_vars[0].data = &p->mcast_probes;
2702 t->neigh_vars[1].data = &p->ucast_probes;
2703 t->neigh_vars[2].data = &p->app_probes;
2704 t->neigh_vars[3].data = &p->retrans_time;
2705 t->neigh_vars[4].data = &p->base_reachable_time;
2706 t->neigh_vars[5].data = &p->delay_probe_time;
2707 t->neigh_vars[6].data = &p->gc_staletime;
2708 t->neigh_vars[7].data = &p->queue_len;
2709 t->neigh_vars[8].data = &p->proxy_qlen;
2710 t->neigh_vars[9].data = &p->anycast_delay;
2711 t->neigh_vars[10].data = &p->proxy_delay;
2712 t->neigh_vars[11].data = &p->locktime;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002713 t->neigh_vars[12].data = &p->retrans_time;
2714 t->neigh_vars[13].data = &p->base_reachable_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715
2716 if (dev) {
2717 dev_name_source = dev->name;
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002718 neigh_path[NEIGH_CTL_PATH_DEV].ctl_name = dev->ifindex;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002719 /* Terminate the table early */
2720 memset(&t->neigh_vars[14], 0, sizeof(t->neigh_vars[14]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721 } else {
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002722 dev_name_source = neigh_path[NEIGH_CTL_PATH_DEV].procname;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002723 t->neigh_vars[14].data = (int *)(p + 1);
2724 t->neigh_vars[15].data = (int *)(p + 1) + 1;
2725 t->neigh_vars[16].data = (int *)(p + 1) + 2;
2726 t->neigh_vars[17].data = (int *)(p + 1) + 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002727 }
2728
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729
2730 if (handler || strategy) {
2731 /* RetransTime */
2732 t->neigh_vars[3].proc_handler = handler;
2733 t->neigh_vars[3].strategy = strategy;
2734 t->neigh_vars[3].extra1 = dev;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002735 if (!strategy)
2736 t->neigh_vars[3].ctl_name = CTL_UNNUMBERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737 /* ReachableTime */
2738 t->neigh_vars[4].proc_handler = handler;
2739 t->neigh_vars[4].strategy = strategy;
2740 t->neigh_vars[4].extra1 = dev;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002741 if (!strategy)
2742 t->neigh_vars[4].ctl_name = CTL_UNNUMBERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 /* RetransTime (in milliseconds)*/
Eric W. Biedermand12af672007-10-18 03:05:25 -07002744 t->neigh_vars[12].proc_handler = handler;
2745 t->neigh_vars[12].strategy = strategy;
2746 t->neigh_vars[12].extra1 = dev;
2747 if (!strategy)
2748 t->neigh_vars[12].ctl_name = CTL_UNNUMBERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749 /* ReachableTime (in milliseconds) */
Eric W. Biedermand12af672007-10-18 03:05:25 -07002750 t->neigh_vars[13].proc_handler = handler;
2751 t->neigh_vars[13].strategy = strategy;
2752 t->neigh_vars[13].extra1 = dev;
2753 if (!strategy)
2754 t->neigh_vars[13].ctl_name = CTL_UNNUMBERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 }
2756
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002757 t->dev_name = kstrdup(dev_name_source, GFP_KERNEL);
2758 if (!t->dev_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002761 neigh_path[NEIGH_CTL_PATH_DEV].procname = t->dev_name;
2762 neigh_path[NEIGH_CTL_PATH_NEIGH].ctl_name = pdev_id;
2763 neigh_path[NEIGH_CTL_PATH_PROTO].procname = p_name;
2764 neigh_path[NEIGH_CTL_PATH_PROTO].ctl_name = p_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002766 t->sysctl_header = register_sysctl_paths(neigh_path, t->neigh_vars);
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002767 if (!t->sysctl_header)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 goto free_procname;
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002769
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 p->sysctl_table = t;
2771 return 0;
2772
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002773free_procname:
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002774 kfree(t->dev_name);
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002775free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 kfree(t);
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002777err:
2778 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779}
2780
2781void neigh_sysctl_unregister(struct neigh_parms *p)
2782{
2783 if (p->sysctl_table) {
2784 struct neigh_sysctl_table *t = p->sysctl_table;
2785 p->sysctl_table = NULL;
2786 unregister_sysctl_table(t->sysctl_header);
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002787 kfree(t->dev_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788 kfree(t);
2789 }
2790}
2791
2792#endif /* CONFIG_SYSCTL */
2793
Thomas Grafc8822a42007-03-22 11:50:06 -07002794static int __init neigh_init(void)
2795{
2796 rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL);
2797 rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL);
2798 rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info);
2799
2800 rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info);
2801 rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL);
2802
2803 return 0;
2804}
2805
2806subsys_initcall(neigh_init);
2807
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808EXPORT_SYMBOL(__neigh_event_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809EXPORT_SYMBOL(neigh_changeaddr);
2810EXPORT_SYMBOL(neigh_compat_output);
2811EXPORT_SYMBOL(neigh_connected_output);
2812EXPORT_SYMBOL(neigh_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813EXPORT_SYMBOL(neigh_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814EXPORT_SYMBOL(neigh_event_ns);
2815EXPORT_SYMBOL(neigh_ifdown);
2816EXPORT_SYMBOL(neigh_lookup);
2817EXPORT_SYMBOL(neigh_lookup_nodev);
2818EXPORT_SYMBOL(neigh_parms_alloc);
2819EXPORT_SYMBOL(neigh_parms_release);
2820EXPORT_SYMBOL(neigh_rand_reach_time);
2821EXPORT_SYMBOL(neigh_resolve_output);
2822EXPORT_SYMBOL(neigh_table_clear);
2823EXPORT_SYMBOL(neigh_table_init);
Simon Kelleybd89efc2006-05-12 14:56:08 -07002824EXPORT_SYMBOL(neigh_table_init_no_netlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825EXPORT_SYMBOL(neigh_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826EXPORT_SYMBOL(pneigh_enqueue);
2827EXPORT_SYMBOL(pneigh_lookup);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -07002828EXPORT_SYMBOL_GPL(__pneigh_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829
2830#ifdef CONFIG_ARPD
2831EXPORT_SYMBOL(neigh_app_ns);
2832#endif
2833#ifdef CONFIG_SYSCTL
2834EXPORT_SYMBOL(neigh_sysctl_register);
2835EXPORT_SYMBOL(neigh_sysctl_unregister);
2836#endif