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