4062b88bfc1b6fa7c598a2c5f66796cfac46c3f5
[sfrench/cifs-2.6.git] / net / core / neighbour.c
1 /*
2  *      Generic address resolution entity
3  *
4  *      Authors:
5  *      Pedro Roque             <roque@di.fc.ul.pt>
6  *      Alexey Kuznetsov        <kuznet@ms2.inr.ac.ru>
7  *
8  *      This program is free software; you can redistribute it and/or
9  *      modify it under the terms of the GNU General Public License
10  *      as published by the Free Software Foundation; either version
11  *      2 of the License, or (at your option) any later version.
12  *
13  *      Fixes:
14  *      Vitaly E. Lavrov        releasing NULL neighbor in neigh_add.
15  *      Harald Welte            Add neighbour cache statistics like rtstat
16  */
17
18 #include <linux/types.h>
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/socket.h>
22 #include <linux/netdevice.h>
23 #include <linux/proc_fs.h>
24 #ifdef CONFIG_SYSCTL
25 #include <linux/sysctl.h>
26 #endif
27 #include <linux/times.h>
28 #include <net/net_namespace.h>
29 #include <net/neighbour.h>
30 #include <net/dst.h>
31 #include <net/sock.h>
32 #include <net/netevent.h>
33 #include <net/netlink.h>
34 #include <linux/rtnetlink.h>
35 #include <linux/random.h>
36 #include <linux/string.h>
37 #include <linux/log2.h>
38
39 #define NEIGH_DEBUG 1
40
41 #define NEIGH_PRINTK(x...) printk(x)
42 #define NEIGH_NOPRINTK(x...) do { ; } while(0)
43 #define NEIGH_PRINTK0 NEIGH_PRINTK
44 #define NEIGH_PRINTK1 NEIGH_NOPRINTK
45 #define NEIGH_PRINTK2 NEIGH_NOPRINTK
46
47 #if NEIGH_DEBUG >= 1
48 #undef NEIGH_PRINTK1
49 #define NEIGH_PRINTK1 NEIGH_PRINTK
50 #endif
51 #if NEIGH_DEBUG >= 2
52 #undef NEIGH_PRINTK2
53 #define NEIGH_PRINTK2 NEIGH_PRINTK
54 #endif
55
56 #define PNEIGH_HASHMASK         0xF
57
58 static void neigh_timer_handler(unsigned long arg);
59 static void __neigh_notify(struct neighbour *n, int type, int flags);
60 static void neigh_update_notify(struct neighbour *neigh);
61 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
62
63 static struct neigh_table *neigh_tables;
64 #ifdef CONFIG_PROC_FS
65 static const struct file_operations neigh_stat_seq_fops;
66 #endif
67
68 /*
69    Neighbour hash table buckets are protected with rwlock tbl->lock.
70
71    - All the scans/updates to hash buckets MUST be made under this lock.
72    - NOTHING clever should be made under this lock: no callbacks
73      to protocol backends, no attempts to send something to network.
74      It will result in deadlocks, if backend/driver wants to use neighbour
75      cache.
76    - If the entry requires some non-trivial actions, increase
77      its reference count and release table lock.
78
79    Neighbour entries are protected:
80    - with reference count.
81    - with rwlock neigh->lock
82
83    Reference count prevents destruction.
84
85    neigh->lock mainly serializes ll address data and its validity state.
86    However, the same lock is used to protect another entry fields:
87     - timer
88     - resolution queue
89
90    Again, nothing clever shall be made under neigh->lock,
91    the most complicated procedure, which we allow is dev->hard_header.
92    It is supposed, that dev->hard_header is simplistic and does
93    not make callbacks to neighbour tables.
94
95    The last lock is neigh_tbl_lock. It is pure SMP lock, protecting
96    list of neighbour tables. This list is used only in process context,
97  */
98
99 static DEFINE_RWLOCK(neigh_tbl_lock);
100
101 static int neigh_blackhole(struct sk_buff *skb)
102 {
103         kfree_skb(skb);
104         return -ENETDOWN;
105 }
106
107 static void neigh_cleanup_and_release(struct neighbour *neigh)
108 {
109         if (neigh->parms->neigh_cleanup)
110                 neigh->parms->neigh_cleanup(neigh);
111
112         __neigh_notify(neigh, RTM_DELNEIGH, 0);
113         neigh_release(neigh);
114 }
115
116 /*
117  * It is random distribution in the interval (1/2)*base...(3/2)*base.
118  * It corresponds to default IPv6 settings and is not overridable,
119  * because it is really reasonable choice.
120  */
121
122 unsigned long neigh_rand_reach_time(unsigned long base)
123 {
124         return (base ? (net_random() % base) + (base >> 1) : 0);
125 }
126
127
128 static int neigh_forced_gc(struct neigh_table *tbl)
129 {
130         int shrunk = 0;
131         int i;
132
133         NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
134
135         write_lock_bh(&tbl->lock);
136         for (i = 0; i <= tbl->hash_mask; i++) {
137                 struct neighbour *n, **np;
138
139                 np = &tbl->hash_buckets[i];
140                 while ((n = *np) != NULL) {
141                         /* Neighbour record may be discarded if:
142                          * - nobody refers to it.
143                          * - it is not permanent
144                          */
145                         write_lock(&n->lock);
146                         if (atomic_read(&n->refcnt) == 1 &&
147                             !(n->nud_state & NUD_PERMANENT)) {
148                                 *np     = n->next;
149                                 n->dead = 1;
150                                 shrunk  = 1;
151                                 write_unlock(&n->lock);
152                                 neigh_cleanup_and_release(n);
153                                 continue;
154                         }
155                         write_unlock(&n->lock);
156                         np = &n->next;
157                 }
158         }
159
160         tbl->last_flush = jiffies;
161
162         write_unlock_bh(&tbl->lock);
163
164         return shrunk;
165 }
166
167 static void neigh_add_timer(struct neighbour *n, unsigned long when)
168 {
169         neigh_hold(n);
170         if (unlikely(mod_timer(&n->timer, when))) {
171                 printk("NEIGH: BUG, double timer add, state is %x\n",
172                        n->nud_state);
173                 dump_stack();
174         }
175 }
176
177 static int neigh_del_timer(struct neighbour *n)
178 {
179         if ((n->nud_state & NUD_IN_TIMER) &&
180             del_timer(&n->timer)) {
181                 neigh_release(n);
182                 return 1;
183         }
184         return 0;
185 }
186
187 static void pneigh_queue_purge(struct sk_buff_head *list)
188 {
189         struct sk_buff *skb;
190
191         while ((skb = skb_dequeue(list)) != NULL) {
192                 dev_put(skb->dev);
193                 kfree_skb(skb);
194         }
195 }
196
197 static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
198 {
199         int i;
200
201         for (i = 0; i <= tbl->hash_mask; i++) {
202                 struct neighbour *n, **np = &tbl->hash_buckets[i];
203
204                 while ((n = *np) != NULL) {
205                         if (dev && n->dev != dev) {
206                                 np = &n->next;
207                                 continue;
208                         }
209                         *np = n->next;
210                         write_lock(&n->lock);
211                         neigh_del_timer(n);
212                         n->dead = 1;
213
214                         if (atomic_read(&n->refcnt) != 1) {
215                                 /* The most unpleasant situation.
216                                    We must destroy neighbour entry,
217                                    but someone still uses it.
218
219                                    The destroy will be delayed until
220                                    the last user releases us, but
221                                    we must kill timers etc. and move
222                                    it to safe state.
223                                  */
224                                 skb_queue_purge(&n->arp_queue);
225                                 n->output = neigh_blackhole;
226                                 if (n->nud_state & NUD_VALID)
227                                         n->nud_state = NUD_NOARP;
228                                 else
229                                         n->nud_state = NUD_NONE;
230                                 NEIGH_PRINTK2("neigh %p is stray.\n", n);
231                         }
232                         write_unlock(&n->lock);
233                         neigh_cleanup_and_release(n);
234                 }
235         }
236 }
237
238 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
239 {
240         write_lock_bh(&tbl->lock);
241         neigh_flush_dev(tbl, dev);
242         write_unlock_bh(&tbl->lock);
243 }
244
245 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
246 {
247         write_lock_bh(&tbl->lock);
248         neigh_flush_dev(tbl, dev);
249         pneigh_ifdown(tbl, dev);
250         write_unlock_bh(&tbl->lock);
251
252         del_timer_sync(&tbl->proxy_timer);
253         pneigh_queue_purge(&tbl->proxy_queue);
254         return 0;
255 }
256
257 static struct neighbour *neigh_alloc(struct neigh_table *tbl)
258 {
259         struct neighbour *n = NULL;
260         unsigned long now = jiffies;
261         int entries;
262
263         entries = atomic_inc_return(&tbl->entries) - 1;
264         if (entries >= tbl->gc_thresh3 ||
265             (entries >= tbl->gc_thresh2 &&
266              time_after(now, tbl->last_flush + 5 * HZ))) {
267                 if (!neigh_forced_gc(tbl) &&
268                     entries >= tbl->gc_thresh3)
269                         goto out_entries;
270         }
271
272         n = kmem_cache_zalloc(tbl->kmem_cachep, GFP_ATOMIC);
273         if (!n)
274                 goto out_entries;
275
276         skb_queue_head_init(&n->arp_queue);
277         rwlock_init(&n->lock);
278         n->updated        = n->used = now;
279         n->nud_state      = NUD_NONE;
280         n->output         = neigh_blackhole;
281         n->parms          = neigh_parms_clone(&tbl->parms);
282         setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n);
283
284         NEIGH_CACHE_STAT_INC(tbl, allocs);
285         n->tbl            = tbl;
286         atomic_set(&n->refcnt, 1);
287         n->dead           = 1;
288 out:
289         return n;
290
291 out_entries:
292         atomic_dec(&tbl->entries);
293         goto out;
294 }
295
296 static struct neighbour **neigh_hash_alloc(unsigned int entries)
297 {
298         unsigned long size = entries * sizeof(struct neighbour *);
299         struct neighbour **ret;
300
301         if (size <= PAGE_SIZE) {
302                 ret = kzalloc(size, GFP_ATOMIC);
303         } else {
304                 ret = (struct neighbour **)
305                       __get_free_pages(GFP_ATOMIC|__GFP_ZERO, get_order(size));
306         }
307         return ret;
308 }
309
310 static void neigh_hash_free(struct neighbour **hash, unsigned int entries)
311 {
312         unsigned long size = entries * sizeof(struct neighbour *);
313
314         if (size <= PAGE_SIZE)
315                 kfree(hash);
316         else
317                 free_pages((unsigned long)hash, get_order(size));
318 }
319
320 static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries)
321 {
322         struct neighbour **new_hash, **old_hash;
323         unsigned int i, new_hash_mask, old_entries;
324
325         NEIGH_CACHE_STAT_INC(tbl, hash_grows);
326
327         BUG_ON(!is_power_of_2(new_entries));
328         new_hash = neigh_hash_alloc(new_entries);
329         if (!new_hash)
330                 return;
331
332         old_entries = tbl->hash_mask + 1;
333         new_hash_mask = new_entries - 1;
334         old_hash = tbl->hash_buckets;
335
336         get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
337         for (i = 0; i < old_entries; i++) {
338                 struct neighbour *n, *next;
339
340                 for (n = old_hash[i]; n; n = next) {
341                         unsigned int hash_val = tbl->hash(n->primary_key, n->dev);
342
343                         hash_val &= new_hash_mask;
344                         next = n->next;
345
346                         n->next = new_hash[hash_val];
347                         new_hash[hash_val] = n;
348                 }
349         }
350         tbl->hash_buckets = new_hash;
351         tbl->hash_mask = new_hash_mask;
352
353         neigh_hash_free(old_hash, old_entries);
354 }
355
356 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
357                                struct net_device *dev)
358 {
359         struct neighbour *n;
360         int key_len = tbl->key_len;
361         u32 hash_val = tbl->hash(pkey, dev);
362
363         NEIGH_CACHE_STAT_INC(tbl, lookups);
364
365         read_lock_bh(&tbl->lock);
366         for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) {
367                 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
368                         neigh_hold(n);
369                         NEIGH_CACHE_STAT_INC(tbl, hits);
370                         break;
371                 }
372         }
373         read_unlock_bh(&tbl->lock);
374         return n;
375 }
376
377 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
378                                      const void *pkey)
379 {
380         struct neighbour *n;
381         int key_len = tbl->key_len;
382         u32 hash_val = tbl->hash(pkey, NULL);
383
384         NEIGH_CACHE_STAT_INC(tbl, lookups);
385
386         read_lock_bh(&tbl->lock);
387         for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) {
388                 if (!memcmp(n->primary_key, pkey, key_len) &&
389                     (net == n->dev->nd_net)) {
390                         neigh_hold(n);
391                         NEIGH_CACHE_STAT_INC(tbl, hits);
392                         break;
393                 }
394         }
395         read_unlock_bh(&tbl->lock);
396         return n;
397 }
398
399 struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey,
400                                struct net_device *dev)
401 {
402         u32 hash_val;
403         int key_len = tbl->key_len;
404         int error;
405         struct neighbour *n1, *rc, *n = neigh_alloc(tbl);
406
407         if (!n) {
408                 rc = ERR_PTR(-ENOBUFS);
409                 goto out;
410         }
411
412         memcpy(n->primary_key, pkey, key_len);
413         n->dev = dev;
414         dev_hold(dev);
415
416         /* Protocol specific setup. */
417         if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
418                 rc = ERR_PTR(error);
419                 goto out_neigh_release;
420         }
421
422         /* Device specific setup. */
423         if (n->parms->neigh_setup &&
424             (error = n->parms->neigh_setup(n)) < 0) {
425                 rc = ERR_PTR(error);
426                 goto out_neigh_release;
427         }
428
429         n->confirmed = jiffies - (n->parms->base_reachable_time << 1);
430
431         write_lock_bh(&tbl->lock);
432
433         if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1))
434                 neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1);
435
436         hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;
437
438         if (n->parms->dead) {
439                 rc = ERR_PTR(-EINVAL);
440                 goto out_tbl_unlock;
441         }
442
443         for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) {
444                 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
445                         neigh_hold(n1);
446                         rc = n1;
447                         goto out_tbl_unlock;
448                 }
449         }
450
451         n->next = tbl->hash_buckets[hash_val];
452         tbl->hash_buckets[hash_val] = n;
453         n->dead = 0;
454         neigh_hold(n);
455         write_unlock_bh(&tbl->lock);
456         NEIGH_PRINTK2("neigh %p is created.\n", n);
457         rc = n;
458 out:
459         return rc;
460 out_tbl_unlock:
461         write_unlock_bh(&tbl->lock);
462 out_neigh_release:
463         neigh_release(n);
464         goto out;
465 }
466
467 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl,
468                                     struct net *net, const void *pkey,
469                                     struct net_device *dev, int creat)
470 {
471         struct pneigh_entry *n;
472         int key_len = tbl->key_len;
473         u32 hash_val = *(u32 *)(pkey + key_len - 4);
474
475         hash_val ^= (hash_val >> 16);
476         hash_val ^= hash_val >> 8;
477         hash_val ^= hash_val >> 4;
478         hash_val &= PNEIGH_HASHMASK;
479
480         read_lock_bh(&tbl->lock);
481
482         for (n = tbl->phash_buckets[hash_val]; n; n = n->next) {
483                 if (!memcmp(n->key, pkey, key_len) &&
484                     (n->net == net) &&
485                     (n->dev == dev || !n->dev)) {
486                         read_unlock_bh(&tbl->lock);
487                         goto out;
488                 }
489         }
490         read_unlock_bh(&tbl->lock);
491         n = NULL;
492         if (!creat)
493                 goto out;
494
495         ASSERT_RTNL();
496
497         n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
498         if (!n)
499                 goto out;
500
501         n->net = hold_net(net);
502         memcpy(n->key, pkey, key_len);
503         n->dev = dev;
504         if (dev)
505                 dev_hold(dev);
506
507         if (tbl->pconstructor && tbl->pconstructor(n)) {
508                 if (dev)
509                         dev_put(dev);
510                 release_net(net);
511                 kfree(n);
512                 n = NULL;
513                 goto out;
514         }
515
516         write_lock_bh(&tbl->lock);
517         n->next = tbl->phash_buckets[hash_val];
518         tbl->phash_buckets[hash_val] = n;
519         write_unlock_bh(&tbl->lock);
520 out:
521         return n;
522 }
523
524
525 int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey,
526                   struct net_device *dev)
527 {
528         struct pneigh_entry *n, **np;
529         int key_len = tbl->key_len;
530         u32 hash_val = *(u32 *)(pkey + key_len - 4);
531
532         hash_val ^= (hash_val >> 16);
533         hash_val ^= hash_val >> 8;
534         hash_val ^= hash_val >> 4;
535         hash_val &= PNEIGH_HASHMASK;
536
537         write_lock_bh(&tbl->lock);
538         for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
539              np = &n->next) {
540                 if (!memcmp(n->key, pkey, key_len) && n->dev == dev &&
541                     (n->net == net)) {
542                         *np = n->next;
543                         write_unlock_bh(&tbl->lock);
544                         if (tbl->pdestructor)
545                                 tbl->pdestructor(n);
546                         if (n->dev)
547                                 dev_put(n->dev);
548                         release_net(n->net);
549                         kfree(n);
550                         return 0;
551                 }
552         }
553         write_unlock_bh(&tbl->lock);
554         return -ENOENT;
555 }
556
557 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
558 {
559         struct pneigh_entry *n, **np;
560         u32 h;
561
562         for (h = 0; h <= PNEIGH_HASHMASK; h++) {
563                 np = &tbl->phash_buckets[h];
564                 while ((n = *np) != NULL) {
565                         if (!dev || n->dev == dev) {
566                                 *np = n->next;
567                                 if (tbl->pdestructor)
568                                         tbl->pdestructor(n);
569                                 if (n->dev)
570                                         dev_put(n->dev);
571                                 release_net(n->net);
572                                 kfree(n);
573                                 continue;
574                         }
575                         np = &n->next;
576                 }
577         }
578         return -ENOENT;
579 }
580
581 static void neigh_parms_destroy(struct neigh_parms *parms);
582
583 static inline void neigh_parms_put(struct neigh_parms *parms)
584 {
585         if (atomic_dec_and_test(&parms->refcnt))
586                 neigh_parms_destroy(parms);
587 }
588
589 /*
590  *      neighbour must already be out of the table;
591  *
592  */
593 void neigh_destroy(struct neighbour *neigh)
594 {
595         struct hh_cache *hh;
596
597         NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
598
599         if (!neigh->dead) {
600                 printk(KERN_WARNING
601                        "Destroying alive neighbour %p\n", neigh);
602                 dump_stack();
603                 return;
604         }
605
606         if (neigh_del_timer(neigh))
607                 printk(KERN_WARNING "Impossible event.\n");
608
609         while ((hh = neigh->hh) != NULL) {
610                 neigh->hh = hh->hh_next;
611                 hh->hh_next = NULL;
612
613                 write_seqlock_bh(&hh->hh_lock);
614                 hh->hh_output = neigh_blackhole;
615                 write_sequnlock_bh(&hh->hh_lock);
616                 if (atomic_dec_and_test(&hh->hh_refcnt))
617                         kfree(hh);
618         }
619
620         skb_queue_purge(&neigh->arp_queue);
621
622         dev_put(neigh->dev);
623         neigh_parms_put(neigh->parms);
624
625         NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh);
626
627         atomic_dec(&neigh->tbl->entries);
628         kmem_cache_free(neigh->tbl->kmem_cachep, neigh);
629 }
630
631 /* Neighbour state is suspicious;
632    disable fast path.
633
634    Called with write_locked neigh.
635  */
636 static void neigh_suspect(struct neighbour *neigh)
637 {
638         struct hh_cache *hh;
639
640         NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
641
642         neigh->output = neigh->ops->output;
643
644         for (hh = neigh->hh; hh; hh = hh->hh_next)
645                 hh->hh_output = neigh->ops->output;
646 }
647
648 /* Neighbour state is OK;
649    enable fast path.
650
651    Called with write_locked neigh.
652  */
653 static void neigh_connect(struct neighbour *neigh)
654 {
655         struct hh_cache *hh;
656
657         NEIGH_PRINTK2("neigh %p is connected.\n", neigh);
658
659         neigh->output = neigh->ops->connected_output;
660
661         for (hh = neigh->hh; hh; hh = hh->hh_next)
662                 hh->hh_output = neigh->ops->hh_output;
663 }
664
665 static void neigh_periodic_timer(unsigned long arg)
666 {
667         struct neigh_table *tbl = (struct neigh_table *)arg;
668         struct neighbour *n, **np;
669         unsigned long expire, now = jiffies;
670
671         NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
672
673         write_lock(&tbl->lock);
674
675         /*
676          *      periodically recompute ReachableTime from random function
677          */
678
679         if (time_after(now, tbl->last_rand + 300 * HZ)) {
680                 struct neigh_parms *p;
681                 tbl->last_rand = now;
682                 for (p = &tbl->parms; p; p = p->next)
683                         p->reachable_time =
684                                 neigh_rand_reach_time(p->base_reachable_time);
685         }
686
687         np = &tbl->hash_buckets[tbl->hash_chain_gc];
688         tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask);
689
690         while ((n = *np) != NULL) {
691                 unsigned int state;
692
693                 write_lock(&n->lock);
694
695                 state = n->nud_state;
696                 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
697                         write_unlock(&n->lock);
698                         goto next_elt;
699                 }
700
701                 if (time_before(n->used, n->confirmed))
702                         n->used = n->confirmed;
703
704                 if (atomic_read(&n->refcnt) == 1 &&
705                     (state == NUD_FAILED ||
706                      time_after(now, n->used + n->parms->gc_staletime))) {
707                         *np = n->next;
708                         n->dead = 1;
709                         write_unlock(&n->lock);
710                         neigh_cleanup_and_release(n);
711                         continue;
712                 }
713                 write_unlock(&n->lock);
714
715 next_elt:
716                 np = &n->next;
717         }
718
719         /* Cycle through all hash buckets every base_reachable_time/2 ticks.
720          * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
721          * base_reachable_time.
722          */
723         expire = tbl->parms.base_reachable_time >> 1;
724         expire /= (tbl->hash_mask + 1);
725         if (!expire)
726                 expire = 1;
727
728         if (expire>HZ)
729                 mod_timer(&tbl->gc_timer, round_jiffies(now + expire));
730         else
731                 mod_timer(&tbl->gc_timer, now + expire);
732
733         write_unlock(&tbl->lock);
734 }
735
736 static __inline__ int neigh_max_probes(struct neighbour *n)
737 {
738         struct neigh_parms *p = n->parms;
739         return (n->nud_state & NUD_PROBE ?
740                 p->ucast_probes :
741                 p->ucast_probes + p->app_probes + p->mcast_probes);
742 }
743
744 /* Called when a timer expires for a neighbour entry. */
745
746 static void neigh_timer_handler(unsigned long arg)
747 {
748         unsigned long now, next;
749         struct neighbour *neigh = (struct neighbour *)arg;
750         unsigned state;
751         int notify = 0;
752
753         write_lock(&neigh->lock);
754
755         state = neigh->nud_state;
756         now = jiffies;
757         next = now + HZ;
758
759         if (!(state & NUD_IN_TIMER)) {
760 #ifndef CONFIG_SMP
761                 printk(KERN_WARNING "neigh: timer & !nud_in_timer\n");
762 #endif
763                 goto out;
764         }
765
766         if (state & NUD_REACHABLE) {
767                 if (time_before_eq(now,
768                                    neigh->confirmed + neigh->parms->reachable_time)) {
769                         NEIGH_PRINTK2("neigh %p is still alive.\n", neigh);
770                         next = neigh->confirmed + neigh->parms->reachable_time;
771                 } else if (time_before_eq(now,
772                                           neigh->used + neigh->parms->delay_probe_time)) {
773                         NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
774                         neigh->nud_state = NUD_DELAY;
775                         neigh->updated = jiffies;
776                         neigh_suspect(neigh);
777                         next = now + neigh->parms->delay_probe_time;
778                 } else {
779                         NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
780                         neigh->nud_state = NUD_STALE;
781                         neigh->updated = jiffies;
782                         neigh_suspect(neigh);
783                         notify = 1;
784                 }
785         } else if (state & NUD_DELAY) {
786                 if (time_before_eq(now,
787                                    neigh->confirmed + neigh->parms->delay_probe_time)) {
788                         NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh);
789                         neigh->nud_state = NUD_REACHABLE;
790                         neigh->updated = jiffies;
791                         neigh_connect(neigh);
792                         notify = 1;
793                         next = neigh->confirmed + neigh->parms->reachable_time;
794                 } else {
795                         NEIGH_PRINTK2("neigh %p is probed.\n", neigh);
796                         neigh->nud_state = NUD_PROBE;
797                         neigh->updated = jiffies;
798                         atomic_set(&neigh->probes, 0);
799                         next = now + neigh->parms->retrans_time;
800                 }
801         } else {
802                 /* NUD_PROBE|NUD_INCOMPLETE */
803                 next = now + neigh->parms->retrans_time;
804         }
805
806         if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
807             atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
808                 struct sk_buff *skb;
809
810                 neigh->nud_state = NUD_FAILED;
811                 neigh->updated = jiffies;
812                 notify = 1;
813                 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
814                 NEIGH_PRINTK2("neigh %p is failed.\n", neigh);
815
816                 /* It is very thin place. report_unreachable is very complicated
817                    routine. Particularly, it can hit the same neighbour entry!
818
819                    So that, we try to be accurate and avoid dead loop. --ANK
820                  */
821                 while (neigh->nud_state == NUD_FAILED &&
822                        (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
823                         write_unlock(&neigh->lock);
824                         neigh->ops->error_report(neigh, skb);
825                         write_lock(&neigh->lock);
826                 }
827                 skb_queue_purge(&neigh->arp_queue);
828         }
829
830         if (neigh->nud_state & NUD_IN_TIMER) {
831                 if (time_before(next, jiffies + HZ/2))
832                         next = jiffies + HZ/2;
833                 if (!mod_timer(&neigh->timer, next))
834                         neigh_hold(neigh);
835         }
836         if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
837                 struct sk_buff *skb = skb_peek(&neigh->arp_queue);
838                 /* keep skb alive even if arp_queue overflows */
839                 if (skb)
840                         skb_get(skb);
841                 write_unlock(&neigh->lock);
842                 neigh->ops->solicit(neigh, skb);
843                 atomic_inc(&neigh->probes);
844                 if (skb)
845                         kfree_skb(skb);
846         } else {
847 out:
848                 write_unlock(&neigh->lock);
849         }
850
851         if (notify)
852                 neigh_update_notify(neigh);
853
854         neigh_release(neigh);
855 }
856
857 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
858 {
859         int rc;
860         unsigned long now;
861
862         write_lock_bh(&neigh->lock);
863
864         rc = 0;
865         if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
866                 goto out_unlock_bh;
867
868         now = jiffies;
869
870         if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
871                 if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
872                         atomic_set(&neigh->probes, neigh->parms->ucast_probes);
873                         neigh->nud_state     = NUD_INCOMPLETE;
874                         neigh->updated = jiffies;
875                         neigh_add_timer(neigh, now + 1);
876                 } else {
877                         neigh->nud_state = NUD_FAILED;
878                         neigh->updated = jiffies;
879                         write_unlock_bh(&neigh->lock);
880
881                         if (skb)
882                                 kfree_skb(skb);
883                         return 1;
884                 }
885         } else if (neigh->nud_state & NUD_STALE) {
886                 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
887                 neigh->nud_state = NUD_DELAY;
888                 neigh->updated = jiffies;
889                 neigh_add_timer(neigh,
890                                 jiffies + neigh->parms->delay_probe_time);
891         }
892
893         if (neigh->nud_state == NUD_INCOMPLETE) {
894                 if (skb) {
895                         if (skb_queue_len(&neigh->arp_queue) >=
896                             neigh->parms->queue_len) {
897                                 struct sk_buff *buff;
898                                 buff = neigh->arp_queue.next;
899                                 __skb_unlink(buff, &neigh->arp_queue);
900                                 kfree_skb(buff);
901                         }
902                         __skb_queue_tail(&neigh->arp_queue, skb);
903                 }
904                 rc = 1;
905         }
906 out_unlock_bh:
907         write_unlock_bh(&neigh->lock);
908         return rc;
909 }
910
911 static void neigh_update_hhs(struct neighbour *neigh)
912 {
913         struct hh_cache *hh;
914         void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
915                 = neigh->dev->header_ops->cache_update;
916
917         if (update) {
918                 for (hh = neigh->hh; hh; hh = hh->hh_next) {
919                         write_seqlock_bh(&hh->hh_lock);
920                         update(hh, neigh->dev, neigh->ha);
921                         write_sequnlock_bh(&hh->hh_lock);
922                 }
923         }
924 }
925
926
927
928 /* Generic update routine.
929    -- lladdr is new lladdr or NULL, if it is not supplied.
930    -- new    is new state.
931    -- flags
932         NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
933                                 if it is different.
934         NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
935                                 lladdr instead of overriding it
936                                 if it is different.
937                                 It also allows to retain current state
938                                 if lladdr is unchanged.
939         NEIGH_UPDATE_F_ADMIN    means that the change is administrative.
940
941         NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
942                                 NTF_ROUTER flag.
943         NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
944                                 a router.
945
946    Caller MUST hold reference count on the entry.
947  */
948
949 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
950                  u32 flags)
951 {
952         u8 old;
953         int err;
954         int notify = 0;
955         struct net_device *dev;
956         int update_isrouter = 0;
957
958         write_lock_bh(&neigh->lock);
959
960         dev    = neigh->dev;
961         old    = neigh->nud_state;
962         err    = -EPERM;
963
964         if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
965             (old & (NUD_NOARP | NUD_PERMANENT)))
966                 goto out;
967
968         if (!(new & NUD_VALID)) {
969                 neigh_del_timer(neigh);
970                 if (old & NUD_CONNECTED)
971                         neigh_suspect(neigh);
972                 neigh->nud_state = new;
973                 err = 0;
974                 notify = old & NUD_VALID;
975                 goto out;
976         }
977
978         /* Compare new lladdr with cached one */
979         if (!dev->addr_len) {
980                 /* First case: device needs no address. */
981                 lladdr = neigh->ha;
982         } else if (lladdr) {
983                 /* The second case: if something is already cached
984                    and a new address is proposed:
985                    - compare new & old
986                    - if they are different, check override flag
987                  */
988                 if ((old & NUD_VALID) &&
989                     !memcmp(lladdr, neigh->ha, dev->addr_len))
990                         lladdr = neigh->ha;
991         } else {
992                 /* No address is supplied; if we know something,
993                    use it, otherwise discard the request.
994                  */
995                 err = -EINVAL;
996                 if (!(old & NUD_VALID))
997                         goto out;
998                 lladdr = neigh->ha;
999         }
1000
1001         if (new & NUD_CONNECTED)
1002                 neigh->confirmed = jiffies;
1003         neigh->updated = jiffies;
1004
1005         /* If entry was valid and address is not changed,
1006            do not change entry state, if new one is STALE.
1007          */
1008         err = 0;
1009         update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1010         if (old & NUD_VALID) {
1011                 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1012                         update_isrouter = 0;
1013                         if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1014                             (old & NUD_CONNECTED)) {
1015                                 lladdr = neigh->ha;
1016                                 new = NUD_STALE;
1017                         } else
1018                                 goto out;
1019                 } else {
1020                         if (lladdr == neigh->ha && new == NUD_STALE &&
1021                             ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1022                              (old & NUD_CONNECTED))
1023                             )
1024                                 new = old;
1025                 }
1026         }
1027
1028         if (new != old) {
1029                 neigh_del_timer(neigh);
1030                 if (new & NUD_IN_TIMER)
1031                         neigh_add_timer(neigh, (jiffies +
1032                                                 ((new & NUD_REACHABLE) ?
1033                                                  neigh->parms->reachable_time :
1034                                                  0)));
1035                 neigh->nud_state = new;
1036         }
1037
1038         if (lladdr != neigh->ha) {
1039                 memcpy(&neigh->ha, lladdr, dev->addr_len);
1040                 neigh_update_hhs(neigh);
1041                 if (!(new & NUD_CONNECTED))
1042                         neigh->confirmed = jiffies -
1043                                       (neigh->parms->base_reachable_time << 1);
1044                 notify = 1;
1045         }
1046         if (new == old)
1047                 goto out;
1048         if (new & NUD_CONNECTED)
1049                 neigh_connect(neigh);
1050         else
1051                 neigh_suspect(neigh);
1052         if (!(old & NUD_VALID)) {
1053                 struct sk_buff *skb;
1054
1055                 /* Again: avoid dead loop if something went wrong */
1056
1057                 while (neigh->nud_state & NUD_VALID &&
1058                        (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1059                         struct neighbour *n1 = neigh;
1060                         write_unlock_bh(&neigh->lock);
1061                         /* On shaper/eql skb->dst->neighbour != neigh :( */
1062                         if (skb->dst && skb->dst->neighbour)
1063                                 n1 = skb->dst->neighbour;
1064                         n1->output(skb);
1065                         write_lock_bh(&neigh->lock);
1066                 }
1067                 skb_queue_purge(&neigh->arp_queue);
1068         }
1069 out:
1070         if (update_isrouter) {
1071                 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1072                         (neigh->flags | NTF_ROUTER) :
1073                         (neigh->flags & ~NTF_ROUTER);
1074         }
1075         write_unlock_bh(&neigh->lock);
1076
1077         if (notify)
1078                 neigh_update_notify(neigh);
1079
1080         return err;
1081 }
1082
1083 struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1084                                  u8 *lladdr, void *saddr,
1085                                  struct net_device *dev)
1086 {
1087         struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1088                                                  lladdr || !dev->addr_len);
1089         if (neigh)
1090                 neigh_update(neigh, lladdr, NUD_STALE,
1091                              NEIGH_UPDATE_F_OVERRIDE);
1092         return neigh;
1093 }
1094
1095 static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,
1096                           __be16 protocol)
1097 {
1098         struct hh_cache *hh;
1099         struct net_device *dev = dst->dev;
1100
1101         for (hh = n->hh; hh; hh = hh->hh_next)
1102                 if (hh->hh_type == protocol)
1103                         break;
1104
1105         if (!hh && (hh = kzalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) {
1106                 seqlock_init(&hh->hh_lock);
1107                 hh->hh_type = protocol;
1108                 atomic_set(&hh->hh_refcnt, 0);
1109                 hh->hh_next = NULL;
1110
1111                 if (dev->header_ops->cache(n, hh)) {
1112                         kfree(hh);
1113                         hh = NULL;
1114                 } else {
1115                         atomic_inc(&hh->hh_refcnt);
1116                         hh->hh_next = n->hh;
1117                         n->hh       = hh;
1118                         if (n->nud_state & NUD_CONNECTED)
1119                                 hh->hh_output = n->ops->hh_output;
1120                         else
1121                                 hh->hh_output = n->ops->output;
1122                 }
1123         }
1124         if (hh) {
1125                 atomic_inc(&hh->hh_refcnt);
1126                 dst->hh = hh;
1127         }
1128 }
1129
1130 /* This function can be used in contexts, where only old dev_queue_xmit
1131    worked, f.e. if you want to override normal output path (eql, shaper),
1132    but resolution is not made yet.
1133  */
1134
1135 int neigh_compat_output(struct sk_buff *skb)
1136 {
1137         struct net_device *dev = skb->dev;
1138
1139         __skb_pull(skb, skb_network_offset(skb));
1140
1141         if (dev_hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
1142                             skb->len) < 0 &&
1143             dev->header_ops->rebuild(skb))
1144                 return 0;
1145
1146         return dev_queue_xmit(skb);
1147 }
1148
1149 /* Slow and careful. */
1150
1151 int neigh_resolve_output(struct sk_buff *skb)
1152 {
1153         struct dst_entry *dst = skb->dst;
1154         struct neighbour *neigh;
1155         int rc = 0;
1156
1157         if (!dst || !(neigh = dst->neighbour))
1158                 goto discard;
1159
1160         __skb_pull(skb, skb_network_offset(skb));
1161
1162         if (!neigh_event_send(neigh, skb)) {
1163                 int err;
1164                 struct net_device *dev = neigh->dev;
1165                 if (dev->header_ops->cache && !dst->hh) {
1166                         write_lock_bh(&neigh->lock);
1167                         if (!dst->hh)
1168                                 neigh_hh_init(neigh, dst, dst->ops->protocol);
1169                         err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1170                                               neigh->ha, NULL, skb->len);
1171                         write_unlock_bh(&neigh->lock);
1172                 } else {
1173                         read_lock_bh(&neigh->lock);
1174                         err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1175                                               neigh->ha, NULL, skb->len);
1176                         read_unlock_bh(&neigh->lock);
1177                 }
1178                 if (err >= 0)
1179                         rc = neigh->ops->queue_xmit(skb);
1180                 else
1181                         goto out_kfree_skb;
1182         }
1183 out:
1184         return rc;
1185 discard:
1186         NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1187                       dst, dst ? dst->neighbour : NULL);
1188 out_kfree_skb:
1189         rc = -EINVAL;
1190         kfree_skb(skb);
1191         goto out;
1192 }
1193
1194 /* As fast as possible without hh cache */
1195
1196 int neigh_connected_output(struct sk_buff *skb)
1197 {
1198         int err;
1199         struct dst_entry *dst = skb->dst;
1200         struct neighbour *neigh = dst->neighbour;
1201         struct net_device *dev = neigh->dev;
1202
1203         __skb_pull(skb, skb_network_offset(skb));
1204
1205         read_lock_bh(&neigh->lock);
1206         err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1207                               neigh->ha, NULL, skb->len);
1208         read_unlock_bh(&neigh->lock);
1209         if (err >= 0)
1210                 err = neigh->ops->queue_xmit(skb);
1211         else {
1212                 err = -EINVAL;
1213                 kfree_skb(skb);
1214         }
1215         return err;
1216 }
1217
1218 static void neigh_proxy_process(unsigned long arg)
1219 {
1220         struct neigh_table *tbl = (struct neigh_table *)arg;
1221         long sched_next = 0;
1222         unsigned long now = jiffies;
1223         struct sk_buff *skb;
1224
1225         spin_lock(&tbl->proxy_queue.lock);
1226
1227         skb = tbl->proxy_queue.next;
1228
1229         while (skb != (struct sk_buff *)&tbl->proxy_queue) {
1230                 struct sk_buff *back = skb;
1231                 long tdif = NEIGH_CB(back)->sched_next - now;
1232
1233                 skb = skb->next;
1234                 if (tdif <= 0) {
1235                         struct net_device *dev = back->dev;
1236                         __skb_unlink(back, &tbl->proxy_queue);
1237                         if (tbl->proxy_redo && netif_running(dev))
1238                                 tbl->proxy_redo(back);
1239                         else
1240                                 kfree_skb(back);
1241
1242                         dev_put(dev);
1243                 } else if (!sched_next || tdif < sched_next)
1244                         sched_next = tdif;
1245         }
1246         del_timer(&tbl->proxy_timer);
1247         if (sched_next)
1248                 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1249         spin_unlock(&tbl->proxy_queue.lock);
1250 }
1251
1252 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1253                     struct sk_buff *skb)
1254 {
1255         unsigned long now = jiffies;
1256         unsigned long sched_next = now + (net_random() % p->proxy_delay);
1257
1258         if (tbl->proxy_queue.qlen > p->proxy_qlen) {
1259                 kfree_skb(skb);
1260                 return;
1261         }
1262
1263         NEIGH_CB(skb)->sched_next = sched_next;
1264         NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
1265
1266         spin_lock(&tbl->proxy_queue.lock);
1267         if (del_timer(&tbl->proxy_timer)) {
1268                 if (time_before(tbl->proxy_timer.expires, sched_next))
1269                         sched_next = tbl->proxy_timer.expires;
1270         }
1271         dst_release(skb->dst);
1272         skb->dst = NULL;
1273         dev_hold(skb->dev);
1274         __skb_queue_tail(&tbl->proxy_queue, skb);
1275         mod_timer(&tbl->proxy_timer, sched_next);
1276         spin_unlock(&tbl->proxy_queue.lock);
1277 }
1278
1279 static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl,
1280                                                       struct net *net, int ifindex)
1281 {
1282         struct neigh_parms *p;
1283
1284         for (p = &tbl->parms; p; p = p->next) {
1285                 if (p->net != net)
1286                         continue;
1287                 if ((p->dev && p->dev->ifindex == ifindex) ||
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 = create_proc_entry(tbl->id, 0, init_net.proc_net_stat);
1391         if (!tbl->pde)
1392                 panic("cannot create neighbour proc dir entry");
1393         tbl->pde->proc_fops = &neigh_stat_seq_fops;
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 = register_sysctl_paths(neigh_path, t->neigh_vars);
2743         if (!t->sysctl_header)
2744                 goto free_procname;
2745
2746         p->sysctl_table = t;
2747         return 0;
2748
2749 free_procname:
2750         kfree(t->dev_name);
2751 free:
2752         kfree(t);
2753 err:
2754         return -ENOBUFS;
2755 }
2756
2757 void neigh_sysctl_unregister(struct neigh_parms *p)
2758 {
2759         if (p->sysctl_table) {
2760                 struct neigh_sysctl_table *t = p->sysctl_table;
2761                 p->sysctl_table = NULL;
2762                 unregister_sysctl_table(t->sysctl_header);
2763                 kfree(t->dev_name);
2764                 kfree(t);
2765         }
2766 }
2767
2768 #endif  /* CONFIG_SYSCTL */
2769
2770 static int __init neigh_init(void)
2771 {
2772         rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL);
2773         rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL);
2774         rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info);
2775
2776         rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info);
2777         rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL);
2778
2779         return 0;
2780 }
2781
2782 subsys_initcall(neigh_init);
2783
2784 EXPORT_SYMBOL(__neigh_event_send);
2785 EXPORT_SYMBOL(neigh_changeaddr);
2786 EXPORT_SYMBOL(neigh_compat_output);
2787 EXPORT_SYMBOL(neigh_connected_output);
2788 EXPORT_SYMBOL(neigh_create);
2789 EXPORT_SYMBOL(neigh_destroy);
2790 EXPORT_SYMBOL(neigh_event_ns);
2791 EXPORT_SYMBOL(neigh_ifdown);
2792 EXPORT_SYMBOL(neigh_lookup);
2793 EXPORT_SYMBOL(neigh_lookup_nodev);
2794 EXPORT_SYMBOL(neigh_parms_alloc);
2795 EXPORT_SYMBOL(neigh_parms_release);
2796 EXPORT_SYMBOL(neigh_rand_reach_time);
2797 EXPORT_SYMBOL(neigh_resolve_output);
2798 EXPORT_SYMBOL(neigh_table_clear);
2799 EXPORT_SYMBOL(neigh_table_init);
2800 EXPORT_SYMBOL(neigh_table_init_no_netlink);
2801 EXPORT_SYMBOL(neigh_update);
2802 EXPORT_SYMBOL(pneigh_enqueue);
2803 EXPORT_SYMBOL(pneigh_lookup);
2804
2805 #ifdef CONFIG_ARPD
2806 EXPORT_SYMBOL(neigh_app_ns);
2807 #endif
2808 #ifdef CONFIG_SYSCTL
2809 EXPORT_SYMBOL(neigh_sysctl_register);
2810 EXPORT_SYMBOL(neigh_sysctl_unregister);
2811 #endif