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