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

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