blob: 1dc728b38589699d4b85b215208bf6f0bde154f9 [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}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900126EXPORT_SYMBOL(neigh_rand_reach_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
128
129static int neigh_forced_gc(struct neigh_table *tbl)
130{
131 int shrunk = 0;
132 int i;
133
134 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
135
136 write_lock_bh(&tbl->lock);
137 for (i = 0; i <= tbl->hash_mask; i++) {
138 struct neighbour *n, **np;
139
140 np = &tbl->hash_buckets[i];
141 while ((n = *np) != NULL) {
142 /* Neighbour record may be discarded if:
143 * - nobody refers to it.
144 * - it is not permanent
145 */
146 write_lock(&n->lock);
147 if (atomic_read(&n->refcnt) == 1 &&
148 !(n->nud_state & NUD_PERMANENT)) {
149 *np = n->next;
150 n->dead = 1;
151 shrunk = 1;
152 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -0700153 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 continue;
155 }
156 write_unlock(&n->lock);
157 np = &n->next;
158 }
159 }
160
161 tbl->last_flush = jiffies;
162
163 write_unlock_bh(&tbl->lock);
164
165 return shrunk;
166}
167
Pavel Emelyanova43d8992007-12-20 15:49:05 -0800168static void neigh_add_timer(struct neighbour *n, unsigned long when)
169{
170 neigh_hold(n);
171 if (unlikely(mod_timer(&n->timer, when))) {
172 printk("NEIGH: BUG, double timer add, state is %x\n",
173 n->nud_state);
174 dump_stack();
175 }
176}
177
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178static int neigh_del_timer(struct neighbour *n)
179{
180 if ((n->nud_state & NUD_IN_TIMER) &&
181 del_timer(&n->timer)) {
182 neigh_release(n);
183 return 1;
184 }
185 return 0;
186}
187
188static void pneigh_queue_purge(struct sk_buff_head *list)
189{
190 struct sk_buff *skb;
191
192 while ((skb = skb_dequeue(list)) != NULL) {
193 dev_put(skb->dev);
194 kfree_skb(skb);
195 }
196}
197
Herbert Xu49636bb2005-10-23 17:18:00 +1000198static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199{
200 int i;
201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 for (i = 0; i <= tbl->hash_mask; i++) {
203 struct neighbour *n, **np = &tbl->hash_buckets[i];
204
205 while ((n = *np) != NULL) {
206 if (dev && n->dev != dev) {
207 np = &n->next;
208 continue;
209 }
210 *np = n->next;
211 write_lock(&n->lock);
212 neigh_del_timer(n);
213 n->dead = 1;
214
215 if (atomic_read(&n->refcnt) != 1) {
216 /* The most unpleasant situation.
217 We must destroy neighbour entry,
218 but someone still uses it.
219
220 The destroy will be delayed until
221 the last user releases us, but
222 we must kill timers etc. and move
223 it to safe state.
224 */
225 skb_queue_purge(&n->arp_queue);
226 n->output = neigh_blackhole;
227 if (n->nud_state & NUD_VALID)
228 n->nud_state = NUD_NOARP;
229 else
230 n->nud_state = NUD_NONE;
231 NEIGH_PRINTK2("neigh %p is stray.\n", n);
232 }
233 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -0700234 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 }
236 }
Herbert Xu49636bb2005-10-23 17:18:00 +1000237}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Herbert Xu49636bb2005-10-23 17:18:00 +1000239void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
240{
241 write_lock_bh(&tbl->lock);
242 neigh_flush_dev(tbl, dev);
243 write_unlock_bh(&tbl->lock);
244}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900245EXPORT_SYMBOL(neigh_changeaddr);
Herbert Xu49636bb2005-10-23 17:18:00 +1000246
247int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
248{
249 write_lock_bh(&tbl->lock);
250 neigh_flush_dev(tbl, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 pneigh_ifdown(tbl, dev);
252 write_unlock_bh(&tbl->lock);
253
254 del_timer_sync(&tbl->proxy_timer);
255 pneigh_queue_purge(&tbl->proxy_queue);
256 return 0;
257}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900258EXPORT_SYMBOL(neigh_ifdown);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260static struct neighbour *neigh_alloc(struct neigh_table *tbl)
261{
262 struct neighbour *n = NULL;
263 unsigned long now = jiffies;
264 int entries;
265
266 entries = atomic_inc_return(&tbl->entries) - 1;
267 if (entries >= tbl->gc_thresh3 ||
268 (entries >= tbl->gc_thresh2 &&
269 time_after(now, tbl->last_flush + 5 * HZ))) {
270 if (!neigh_forced_gc(tbl) &&
271 entries >= tbl->gc_thresh3)
272 goto out_entries;
273 }
274
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800275 n = kmem_cache_zalloc(tbl->kmem_cachep, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 if (!n)
277 goto out_entries;
278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 skb_queue_head_init(&n->arp_queue);
280 rwlock_init(&n->lock);
281 n->updated = n->used = now;
282 n->nud_state = NUD_NONE;
283 n->output = neigh_blackhole;
284 n->parms = neigh_parms_clone(&tbl->parms);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800285 setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 NEIGH_CACHE_STAT_INC(tbl, allocs);
288 n->tbl = tbl;
289 atomic_set(&n->refcnt, 1);
290 n->dead = 1;
291out:
292 return n;
293
294out_entries:
295 atomic_dec(&tbl->entries);
296 goto out;
297}
298
299static struct neighbour **neigh_hash_alloc(unsigned int entries)
300{
301 unsigned long size = entries * sizeof(struct neighbour *);
302 struct neighbour **ret;
303
304 if (size <= PAGE_SIZE) {
Andrew Morton77d04bd2006-04-07 14:52:59 -0700305 ret = kzalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 } else {
307 ret = (struct neighbour **)
Andrew Morton77d04bd2006-04-07 14:52:59 -0700308 __get_free_pages(GFP_ATOMIC|__GFP_ZERO, get_order(size));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 return ret;
311}
312
313static void neigh_hash_free(struct neighbour **hash, unsigned int entries)
314{
315 unsigned long size = entries * sizeof(struct neighbour *);
316
317 if (size <= PAGE_SIZE)
318 kfree(hash);
319 else
320 free_pages((unsigned long)hash, get_order(size));
321}
322
323static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries)
324{
325 struct neighbour **new_hash, **old_hash;
326 unsigned int i, new_hash_mask, old_entries;
327
328 NEIGH_CACHE_STAT_INC(tbl, hash_grows);
329
vignesh babuc3609d52007-08-24 22:27:55 -0700330 BUG_ON(!is_power_of_2(new_entries));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 new_hash = neigh_hash_alloc(new_entries);
332 if (!new_hash)
333 return;
334
335 old_entries = tbl->hash_mask + 1;
336 new_hash_mask = new_entries - 1;
337 old_hash = tbl->hash_buckets;
338
339 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
340 for (i = 0; i < old_entries; i++) {
341 struct neighbour *n, *next;
342
343 for (n = old_hash[i]; n; n = next) {
344 unsigned int hash_val = tbl->hash(n->primary_key, n->dev);
345
346 hash_val &= new_hash_mask;
347 next = n->next;
348
349 n->next = new_hash[hash_val];
350 new_hash[hash_val] = n;
351 }
352 }
353 tbl->hash_buckets = new_hash;
354 tbl->hash_mask = new_hash_mask;
355
356 neigh_hash_free(old_hash, old_entries);
357}
358
359struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
360 struct net_device *dev)
361{
362 struct neighbour *n;
363 int key_len = tbl->key_len;
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800364 u32 hash_val;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 NEIGH_CACHE_STAT_INC(tbl, lookups);
367
368 read_lock_bh(&tbl->lock);
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800369 hash_val = tbl->hash(pkey, dev);
Julian Anastasovc5e29462006-10-03 15:49:46 -0700370 for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
372 neigh_hold(n);
373 NEIGH_CACHE_STAT_INC(tbl, hits);
374 break;
375 }
376 }
377 read_unlock_bh(&tbl->lock);
378 return n;
379}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900380EXPORT_SYMBOL(neigh_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Eric W. Biederman426b5302008-01-24 00:13:18 -0800382struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
383 const void *pkey)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384{
385 struct neighbour *n;
386 int key_len = tbl->key_len;
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800387 u32 hash_val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
389 NEIGH_CACHE_STAT_INC(tbl, lookups);
390
391 read_lock_bh(&tbl->lock);
Pavel Emelyanovbc4bf5f2008-02-23 19:57:02 -0800392 hash_val = tbl->hash(pkey, NULL);
Julian Anastasovc5e29462006-10-03 15:49:46 -0700393 for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) {
Eric W. Biederman426b5302008-01-24 00:13:18 -0800394 if (!memcmp(n->primary_key, pkey, key_len) &&
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +0900395 net_eq(dev_net(n->dev), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 neigh_hold(n);
397 NEIGH_CACHE_STAT_INC(tbl, hits);
398 break;
399 }
400 }
401 read_unlock_bh(&tbl->lock);
402 return n;
403}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900404EXPORT_SYMBOL(neigh_lookup_nodev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
406struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey,
407 struct net_device *dev)
408{
409 u32 hash_val;
410 int key_len = tbl->key_len;
411 int error;
412 struct neighbour *n1, *rc, *n = neigh_alloc(tbl);
413
414 if (!n) {
415 rc = ERR_PTR(-ENOBUFS);
416 goto out;
417 }
418
419 memcpy(n->primary_key, pkey, key_len);
420 n->dev = dev;
421 dev_hold(dev);
422
423 /* Protocol specific setup. */
424 if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
425 rc = ERR_PTR(error);
426 goto out_neigh_release;
427 }
428
429 /* Device specific setup. */
430 if (n->parms->neigh_setup &&
431 (error = n->parms->neigh_setup(n)) < 0) {
432 rc = ERR_PTR(error);
433 goto out_neigh_release;
434 }
435
436 n->confirmed = jiffies - (n->parms->base_reachable_time << 1);
437
438 write_lock_bh(&tbl->lock);
439
440 if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1))
441 neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1);
442
443 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;
444
445 if (n->parms->dead) {
446 rc = ERR_PTR(-EINVAL);
447 goto out_tbl_unlock;
448 }
449
450 for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) {
451 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
452 neigh_hold(n1);
453 rc = n1;
454 goto out_tbl_unlock;
455 }
456 }
457
458 n->next = tbl->hash_buckets[hash_val];
459 tbl->hash_buckets[hash_val] = n;
460 n->dead = 0;
461 neigh_hold(n);
462 write_unlock_bh(&tbl->lock);
463 NEIGH_PRINTK2("neigh %p is created.\n", n);
464 rc = n;
465out:
466 return rc;
467out_tbl_unlock:
468 write_unlock_bh(&tbl->lock);
469out_neigh_release:
470 neigh_release(n);
471 goto out;
472}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900473EXPORT_SYMBOL(neigh_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900475static u32 pneigh_hash(const void *pkey, int key_len)
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700476{
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700477 u32 hash_val = *(u32 *)(pkey + key_len - 4);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700478 hash_val ^= (hash_val >> 16);
479 hash_val ^= hash_val >> 8;
480 hash_val ^= hash_val >> 4;
481 hash_val &= PNEIGH_HASHMASK;
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900482 return hash_val;
483}
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700484
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900485static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n,
486 struct net *net,
487 const void *pkey,
488 int key_len,
489 struct net_device *dev)
490{
491 while (n) {
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700492 if (!memcmp(n->key, pkey, key_len) &&
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900493 net_eq(pneigh_net(n), net) &&
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700494 (n->dev == dev || !n->dev))
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900495 return n;
496 n = n->next;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700497 }
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900498 return NULL;
499}
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700500
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900501struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl,
502 struct net *net, const void *pkey, struct net_device *dev)
503{
504 int key_len = tbl->key_len;
505 u32 hash_val = pneigh_hash(pkey, key_len);
506
507 return __pneigh_lookup_1(tbl->phash_buckets[hash_val],
508 net, pkey, key_len, dev);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700509}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900510EXPORT_SYMBOL_GPL(__pneigh_lookup);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700511
Eric W. Biederman426b5302008-01-24 00:13:18 -0800512struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl,
513 struct net *net, const void *pkey,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 struct net_device *dev, int creat)
515{
516 struct pneigh_entry *n;
517 int key_len = tbl->key_len;
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900518 u32 hash_val = pneigh_hash(pkey, key_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520 read_lock_bh(&tbl->lock);
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900521 n = __pneigh_lookup_1(tbl->phash_buckets[hash_val],
522 net, pkey, key_len, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 read_unlock_bh(&tbl->lock);
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900524
525 if (n || !creat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 goto out;
527
Pavel Emelyanov4ae28942007-10-15 12:54:15 -0700528 ASSERT_RTNL();
529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
531 if (!n)
532 goto out;
533
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900534#ifdef CONFIG_NET_NS
Eric W. Biederman426b5302008-01-24 00:13:18 -0800535 n->net = hold_net(net);
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900536#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 memcpy(n->key, pkey, key_len);
538 n->dev = dev;
539 if (dev)
540 dev_hold(dev);
541
542 if (tbl->pconstructor && tbl->pconstructor(n)) {
543 if (dev)
544 dev_put(dev);
Denis V. Lunevda12f732008-02-20 00:26:16 -0800545 release_net(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 kfree(n);
547 n = NULL;
548 goto out;
549 }
550
551 write_lock_bh(&tbl->lock);
552 n->next = tbl->phash_buckets[hash_val];
553 tbl->phash_buckets[hash_val] = n;
554 write_unlock_bh(&tbl->lock);
555out:
556 return n;
557}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900558EXPORT_SYMBOL(pneigh_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
560
Eric W. Biederman426b5302008-01-24 00:13:18 -0800561int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 struct net_device *dev)
563{
564 struct pneigh_entry *n, **np;
565 int key_len = tbl->key_len;
YOSHIFUJI Hideakibe01d652008-03-28 12:46:53 +0900566 u32 hash_val = pneigh_hash(pkey, key_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568 write_lock_bh(&tbl->lock);
569 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
570 np = &n->next) {
Eric W. Biederman426b5302008-01-24 00:13:18 -0800571 if (!memcmp(n->key, pkey, key_len) && n->dev == dev &&
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +0900572 net_eq(pneigh_net(n), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 *np = n->next;
574 write_unlock_bh(&tbl->lock);
575 if (tbl->pdestructor)
576 tbl->pdestructor(n);
577 if (n->dev)
578 dev_put(n->dev);
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900579 release_net(pneigh_net(n));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 kfree(n);
581 return 0;
582 }
583 }
584 write_unlock_bh(&tbl->lock);
585 return -ENOENT;
586}
587
588static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
589{
590 struct pneigh_entry *n, **np;
591 u32 h;
592
593 for (h = 0; h <= PNEIGH_HASHMASK; h++) {
594 np = &tbl->phash_buckets[h];
595 while ((n = *np) != NULL) {
596 if (!dev || n->dev == dev) {
597 *np = n->next;
598 if (tbl->pdestructor)
599 tbl->pdestructor(n);
600 if (n->dev)
601 dev_put(n->dev);
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900602 release_net(pneigh_net(n));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 kfree(n);
604 continue;
605 }
606 np = &n->next;
607 }
608 }
609 return -ENOENT;
610}
611
Denis V. Lunev06f05112008-01-24 00:30:58 -0800612static void neigh_parms_destroy(struct neigh_parms *parms);
613
614static inline void neigh_parms_put(struct neigh_parms *parms)
615{
616 if (atomic_dec_and_test(&parms->refcnt))
617 neigh_parms_destroy(parms);
618}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
620/*
621 * neighbour must already be out of the table;
622 *
623 */
624void neigh_destroy(struct neighbour *neigh)
625{
626 struct hh_cache *hh;
627
628 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
629
630 if (!neigh->dead) {
631 printk(KERN_WARNING
632 "Destroying alive neighbour %p\n", neigh);
633 dump_stack();
634 return;
635 }
636
637 if (neigh_del_timer(neigh))
638 printk(KERN_WARNING "Impossible event.\n");
639
640 while ((hh = neigh->hh) != NULL) {
641 neigh->hh = hh->hh_next;
642 hh->hh_next = NULL;
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800643
644 write_seqlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 hh->hh_output = neigh_blackhole;
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800646 write_sequnlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (atomic_dec_and_test(&hh->hh_refcnt))
648 kfree(hh);
649 }
650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 skb_queue_purge(&neigh->arp_queue);
652
653 dev_put(neigh->dev);
654 neigh_parms_put(neigh->parms);
655
656 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh);
657
658 atomic_dec(&neigh->tbl->entries);
659 kmem_cache_free(neigh->tbl->kmem_cachep, neigh);
660}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900661EXPORT_SYMBOL(neigh_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
663/* Neighbour state is suspicious;
664 disable fast path.
665
666 Called with write_locked neigh.
667 */
668static void neigh_suspect(struct neighbour *neigh)
669{
670 struct hh_cache *hh;
671
672 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
673
674 neigh->output = neigh->ops->output;
675
676 for (hh = neigh->hh; hh; hh = hh->hh_next)
677 hh->hh_output = neigh->ops->output;
678}
679
680/* Neighbour state is OK;
681 enable fast path.
682
683 Called with write_locked neigh.
684 */
685static void neigh_connect(struct neighbour *neigh)
686{
687 struct hh_cache *hh;
688
689 NEIGH_PRINTK2("neigh %p is connected.\n", neigh);
690
691 neigh->output = neigh->ops->connected_output;
692
693 for (hh = neigh->hh; hh; hh = hh->hh_next)
694 hh->hh_output = neigh->ops->hh_output;
695}
696
697static void neigh_periodic_timer(unsigned long arg)
698{
699 struct neigh_table *tbl = (struct neigh_table *)arg;
700 struct neighbour *n, **np;
701 unsigned long expire, now = jiffies;
702
703 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
704
705 write_lock(&tbl->lock);
706
707 /*
708 * periodically recompute ReachableTime from random function
709 */
710
711 if (time_after(now, tbl->last_rand + 300 * HZ)) {
712 struct neigh_parms *p;
713 tbl->last_rand = now;
714 for (p = &tbl->parms; p; p = p->next)
715 p->reachable_time =
716 neigh_rand_reach_time(p->base_reachable_time);
717 }
718
719 np = &tbl->hash_buckets[tbl->hash_chain_gc];
720 tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask);
721
722 while ((n = *np) != NULL) {
723 unsigned int state;
724
725 write_lock(&n->lock);
726
727 state = n->nud_state;
728 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
729 write_unlock(&n->lock);
730 goto next_elt;
731 }
732
733 if (time_before(n->used, n->confirmed))
734 n->used = n->confirmed;
735
736 if (atomic_read(&n->refcnt) == 1 &&
737 (state == NUD_FAILED ||
738 time_after(now, n->used + n->parms->gc_staletime))) {
739 *np = n->next;
740 n->dead = 1;
741 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -0700742 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 continue;
744 }
745 write_unlock(&n->lock);
746
747next_elt:
748 np = &n->next;
749 }
750
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900751 /* Cycle through all hash buckets every base_reachable_time/2 ticks.
752 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
753 * base_reachable_time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 */
755 expire = tbl->parms.base_reachable_time >> 1;
756 expire /= (tbl->hash_mask + 1);
757 if (!expire)
758 expire = 1;
759
Arjan van de Venf5a6e012007-02-05 17:59:51 -0800760 if (expire>HZ)
761 mod_timer(&tbl->gc_timer, round_jiffies(now + expire));
762 else
763 mod_timer(&tbl->gc_timer, now + expire);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
765 write_unlock(&tbl->lock);
766}
767
768static __inline__ int neigh_max_probes(struct neighbour *n)
769{
770 struct neigh_parms *p = n->parms;
771 return (n->nud_state & NUD_PROBE ?
772 p->ucast_probes :
773 p->ucast_probes + p->app_probes + p->mcast_probes);
774}
775
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776/* Called when a timer expires for a neighbour entry. */
777
778static void neigh_timer_handler(unsigned long arg)
779{
780 unsigned long now, next;
781 struct neighbour *neigh = (struct neighbour *)arg;
782 unsigned state;
783 int notify = 0;
784
785 write_lock(&neigh->lock);
786
787 state = neigh->nud_state;
788 now = jiffies;
789 next = now + HZ;
790
791 if (!(state & NUD_IN_TIMER)) {
792#ifndef CONFIG_SMP
793 printk(KERN_WARNING "neigh: timer & !nud_in_timer\n");
794#endif
795 goto out;
796 }
797
798 if (state & NUD_REACHABLE) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900799 if (time_before_eq(now,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 neigh->confirmed + neigh->parms->reachable_time)) {
801 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh);
802 next = neigh->confirmed + neigh->parms->reachable_time;
803 } else if (time_before_eq(now,
804 neigh->used + neigh->parms->delay_probe_time)) {
805 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
806 neigh->nud_state = NUD_DELAY;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800807 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 neigh_suspect(neigh);
809 next = now + neigh->parms->delay_probe_time;
810 } else {
811 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
812 neigh->nud_state = NUD_STALE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800813 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 neigh_suspect(neigh);
Tom Tucker8d717402006-07-30 20:43:36 -0700815 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 }
817 } else if (state & NUD_DELAY) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900818 if (time_before_eq(now,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 neigh->confirmed + neigh->parms->delay_probe_time)) {
820 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh);
821 neigh->nud_state = NUD_REACHABLE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800822 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 neigh_connect(neigh);
Tom Tucker8d717402006-07-30 20:43:36 -0700824 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 next = neigh->confirmed + neigh->parms->reachable_time;
826 } else {
827 NEIGH_PRINTK2("neigh %p is probed.\n", neigh);
828 neigh->nud_state = NUD_PROBE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800829 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 atomic_set(&neigh->probes, 0);
831 next = now + neigh->parms->retrans_time;
832 }
833 } else {
834 /* NUD_PROBE|NUD_INCOMPLETE */
835 next = now + neigh->parms->retrans_time;
836 }
837
838 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
839 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
840 struct sk_buff *skb;
841
842 neigh->nud_state = NUD_FAILED;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800843 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 notify = 1;
845 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
846 NEIGH_PRINTK2("neigh %p is failed.\n", neigh);
847
848 /* It is very thin place. report_unreachable is very complicated
849 routine. Particularly, it can hit the same neighbour entry!
850
851 So that, we try to be accurate and avoid dead loop. --ANK
852 */
853 while (neigh->nud_state == NUD_FAILED &&
854 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
855 write_unlock(&neigh->lock);
856 neigh->ops->error_report(neigh, skb);
857 write_lock(&neigh->lock);
858 }
859 skb_queue_purge(&neigh->arp_queue);
860 }
861
862 if (neigh->nud_state & NUD_IN_TIMER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 if (time_before(next, jiffies + HZ/2))
864 next = jiffies + HZ/2;
Herbert Xu6fb99742005-10-23 16:37:48 +1000865 if (!mod_timer(&neigh->timer, next))
866 neigh_hold(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 }
868 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
869 struct sk_buff *skb = skb_peek(&neigh->arp_queue);
David S. Miller9ff56602008-02-17 18:39:54 -0800870 /* keep skb alive even if arp_queue overflows */
871 if (skb)
Frank Blaschka7e367632008-03-03 12:16:04 -0800872 skb = skb_copy(skb, GFP_ATOMIC);
David S. Miller9ff56602008-02-17 18:39:54 -0800873 write_unlock(&neigh->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 neigh->ops->solicit(neigh, skb);
875 atomic_inc(&neigh->probes);
David S. Miller9ff56602008-02-17 18:39:54 -0800876 if (skb)
877 kfree_skb(skb);
878 } else {
David S. Miller69cc64d2008-02-11 21:45:44 -0800879out:
David S. Miller9ff56602008-02-17 18:39:54 -0800880 write_unlock(&neigh->lock);
881 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
Thomas Grafd961db32007-08-08 23:12:56 -0700883 if (notify)
884 neigh_update_notify(neigh);
885
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 neigh_release(neigh);
887}
888
889int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
890{
891 int rc;
892 unsigned long now;
893
894 write_lock_bh(&neigh->lock);
895
896 rc = 0;
897 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
898 goto out_unlock_bh;
899
900 now = jiffies;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900901
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
903 if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
904 atomic_set(&neigh->probes, neigh->parms->ucast_probes);
905 neigh->nud_state = NUD_INCOMPLETE;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800906 neigh->updated = jiffies;
David S. Miller667347f2005-09-27 12:07:44 -0700907 neigh_add_timer(neigh, now + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 } else {
909 neigh->nud_state = NUD_FAILED;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800910 neigh->updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 write_unlock_bh(&neigh->lock);
912
913 if (skb)
914 kfree_skb(skb);
915 return 1;
916 }
917 } else if (neigh->nud_state & NUD_STALE) {
918 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 neigh->nud_state = NUD_DELAY;
YOSHIFUJI Hideaki955aaa22006-03-20 16:52:52 -0800920 neigh->updated = jiffies;
David S. Miller667347f2005-09-27 12:07:44 -0700921 neigh_add_timer(neigh,
922 jiffies + neigh->parms->delay_probe_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 }
924
925 if (neigh->nud_state == NUD_INCOMPLETE) {
926 if (skb) {
927 if (skb_queue_len(&neigh->arp_queue) >=
928 neigh->parms->queue_len) {
929 struct sk_buff *buff;
David S. Millerf72051b2008-09-23 01:11:18 -0700930 buff = __skb_dequeue(&neigh->arp_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 kfree_skb(buff);
Neil Horman9a6d2762008-07-16 20:50:49 -0700932 NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 }
934 __skb_queue_tail(&neigh->arp_queue, skb);
935 }
936 rc = 1;
937 }
938out_unlock_bh:
939 write_unlock_bh(&neigh->lock);
940 return rc;
941}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +0900942EXPORT_SYMBOL(__neigh_event_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
Stephen Hemmingere92b43a2006-08-17 18:17:37 -0700944static void neigh_update_hhs(struct neighbour *neigh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945{
946 struct hh_cache *hh;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700947 void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
948 = neigh->dev->header_ops->cache_update;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
950 if (update) {
951 for (hh = neigh->hh; hh; hh = hh->hh_next) {
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800952 write_seqlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 update(hh, neigh->dev, neigh->ha);
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800954 write_sequnlock_bh(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 }
956 }
957}
958
959
960
961/* Generic update routine.
962 -- lladdr is new lladdr or NULL, if it is not supplied.
963 -- new is new state.
964 -- flags
965 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
966 if it is different.
967 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900968 lladdr instead of overriding it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 if it is different.
970 It also allows to retain current state
971 if lladdr is unchanged.
972 NEIGH_UPDATE_F_ADMIN means that the change is administrative.
973
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900974 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 NTF_ROUTER flag.
976 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
977 a router.
978
979 Caller MUST hold reference count on the entry.
980 */
981
982int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
983 u32 flags)
984{
985 u8 old;
986 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 int notify = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 struct net_device *dev;
989 int update_isrouter = 0;
990
991 write_lock_bh(&neigh->lock);
992
993 dev = neigh->dev;
994 old = neigh->nud_state;
995 err = -EPERM;
996
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900997 if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 (old & (NUD_NOARP | NUD_PERMANENT)))
999 goto out;
1000
1001 if (!(new & NUD_VALID)) {
1002 neigh_del_timer(neigh);
1003 if (old & NUD_CONNECTED)
1004 neigh_suspect(neigh);
1005 neigh->nud_state = new;
1006 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 notify = old & NUD_VALID;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 goto out;
1009 }
1010
1011 /* Compare new lladdr with cached one */
1012 if (!dev->addr_len) {
1013 /* First case: device needs no address. */
1014 lladdr = neigh->ha;
1015 } else if (lladdr) {
1016 /* The second case: if something is already cached
1017 and a new address is proposed:
1018 - compare new & old
1019 - if they are different, check override flag
1020 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001021 if ((old & NUD_VALID) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 !memcmp(lladdr, neigh->ha, dev->addr_len))
1023 lladdr = neigh->ha;
1024 } else {
1025 /* No address is supplied; if we know something,
1026 use it, otherwise discard the request.
1027 */
1028 err = -EINVAL;
1029 if (!(old & NUD_VALID))
1030 goto out;
1031 lladdr = neigh->ha;
1032 }
1033
1034 if (new & NUD_CONNECTED)
1035 neigh->confirmed = jiffies;
1036 neigh->updated = jiffies;
1037
1038 /* If entry was valid and address is not changed,
1039 do not change entry state, if new one is STALE.
1040 */
1041 err = 0;
1042 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1043 if (old & NUD_VALID) {
1044 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1045 update_isrouter = 0;
1046 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1047 (old & NUD_CONNECTED)) {
1048 lladdr = neigh->ha;
1049 new = NUD_STALE;
1050 } else
1051 goto out;
1052 } else {
1053 if (lladdr == neigh->ha && new == NUD_STALE &&
1054 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1055 (old & NUD_CONNECTED))
1056 )
1057 new = old;
1058 }
1059 }
1060
1061 if (new != old) {
1062 neigh_del_timer(neigh);
Pavel Emelyanova43d8992007-12-20 15:49:05 -08001063 if (new & NUD_IN_TIMER)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001064 neigh_add_timer(neigh, (jiffies +
1065 ((new & NUD_REACHABLE) ?
David S. Miller667347f2005-09-27 12:07:44 -07001066 neigh->parms->reachable_time :
1067 0)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 neigh->nud_state = new;
1069 }
1070
1071 if (lladdr != neigh->ha) {
1072 memcpy(&neigh->ha, lladdr, dev->addr_len);
1073 neigh_update_hhs(neigh);
1074 if (!(new & NUD_CONNECTED))
1075 neigh->confirmed = jiffies -
1076 (neigh->parms->base_reachable_time << 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 notify = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 }
1079 if (new == old)
1080 goto out;
1081 if (new & NUD_CONNECTED)
1082 neigh_connect(neigh);
1083 else
1084 neigh_suspect(neigh);
1085 if (!(old & NUD_VALID)) {
1086 struct sk_buff *skb;
1087
1088 /* Again: avoid dead loop if something went wrong */
1089
1090 while (neigh->nud_state & NUD_VALID &&
1091 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1092 struct neighbour *n1 = neigh;
1093 write_unlock_bh(&neigh->lock);
1094 /* On shaper/eql skb->dst->neighbour != neigh :( */
1095 if (skb->dst && skb->dst->neighbour)
1096 n1 = skb->dst->neighbour;
1097 n1->output(skb);
1098 write_lock_bh(&neigh->lock);
1099 }
1100 skb_queue_purge(&neigh->arp_queue);
1101 }
1102out:
1103 if (update_isrouter) {
1104 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1105 (neigh->flags | NTF_ROUTER) :
1106 (neigh->flags & ~NTF_ROUTER);
1107 }
1108 write_unlock_bh(&neigh->lock);
Tom Tucker8d717402006-07-30 20:43:36 -07001109
1110 if (notify)
Thomas Grafd961db32007-08-08 23:12:56 -07001111 neigh_update_notify(neigh);
1112
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 return err;
1114}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001115EXPORT_SYMBOL(neigh_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
1117struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1118 u8 *lladdr, void *saddr,
1119 struct net_device *dev)
1120{
1121 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1122 lladdr || !dev->addr_len);
1123 if (neigh)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001124 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 NEIGH_UPDATE_F_OVERRIDE);
1126 return neigh;
1127}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001128EXPORT_SYMBOL(neigh_event_ns);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
1130static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,
Al Virod77072e2006-09-28 14:20:34 -07001131 __be16 protocol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132{
1133 struct hh_cache *hh;
1134 struct net_device *dev = dst->dev;
1135
1136 for (hh = n->hh; hh; hh = hh->hh_next)
1137 if (hh->hh_type == protocol)
1138 break;
1139
Andrew Morton77d04bd2006-04-07 14:52:59 -07001140 if (!hh && (hh = kzalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) {
Stephen Hemminger3644f0c2006-12-07 15:08:17 -08001141 seqlock_init(&hh->hh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 hh->hh_type = protocol;
1143 atomic_set(&hh->hh_refcnt, 0);
1144 hh->hh_next = NULL;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001145
1146 if (dev->header_ops->cache(n, hh)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 kfree(hh);
1148 hh = NULL;
1149 } else {
1150 atomic_inc(&hh->hh_refcnt);
1151 hh->hh_next = n->hh;
1152 n->hh = hh;
1153 if (n->nud_state & NUD_CONNECTED)
1154 hh->hh_output = n->ops->hh_output;
1155 else
1156 hh->hh_output = n->ops->output;
1157 }
1158 }
1159 if (hh) {
1160 atomic_inc(&hh->hh_refcnt);
1161 dst->hh = hh;
1162 }
1163}
1164
1165/* This function can be used in contexts, where only old dev_queue_xmit
1166 worked, f.e. if you want to override normal output path (eql, shaper),
1167 but resolution is not made yet.
1168 */
1169
1170int neigh_compat_output(struct sk_buff *skb)
1171{
1172 struct net_device *dev = skb->dev;
1173
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03001174 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001176 if (dev_hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
1177 skb->len) < 0 &&
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001178 dev->header_ops->rebuild(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 return 0;
1180
1181 return dev_queue_xmit(skb);
1182}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001183EXPORT_SYMBOL(neigh_compat_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
1185/* Slow and careful. */
1186
1187int neigh_resolve_output(struct sk_buff *skb)
1188{
1189 struct dst_entry *dst = skb->dst;
1190 struct neighbour *neigh;
1191 int rc = 0;
1192
1193 if (!dst || !(neigh = dst->neighbour))
1194 goto discard;
1195
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03001196 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
1198 if (!neigh_event_send(neigh, skb)) {
1199 int err;
1200 struct net_device *dev = neigh->dev;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001201 if (dev->header_ops->cache && !dst->hh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 write_lock_bh(&neigh->lock);
1203 if (!dst->hh)
1204 neigh_hh_init(neigh, dst, dst->ops->protocol);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001205 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1206 neigh->ha, NULL, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 write_unlock_bh(&neigh->lock);
1208 } else {
1209 read_lock_bh(&neigh->lock);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001210 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1211 neigh->ha, NULL, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 read_unlock_bh(&neigh->lock);
1213 }
1214 if (err >= 0)
1215 rc = neigh->ops->queue_xmit(skb);
1216 else
1217 goto out_kfree_skb;
1218 }
1219out:
1220 return rc;
1221discard:
1222 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1223 dst, dst ? dst->neighbour : NULL);
1224out_kfree_skb:
1225 rc = -EINVAL;
1226 kfree_skb(skb);
1227 goto out;
1228}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001229EXPORT_SYMBOL(neigh_resolve_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
1231/* As fast as possible without hh cache */
1232
1233int neigh_connected_output(struct sk_buff *skb)
1234{
1235 int err;
1236 struct dst_entry *dst = skb->dst;
1237 struct neighbour *neigh = dst->neighbour;
1238 struct net_device *dev = neigh->dev;
1239
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03001240 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
1242 read_lock_bh(&neigh->lock);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001243 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1244 neigh->ha, NULL, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 read_unlock_bh(&neigh->lock);
1246 if (err >= 0)
1247 err = neigh->ops->queue_xmit(skb);
1248 else {
1249 err = -EINVAL;
1250 kfree_skb(skb);
1251 }
1252 return err;
1253}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001254EXPORT_SYMBOL(neigh_connected_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
1256static void neigh_proxy_process(unsigned long arg)
1257{
1258 struct neigh_table *tbl = (struct neigh_table *)arg;
1259 long sched_next = 0;
1260 unsigned long now = jiffies;
David S. Millerf72051b2008-09-23 01:11:18 -07001261 struct sk_buff *skb, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
1263 spin_lock(&tbl->proxy_queue.lock);
1264
David S. Millerf72051b2008-09-23 01:11:18 -07001265 skb_queue_walk_safe(&tbl->proxy_queue, skb, n) {
1266 long tdif = NEIGH_CB(skb)->sched_next - now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 if (tdif <= 0) {
David S. Millerf72051b2008-09-23 01:11:18 -07001269 struct net_device *dev = skb->dev;
1270 __skb_unlink(skb, &tbl->proxy_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 if (tbl->proxy_redo && netif_running(dev))
David S. Millerf72051b2008-09-23 01:11:18 -07001272 tbl->proxy_redo(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 else
David S. Millerf72051b2008-09-23 01:11:18 -07001274 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
1276 dev_put(dev);
1277 } else if (!sched_next || tdif < sched_next)
1278 sched_next = tdif;
1279 }
1280 del_timer(&tbl->proxy_timer);
1281 if (sched_next)
1282 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1283 spin_unlock(&tbl->proxy_queue.lock);
1284}
1285
1286void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1287 struct sk_buff *skb)
1288{
1289 unsigned long now = jiffies;
1290 unsigned long sched_next = now + (net_random() % p->proxy_delay);
1291
1292 if (tbl->proxy_queue.qlen > p->proxy_qlen) {
1293 kfree_skb(skb);
1294 return;
1295 }
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001296
1297 NEIGH_CB(skb)->sched_next = sched_next;
1298 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
1300 spin_lock(&tbl->proxy_queue.lock);
1301 if (del_timer(&tbl->proxy_timer)) {
1302 if (time_before(tbl->proxy_timer.expires, sched_next))
1303 sched_next = tbl->proxy_timer.expires;
1304 }
1305 dst_release(skb->dst);
1306 skb->dst = NULL;
1307 dev_hold(skb->dev);
1308 __skb_queue_tail(&tbl->proxy_queue, skb);
1309 mod_timer(&tbl->proxy_timer, sched_next);
1310 spin_unlock(&tbl->proxy_queue.lock);
1311}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001312EXPORT_SYMBOL(pneigh_enqueue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313
Eric W. Biederman426b5302008-01-24 00:13:18 -08001314static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl,
1315 struct net *net, int ifindex)
1316{
1317 struct neigh_parms *p;
1318
1319 for (p = &tbl->parms; p; p = p->next) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001320 if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) ||
Eric W. Biederman426b5302008-01-24 00:13:18 -08001321 (!p->dev && !ifindex))
1322 return p;
1323 }
1324
1325 return NULL;
1326}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
1328struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1329 struct neigh_table *tbl)
1330{
Eric W. Biederman426b5302008-01-24 00:13:18 -08001331 struct neigh_parms *p, *ref;
1332 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001334 net = dev_net(dev);
Eric W. Biederman426b5302008-01-24 00:13:18 -08001335 ref = lookup_neigh_params(tbl, net, 0);
1336 if (!ref)
1337 return NULL;
1338
1339 p = kmemdup(ref, sizeof(*p), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 p->tbl = tbl;
1342 atomic_set(&p->refcnt, 1);
1343 INIT_RCU_HEAD(&p->rcu_head);
1344 p->reachable_time =
1345 neigh_rand_reach_time(p->base_reachable_time);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001346
Denis V. Lunev486b51d2008-01-14 22:59:59 -08001347 if (dev->neigh_setup && dev->neigh_setup(dev, p)) {
1348 kfree(p);
1349 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 }
Denis V. Lunev486b51d2008-01-14 22:59:59 -08001351
1352 dev_hold(dev);
1353 p->dev = dev;
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +09001354#ifdef CONFIG_NET_NS
Eric W. Biederman426b5302008-01-24 00:13:18 -08001355 p->net = hold_net(net);
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +09001356#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 p->sysctl_table = NULL;
1358 write_lock_bh(&tbl->lock);
1359 p->next = tbl->parms.next;
1360 tbl->parms.next = p;
1361 write_unlock_bh(&tbl->lock);
1362 }
1363 return p;
1364}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001365EXPORT_SYMBOL(neigh_parms_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366
1367static void neigh_rcu_free_parms(struct rcu_head *head)
1368{
1369 struct neigh_parms *parms =
1370 container_of(head, struct neigh_parms, rcu_head);
1371
1372 neigh_parms_put(parms);
1373}
1374
1375void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1376{
1377 struct neigh_parms **p;
1378
1379 if (!parms || parms == &tbl->parms)
1380 return;
1381 write_lock_bh(&tbl->lock);
1382 for (p = &tbl->parms.next; *p; p = &(*p)->next) {
1383 if (*p == parms) {
1384 *p = parms->next;
1385 parms->dead = 1;
1386 write_unlock_bh(&tbl->lock);
David S. Millercecbb632008-01-20 16:39:03 -08001387 if (parms->dev)
1388 dev_put(parms->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1390 return;
1391 }
1392 }
1393 write_unlock_bh(&tbl->lock);
1394 NEIGH_PRINTK1("neigh_parms_release: not found\n");
1395}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001396EXPORT_SYMBOL(neigh_parms_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397
Denis V. Lunev06f05112008-01-24 00:30:58 -08001398static void neigh_parms_destroy(struct neigh_parms *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399{
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +09001400 release_net(neigh_parms_net(parms));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 kfree(parms);
1402}
1403
Pavel Emelianovc2ecba72007-04-17 12:45:31 -07001404static struct lock_class_key neigh_table_proxy_queue_class;
1405
Simon Kelleybd89efc2006-05-12 14:56:08 -07001406void neigh_table_init_no_netlink(struct neigh_table *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407{
1408 unsigned long now = jiffies;
1409 unsigned long phsize;
1410
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +09001411#ifdef CONFIG_NET_NS
Eric W. Biederman426b5302008-01-24 00:13:18 -08001412 tbl->parms.net = &init_net;
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +09001413#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 atomic_set(&tbl->parms.refcnt, 1);
1415 INIT_RCU_HEAD(&tbl->parms.rcu_head);
1416 tbl->parms.reachable_time =
1417 neigh_rand_reach_time(tbl->parms.base_reachable_time);
1418
1419 if (!tbl->kmem_cachep)
Alexey Dobriyane5d679f2006-08-26 19:25:52 -07001420 tbl->kmem_cachep =
1421 kmem_cache_create(tbl->id, tbl->entry_size, 0,
1422 SLAB_HWCACHE_ALIGN|SLAB_PANIC,
Paul Mundt20c2df82007-07-20 10:11:58 +09001423 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 tbl->stats = alloc_percpu(struct neigh_statistics);
1425 if (!tbl->stats)
1426 panic("cannot create neighbour cache statistics");
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001427
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428#ifdef CONFIG_PROC_FS
Denis V. Lunev5efdccb2008-05-02 02:46:22 -07001429 tbl->pde = proc_create_data(tbl->id, 0, init_net.proc_net_stat,
1430 &neigh_stat_seq_fops, tbl);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001431 if (!tbl->pde)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 panic("cannot create neighbour proc dir entry");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433#endif
1434
1435 tbl->hash_mask = 1;
1436 tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1);
1437
1438 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
Andrew Morton77d04bd2006-04-07 14:52:59 -07001439 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
1441 if (!tbl->hash_buckets || !tbl->phash_buckets)
1442 panic("cannot allocate neighbour cache hashes");
1443
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
1445
1446 rwlock_init(&tbl->lock);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -08001447 setup_timer(&tbl->gc_timer, neigh_periodic_timer, (unsigned long)tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 tbl->gc_timer.expires = now + 1;
1449 add_timer(&tbl->gc_timer);
1450
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -08001451 setup_timer(&tbl->proxy_timer, neigh_proxy_process, (unsigned long)tbl);
Pavel Emelianovc2ecba72007-04-17 12:45:31 -07001452 skb_queue_head_init_class(&tbl->proxy_queue,
1453 &neigh_table_proxy_queue_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454
1455 tbl->last_flush = now;
1456 tbl->last_rand = now + tbl->parms.reachable_time * 20;
Simon Kelleybd89efc2006-05-12 14:56:08 -07001457}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001458EXPORT_SYMBOL(neigh_table_init_no_netlink);
Simon Kelleybd89efc2006-05-12 14:56:08 -07001459
1460void neigh_table_init(struct neigh_table *tbl)
1461{
1462 struct neigh_table *tmp;
1463
1464 neigh_table_init_no_netlink(tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 write_lock(&neigh_tbl_lock);
Simon Kelleybd89efc2006-05-12 14:56:08 -07001466 for (tmp = neigh_tables; tmp; tmp = tmp->next) {
1467 if (tmp->family == tbl->family)
1468 break;
1469 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 tbl->next = neigh_tables;
1471 neigh_tables = tbl;
1472 write_unlock(&neigh_tbl_lock);
Simon Kelleybd89efc2006-05-12 14:56:08 -07001473
1474 if (unlikely(tmp)) {
1475 printk(KERN_ERR "NEIGH: Registering multiple tables for "
1476 "family %d\n", tbl->family);
1477 dump_stack();
1478 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001480EXPORT_SYMBOL(neigh_table_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
1482int neigh_table_clear(struct neigh_table *tbl)
1483{
1484 struct neigh_table **tp;
1485
1486 /* It is not clean... Fix it to unload IPv6 module safely */
1487 del_timer_sync(&tbl->gc_timer);
1488 del_timer_sync(&tbl->proxy_timer);
1489 pneigh_queue_purge(&tbl->proxy_queue);
1490 neigh_ifdown(tbl, NULL);
1491 if (atomic_read(&tbl->entries))
1492 printk(KERN_CRIT "neighbour leakage\n");
1493 write_lock(&neigh_tbl_lock);
1494 for (tp = &neigh_tables; *tp; tp = &(*tp)->next) {
1495 if (*tp == tbl) {
1496 *tp = tbl->next;
1497 break;
1498 }
1499 }
1500 write_unlock(&neigh_tbl_lock);
1501
1502 neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1);
1503 tbl->hash_buckets = NULL;
1504
1505 kfree(tbl->phash_buckets);
1506 tbl->phash_buckets = NULL;
1507
Alexey Dobriyan3f192b52007-11-05 21:28:13 -08001508 remove_proc_entry(tbl->id, init_net.proc_net_stat);
1509
Kirill Korotaev3fcde742006-09-01 01:34:10 -07001510 free_percpu(tbl->stats);
1511 tbl->stats = NULL;
1512
Randy Dunlapbfb85c92007-10-21 16:24:27 -07001513 kmem_cache_destroy(tbl->kmem_cachep);
1514 tbl->kmem_cachep = NULL;
1515
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 return 0;
1517}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09001518EXPORT_SYMBOL(neigh_table_clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519
Thomas Grafc8822a42007-03-22 11:50:06 -07001520static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001522 struct net *net = sock_net(skb->sk);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001523 struct ndmsg *ndm;
1524 struct nlattr *dst_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 struct neigh_table *tbl;
1526 struct net_device *dev = NULL;
Thomas Grafa14a49d2006-08-07 17:53:08 -07001527 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528
Thomas Grafa14a49d2006-08-07 17:53:08 -07001529 if (nlmsg_len(nlh) < sizeof(*ndm))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 goto out;
1531
Thomas Grafa14a49d2006-08-07 17:53:08 -07001532 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1533 if (dst_attr == NULL)
1534 goto out;
1535
1536 ndm = nlmsg_data(nlh);
1537 if (ndm->ndm_ifindex) {
Eric W. Biederman881d9662007-09-17 11:56:21 -07001538 dev = dev_get_by_index(net, ndm->ndm_ifindex);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001539 if (dev == NULL) {
1540 err = -ENODEV;
1541 goto out;
1542 }
1543 }
1544
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 read_lock(&neigh_tbl_lock);
1546 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
Thomas Grafa14a49d2006-08-07 17:53:08 -07001547 struct neighbour *neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548
1549 if (tbl->family != ndm->ndm_family)
1550 continue;
1551 read_unlock(&neigh_tbl_lock);
1552
Thomas Grafa14a49d2006-08-07 17:53:08 -07001553 if (nla_len(dst_attr) < tbl->key_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 goto out_dev_put;
1555
1556 if (ndm->ndm_flags & NTF_PROXY) {
Eric W. Biederman426b5302008-01-24 00:13:18 -08001557 err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 goto out_dev_put;
1559 }
1560
Thomas Grafa14a49d2006-08-07 17:53:08 -07001561 if (dev == NULL)
1562 goto out_dev_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563
Thomas Grafa14a49d2006-08-07 17:53:08 -07001564 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1565 if (neigh == NULL) {
1566 err = -ENOENT;
1567 goto out_dev_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 }
Thomas Grafa14a49d2006-08-07 17:53:08 -07001569
1570 err = neigh_update(neigh, NULL, NUD_FAILED,
1571 NEIGH_UPDATE_F_OVERRIDE |
1572 NEIGH_UPDATE_F_ADMIN);
1573 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 goto out_dev_put;
1575 }
1576 read_unlock(&neigh_tbl_lock);
Thomas Grafa14a49d2006-08-07 17:53:08 -07001577 err = -EAFNOSUPPORT;
1578
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579out_dev_put:
1580 if (dev)
1581 dev_put(dev);
1582out:
1583 return err;
1584}
1585
Thomas Grafc8822a42007-03-22 11:50:06 -07001586static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001588 struct net *net = sock_net(skb->sk);
Thomas Graf5208deb2006-08-07 17:55:40 -07001589 struct ndmsg *ndm;
1590 struct nlattr *tb[NDA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 struct neigh_table *tbl;
1592 struct net_device *dev = NULL;
Thomas Graf5208deb2006-08-07 17:55:40 -07001593 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
Thomas Graf5208deb2006-08-07 17:55:40 -07001595 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
1596 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 goto out;
1598
Thomas Graf5208deb2006-08-07 17:55:40 -07001599 err = -EINVAL;
1600 if (tb[NDA_DST] == NULL)
1601 goto out;
1602
1603 ndm = nlmsg_data(nlh);
1604 if (ndm->ndm_ifindex) {
Eric W. Biederman881d9662007-09-17 11:56:21 -07001605 dev = dev_get_by_index(net, ndm->ndm_ifindex);
Thomas Graf5208deb2006-08-07 17:55:40 -07001606 if (dev == NULL) {
1607 err = -ENODEV;
1608 goto out;
1609 }
1610
1611 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
1612 goto out_dev_put;
1613 }
1614
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 read_lock(&neigh_tbl_lock);
1616 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
Thomas Graf5208deb2006-08-07 17:55:40 -07001617 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
1618 struct neighbour *neigh;
1619 void *dst, *lladdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620
1621 if (tbl->family != ndm->ndm_family)
1622 continue;
1623 read_unlock(&neigh_tbl_lock);
1624
Thomas Graf5208deb2006-08-07 17:55:40 -07001625 if (nla_len(tb[NDA_DST]) < tbl->key_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 goto out_dev_put;
Thomas Graf5208deb2006-08-07 17:55:40 -07001627 dst = nla_data(tb[NDA_DST]);
1628 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
1630 if (ndm->ndm_flags & NTF_PROXY) {
Ville Nuorvala62dd9312006-09-22 14:43:19 -07001631 struct pneigh_entry *pn;
1632
1633 err = -ENOBUFS;
Eric W. Biederman426b5302008-01-24 00:13:18 -08001634 pn = pneigh_lookup(tbl, net, dst, dev, 1);
Ville Nuorvala62dd9312006-09-22 14:43:19 -07001635 if (pn) {
1636 pn->flags = ndm->ndm_flags;
1637 err = 0;
1638 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 goto out_dev_put;
1640 }
1641
Thomas Graf5208deb2006-08-07 17:55:40 -07001642 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 goto out_dev_put;
Thomas Graf5208deb2006-08-07 17:55:40 -07001644
1645 neigh = neigh_lookup(tbl, dst, dev);
1646 if (neigh == NULL) {
1647 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1648 err = -ENOENT;
1649 goto out_dev_put;
1650 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001651
Thomas Graf5208deb2006-08-07 17:55:40 -07001652 neigh = __neigh_lookup_errno(tbl, dst, dev);
1653 if (IS_ERR(neigh)) {
1654 err = PTR_ERR(neigh);
1655 goto out_dev_put;
1656 }
1657 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1659 err = -EEXIST;
Thomas Graf5208deb2006-08-07 17:55:40 -07001660 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 goto out_dev_put;
1662 }
Thomas Graf5208deb2006-08-07 17:55:40 -07001663
1664 if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
1665 flags &= ~NEIGH_UPDATE_F_OVERRIDE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 }
1667
Thomas Graf5208deb2006-08-07 17:55:40 -07001668 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
1669 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 goto out_dev_put;
1671 }
1672
1673 read_unlock(&neigh_tbl_lock);
Thomas Graf5208deb2006-08-07 17:55:40 -07001674 err = -EAFNOSUPPORT;
1675
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676out_dev_put:
1677 if (dev)
1678 dev_put(dev);
1679out:
1680 return err;
1681}
1682
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001683static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1684{
Thomas Grafca860fb2006-08-07 18:00:18 -07001685 struct nlattr *nest;
1686
1687 nest = nla_nest_start(skb, NDTA_PARMS);
1688 if (nest == NULL)
1689 return -ENOBUFS;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001690
1691 if (parms->dev)
Thomas Grafca860fb2006-08-07 18:00:18 -07001692 NLA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001693
Thomas Grafca860fb2006-08-07 18:00:18 -07001694 NLA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt));
1695 NLA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len);
1696 NLA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen);
1697 NLA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes);
1698 NLA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes);
1699 NLA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes);
1700 NLA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time);
1701 NLA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME,
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001702 parms->base_reachable_time);
Thomas Grafca860fb2006-08-07 18:00:18 -07001703 NLA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime);
1704 NLA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time);
1705 NLA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time);
1706 NLA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay);
1707 NLA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay);
1708 NLA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001709
Thomas Grafca860fb2006-08-07 18:00:18 -07001710 return nla_nest_end(skb, nest);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001711
Thomas Grafca860fb2006-08-07 18:00:18 -07001712nla_put_failure:
Thomas Grafbc3ed282008-06-03 16:36:54 -07001713 nla_nest_cancel(skb, nest);
1714 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001715}
1716
Thomas Grafca860fb2006-08-07 18:00:18 -07001717static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
1718 u32 pid, u32 seq, int type, int flags)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001719{
1720 struct nlmsghdr *nlh;
1721 struct ndtmsg *ndtmsg;
1722
Thomas Grafca860fb2006-08-07 18:00:18 -07001723 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1724 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001725 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001726
Thomas Grafca860fb2006-08-07 18:00:18 -07001727 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001728
1729 read_lock_bh(&tbl->lock);
1730 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001731 ndtmsg->ndtm_pad1 = 0;
1732 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001733
Thomas Grafca860fb2006-08-07 18:00:18 -07001734 NLA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1735 NLA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval);
1736 NLA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1);
1737 NLA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2);
1738 NLA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001739
1740 {
1741 unsigned long now = jiffies;
1742 unsigned int flush_delta = now - tbl->last_flush;
1743 unsigned int rand_delta = now - tbl->last_rand;
1744
1745 struct ndt_config ndc = {
1746 .ndtc_key_len = tbl->key_len,
1747 .ndtc_entry_size = tbl->entry_size,
1748 .ndtc_entries = atomic_read(&tbl->entries),
1749 .ndtc_last_flush = jiffies_to_msecs(flush_delta),
1750 .ndtc_last_rand = jiffies_to_msecs(rand_delta),
1751 .ndtc_hash_rnd = tbl->hash_rnd,
1752 .ndtc_hash_mask = tbl->hash_mask,
1753 .ndtc_hash_chain_gc = tbl->hash_chain_gc,
1754 .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
1755 };
1756
Thomas Grafca860fb2006-08-07 18:00:18 -07001757 NLA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001758 }
1759
1760 {
1761 int cpu;
1762 struct ndt_stats ndst;
1763
1764 memset(&ndst, 0, sizeof(ndst));
1765
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -07001766 for_each_possible_cpu(cpu) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001767 struct neigh_statistics *st;
1768
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001769 st = per_cpu_ptr(tbl->stats, cpu);
1770 ndst.ndts_allocs += st->allocs;
1771 ndst.ndts_destroys += st->destroys;
1772 ndst.ndts_hash_grows += st->hash_grows;
1773 ndst.ndts_res_failed += st->res_failed;
1774 ndst.ndts_lookups += st->lookups;
1775 ndst.ndts_hits += st->hits;
1776 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
1777 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
1778 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
1779 ndst.ndts_forced_gc_runs += st->forced_gc_runs;
1780 }
1781
Thomas Grafca860fb2006-08-07 18:00:18 -07001782 NLA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001783 }
1784
1785 BUG_ON(tbl->parms.dev);
1786 if (neightbl_fill_parms(skb, &tbl->parms) < 0)
Thomas Grafca860fb2006-08-07 18:00:18 -07001787 goto nla_put_failure;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001788
1789 read_unlock_bh(&tbl->lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001790 return nlmsg_end(skb, nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001791
Thomas Grafca860fb2006-08-07 18:00:18 -07001792nla_put_failure:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001793 read_unlock_bh(&tbl->lock);
Patrick McHardy26932562007-01-31 23:16:40 -08001794 nlmsg_cancel(skb, nlh);
1795 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001796}
1797
Thomas Grafca860fb2006-08-07 18:00:18 -07001798static int neightbl_fill_param_info(struct sk_buff *skb,
1799 struct neigh_table *tbl,
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001800 struct neigh_parms *parms,
Thomas Grafca860fb2006-08-07 18:00:18 -07001801 u32 pid, u32 seq, int type,
1802 unsigned int flags)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001803{
1804 struct ndtmsg *ndtmsg;
1805 struct nlmsghdr *nlh;
1806
Thomas Grafca860fb2006-08-07 18:00:18 -07001807 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1808 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001809 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001810
Thomas Grafca860fb2006-08-07 18:00:18 -07001811 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001812
1813 read_lock_bh(&tbl->lock);
1814 ndtmsg->ndtm_family = tbl->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001815 ndtmsg->ndtm_pad1 = 0;
1816 ndtmsg->ndtm_pad2 = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001817
Thomas Grafca860fb2006-08-07 18:00:18 -07001818 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
1819 neightbl_fill_parms(skb, parms) < 0)
1820 goto errout;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001821
1822 read_unlock_bh(&tbl->lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001823 return nlmsg_end(skb, nlh);
1824errout:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001825 read_unlock_bh(&tbl->lock);
Patrick McHardy26932562007-01-31 23:16:40 -08001826 nlmsg_cancel(skb, nlh);
1827 return -EMSGSIZE;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001828}
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001829
Patrick McHardyef7c79e2007-06-05 12:38:30 -07001830static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
Thomas Graf6b3f8672006-08-07 17:58:53 -07001831 [NDTA_NAME] = { .type = NLA_STRING },
1832 [NDTA_THRESH1] = { .type = NLA_U32 },
1833 [NDTA_THRESH2] = { .type = NLA_U32 },
1834 [NDTA_THRESH3] = { .type = NLA_U32 },
1835 [NDTA_GC_INTERVAL] = { .type = NLA_U64 },
1836 [NDTA_PARMS] = { .type = NLA_NESTED },
1837};
1838
Patrick McHardyef7c79e2007-06-05 12:38:30 -07001839static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
Thomas Graf6b3f8672006-08-07 17:58:53 -07001840 [NDTPA_IFINDEX] = { .type = NLA_U32 },
1841 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 },
1842 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 },
1843 [NDTPA_APP_PROBES] = { .type = NLA_U32 },
1844 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 },
1845 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 },
1846 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 },
1847 [NDTPA_GC_STALETIME] = { .type = NLA_U64 },
1848 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 },
1849 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 },
1850 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 },
1851 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 },
1852 [NDTPA_LOCKTIME] = { .type = NLA_U64 },
1853};
1854
Thomas Grafc8822a42007-03-22 11:50:06 -07001855static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001856{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001857 struct net *net = sock_net(skb->sk);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001858 struct neigh_table *tbl;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001859 struct ndtmsg *ndtmsg;
1860 struct nlattr *tb[NDTA_MAX+1];
1861 int err;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001862
Thomas Graf6b3f8672006-08-07 17:58:53 -07001863 err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
1864 nl_neightbl_policy);
1865 if (err < 0)
1866 goto errout;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001867
Thomas Graf6b3f8672006-08-07 17:58:53 -07001868 if (tb[NDTA_NAME] == NULL) {
1869 err = -EINVAL;
1870 goto errout;
1871 }
1872
1873 ndtmsg = nlmsg_data(nlh);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001874 read_lock(&neigh_tbl_lock);
1875 for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1876 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1877 continue;
1878
Thomas Graf6b3f8672006-08-07 17:58:53 -07001879 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001880 break;
1881 }
1882
1883 if (tbl == NULL) {
1884 err = -ENOENT;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001885 goto errout_locked;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001886 }
1887
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001888 /*
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001889 * We acquire tbl->lock to be nice to the periodic timers and
1890 * make sure they always see a consistent set of values.
1891 */
1892 write_lock_bh(&tbl->lock);
1893
Thomas Graf6b3f8672006-08-07 17:58:53 -07001894 if (tb[NDTA_PARMS]) {
1895 struct nlattr *tbp[NDTPA_MAX+1];
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001896 struct neigh_parms *p;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001897 int i, ifindex = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001898
Thomas Graf6b3f8672006-08-07 17:58:53 -07001899 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
1900 nl_ntbl_parm_policy);
1901 if (err < 0)
1902 goto errout_tbl_lock;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001903
Thomas Graf6b3f8672006-08-07 17:58:53 -07001904 if (tbp[NDTPA_IFINDEX])
1905 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001906
Eric W. Biederman426b5302008-01-24 00:13:18 -08001907 p = lookup_neigh_params(tbl, net, ifindex);
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001908 if (p == NULL) {
1909 err = -ENOENT;
Thomas Graf6b3f8672006-08-07 17:58:53 -07001910 goto errout_tbl_lock;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001911 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001912
Thomas Graf6b3f8672006-08-07 17:58:53 -07001913 for (i = 1; i <= NDTPA_MAX; i++) {
1914 if (tbp[i] == NULL)
1915 continue;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001916
Thomas Graf6b3f8672006-08-07 17:58:53 -07001917 switch (i) {
1918 case NDTPA_QUEUE_LEN:
1919 p->queue_len = nla_get_u32(tbp[i]);
1920 break;
1921 case NDTPA_PROXY_QLEN:
1922 p->proxy_qlen = nla_get_u32(tbp[i]);
1923 break;
1924 case NDTPA_APP_PROBES:
1925 p->app_probes = nla_get_u32(tbp[i]);
1926 break;
1927 case NDTPA_UCAST_PROBES:
1928 p->ucast_probes = nla_get_u32(tbp[i]);
1929 break;
1930 case NDTPA_MCAST_PROBES:
1931 p->mcast_probes = nla_get_u32(tbp[i]);
1932 break;
1933 case NDTPA_BASE_REACHABLE_TIME:
1934 p->base_reachable_time = nla_get_msecs(tbp[i]);
1935 break;
1936 case NDTPA_GC_STALETIME:
1937 p->gc_staletime = nla_get_msecs(tbp[i]);
1938 break;
1939 case NDTPA_DELAY_PROBE_TIME:
1940 p->delay_probe_time = nla_get_msecs(tbp[i]);
1941 break;
1942 case NDTPA_RETRANS_TIME:
1943 p->retrans_time = nla_get_msecs(tbp[i]);
1944 break;
1945 case NDTPA_ANYCAST_DELAY:
1946 p->anycast_delay = nla_get_msecs(tbp[i]);
1947 break;
1948 case NDTPA_PROXY_DELAY:
1949 p->proxy_delay = nla_get_msecs(tbp[i]);
1950 break;
1951 case NDTPA_LOCKTIME:
1952 p->locktime = nla_get_msecs(tbp[i]);
1953 break;
1954 }
1955 }
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001956 }
1957
Thomas Graf6b3f8672006-08-07 17:58:53 -07001958 if (tb[NDTA_THRESH1])
1959 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
1960
1961 if (tb[NDTA_THRESH2])
1962 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
1963
1964 if (tb[NDTA_THRESH3])
1965 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
1966
1967 if (tb[NDTA_GC_INTERVAL])
1968 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
1969
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001970 err = 0;
1971
Thomas Graf6b3f8672006-08-07 17:58:53 -07001972errout_tbl_lock:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001973 write_unlock_bh(&tbl->lock);
Thomas Graf6b3f8672006-08-07 17:58:53 -07001974errout_locked:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001975 read_unlock(&neigh_tbl_lock);
Thomas Graf6b3f8672006-08-07 17:58:53 -07001976errout:
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001977 return err;
1978}
1979
Thomas Grafc8822a42007-03-22 11:50:06 -07001980static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001981{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001982 struct net *net = sock_net(skb->sk);
Thomas Grafca860fb2006-08-07 18:00:18 -07001983 int family, tidx, nidx = 0;
1984 int tbl_skip = cb->args[0];
1985 int neigh_skip = cb->args[1];
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001986 struct neigh_table *tbl;
1987
Thomas Grafca860fb2006-08-07 18:00:18 -07001988 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001989
1990 read_lock(&neigh_tbl_lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07001991 for (tbl = neigh_tables, tidx = 0; tbl; tbl = tbl->next, tidx++) {
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001992 struct neigh_parms *p;
1993
Thomas Grafca860fb2006-08-07 18:00:18 -07001994 if (tidx < tbl_skip || (family && tbl->family != family))
Thomas Grafc7fb64d2005-06-18 22:50:55 -07001995 continue;
1996
Thomas Grafca860fb2006-08-07 18:00:18 -07001997 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).pid,
1998 cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
1999 NLM_F_MULTI) <= 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002000 break;
2001
Eric W. Biederman426b5302008-01-24 00:13:18 -08002002 for (nidx = 0, p = tbl->parms.next; p; p = p->next) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002003 if (!net_eq(neigh_parms_net(p), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002004 continue;
2005
2006 if (nidx++ < neigh_skip)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002007 continue;
2008
Thomas Grafca860fb2006-08-07 18:00:18 -07002009 if (neightbl_fill_param_info(skb, tbl, p,
2010 NETLINK_CB(cb->skb).pid,
2011 cb->nlh->nlmsg_seq,
2012 RTM_NEWNEIGHTBL,
2013 NLM_F_MULTI) <= 0)
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002014 goto out;
2015 }
2016
Thomas Grafca860fb2006-08-07 18:00:18 -07002017 neigh_skip = 0;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002018 }
2019out:
2020 read_unlock(&neigh_tbl_lock);
Thomas Grafca860fb2006-08-07 18:00:18 -07002021 cb->args[0] = tidx;
2022 cb->args[1] = nidx;
Thomas Grafc7fb64d2005-06-18 22:50:55 -07002023
2024 return skb->len;
2025}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026
Thomas Graf8b8aec52006-08-07 17:56:37 -07002027static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
2028 u32 pid, u32 seq, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029{
2030 unsigned long now = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 struct nda_cacheinfo ci;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002032 struct nlmsghdr *nlh;
2033 struct ndmsg *ndm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034
Thomas Graf8b8aec52006-08-07 17:56:37 -07002035 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2036 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08002037 return -EMSGSIZE;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002038
2039 ndm = nlmsg_data(nlh);
2040 ndm->ndm_family = neigh->ops->family;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07002041 ndm->ndm_pad1 = 0;
2042 ndm->ndm_pad2 = 0;
Thomas Graf8b8aec52006-08-07 17:56:37 -07002043 ndm->ndm_flags = neigh->flags;
2044 ndm->ndm_type = neigh->type;
2045 ndm->ndm_ifindex = neigh->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046
Thomas Graf8b8aec52006-08-07 17:56:37 -07002047 NLA_PUT(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key);
2048
2049 read_lock_bh(&neigh->lock);
2050 ndm->ndm_state = neigh->nud_state;
2051 if ((neigh->nud_state & NUD_VALID) &&
2052 nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, neigh->ha) < 0) {
2053 read_unlock_bh(&neigh->lock);
2054 goto nla_put_failure;
2055 }
2056
Stephen Hemmingerb9f5f522008-06-03 16:03:15 -07002057 ci.ndm_used = jiffies_to_clock_t(now - neigh->used);
2058 ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
2059 ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002060 ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1;
2061 read_unlock_bh(&neigh->lock);
2062
2063 NLA_PUT_U32(skb, NDA_PROBES, atomic_read(&neigh->probes));
2064 NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
2065
2066 return nlmsg_end(skb, nlh);
2067
2068nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002069 nlmsg_cancel(skb, nlh);
2070 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071}
2072
Thomas Grafd961db32007-08-08 23:12:56 -07002073static void neigh_update_notify(struct neighbour *neigh)
2074{
2075 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2076 __neigh_notify(neigh, RTM_NEWNEIGH, 0);
2077}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078
2079static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2080 struct netlink_callback *cb)
2081{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002082 struct net * net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 struct neighbour *n;
2084 int rc, h, s_h = cb->args[1];
2085 int idx, s_idx = idx = cb->args[2];
2086
Julian Anastasovc5e29462006-10-03 15:49:46 -07002087 read_lock_bh(&tbl->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 for (h = 0; h <= tbl->hash_mask; h++) {
2089 if (h < s_h)
2090 continue;
2091 if (h > s_h)
2092 s_idx = 0;
Eric W. Biederman426b5302008-01-24 00:13:18 -08002093 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next) {
2094 int lidx;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002095 if (dev_net(n->dev) != net)
Eric W. Biederman426b5302008-01-24 00:13:18 -08002096 continue;
2097 lidx = idx++;
2098 if (lidx < s_idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 continue;
2100 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid,
2101 cb->nlh->nlmsg_seq,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07002102 RTM_NEWNEIGH,
2103 NLM_F_MULTI) <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 read_unlock_bh(&tbl->lock);
2105 rc = -1;
2106 goto out;
2107 }
2108 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 }
Julian Anastasovc5e29462006-10-03 15:49:46 -07002110 read_unlock_bh(&tbl->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 rc = skb->len;
2112out:
2113 cb->args[1] = h;
2114 cb->args[2] = idx;
2115 return rc;
2116}
2117
Thomas Grafc8822a42007-03-22 11:50:06 -07002118static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119{
2120 struct neigh_table *tbl;
2121 int t, family, s_t;
2122
2123 read_lock(&neigh_tbl_lock);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002124 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 s_t = cb->args[0];
2126
2127 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
2128 if (t < s_t || (family && tbl->family != family))
2129 continue;
2130 if (t > s_t)
2131 memset(&cb->args[1], 0, sizeof(cb->args) -
2132 sizeof(cb->args[0]));
2133 if (neigh_dump_table(tbl, skb, cb) < 0)
2134 break;
2135 }
2136 read_unlock(&neigh_tbl_lock);
2137
2138 cb->args[0] = t;
2139 return skb->len;
2140}
2141
2142void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2143{
2144 int chain;
2145
2146 read_lock_bh(&tbl->lock);
2147 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2148 struct neighbour *n;
2149
2150 for (n = tbl->hash_buckets[chain]; n; n = n->next)
2151 cb(n, cookie);
2152 }
2153 read_unlock_bh(&tbl->lock);
2154}
2155EXPORT_SYMBOL(neigh_for_each);
2156
2157/* The tbl->lock must be held as a writer and BH disabled. */
2158void __neigh_for_each_release(struct neigh_table *tbl,
2159 int (*cb)(struct neighbour *))
2160{
2161 int chain;
2162
2163 for (chain = 0; chain <= tbl->hash_mask; chain++) {
2164 struct neighbour *n, **np;
2165
2166 np = &tbl->hash_buckets[chain];
2167 while ((n = *np) != NULL) {
2168 int release;
2169
2170 write_lock(&n->lock);
2171 release = cb(n);
2172 if (release) {
2173 *np = n->next;
2174 n->dead = 1;
2175 } else
2176 np = &n->next;
2177 write_unlock(&n->lock);
Thomas Graf4f494552007-08-08 23:12:36 -07002178 if (release)
2179 neigh_cleanup_and_release(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 }
2181 }
2182}
2183EXPORT_SYMBOL(__neigh_for_each_release);
2184
2185#ifdef CONFIG_PROC_FS
2186
2187static struct neighbour *neigh_get_first(struct seq_file *seq)
2188{
2189 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002190 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 struct neigh_table *tbl = state->tbl;
2192 struct neighbour *n = NULL;
2193 int bucket = state->bucket;
2194
2195 state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2196 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) {
2197 n = tbl->hash_buckets[bucket];
2198
2199 while (n) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002200 if (!net_eq(dev_net(n->dev), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002201 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 if (state->neigh_sub_iter) {
2203 loff_t fakep = 0;
2204 void *v;
2205
2206 v = state->neigh_sub_iter(state, n, &fakep);
2207 if (!v)
2208 goto next;
2209 }
2210 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2211 break;
2212 if (n->nud_state & ~NUD_NOARP)
2213 break;
2214 next:
2215 n = n->next;
2216 }
2217
2218 if (n)
2219 break;
2220 }
2221 state->bucket = bucket;
2222
2223 return n;
2224}
2225
2226static struct neighbour *neigh_get_next(struct seq_file *seq,
2227 struct neighbour *n,
2228 loff_t *pos)
2229{
2230 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002231 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 struct neigh_table *tbl = state->tbl;
2233
2234 if (state->neigh_sub_iter) {
2235 void *v = state->neigh_sub_iter(state, n, pos);
2236 if (v)
2237 return n;
2238 }
2239 n = n->next;
2240
2241 while (1) {
2242 while (n) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002243 if (!net_eq(dev_net(n->dev), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002244 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 if (state->neigh_sub_iter) {
2246 void *v = state->neigh_sub_iter(state, n, pos);
2247 if (v)
2248 return n;
2249 goto next;
2250 }
2251 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2252 break;
2253
2254 if (n->nud_state & ~NUD_NOARP)
2255 break;
2256 next:
2257 n = n->next;
2258 }
2259
2260 if (n)
2261 break;
2262
2263 if (++state->bucket > tbl->hash_mask)
2264 break;
2265
2266 n = tbl->hash_buckets[state->bucket];
2267 }
2268
2269 if (n && pos)
2270 --(*pos);
2271 return n;
2272}
2273
2274static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2275{
2276 struct neighbour *n = neigh_get_first(seq);
2277
2278 if (n) {
Chris Larson745e2032008-08-03 01:10:55 -07002279 --(*pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280 while (*pos) {
2281 n = neigh_get_next(seq, n, pos);
2282 if (!n)
2283 break;
2284 }
2285 }
2286 return *pos ? NULL : n;
2287}
2288
2289static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2290{
2291 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002292 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293 struct neigh_table *tbl = state->tbl;
2294 struct pneigh_entry *pn = NULL;
2295 int bucket = state->bucket;
2296
2297 state->flags |= NEIGH_SEQ_IS_PNEIGH;
2298 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2299 pn = tbl->phash_buckets[bucket];
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002300 while (pn && !net_eq(pneigh_net(pn), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002301 pn = pn->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 if (pn)
2303 break;
2304 }
2305 state->bucket = bucket;
2306
2307 return pn;
2308}
2309
2310static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2311 struct pneigh_entry *pn,
2312 loff_t *pos)
2313{
2314 struct neigh_seq_state *state = seq->private;
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002315 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316 struct neigh_table *tbl = state->tbl;
2317
2318 pn = pn->next;
2319 while (!pn) {
2320 if (++state->bucket > PNEIGH_HASHMASK)
2321 break;
2322 pn = tbl->phash_buckets[state->bucket];
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002323 while (pn && !net_eq(pneigh_net(pn), net))
Eric W. Biederman426b5302008-01-24 00:13:18 -08002324 pn = pn->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 if (pn)
2326 break;
2327 }
2328
2329 if (pn && pos)
2330 --(*pos);
2331
2332 return pn;
2333}
2334
2335static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2336{
2337 struct pneigh_entry *pn = pneigh_get_first(seq);
2338
2339 if (pn) {
Chris Larson745e2032008-08-03 01:10:55 -07002340 --(*pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 while (*pos) {
2342 pn = pneigh_get_next(seq, pn, pos);
2343 if (!pn)
2344 break;
2345 }
2346 }
2347 return *pos ? NULL : pn;
2348}
2349
2350static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2351{
2352 struct neigh_seq_state *state = seq->private;
2353 void *rc;
Chris Larson745e2032008-08-03 01:10:55 -07002354 loff_t idxpos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355
Chris Larson745e2032008-08-03 01:10:55 -07002356 rc = neigh_get_idx(seq, &idxpos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
Chris Larson745e2032008-08-03 01:10:55 -07002358 rc = pneigh_get_idx(seq, &idxpos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359
2360 return rc;
2361}
2362
2363void *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 -08002364 __acquires(tbl->lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365{
2366 struct neigh_seq_state *state = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367
2368 state->tbl = tbl;
2369 state->bucket = 0;
2370 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2371
2372 read_lock_bh(&tbl->lock);
2373
Chris Larson745e2032008-08-03 01:10:55 -07002374 return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375}
2376EXPORT_SYMBOL(neigh_seq_start);
2377
2378void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2379{
2380 struct neigh_seq_state *state;
2381 void *rc;
2382
2383 if (v == SEQ_START_TOKEN) {
Chris Larsonbff69732008-08-03 01:02:41 -07002384 rc = neigh_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385 goto out;
2386 }
2387
2388 state = seq->private;
2389 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2390 rc = neigh_get_next(seq, v, NULL);
2391 if (rc)
2392 goto out;
2393 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2394 rc = pneigh_get_first(seq);
2395 } else {
2396 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2397 rc = pneigh_get_next(seq, v, NULL);
2398 }
2399out:
2400 ++(*pos);
2401 return rc;
2402}
2403EXPORT_SYMBOL(neigh_seq_next);
2404
2405void neigh_seq_stop(struct seq_file *seq, void *v)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002406 __releases(tbl->lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407{
2408 struct neigh_seq_state *state = seq->private;
2409 struct neigh_table *tbl = state->tbl;
2410
2411 read_unlock_bh(&tbl->lock);
2412}
2413EXPORT_SYMBOL(neigh_seq_stop);
2414
2415/* statistics via seq_file */
2416
2417static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2418{
2419 struct proc_dir_entry *pde = seq->private;
2420 struct neigh_table *tbl = pde->data;
2421 int cpu;
2422
2423 if (*pos == 0)
2424 return SEQ_START_TOKEN;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002425
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
2427 if (!cpu_possible(cpu))
2428 continue;
2429 *pos = cpu+1;
2430 return per_cpu_ptr(tbl->stats, cpu);
2431 }
2432 return NULL;
2433}
2434
2435static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2436{
2437 struct proc_dir_entry *pde = seq->private;
2438 struct neigh_table *tbl = pde->data;
2439 int cpu;
2440
2441 for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
2442 if (!cpu_possible(cpu))
2443 continue;
2444 *pos = cpu+1;
2445 return per_cpu_ptr(tbl->stats, cpu);
2446 }
2447 return NULL;
2448}
2449
2450static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2451{
2452
2453}
2454
2455static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2456{
2457 struct proc_dir_entry *pde = seq->private;
2458 struct neigh_table *tbl = pde->data;
2459 struct neigh_statistics *st = v;
2460
2461 if (v == SEQ_START_TOKEN) {
Neil Horman9a6d2762008-07-16 20:50:49 -07002462 seq_printf(seq, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs unresolved_discards\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463 return 0;
2464 }
2465
2466 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
Neil Horman9a6d2762008-07-16 20:50:49 -07002467 "%08lx %08lx %08lx %08lx %08lx\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468 atomic_read(&tbl->entries),
2469
2470 st->allocs,
2471 st->destroys,
2472 st->hash_grows,
2473
2474 st->lookups,
2475 st->hits,
2476
2477 st->res_failed,
2478
2479 st->rcv_probes_mcast,
2480 st->rcv_probes_ucast,
2481
2482 st->periodic_gc_runs,
Neil Horman9a6d2762008-07-16 20:50:49 -07002483 st->forced_gc_runs,
2484 st->unres_discards
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 );
2486
2487 return 0;
2488}
2489
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002490static const struct seq_operations neigh_stat_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 .start = neigh_stat_seq_start,
2492 .next = neigh_stat_seq_next,
2493 .stop = neigh_stat_seq_stop,
2494 .show = neigh_stat_seq_show,
2495};
2496
2497static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2498{
2499 int ret = seq_open(file, &neigh_stat_seq_ops);
2500
2501 if (!ret) {
2502 struct seq_file *sf = file->private_data;
2503 sf->private = PDE(inode);
2504 }
2505 return ret;
2506};
2507
Arjan van de Ven9a321442007-02-12 00:55:35 -08002508static const struct file_operations neigh_stat_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509 .owner = THIS_MODULE,
2510 .open = neigh_stat_seq_open,
2511 .read = seq_read,
2512 .llseek = seq_lseek,
2513 .release = seq_release,
2514};
2515
2516#endif /* CONFIG_PROC_FS */
2517
Thomas Graf339bf982006-11-10 14:10:15 -08002518static inline size_t neigh_nlmsg_size(void)
2519{
2520 return NLMSG_ALIGN(sizeof(struct ndmsg))
2521 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2522 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2523 + nla_total_size(sizeof(struct nda_cacheinfo))
2524 + nla_total_size(4); /* NDA_PROBES */
2525}
2526
Thomas Grafb8673312006-08-15 00:33:14 -07002527static void __neigh_notify(struct neighbour *n, int type, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002529 struct net *net = dev_net(n->dev);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002530 struct sk_buff *skb;
Thomas Grafb8673312006-08-15 00:33:14 -07002531 int err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532
Thomas Graf339bf982006-11-10 14:10:15 -08002533 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
Thomas Graf8b8aec52006-08-07 17:56:37 -07002534 if (skb == NULL)
Thomas Grafb8673312006-08-15 00:33:14 -07002535 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536
Thomas Grafb8673312006-08-15 00:33:14 -07002537 err = neigh_fill_info(skb, n, 0, 0, type, flags);
Patrick McHardy26932562007-01-31 23:16:40 -08002538 if (err < 0) {
2539 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2540 WARN_ON(err == -EMSGSIZE);
2541 kfree_skb(skb);
2542 goto errout;
2543 }
Eric W. Biederman426b5302008-01-24 00:13:18 -08002544 err = rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
Thomas Grafb8673312006-08-15 00:33:14 -07002545errout:
2546 if (err < 0)
Eric W. Biederman426b5302008-01-24 00:13:18 -08002547 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
Thomas Grafb8673312006-08-15 00:33:14 -07002548}
2549
Thomas Grafd961db32007-08-08 23:12:56 -07002550#ifdef CONFIG_ARPD
Thomas Grafb8673312006-08-15 00:33:14 -07002551void neigh_app_ns(struct neighbour *n)
2552{
2553 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09002555EXPORT_SYMBOL(neigh_app_ns);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002556#endif /* CONFIG_ARPD */
2557
2558#ifdef CONFIG_SYSCTL
2559
2560static struct neigh_sysctl_table {
2561 struct ctl_table_header *sysctl_header;
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002562 struct ctl_table neigh_vars[__NET_NEIGH_MAX];
2563 char *dev_name;
Brian Haleyab32ea52006-09-22 14:15:41 -07002564} neigh_sysctl_template __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565 .neigh_vars = {
2566 {
2567 .ctl_name = NET_NEIGH_MCAST_SOLICIT,
2568 .procname = "mcast_solicit",
2569 .maxlen = sizeof(int),
2570 .mode = 0644,
2571 .proc_handler = &proc_dointvec,
2572 },
2573 {
2574 .ctl_name = NET_NEIGH_UCAST_SOLICIT,
2575 .procname = "ucast_solicit",
2576 .maxlen = sizeof(int),
2577 .mode = 0644,
2578 .proc_handler = &proc_dointvec,
2579 },
2580 {
2581 .ctl_name = NET_NEIGH_APP_SOLICIT,
2582 .procname = "app_solicit",
2583 .maxlen = sizeof(int),
2584 .mode = 0644,
2585 .proc_handler = &proc_dointvec,
2586 },
2587 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 .procname = "retrans_time",
2589 .maxlen = sizeof(int),
2590 .mode = 0644,
2591 .proc_handler = &proc_dointvec_userhz_jiffies,
2592 },
2593 {
2594 .ctl_name = NET_NEIGH_REACHABLE_TIME,
2595 .procname = "base_reachable_time",
2596 .maxlen = sizeof(int),
2597 .mode = 0644,
2598 .proc_handler = &proc_dointvec_jiffies,
2599 .strategy = &sysctl_jiffies,
2600 },
2601 {
2602 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME,
2603 .procname = "delay_first_probe_time",
2604 .maxlen = sizeof(int),
2605 .mode = 0644,
2606 .proc_handler = &proc_dointvec_jiffies,
2607 .strategy = &sysctl_jiffies,
2608 },
2609 {
2610 .ctl_name = NET_NEIGH_GC_STALE_TIME,
2611 .procname = "gc_stale_time",
2612 .maxlen = sizeof(int),
2613 .mode = 0644,
2614 .proc_handler = &proc_dointvec_jiffies,
2615 .strategy = &sysctl_jiffies,
2616 },
2617 {
2618 .ctl_name = NET_NEIGH_UNRES_QLEN,
2619 .procname = "unres_qlen",
2620 .maxlen = sizeof(int),
2621 .mode = 0644,
2622 .proc_handler = &proc_dointvec,
2623 },
2624 {
2625 .ctl_name = NET_NEIGH_PROXY_QLEN,
2626 .procname = "proxy_qlen",
2627 .maxlen = sizeof(int),
2628 .mode = 0644,
2629 .proc_handler = &proc_dointvec,
2630 },
2631 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 .procname = "anycast_delay",
2633 .maxlen = sizeof(int),
2634 .mode = 0644,
2635 .proc_handler = &proc_dointvec_userhz_jiffies,
2636 },
2637 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 .procname = "proxy_delay",
2639 .maxlen = sizeof(int),
2640 .mode = 0644,
2641 .proc_handler = &proc_dointvec_userhz_jiffies,
2642 },
2643 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644 .procname = "locktime",
2645 .maxlen = sizeof(int),
2646 .mode = 0644,
2647 .proc_handler = &proc_dointvec_userhz_jiffies,
2648 },
2649 {
Eric W. Biedermand12af672007-10-18 03:05:25 -07002650 .ctl_name = NET_NEIGH_RETRANS_TIME_MS,
2651 .procname = "retrans_time_ms",
2652 .maxlen = sizeof(int),
2653 .mode = 0644,
2654 .proc_handler = &proc_dointvec_ms_jiffies,
2655 .strategy = &sysctl_ms_jiffies,
2656 },
2657 {
2658 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS,
2659 .procname = "base_reachable_time_ms",
2660 .maxlen = sizeof(int),
2661 .mode = 0644,
2662 .proc_handler = &proc_dointvec_ms_jiffies,
2663 .strategy = &sysctl_ms_jiffies,
2664 },
2665 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002666 .ctl_name = NET_NEIGH_GC_INTERVAL,
2667 .procname = "gc_interval",
2668 .maxlen = sizeof(int),
2669 .mode = 0644,
2670 .proc_handler = &proc_dointvec_jiffies,
2671 .strategy = &sysctl_jiffies,
2672 },
2673 {
2674 .ctl_name = NET_NEIGH_GC_THRESH1,
2675 .procname = "gc_thresh1",
2676 .maxlen = sizeof(int),
2677 .mode = 0644,
2678 .proc_handler = &proc_dointvec,
2679 },
2680 {
2681 .ctl_name = NET_NEIGH_GC_THRESH2,
2682 .procname = "gc_thresh2",
2683 .maxlen = sizeof(int),
2684 .mode = 0644,
2685 .proc_handler = &proc_dointvec,
2686 },
2687 {
2688 .ctl_name = NET_NEIGH_GC_THRESH3,
2689 .procname = "gc_thresh3",
2690 .maxlen = sizeof(int),
2691 .mode = 0644,
2692 .proc_handler = &proc_dointvec,
2693 },
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002694 {},
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695 },
2696};
2697
2698int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002699 int p_id, int pdev_id, char *p_name,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 proc_handler *handler, ctl_handler *strategy)
2701{
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002702 struct neigh_sysctl_table *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 const char *dev_name_source = NULL;
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002704
2705#define NEIGH_CTL_PATH_ROOT 0
2706#define NEIGH_CTL_PATH_PROTO 1
2707#define NEIGH_CTL_PATH_NEIGH 2
2708#define NEIGH_CTL_PATH_DEV 3
2709
2710 struct ctl_path neigh_path[] = {
2711 { .procname = "net", .ctl_name = CTL_NET, },
2712 { .procname = "proto", .ctl_name = 0, },
2713 { .procname = "neigh", .ctl_name = 0, },
2714 { .procname = "default", .ctl_name = NET_PROTO_CONF_DEFAULT, },
2715 { },
2716 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002718 t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719 if (!t)
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002720 goto err;
2721
Linus Torvalds1da177e2005-04-16 15:20:36 -07002722 t->neigh_vars[0].data = &p->mcast_probes;
2723 t->neigh_vars[1].data = &p->ucast_probes;
2724 t->neigh_vars[2].data = &p->app_probes;
2725 t->neigh_vars[3].data = &p->retrans_time;
2726 t->neigh_vars[4].data = &p->base_reachable_time;
2727 t->neigh_vars[5].data = &p->delay_probe_time;
2728 t->neigh_vars[6].data = &p->gc_staletime;
2729 t->neigh_vars[7].data = &p->queue_len;
2730 t->neigh_vars[8].data = &p->proxy_qlen;
2731 t->neigh_vars[9].data = &p->anycast_delay;
2732 t->neigh_vars[10].data = &p->proxy_delay;
2733 t->neigh_vars[11].data = &p->locktime;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002734 t->neigh_vars[12].data = &p->retrans_time;
2735 t->neigh_vars[13].data = &p->base_reachable_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736
2737 if (dev) {
2738 dev_name_source = dev->name;
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002739 neigh_path[NEIGH_CTL_PATH_DEV].ctl_name = dev->ifindex;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002740 /* Terminate the table early */
2741 memset(&t->neigh_vars[14], 0, sizeof(t->neigh_vars[14]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742 } else {
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002743 dev_name_source = neigh_path[NEIGH_CTL_PATH_DEV].procname;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002744 t->neigh_vars[14].data = (int *)(p + 1);
2745 t->neigh_vars[15].data = (int *)(p + 1) + 1;
2746 t->neigh_vars[16].data = (int *)(p + 1) + 2;
2747 t->neigh_vars[17].data = (int *)(p + 1) + 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748 }
2749
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750
2751 if (handler || strategy) {
2752 /* RetransTime */
2753 t->neigh_vars[3].proc_handler = handler;
2754 t->neigh_vars[3].strategy = strategy;
2755 t->neigh_vars[3].extra1 = dev;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002756 if (!strategy)
2757 t->neigh_vars[3].ctl_name = CTL_UNNUMBERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758 /* ReachableTime */
2759 t->neigh_vars[4].proc_handler = handler;
2760 t->neigh_vars[4].strategy = strategy;
2761 t->neigh_vars[4].extra1 = dev;
Eric W. Biedermand12af672007-10-18 03:05:25 -07002762 if (!strategy)
2763 t->neigh_vars[4].ctl_name = CTL_UNNUMBERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764 /* RetransTime (in milliseconds)*/
Eric W. Biedermand12af672007-10-18 03:05:25 -07002765 t->neigh_vars[12].proc_handler = handler;
2766 t->neigh_vars[12].strategy = strategy;
2767 t->neigh_vars[12].extra1 = dev;
2768 if (!strategy)
2769 t->neigh_vars[12].ctl_name = CTL_UNNUMBERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 /* ReachableTime (in milliseconds) */
Eric W. Biedermand12af672007-10-18 03:05:25 -07002771 t->neigh_vars[13].proc_handler = handler;
2772 t->neigh_vars[13].strategy = strategy;
2773 t->neigh_vars[13].extra1 = dev;
2774 if (!strategy)
2775 t->neigh_vars[13].ctl_name = CTL_UNNUMBERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 }
2777
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002778 t->dev_name = kstrdup(dev_name_source, GFP_KERNEL);
2779 if (!t->dev_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002782 neigh_path[NEIGH_CTL_PATH_DEV].procname = t->dev_name;
2783 neigh_path[NEIGH_CTL_PATH_NEIGH].ctl_name = pdev_id;
2784 neigh_path[NEIGH_CTL_PATH_PROTO].procname = p_name;
2785 neigh_path[NEIGH_CTL_PATH_PROTO].ctl_name = p_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786
Denis V. Lunev4ab438f2008-02-28 20:48:01 -08002787 t->sysctl_header =
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +09002788 register_net_sysctl_table(neigh_parms_net(p), neigh_path, t->neigh_vars);
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002789 if (!t->sysctl_header)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790 goto free_procname;
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002791
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792 p->sysctl_table = t;
2793 return 0;
2794
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002795free_procname:
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002796 kfree(t->dev_name);
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002797free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798 kfree(t);
Pavel Emelyanov3c607bb2007-12-02 00:06:34 +11002799err:
2800 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09002802EXPORT_SYMBOL(neigh_sysctl_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803
2804void neigh_sysctl_unregister(struct neigh_parms *p)
2805{
2806 if (p->sysctl_table) {
2807 struct neigh_sysctl_table *t = p->sysctl_table;
2808 p->sysctl_table = NULL;
2809 unregister_sysctl_table(t->sysctl_header);
Pavel Emelyanovc3bac5a2007-12-02 00:08:16 +11002810 kfree(t->dev_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 kfree(t);
2812 }
2813}
YOSHIFUJI Hideaki0a204502008-03-24 18:39:10 +09002814EXPORT_SYMBOL(neigh_sysctl_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815
2816#endif /* CONFIG_SYSCTL */
2817
Thomas Grafc8822a42007-03-22 11:50:06 -07002818static int __init neigh_init(void)
2819{
2820 rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL);
2821 rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL);
2822 rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info);
2823
2824 rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info);
2825 rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL);
2826
2827 return 0;
2828}
2829
2830subsys_initcall(neigh_init);
2831