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