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