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

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