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