net/core/neighbour.c

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