git.oblomov.eu Git - linux-2.6/blob - net/core/neighbour.c

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