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