23c0a10c0c379463258d0a86bf2a4bb0139d84fa
[linux-3.10.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 = skb_copy(skb, GFP_ATOMIC);
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->dev && p->dev->ifindex == ifindex && p->net == net) ||
1288                     (!p->dev && !ifindex))
1289                         return p;
1290         }
1291
1292         return NULL;
1293 }
1294
1295 struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1296                                       struct neigh_table *tbl)
1297 {
1298         struct neigh_parms *p, *ref;
1299         struct net *net;
1300
1301         net = dev->nd_net;
1302         ref = lookup_neigh_params(tbl, net, 0);
1303         if (!ref)
1304                 return NULL;
1305
1306         p = kmemdup(ref, sizeof(*p), GFP_KERNEL);
1307         if (p) {
1308                 p->tbl            = tbl;
1309                 atomic_set(&p->refcnt, 1);
1310                 INIT_RCU_HEAD(&p->rcu_head);
1311                 p->reachable_time =
1312                                 neigh_rand_reach_time(p->base_reachable_time);
1313
1314                 if (dev->neigh_setup && dev->neigh_setup(dev, p)) {
1315                         kfree(p);
1316                         return NULL;
1317                 }
1318
1319                 dev_hold(dev);
1320                 p->dev = dev;
1321                 p->net = hold_net(net);
1322                 p->sysctl_table = NULL;
1323                 write_lock_bh(&tbl->lock);
1324                 p->next         = tbl->parms.next;
1325                 tbl->parms.next = p;
1326                 write_unlock_bh(&tbl->lock);
1327         }
1328         return p;
1329 }
1330
1331 static void neigh_rcu_free_parms(struct rcu_head *head)
1332 {
1333         struct neigh_parms *parms =
1334                 container_of(head, struct neigh_parms, rcu_head);
1335
1336         neigh_parms_put(parms);
1337 }
1338
1339 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1340 {
1341         struct neigh_parms **p;
1342
1343         if (!parms || parms == &tbl->parms)
1344                 return;
1345         write_lock_bh(&tbl->lock);
1346         for (p = &tbl->parms.next; *p; p = &(*p)->next) {
1347                 if (*p == parms) {
1348                         *p = parms->next;
1349                         parms->dead = 1;
1350                         write_unlock_bh(&tbl->lock);
1351                         if (parms->dev)
1352                                 dev_put(parms->dev);
1353                         call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1354                         return;
1355                 }
1356         }
1357         write_unlock_bh(&tbl->lock);
1358         NEIGH_PRINTK1("neigh_parms_release: not found\n");
1359 }
1360
1361 static void neigh_parms_destroy(struct neigh_parms *parms)
1362 {
1363         release_net(parms->net);
1364         kfree(parms);
1365 }
1366
1367 static struct lock_class_key neigh_table_proxy_queue_class;
1368
1369 void neigh_table_init_no_netlink(struct neigh_table *tbl)
1370 {
1371         unsigned long now = jiffies;
1372         unsigned long phsize;
1373
1374         tbl->parms.net = &init_net;
1375         atomic_set(&tbl->parms.refcnt, 1);
1376         INIT_RCU_HEAD(&tbl->parms.rcu_head);
1377         tbl->parms.reachable_time =
1378                           neigh_rand_reach_time(tbl->parms.base_reachable_time);
1379
1380         if (!tbl->kmem_cachep)
1381                 tbl->kmem_cachep =
1382                         kmem_cache_create(tbl->id, tbl->entry_size, 0,
1383                                           SLAB_HWCACHE_ALIGN|SLAB_PANIC,
1384                                           NULL);
1385         tbl->stats = alloc_percpu(struct neigh_statistics);
1386         if (!tbl->stats)
1387                 panic("cannot create neighbour cache statistics");
1388
1389 #ifdef CONFIG_PROC_FS
1390         tbl->pde = proc_create(tbl->id, 0, init_net.proc_net_stat,
1391                                &neigh_stat_seq_fops);
1392         if (!tbl->pde)
1393                 panic("cannot create neighbour proc dir entry");
1394         tbl->pde->data = tbl;
1395 #endif
1396
1397         tbl->hash_mask = 1;
1398         tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1);
1399
1400         phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
1401         tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
1402
1403         if (!tbl->hash_buckets || !tbl->phash_buckets)
1404                 panic("cannot allocate neighbour cache hashes");
1405
1406         get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
1407
1408         rwlock_init(&tbl->lock);
1409         setup_timer(&tbl->gc_timer, neigh_periodic_timer, (unsigned long)tbl);
1410         tbl->gc_timer.expires  = now + 1;
1411         add_timer(&tbl->gc_timer);
1412
1413         setup_timer(&tbl->proxy_timer, neigh_proxy_process, (unsigned long)tbl);
1414         skb_queue_head_init_class(&tbl->proxy_queue,
1415                         &neigh_table_proxy_queue_class);
1416
1417         tbl->last_flush = now;
1418         tbl->last_rand  = now + tbl->parms.reachable_time * 20;
1419 }
1420
1421 void neigh_table_init(struct neigh_table *tbl)
1422 {
1423         struct neigh_table *tmp;
1424
1425         neigh_table_init_no_netlink(tbl);
1426         write_lock(&neigh_tbl_lock);
1427         for (tmp = neigh_tables; tmp; tmp = tmp->next) {
1428                 if (tmp->family == tbl->family)
1429                         break;
1430         }
1431         tbl->next       = neigh_tables;
1432         neigh_tables    = tbl;
1433         write_unlock(&neigh_tbl_lock);
1434
1435         if (unlikely(tmp)) {
1436                 printk(KERN_ERR "NEIGH: Registering multiple tables for "
1437                        "family %d\n", tbl->family);
1438                 dump_stack();
1439         }
1440 }
1441
1442 int neigh_table_clear(struct neigh_table *tbl)
1443 {
1444         struct neigh_table **tp;
1445
1446         /* It is not clean... Fix it to unload IPv6 module safely */
1447         del_timer_sync(&tbl->gc_timer);
1448         del_timer_sync(&tbl->proxy_timer);
1449         pneigh_queue_purge(&tbl->proxy_queue);
1450         neigh_ifdown(tbl, NULL);
1451         if (atomic_read(&tbl->entries))
1452                 printk(KERN_CRIT "neighbour leakage\n");
1453         write_lock(&neigh_tbl_lock);
1454         for (tp = &neigh_tables; *tp; tp = &(*tp)->next) {
1455                 if (*tp == tbl) {
1456                         *tp = tbl->next;
1457                         break;
1458                 }
1459         }
1460         write_unlock(&neigh_tbl_lock);
1461
1462         neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1);
1463         tbl->hash_buckets = NULL;
1464
1465         kfree(tbl->phash_buckets);
1466         tbl->phash_buckets = NULL;
1467
1468         remove_proc_entry(tbl->id, init_net.proc_net_stat);
1469
1470         free_percpu(tbl->stats);
1471         tbl->stats = NULL;
1472
1473         kmem_cache_destroy(tbl->kmem_cachep);
1474         tbl->kmem_cachep = NULL;
1475
1476         return 0;
1477 }
1478
1479 static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1480 {
1481         struct net *net = skb->sk->sk_net;
1482         struct ndmsg *ndm;
1483         struct nlattr *dst_attr;
1484         struct neigh_table *tbl;
1485         struct net_device *dev = NULL;
1486         int err = -EINVAL;
1487
1488         if (nlmsg_len(nlh) < sizeof(*ndm))
1489                 goto out;
1490
1491         dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1492         if (dst_attr == NULL)
1493                 goto out;
1494
1495         ndm = nlmsg_data(nlh);
1496         if (ndm->ndm_ifindex) {
1497                 dev = dev_get_by_index(net, ndm->ndm_ifindex);
1498                 if (dev == NULL) {
1499                         err = -ENODEV;
1500                         goto out;
1501                 }
1502         }
1503
1504         read_lock(&neigh_tbl_lock);
1505         for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1506                 struct neighbour *neigh;
1507
1508                 if (tbl->family != ndm->ndm_family)
1509                         continue;
1510                 read_unlock(&neigh_tbl_lock);
1511
1512                 if (nla_len(dst_attr) < tbl->key_len)
1513                         goto out_dev_put;
1514
1515                 if (ndm->ndm_flags & NTF_PROXY) {
1516                         err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
1517                         goto out_dev_put;
1518                 }
1519
1520                 if (dev == NULL)
1521                         goto out_dev_put;
1522
1523                 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1524                 if (neigh == NULL) {
1525                         err = -ENOENT;
1526                         goto out_dev_put;
1527                 }
1528
1529                 err = neigh_update(neigh, NULL, NUD_FAILED,
1530                                    NEIGH_UPDATE_F_OVERRIDE |
1531                                    NEIGH_UPDATE_F_ADMIN);
1532                 neigh_release(neigh);
1533                 goto out_dev_put;
1534         }
1535         read_unlock(&neigh_tbl_lock);
1536         err = -EAFNOSUPPORT;
1537
1538 out_dev_put:
1539         if (dev)
1540                 dev_put(dev);
1541 out:
1542         return err;
1543 }
1544
1545 static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1546 {
1547         struct net *net = skb->sk->sk_net;
1548         struct ndmsg *ndm;
1549         struct nlattr *tb[NDA_MAX+1];
1550         struct neigh_table *tbl;
1551         struct net_device *dev = NULL;
1552         int err;
1553
1554         err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
1555         if (err < 0)
1556                 goto out;
1557
1558         err = -EINVAL;
1559         if (tb[NDA_DST] == NULL)
1560                 goto out;
1561
1562         ndm = nlmsg_data(nlh);
1563         if (ndm->ndm_ifindex) {
1564                 dev = dev_get_by_index(net, ndm->ndm_ifindex);
1565                 if (dev == NULL) {
1566                         err = -ENODEV;
1567                         goto out;
1568                 }
1569
1570                 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
1571                         goto out_dev_put;
1572         }
1573
1574         read_lock(&neigh_tbl_lock);
1575         for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1576                 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
1577                 struct neighbour *neigh;
1578                 void *dst, *lladdr;
1579
1580                 if (tbl->family != ndm->ndm_family)
1581                         continue;
1582                 read_unlock(&neigh_tbl_lock);
1583
1584                 if (nla_len(tb[NDA_DST]) < tbl->key_len)
1585                         goto out_dev_put;
1586                 dst = nla_data(tb[NDA_DST]);
1587                 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
1588
1589                 if (ndm->ndm_flags & NTF_PROXY) {
1590                         struct pneigh_entry *pn;
1591
1592                         err = -ENOBUFS;
1593                         pn = pneigh_lookup(tbl, net, dst, dev, 1);
1594                         if (pn) {
1595                                 pn->flags = ndm->ndm_flags;
1596                                 err = 0;
1597                         }
1598                         goto out_dev_put;
1599                 }
1600
1601                 if (dev == NULL)
1602                         goto out_dev_put;
1603
1604                 neigh = neigh_lookup(tbl, dst, dev);
1605                 if (neigh == NULL) {
1606                         if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1607                                 err = -ENOENT;
1608                                 goto out_dev_put;
1609                         }
1610
1611                         neigh = __neigh_lookup_errno(tbl, dst, dev);
1612                         if (IS_ERR(neigh)) {
1613                                 err = PTR_ERR(neigh);
1614                                 goto out_dev_put;
1615                         }
1616                 } else {
1617                         if (nlh->nlmsg_flags & NLM_F_EXCL) {
1618                                 err = -EEXIST;
1619                                 neigh_release(neigh);
1620                                 goto out_dev_put;
1621                         }
1622
1623                         if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
1624                                 flags &= ~NEIGH_UPDATE_F_OVERRIDE;
1625                 }
1626
1627                 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
1628                 neigh_release(neigh);
1629                 goto out_dev_put;
1630         }
1631
1632         read_unlock(&neigh_tbl_lock);
1633         err = -EAFNOSUPPORT;
1634
1635 out_dev_put:
1636         if (dev)
1637                 dev_put(dev);
1638 out:
1639         return err;
1640 }
1641
1642 static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1643 {
1644         struct nlattr *nest;
1645
1646         nest = nla_nest_start(skb, NDTA_PARMS);
1647         if (nest == NULL)
1648                 return -ENOBUFS;
1649
1650         if (parms->dev)
1651                 NLA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex);
1652
1653         NLA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt));
1654         NLA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len);
1655         NLA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen);
1656         NLA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes);
1657         NLA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes);
1658         NLA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes);
1659         NLA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time);
1660         NLA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME,
1661                       parms->base_reachable_time);
1662         NLA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime);
1663         NLA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time);
1664         NLA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time);
1665         NLA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay);
1666         NLA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay);
1667         NLA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime);
1668
1669         return nla_nest_end(skb, nest);
1670
1671 nla_put_failure:
1672         return nla_nest_cancel(skb, nest);
1673 }
1674
1675 static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
1676                               u32 pid, u32 seq, int type, int flags)
1677 {
1678         struct nlmsghdr *nlh;
1679         struct ndtmsg *ndtmsg;
1680
1681         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1682         if (nlh == NULL)
1683                 return -EMSGSIZE;
1684
1685         ndtmsg = nlmsg_data(nlh);
1686
1687         read_lock_bh(&tbl->lock);
1688         ndtmsg->ndtm_family = tbl->family;
1689         ndtmsg->ndtm_pad1   = 0;
1690         ndtmsg->ndtm_pad2   = 0;
1691
1692         NLA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1693         NLA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval);
1694         NLA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1);
1695         NLA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2);
1696         NLA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3);
1697
1698         {
1699                 unsigned long now = jiffies;
1700                 unsigned int flush_delta = now - tbl->last_flush;
1701                 unsigned int rand_delta = now - tbl->last_rand;
1702
1703                 struct ndt_config ndc = {
1704                         .ndtc_key_len           = tbl->key_len,
1705                         .ndtc_entry_size        = tbl->entry_size,
1706                         .ndtc_entries           = atomic_read(&tbl->entries),
1707                         .ndtc_last_flush        = jiffies_to_msecs(flush_delta),
1708                         .ndtc_last_rand         = jiffies_to_msecs(rand_delta),
1709                         .ndtc_hash_rnd          = tbl->hash_rnd,
1710                         .ndtc_hash_mask         = tbl->hash_mask,
1711                         .ndtc_hash_chain_gc     = tbl->hash_chain_gc,
1712                         .ndtc_proxy_qlen        = tbl->proxy_queue.qlen,
1713                 };
1714
1715                 NLA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc);
1716         }
1717
1718         {
1719                 int cpu;
1720                 struct ndt_stats ndst;
1721
1722                 memset(&ndst, 0, sizeof(ndst));
1723
1724                 for_each_possible_cpu(cpu) {
1725                         struct neigh_statistics *st;
1726
1727                         st = per_cpu_ptr(tbl->stats, cpu);
1728                         ndst.ndts_allocs                += st->allocs;
1729                         ndst.ndts_destroys              += st->destroys;
1730                         ndst.ndts_hash_grows            += st->hash_grows;
1731                         ndst.ndts_res_failed            += st->res_failed;
1732                         ndst.ndts_lookups               += st->lookups;
1733                         ndst.ndts_hits                  += st->hits;
1734                         ndst.ndts_rcv_probes_mcast      += st->rcv_probes_mcast;
1735                         ndst.ndts_rcv_probes_ucast      += st->rcv_probes_ucast;
1736                         ndst.ndts_periodic_gc_runs      += st->periodic_gc_runs;
1737                         ndst.ndts_forced_gc_runs        += st->forced_gc_runs;
1738                 }
1739
1740                 NLA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst);
1741         }
1742
1743         BUG_ON(tbl->parms.dev);
1744         if (neightbl_fill_parms(skb, &tbl->parms) < 0)
1745                 goto nla_put_failure;
1746
1747         read_unlock_bh(&tbl->lock);
1748         return nlmsg_end(skb, nlh);
1749
1750 nla_put_failure:
1751         read_unlock_bh(&tbl->lock);
1752         nlmsg_cancel(skb, nlh);
1753         return -EMSGSIZE;
1754 }
1755
1756 static int neightbl_fill_param_info(struct sk_buff *skb,
1757                                     struct neigh_table *tbl,
1758                                     struct neigh_parms *parms,
1759                                     u32 pid, u32 seq, int type,
1760                                     unsigned int flags)
1761 {
1762         struct ndtmsg *ndtmsg;
1763         struct nlmsghdr *nlh;
1764
1765         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1766         if (nlh == NULL)
1767                 return -EMSGSIZE;
1768
1769         ndtmsg = nlmsg_data(nlh);
1770
1771         read_lock_bh(&tbl->lock);
1772         ndtmsg->ndtm_family = tbl->family;
1773         ndtmsg->ndtm_pad1   = 0;
1774         ndtmsg->ndtm_pad2   = 0;
1775
1776         if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
1777             neightbl_fill_parms(skb, parms) < 0)
1778                 goto errout;
1779
1780         read_unlock_bh(&tbl->lock);
1781         return nlmsg_end(skb, nlh);
1782 errout:
1783         read_unlock_bh(&tbl->lock);
1784         nlmsg_cancel(skb, nlh);
1785         return -EMSGSIZE;
1786 }
1787
1788 static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
1789         [NDTA_NAME]             = { .type = NLA_STRING },
1790         [NDTA_THRESH1]          = { .type = NLA_U32 },
1791         [NDTA_THRESH2]          = { .type = NLA_U32 },
1792         [NDTA_THRESH3]          = { .type = NLA_U32 },
1793         [NDTA_GC_INTERVAL]      = { .type = NLA_U64 },
1794         [NDTA_PARMS]            = { .type = NLA_NESTED },
1795 };
1796
1797 static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
1798         [NDTPA_IFINDEX]                 = { .type = NLA_U32 },
1799         [NDTPA_QUEUE_LEN]               = { .type = NLA_U32 },
1800         [NDTPA_PROXY_QLEN]              = { .type = NLA_U32 },
1801         [NDTPA_APP_PROBES]              = { .type = NLA_U32 },
1802         [NDTPA_UCAST_PROBES]            = { .type = NLA_U32 },
1803         [NDTPA_MCAST_PROBES]            = { .type = NLA_U32 },
1804         [NDTPA_BASE_REACHABLE_TIME]     = { .type = NLA_U64 },
1805         [NDTPA_GC_STALETIME]            = { .type = NLA_U64 },
1806         [NDTPA_DELAY_PROBE_TIME]        = { .type = NLA_U64 },
1807         [NDTPA_RETRANS_TIME]            = { .type = NLA_U64 },
1808         [NDTPA_ANYCAST_DELAY]           = { .type = NLA_U64 },
1809         [NDTPA_PROXY_DELAY]             = { .type = NLA_U64 },
1810         [NDTPA_LOCKTIME]                = { .type = NLA_U64 },
1811 };
1812
1813 static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1814 {
1815         struct net *net = skb->sk->sk_net;
1816         struct neigh_table *tbl;
1817         struct ndtmsg *ndtmsg;
1818         struct nlattr *tb[NDTA_MAX+1];
1819         int err;
1820
1821         err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
1822                           nl_neightbl_policy);
1823         if (err < 0)
1824                 goto errout;
1825
1826         if (tb[NDTA_NAME] == NULL) {
1827                 err = -EINVAL;
1828                 goto errout;
1829         }
1830
1831         ndtmsg = nlmsg_data(nlh);
1832         read_lock(&neigh_tbl_lock);
1833         for (tbl = neigh_tables; tbl; tbl = tbl->next) {
1834                 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1835                         continue;
1836
1837                 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0)
1838                         break;
1839         }
1840
1841         if (tbl == NULL) {
1842                 err = -ENOENT;
1843                 goto errout_locked;
1844         }
1845
1846         /*
1847          * We acquire tbl->lock to be nice to the periodic timers and
1848          * make sure they always see a consistent set of values.
1849          */
1850         write_lock_bh(&tbl->lock);
1851
1852         if (tb[NDTA_PARMS]) {
1853                 struct nlattr *tbp[NDTPA_MAX+1];
1854                 struct neigh_parms *p;
1855                 int i, ifindex = 0;
1856
1857                 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
1858                                        nl_ntbl_parm_policy);
1859                 if (err < 0)
1860                         goto errout_tbl_lock;
1861
1862                 if (tbp[NDTPA_IFINDEX])
1863                         ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
1864
1865                 p = lookup_neigh_params(tbl, net, ifindex);
1866                 if (p == NULL) {
1867                         err = -ENOENT;
1868                         goto errout_tbl_lock;
1869                 }
1870
1871                 for (i = 1; i <= NDTPA_MAX; i++) {
1872                         if (tbp[i] == NULL)
1873                                 continue;
1874
1875                         switch (i) {
1876                         case NDTPA_QUEUE_LEN:
1877                                 p->queue_len = nla_get_u32(tbp[i]);
1878                                 break;
1879                         case NDTPA_PROXY_QLEN:
1880                                 p->proxy_qlen = nla_get_u32(tbp[i]);
1881                                 break;
1882                         case NDTPA_APP_PROBES:
1883                                 p->app_probes = nla_get_u32(tbp[i]);
1884                                 break;
1885                         case NDTPA_UCAST_PROBES:
1886                                 p->ucast_probes = nla_get_u32(tbp[i]);
1887                                 break;
1888                         case NDTPA_MCAST_PROBES:
1889                                 p->mcast_probes = nla_get_u32(tbp[i]);
1890                                 break;
1891                         case NDTPA_BASE_REACHABLE_TIME:
1892                                 p->base_reachable_time = nla_get_msecs(tbp[i]);
1893                                 break;
1894                         case NDTPA_GC_STALETIME:
1895                                 p->gc_staletime = nla_get_msecs(tbp[i]);
1896                                 break;
1897                         case NDTPA_DELAY_PROBE_TIME:
1898                                 p->delay_probe_time = nla_get_msecs(tbp[i]);
1899                                 break;
1900                         case NDTPA_RETRANS_TIME:
1901                                 p->retrans_time = nla_get_msecs(tbp[i]);
1902                                 break;
1903                         case NDTPA_ANYCAST_DELAY:
1904                                 p->anycast_delay = nla_get_msecs(tbp[i]);
1905                                 break;
1906                         case NDTPA_PROXY_DELAY:
1907                                 p->proxy_delay = nla_get_msecs(tbp[i]);
1908                                 break;
1909                         case NDTPA_LOCKTIME:
1910                                 p->locktime = nla_get_msecs(tbp[i]);
1911                                 break;
1912                         }
1913                 }
1914         }
1915
1916         if (tb[NDTA_THRESH1])
1917                 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
1918
1919         if (tb[NDTA_THRESH2])
1920                 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
1921
1922         if (tb[NDTA_THRESH3])
1923                 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
1924
1925         if (tb[NDTA_GC_INTERVAL])
1926                 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
1927
1928         err = 0;
1929
1930 errout_tbl_lock:
1931         write_unlock_bh(&tbl->lock);
1932 errout_locked:
1933         read_unlock(&neigh_tbl_lock);
1934 errout:
1935         return err;
1936 }
1937
1938 static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
1939 {
1940         struct net *net = skb->sk->sk_net;
1941         int family, tidx, nidx = 0;
1942         int tbl_skip = cb->args[0];
1943         int neigh_skip = cb->args[1];
1944         struct neigh_table *tbl;
1945
1946         family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
1947
1948         read_lock(&neigh_tbl_lock);
1949         for (tbl = neigh_tables, tidx = 0; tbl; tbl = tbl->next, tidx++) {
1950                 struct neigh_parms *p;
1951
1952                 if (tidx < tbl_skip || (family && tbl->family != family))
1953                         continue;
1954
1955                 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).pid,
1956                                        cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
1957                                        NLM_F_MULTI) <= 0)
1958                         break;
1959
1960                 for (nidx = 0, p = tbl->parms.next; p; p = p->next) {
1961                         if (net != p->net)
1962                                 continue;
1963
1964                         if (nidx++ < neigh_skip)
1965                                 continue;
1966
1967                         if (neightbl_fill_param_info(skb, tbl, p,
1968                                                      NETLINK_CB(cb->skb).pid,
1969                                                      cb->nlh->nlmsg_seq,
1970                                                      RTM_NEWNEIGHTBL,
1971                                                      NLM_F_MULTI) <= 0)
1972                                 goto out;
1973                 }
1974
1975                 neigh_skip = 0;
1976         }
1977 out:
1978         read_unlock(&neigh_tbl_lock);
1979         cb->args[0] = tidx;
1980         cb->args[1] = nidx;
1981
1982         return skb->len;
1983 }
1984
1985 static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
1986                            u32 pid, u32 seq, int type, unsigned int flags)
1987 {
1988         unsigned long now = jiffies;
1989         struct nda_cacheinfo ci;
1990         struct nlmsghdr *nlh;
1991         struct ndmsg *ndm;
1992
1993         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
1994         if (nlh == NULL)
1995                 return -EMSGSIZE;
1996
1997         ndm = nlmsg_data(nlh);
1998         ndm->ndm_family  = neigh->ops->family;
1999         ndm->ndm_pad1    = 0;
2000         ndm->ndm_pad2    = 0;
2001         ndm->ndm_flags   = neigh->flags;
2002         ndm->ndm_type    = neigh->type;
2003         ndm->ndm_ifindex = neigh->dev->ifindex;
2004
2005         NLA_PUT(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key);
2006
2007         read_lock_bh(&neigh->lock);
2008         ndm->ndm_state   = neigh->nud_state;
2009         if ((neigh->nud_state & NUD_VALID) &&
2010             nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, neigh->ha) < 0) {
2011                 read_unlock_bh(&neigh->lock);
2012                 goto nla_put_failure;
2013         }
2014
2015         ci.ndm_used      = now - neigh->used;
2016         ci.ndm_confirmed = now - neigh->confirmed;
2017         ci.ndm_updated   = now - neigh->updated;
2018         ci.ndm_refcnt    = atomic_read(&neigh->refcnt) - 1;
2019         read_unlock_bh(&neigh->lock);
2020
2021         NLA_PUT_U32(skb, NDA_PROBES, atomic_read(&neigh->probes));
2022         NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
2023
2024         return nlmsg_end(skb, nlh);
2025
2026 nla_put_failure:
2027         nlmsg_cancel(skb, nlh);
2028         return -EMSGSIZE;
2029 }
2030
2031 static void neigh_update_notify(struct neighbour *neigh)
2032 {
2033         call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2034         __neigh_notify(neigh, RTM_NEWNEIGH, 0);
2035 }
2036
2037 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2038                             struct netlink_callback *cb)
2039 {
2040         struct net * net = skb->sk->sk_net;
2041         struct neighbour *n;
2042         int rc, h, s_h = cb->args[1];
2043         int idx, s_idx = idx = cb->args[2];
2044
2045         read_lock_bh(&tbl->lock);
2046         for (h = 0; h <= tbl->hash_mask; h++) {
2047                 if (h < s_h)
2048                         continue;
2049                 if (h > s_h)
2050                         s_idx = 0;
2051                 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next) {
2052                         int lidx;
2053                         if (n->dev->nd_net != net)
2054                                 continue;
2055                         lidx = idx++;
2056                         if (lidx < s_idx)
2057                                 continue;
2058                         if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid,
2059                                             cb->nlh->nlmsg_seq,
2060                                             RTM_NEWNEIGH,
2061                                             NLM_F_MULTI) <= 0) {
2062                                 read_unlock_bh(&tbl->lock);
2063                                 rc = -1;
2064                                 goto out;
2065                         }
2066                 }
2067         }
2068         read_unlock_bh(&tbl->lock);
2069         rc = skb->len;
2070 out:
2071         cb->args[1] = h;
2072         cb->args[2] = idx;
2073         return rc;
2074 }
2075
2076 static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
2077 {
2078         struct neigh_table *tbl;
2079         int t, family, s_t;
2080
2081         read_lock(&neigh_tbl_lock);
2082         family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
2083         s_t = cb->args[0];
2084
2085         for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
2086                 if (t < s_t || (family && tbl->family != family))
2087                         continue;
2088                 if (t > s_t)
2089                         memset(&cb->args[1], 0, sizeof(cb->args) -
2090                                                 sizeof(cb->args[0]));
2091                 if (neigh_dump_table(tbl, skb, cb) < 0)
2092                         break;
2093         }
2094         read_unlock(&neigh_tbl_lock);
2095
2096         cb->args[0] = t;
2097         return skb->len;
2098 }
2099
2100 void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2101 {
2102         int chain;
2103
2104         read_lock_bh(&tbl->lock);
2105         for (chain = 0; chain <= tbl->hash_mask; chain++) {
2106                 struct neighbour *n;
2107
2108                 for (n = tbl->hash_buckets[chain]; n; n = n->next)
2109                         cb(n, cookie);
2110         }
2111         read_unlock_bh(&tbl->lock);
2112 }
2113 EXPORT_SYMBOL(neigh_for_each);
2114
2115 /* The tbl->lock must be held as a writer and BH disabled. */
2116 void __neigh_for_each_release(struct neigh_table *tbl,
2117                               int (*cb)(struct neighbour *))
2118 {
2119         int chain;
2120
2121         for (chain = 0; chain <= tbl->hash_mask; chain++) {
2122                 struct neighbour *n, **np;
2123
2124                 np = &tbl->hash_buckets[chain];
2125                 while ((n = *np) != NULL) {
2126                         int release;
2127
2128                         write_lock(&n->lock);
2129                         release = cb(n);
2130                         if (release) {
2131                                 *np = n->next;
2132                                 n->dead = 1;
2133                         } else
2134                                 np = &n->next;
2135                         write_unlock(&n->lock);
2136                         if (release)
2137                                 neigh_cleanup_and_release(n);
2138                 }
2139         }
2140 }
2141 EXPORT_SYMBOL(__neigh_for_each_release);
2142
2143 #ifdef CONFIG_PROC_FS
2144
2145 static struct neighbour *neigh_get_first(struct seq_file *seq)
2146 {
2147         struct neigh_seq_state *state = seq->private;
2148         struct net *net = state->p.net;
2149         struct neigh_table *tbl = state->tbl;
2150         struct neighbour *n = NULL;
2151         int bucket = state->bucket;
2152
2153         state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2154         for (bucket = 0; bucket <= tbl->hash_mask; bucket++) {
2155                 n = tbl->hash_buckets[bucket];
2156
2157                 while (n) {
2158                         if (n->dev->nd_net != net)
2159                                 goto next;
2160                         if (state->neigh_sub_iter) {
2161                                 loff_t fakep = 0;
2162                                 void *v;
2163
2164                                 v = state->neigh_sub_iter(state, n, &fakep);
2165                                 if (!v)
2166                                         goto next;
2167                         }
2168                         if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2169                                 break;
2170                         if (n->nud_state & ~NUD_NOARP)
2171                                 break;
2172                 next:
2173                         n = n->next;
2174                 }
2175
2176                 if (n)
2177                         break;
2178         }
2179         state->bucket = bucket;
2180
2181         return n;
2182 }
2183
2184 static struct neighbour *neigh_get_next(struct seq_file *seq,
2185                                         struct neighbour *n,
2186                                         loff_t *pos)
2187 {
2188         struct neigh_seq_state *state = seq->private;
2189         struct net *net = state->p.net;
2190         struct neigh_table *tbl = state->tbl;
2191
2192         if (state->neigh_sub_iter) {
2193                 void *v = state->neigh_sub_iter(state, n, pos);
2194                 if (v)
2195                         return n;
2196         }
2197         n = n->next;
2198
2199         while (1) {
2200                 while (n) {
2201                         if (n->dev->nd_net != net)
2202                                 goto next;
2203                         if (state->neigh_sub_iter) {
2204                                 void *v = state->neigh_sub_iter(state, n, pos);
2205                                 if (v)
2206                                         return n;
2207                                 goto next;
2208                         }
2209                         if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2210                                 break;
2211
2212                         if (n->nud_state & ~NUD_NOARP)
2213                                 break;
2214                 next:
2215                         n = n->next;
2216                 }
2217
2218                 if (n)
2219                         break;
2220
2221                 if (++state->bucket > tbl->hash_mask)
2222                         break;
2223
2224                 n = tbl->hash_buckets[state->bucket];
2225         }
2226
2227         if (n && pos)
2228                 --(*pos);
2229         return n;
2230 }
2231
2232 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2233 {
2234         struct neighbour *n = neigh_get_first(seq);
2235
2236         if (n) {
2237                 while (*pos) {
2238                         n = neigh_get_next(seq, n, pos);
2239                         if (!n)
2240                                 break;
2241                 }
2242         }
2243         return *pos ? NULL : n;
2244 }
2245
2246 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2247 {
2248         struct neigh_seq_state *state = seq->private;
2249         struct net * net = state->p.net;
2250         struct neigh_table *tbl = state->tbl;
2251         struct pneigh_entry *pn = NULL;
2252         int bucket = state->bucket;
2253
2254         state->flags |= NEIGH_SEQ_IS_PNEIGH;
2255         for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2256                 pn = tbl->phash_buckets[bucket];
2257                 while (pn && (pn->net != net))
2258                         pn = pn->next;
2259                 if (pn)
2260                         break;
2261         }
2262         state->bucket = bucket;
2263
2264         return pn;
2265 }
2266
2267 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2268                                             struct pneigh_entry *pn,
2269                                             loff_t *pos)
2270 {
2271         struct neigh_seq_state *state = seq->private;
2272         struct net * net = state->p.net;
2273         struct neigh_table *tbl = state->tbl;
2274
2275         pn = pn->next;
2276         while (!pn) {
2277                 if (++state->bucket > PNEIGH_HASHMASK)
2278                         break;
2279                 pn = tbl->phash_buckets[state->bucket];
2280                 while (pn && (pn->net != net))
2281                         pn = pn->next;
2282                 if (pn)
2283                         break;
2284         }
2285
2286         if (pn && pos)
2287                 --(*pos);
2288
2289         return pn;
2290 }
2291
2292 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2293 {
2294         struct pneigh_entry *pn = pneigh_get_first(seq);
2295
2296         if (pn) {
2297                 while (*pos) {
2298                         pn = pneigh_get_next(seq, pn, pos);
2299                         if (!pn)
2300                                 break;
2301                 }
2302         }
2303         return *pos ? NULL : pn;
2304 }
2305
2306 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2307 {
2308         struct neigh_seq_state *state = seq->private;
2309         void *rc;
2310
2311         rc = neigh_get_idx(seq, pos);
2312         if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2313                 rc = pneigh_get_idx(seq, pos);
2314
2315         return rc;
2316 }
2317
2318 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
2319         __acquires(tbl->lock)
2320 {
2321         struct neigh_seq_state *state = seq->private;
2322         loff_t pos_minus_one;
2323
2324         state->tbl = tbl;
2325         state->bucket = 0;
2326         state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2327
2328         read_lock_bh(&tbl->lock);
2329
2330         pos_minus_one = *pos - 1;
2331         return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN;
2332 }
2333 EXPORT_SYMBOL(neigh_seq_start);
2334
2335 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2336 {
2337         struct neigh_seq_state *state;
2338         void *rc;
2339
2340         if (v == SEQ_START_TOKEN) {
2341                 rc = neigh_get_idx(seq, pos);
2342                 goto out;
2343         }
2344
2345         state = seq->private;
2346         if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2347                 rc = neigh_get_next(seq, v, NULL);
2348                 if (rc)
2349                         goto out;
2350                 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2351                         rc = pneigh_get_first(seq);
2352         } else {
2353                 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2354                 rc = pneigh_get_next(seq, v, NULL);
2355         }
2356 out:
2357         ++(*pos);
2358         return rc;
2359 }
2360 EXPORT_SYMBOL(neigh_seq_next);
2361
2362 void neigh_seq_stop(struct seq_file *seq, void *v)
2363         __releases(tbl->lock)
2364 {
2365         struct neigh_seq_state *state = seq->private;
2366         struct neigh_table *tbl = state->tbl;
2367
2368         read_unlock_bh(&tbl->lock);
2369 }
2370 EXPORT_SYMBOL(neigh_seq_stop);
2371
2372 /* statistics via seq_file */
2373
2374 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2375 {
2376         struct proc_dir_entry *pde = seq->private;
2377         struct neigh_table *tbl = pde->data;
2378         int cpu;
2379
2380         if (*pos == 0)
2381                 return SEQ_START_TOKEN;
2382
2383         for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
2384                 if (!cpu_possible(cpu))
2385                         continue;
2386                 *pos = cpu+1;
2387                 return per_cpu_ptr(tbl->stats, cpu);
2388         }
2389         return NULL;
2390 }
2391
2392 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2393 {
2394         struct proc_dir_entry *pde = seq->private;
2395         struct neigh_table *tbl = pde->data;
2396         int cpu;
2397
2398         for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
2399                 if (!cpu_possible(cpu))
2400                         continue;
2401                 *pos = cpu+1;
2402                 return per_cpu_ptr(tbl->stats, cpu);
2403         }
2404         return NULL;
2405 }
2406
2407 static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2408 {
2409
2410 }
2411
2412 static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2413 {
2414         struct proc_dir_entry *pde = seq->private;
2415         struct neigh_table *tbl = pde->data;
2416         struct neigh_statistics *st = v;
2417
2418         if (v == SEQ_START_TOKEN) {
2419                 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");
2420                 return 0;
2421         }
2422
2423         seq_printf(seq, "%08x  %08lx %08lx %08lx  %08lx %08lx  %08lx  "
2424                         "%08lx %08lx  %08lx %08lx\n",
2425                    atomic_read(&tbl->entries),
2426
2427                    st->allocs,
2428                    st->destroys,
2429                    st->hash_grows,
2430
2431                    st->lookups,
2432                    st->hits,
2433
2434                    st->res_failed,
2435
2436                    st->rcv_probes_mcast,
2437                    st->rcv_probes_ucast,
2438
2439                    st->periodic_gc_runs,
2440                    st->forced_gc_runs
2441                    );
2442
2443         return 0;
2444 }
2445
2446 static const struct seq_operations neigh_stat_seq_ops = {
2447         .start  = neigh_stat_seq_start,
2448         .next   = neigh_stat_seq_next,
2449         .stop   = neigh_stat_seq_stop,
2450         .show   = neigh_stat_seq_show,
2451 };
2452
2453 static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2454 {
2455         int ret = seq_open(file, &neigh_stat_seq_ops);
2456
2457         if (!ret) {
2458                 struct seq_file *sf = file->private_data;
2459                 sf->private = PDE(inode);
2460         }
2461         return ret;
2462 };
2463
2464 static const struct file_operations neigh_stat_seq_fops = {
2465         .owner   = THIS_MODULE,
2466         .open    = neigh_stat_seq_open,
2467         .read    = seq_read,
2468         .llseek  = seq_lseek,
2469         .release = seq_release,
2470 };
2471
2472 #endif /* CONFIG_PROC_FS */
2473
2474 static inline size_t neigh_nlmsg_size(void)
2475 {
2476         return NLMSG_ALIGN(sizeof(struct ndmsg))
2477                + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2478                + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2479                + nla_total_size(sizeof(struct nda_cacheinfo))
2480                + nla_total_size(4); /* NDA_PROBES */
2481 }
2482
2483 static void __neigh_notify(struct neighbour *n, int type, int flags)
2484 {
2485         struct net *net = n->dev->nd_net;
2486         struct sk_buff *skb;
2487         int err = -ENOBUFS;
2488
2489         skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
2490         if (skb == NULL)
2491                 goto errout;
2492
2493         err = neigh_fill_info(skb, n, 0, 0, type, flags);
2494         if (err < 0) {
2495                 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2496                 WARN_ON(err == -EMSGSIZE);
2497                 kfree_skb(skb);
2498                 goto errout;
2499         }
2500         err = rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
2501 errout:
2502         if (err < 0)
2503                 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
2504 }
2505
2506 #ifdef CONFIG_ARPD
2507 void neigh_app_ns(struct neighbour *n)
2508 {
2509         __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
2510 }
2511 #endif /* CONFIG_ARPD */
2512
2513 #ifdef CONFIG_SYSCTL
2514
2515 static struct neigh_sysctl_table {
2516         struct ctl_table_header *sysctl_header;
2517         struct ctl_table neigh_vars[__NET_NEIGH_MAX];
2518         char *dev_name;
2519 } neigh_sysctl_template __read_mostly = {
2520         .neigh_vars = {
2521                 {
2522                         .ctl_name       = NET_NEIGH_MCAST_SOLICIT,
2523                         .procname       = "mcast_solicit",
2524                         .maxlen         = sizeof(int),
2525                         .mode           = 0644,
2526                         .proc_handler   = &proc_dointvec,
2527                 },
2528                 {
2529                         .ctl_name       = NET_NEIGH_UCAST_SOLICIT,
2530                         .procname       = "ucast_solicit",
2531                         .maxlen         = sizeof(int),
2532                         .mode           = 0644,
2533                         .proc_handler   = &proc_dointvec,
2534                 },
2535                 {
2536                         .ctl_name       = NET_NEIGH_APP_SOLICIT,
2537                         .procname       = "app_solicit",
2538                         .maxlen         = sizeof(int),
2539                         .mode           = 0644,
2540                         .proc_handler   = &proc_dointvec,
2541                 },
2542                 {
2543                         .procname       = "retrans_time",
2544                         .maxlen         = sizeof(int),
2545                         .mode           = 0644,
2546                         .proc_handler   = &proc_dointvec_userhz_jiffies,
2547                 },
2548                 {
2549                         .ctl_name       = NET_NEIGH_REACHABLE_TIME,
2550                         .procname       = "base_reachable_time",
2551                         .maxlen         = sizeof(int),
2552                         .mode           = 0644,
2553                         .proc_handler   = &proc_dointvec_jiffies,
2554                         .strategy       = &sysctl_jiffies,
2555                 },
2556                 {
2557                         .ctl_name       = NET_NEIGH_DELAY_PROBE_TIME,
2558                         .procname       = "delay_first_probe_time",
2559                         .maxlen         = sizeof(int),
2560                         .mode           = 0644,
2561                         .proc_handler   = &proc_dointvec_jiffies,
2562                         .strategy       = &sysctl_jiffies,
2563                 },
2564                 {
2565                         .ctl_name       = NET_NEIGH_GC_STALE_TIME,
2566                         .procname       = "gc_stale_time",
2567                         .maxlen         = sizeof(int),
2568                         .mode           = 0644,
2569                         .proc_handler   = &proc_dointvec_jiffies,
2570                         .strategy       = &sysctl_jiffies,
2571                 },
2572                 {
2573                         .ctl_name       = NET_NEIGH_UNRES_QLEN,
2574                         .procname       = "unres_qlen",
2575                         .maxlen         = sizeof(int),
2576                         .mode           = 0644,
2577                         .proc_handler   = &proc_dointvec,
2578                 },
2579                 {
2580                         .ctl_name       = NET_NEIGH_PROXY_QLEN,
2581                         .procname       = "proxy_qlen",
2582                         .maxlen         = sizeof(int),
2583                         .mode           = 0644,
2584                         .proc_handler   = &proc_dointvec,
2585                 },
2586                 {
2587                         .procname       = "anycast_delay",
2588                         .maxlen         = sizeof(int),
2589                         .mode           = 0644,
2590                         .proc_handler   = &proc_dointvec_userhz_jiffies,
2591                 },
2592                 {
2593                         .procname       = "proxy_delay",
2594                         .maxlen         = sizeof(int),
2595                         .mode           = 0644,
2596                         .proc_handler   = &proc_dointvec_userhz_jiffies,
2597                 },
2598                 {
2599                         .procname       = "locktime",
2600                         .maxlen         = sizeof(int),
2601                         .mode           = 0644,
2602                         .proc_handler   = &proc_dointvec_userhz_jiffies,
2603                 },
2604                 {
2605                         .ctl_name       = NET_NEIGH_RETRANS_TIME_MS,
2606                         .procname       = "retrans_time_ms",
2607                         .maxlen         = sizeof(int),
2608                         .mode           = 0644,
2609                         .proc_handler   = &proc_dointvec_ms_jiffies,
2610                         .strategy       = &sysctl_ms_jiffies,
2611                 },
2612                 {
2613                         .ctl_name       = NET_NEIGH_REACHABLE_TIME_MS,
2614                         .procname       = "base_reachable_time_ms",
2615                         .maxlen         = sizeof(int),
2616                         .mode           = 0644,
2617                         .proc_handler   = &proc_dointvec_ms_jiffies,
2618                         .strategy       = &sysctl_ms_jiffies,
2619                 },
2620                 {
2621                         .ctl_name       = NET_NEIGH_GC_INTERVAL,
2622                         .procname       = "gc_interval",
2623                         .maxlen         = sizeof(int),
2624                         .mode           = 0644,
2625                         .proc_handler   = &proc_dointvec_jiffies,
2626                         .strategy       = &sysctl_jiffies,
2627                 },
2628                 {
2629                         .ctl_name       = NET_NEIGH_GC_THRESH1,
2630                         .procname       = "gc_thresh1",
2631                         .maxlen         = sizeof(int),
2632                         .mode           = 0644,
2633                         .proc_handler   = &proc_dointvec,
2634                 },
2635                 {
2636                         .ctl_name       = NET_NEIGH_GC_THRESH2,
2637                         .procname       = "gc_thresh2",
2638                         .maxlen         = sizeof(int),
2639                         .mode           = 0644,
2640                         .proc_handler   = &proc_dointvec,
2641                 },
2642                 {
2643                         .ctl_name       = NET_NEIGH_GC_THRESH3,
2644                         .procname       = "gc_thresh3",
2645                         .maxlen         = sizeof(int),
2646                         .mode           = 0644,
2647                         .proc_handler   = &proc_dointvec,
2648                 },
2649                 {},
2650         },
2651 };
2652
2653 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
2654                           int p_id, int pdev_id, char *p_name,
2655                           proc_handler *handler, ctl_handler *strategy)
2656 {
2657         struct neigh_sysctl_table *t;
2658         const char *dev_name_source = NULL;
2659
2660 #define NEIGH_CTL_PATH_ROOT     0
2661 #define NEIGH_CTL_PATH_PROTO    1
2662 #define NEIGH_CTL_PATH_NEIGH    2
2663 #define NEIGH_CTL_PATH_DEV      3
2664
2665         struct ctl_path neigh_path[] = {
2666                 { .procname = "net",     .ctl_name = CTL_NET, },
2667                 { .procname = "proto",   .ctl_name = 0, },
2668                 { .procname = "neigh",   .ctl_name = 0, },
2669                 { .procname = "default", .ctl_name = NET_PROTO_CONF_DEFAULT, },
2670                 { },
2671         };
2672
2673         t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
2674         if (!t)
2675                 goto err;
2676
2677         t->neigh_vars[0].data  = &p->mcast_probes;
2678         t->neigh_vars[1].data  = &p->ucast_probes;
2679         t->neigh_vars[2].data  = &p->app_probes;
2680         t->neigh_vars[3].data  = &p->retrans_time;
2681         t->neigh_vars[4].data  = &p->base_reachable_time;
2682         t->neigh_vars[5].data  = &p->delay_probe_time;
2683         t->neigh_vars[6].data  = &p->gc_staletime;
2684         t->neigh_vars[7].data  = &p->queue_len;
2685         t->neigh_vars[8].data  = &p->proxy_qlen;
2686         t->neigh_vars[9].data  = &p->anycast_delay;
2687         t->neigh_vars[10].data = &p->proxy_delay;
2688         t->neigh_vars[11].data = &p->locktime;
2689         t->neigh_vars[12].data  = &p->retrans_time;
2690         t->neigh_vars[13].data  = &p->base_reachable_time;
2691
2692         if (dev) {
2693                 dev_name_source = dev->name;
2694                 neigh_path[NEIGH_CTL_PATH_DEV].ctl_name = dev->ifindex;
2695                 /* Terminate the table early */
2696                 memset(&t->neigh_vars[14], 0, sizeof(t->neigh_vars[14]));
2697         } else {
2698                 dev_name_source = neigh_path[NEIGH_CTL_PATH_DEV].procname;
2699                 t->neigh_vars[14].data = (int *)(p + 1);
2700                 t->neigh_vars[15].data = (int *)(p + 1) + 1;
2701                 t->neigh_vars[16].data = (int *)(p + 1) + 2;
2702                 t->neigh_vars[17].data = (int *)(p + 1) + 3;
2703         }
2704
2705
2706         if (handler || strategy) {
2707                 /* RetransTime */
2708                 t->neigh_vars[3].proc_handler = handler;
2709                 t->neigh_vars[3].strategy = strategy;
2710                 t->neigh_vars[3].extra1 = dev;
2711                 if (!strategy)
2712                         t->neigh_vars[3].ctl_name = CTL_UNNUMBERED;
2713                 /* ReachableTime */
2714                 t->neigh_vars[4].proc_handler = handler;
2715                 t->neigh_vars[4].strategy = strategy;
2716                 t->neigh_vars[4].extra1 = dev;
2717                 if (!strategy)
2718                         t->neigh_vars[4].ctl_name = CTL_UNNUMBERED;
2719                 /* RetransTime (in milliseconds)*/
2720                 t->neigh_vars[12].proc_handler = handler;
2721                 t->neigh_vars[12].strategy = strategy;
2722                 t->neigh_vars[12].extra1 = dev;
2723                 if (!strategy)
2724                         t->neigh_vars[12].ctl_name = CTL_UNNUMBERED;
2725                 /* ReachableTime (in milliseconds) */
2726                 t->neigh_vars[13].proc_handler = handler;
2727                 t->neigh_vars[13].strategy = strategy;
2728                 t->neigh_vars[13].extra1 = dev;
2729                 if (!strategy)
2730                         t->neigh_vars[13].ctl_name = CTL_UNNUMBERED;
2731         }
2732
2733         t->dev_name = kstrdup(dev_name_source, GFP_KERNEL);
2734         if (!t->dev_name)
2735                 goto free;
2736
2737         neigh_path[NEIGH_CTL_PATH_DEV].procname = t->dev_name;
2738         neigh_path[NEIGH_CTL_PATH_NEIGH].ctl_name = pdev_id;
2739         neigh_path[NEIGH_CTL_PATH_PROTO].procname = p_name;
2740         neigh_path[NEIGH_CTL_PATH_PROTO].ctl_name = p_id;
2741
2742         t->sysctl_header =
2743                 register_net_sysctl_table(p->net, neigh_path, t->neigh_vars);
2744         if (!t->sysctl_header)
2745                 goto free_procname;
2746
2747         p->sysctl_table = t;
2748         return 0;
2749
2750 free_procname:
2751         kfree(t->dev_name);
2752 free:
2753         kfree(t);
2754 err:
2755         return -ENOBUFS;
2756 }
2757
2758 void neigh_sysctl_unregister(struct neigh_parms *p)
2759 {
2760         if (p->sysctl_table) {
2761                 struct neigh_sysctl_table *t = p->sysctl_table;
2762                 p->sysctl_table = NULL;
2763                 unregister_sysctl_table(t->sysctl_header);
2764                 kfree(t->dev_name);
2765                 kfree(t);
2766         }
2767 }
2768
2769 #endif  /* CONFIG_SYSCTL */
2770
2771 static int __init neigh_init(void)
2772 {
2773         rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL);
2774         rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL);
2775         rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info);
2776
2777         rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info);
2778         rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL);
2779
2780         return 0;
2781 }
2782
2783 subsys_initcall(neigh_init);
2784
2785 EXPORT_SYMBOL(__neigh_event_send);
2786 EXPORT_SYMBOL(neigh_changeaddr);
2787 EXPORT_SYMBOL(neigh_compat_output);
2788 EXPORT_SYMBOL(neigh_connected_output);
2789 EXPORT_SYMBOL(neigh_create);
2790 EXPORT_SYMBOL(neigh_destroy);
2791 EXPORT_SYMBOL(neigh_event_ns);
2792 EXPORT_SYMBOL(neigh_ifdown);
2793 EXPORT_SYMBOL(neigh_lookup);
2794 EXPORT_SYMBOL(neigh_lookup_nodev);
2795 EXPORT_SYMBOL(neigh_parms_alloc);
2796 EXPORT_SYMBOL(neigh_parms_release);
2797 EXPORT_SYMBOL(neigh_rand_reach_time);
2798 EXPORT_SYMBOL(neigh_resolve_output);
2799 EXPORT_SYMBOL(neigh_table_clear);
2800 EXPORT_SYMBOL(neigh_table_init);
2801 EXPORT_SYMBOL(neigh_table_init_no_netlink);
2802 EXPORT_SYMBOL(neigh_update);
2803 EXPORT_SYMBOL(pneigh_enqueue);
2804 EXPORT_SYMBOL(pneigh_lookup);
2805
2806 #ifdef CONFIG_ARPD
2807 EXPORT_SYMBOL(neigh_app_ns);
2808 #endif
2809 #ifdef CONFIG_SYSCTL
2810 EXPORT_SYMBOL(neigh_sysctl_register);
2811 EXPORT_SYMBOL(neigh_sysctl_unregister);
2812 #endif