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