net/core/neighbour.c

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