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_PRINTK1 NEIGH_NOPRINTK
  45 #define NEIGH_PRINTK2 NEIGH_NOPRINTK
  46
  47 #if NEIGH_DEBUG >= 1
  48 #undef NEIGH_PRINTK1
  49 #define NEIGH_PRINTK1 NEIGH_PRINTK
  50 #endif
  51 #if NEIGH_DEBUG >= 2
  52 #undef NEIGH_PRINTK2
  53 #define NEIGH_PRINTK2 NEIGH_PRINTK
  54 #endif
  55
  56 #define PNEIGH_HASHMASK         0xF
  57
  58 static void neigh_timer_handler(unsigned long arg);
  59 static void __neigh_notify(struct neighbour *n, int type, int flags);
  60 static void neigh_update_notify(struct neighbour *neigh);
  61 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
  62
  63 static struct neigh_table *neigh_tables;
  64 #ifdef CONFIG_PROC_FS
  65 static const struct file_operations neigh_stat_seq_fops;
  66 #endif
  67
  68 /*
  69    Neighbour hash table buckets are protected with rwlock tbl->lock.
  70
  71    - All the scans/updates to hash buckets MUST be made under this lock.
  72    - NOTHING clever should be made under this lock: no callbacks
  73      to protocol backends, no attempts to send something to network.
  74      It will result in deadlocks, if backend/driver wants to use neighbour
  75      cache.
  76    - If the entry requires some non-trivial actions, increase
  77      its reference count and release table lock.
  78
  79    Neighbour entries are protected:
  80    - with reference count.
  81    - with rwlock neigh->lock
  82
  83    Reference count prevents destruction.
  84
  85    neigh->lock mainly serializes ll address data and its validity state.
  86    However, the same lock is used to protect another entry fields:
  87     - timer
  88     - resolution queue
  89
  90    Again, nothing clever shall be made under neigh->lock,
  91    the most complicated procedure, which we allow is dev->hard_header.
  92    It is supposed, that dev->hard_header is simplistic and does
  93    not make callbacks to neighbour tables.
  94
  95    The last lock is neigh_tbl_lock. It is pure SMP lock, protecting
  96    list of neighbour tables. This list is used only in process context,
  97  */
  98
  99 static DEFINE_RWLOCK(neigh_tbl_lock);
 100
 101 static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb)
 102 {
 103         kfree_skb(skb);
 104         return -ENETDOWN;
 105 }
 106
 107 static void neigh_cleanup_and_release(struct neighbour *neigh)
 108 {
 109         if (neigh->parms->neigh_cleanup)
 110                 neigh->parms->neigh_cleanup(neigh);
 111
 112         __neigh_notify(neigh, RTM_DELNEIGH, 0);
 113         neigh_release(neigh);
 114 }
 115
 116 /*
 117  * It is random distribution in the interval (1/2)*base...(3/2)*base.
 118  * It corresponds to default IPv6 settings and is not overridable,
 119  * because it is really reasonable choice.
 120  */
 121
 122 unsigned long neigh_rand_reach_time(unsigned long base)
 123 {
 124         return base ? (net_random() % base) + (base >> 1) : 0;
 125 }
 126 EXPORT_SYMBOL(neigh_rand_reach_time);
 127
 128
 129 static int neigh_forced_gc(struct neigh_table *tbl)
 130 {
 131         int shrunk = 0;
 132         int i;
 133         struct neigh_hash_table *nht;
 134
 135         NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
 136
 137         write_lock_bh(&tbl->lock);
 138         nht = rcu_dereference_protected(tbl->nht,
 139                                         lockdep_is_held(&tbl->lock));
 140         for (i = 0; i < (1 << nht->hash_shift); i++) {
 141                 struct neighbour *n;
 142                 struct neighbour __rcu **np;
 143
 144                 np = &nht->hash_buckets[i];
 145                 while ((n = rcu_dereference_protected(*np,
 146                                         lockdep_is_held(&tbl->lock))) != NULL) {
 147                         /* Neighbour record may be discarded if:
 148                          * - nobody refers to it.
 149                          * - it is not permanent
 150                          */
 151                         write_lock(&n->lock);
 152                         if (atomic_read(&n->refcnt) == 1 &&
 153                             !(n->nud_state & NUD_PERMANENT)) {
 154                                 rcu_assign_pointer(*np,
 155                                         rcu_dereference_protected(n->next,
 156                                                   lockdep_is_held(&tbl->lock)));
 157                                 n->dead = 1;
 158                                 shrunk  = 1;
 159                                 write_unlock(&n->lock);
 160                                 neigh_cleanup_and_release(n);
 161                                 continue;
 162                         }
 163                         write_unlock(&n->lock);
 164                         np = &n->next;
 165                 }
 166         }
 167
 168         tbl->last_flush = jiffies;
 169
 170         write_unlock_bh(&tbl->lock);
 171
 172         return shrunk;
 173 }
 174
 175 static void neigh_add_timer(struct neighbour *n, unsigned long when)
 176 {
 177         neigh_hold(n);
 178         if (unlikely(mod_timer(&n->timer, when))) {
 179                 printk("NEIGH: BUG, double timer add, state is %x\n",
 180                        n->nud_state);
 181                 dump_stack();
 182         }
 183 }
 184
 185 static int neigh_del_timer(struct neighbour *n)
 186 {
 187         if ((n->nud_state & NUD_IN_TIMER) &&
 188             del_timer(&n->timer)) {
 189                 neigh_release(n);
 190                 return 1;
 191         }
 192         return 0;
 193 }
 194
 195 static void pneigh_queue_purge(struct sk_buff_head *list)
 196 {
 197         struct sk_buff *skb;
 198
 199         while ((skb = skb_dequeue(list)) != NULL) {
 200                 dev_put(skb->dev);
 201                 kfree_skb(skb);
 202         }
 203 }
 204
 205 static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
 206 {
 207         int i;
 208         struct neigh_hash_table *nht;
 209
 210         nht = rcu_dereference_protected(tbl->nht,
 211                                         lockdep_is_held(&tbl->lock));
 212
 213         for (i = 0; i < (1 << nht->hash_shift); i++) {
 214                 struct neighbour *n;
 215                 struct neighbour __rcu **np = &nht->hash_buckets[i];
 216
 217                 while ((n = rcu_dereference_protected(*np,
 218                                         lockdep_is_held(&tbl->lock))) != NULL) {
 219                         if (dev && n->dev != dev) {
 220                                 np = &n->next;
 221                                 continue;
 222                         }
 223                         rcu_assign_pointer(*np,
 224                                    rcu_dereference_protected(n->next,
 225                                                 lockdep_is_held(&tbl->lock)));
 226                         write_lock(&n->lock);
 227                         neigh_del_timer(n);
 228                         n->dead = 1;
 229
 230                         if (atomic_read(&n->refcnt) != 1) {
 231                                 /* The most unpleasant situation.
 232                                    We must destroy neighbour entry,
 233                                    but someone still uses it.
 234
 235                                    The destroy will be delayed until
 236                                    the last user releases us, but
 237                                    we must kill timers etc. and move
 238                                    it to safe state.
 239                                  */
 240                                 skb_queue_purge(&n->arp_queue);
 241                                 n->output = neigh_blackhole;
 242                                 if (n->nud_state & NUD_VALID)
 243                                         n->nud_state = NUD_NOARP;
 244                                 else
 245                                         n->nud_state = NUD_NONE;
 246                                 NEIGH_PRINTK2("neigh %p is stray.\n", n);
 247                         }
 248                         write_unlock(&n->lock);
 249                         neigh_cleanup_and_release(n);
 250                 }
 251         }
 252 }
 253
 254 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
 255 {
 256         write_lock_bh(&tbl->lock);
 257         neigh_flush_dev(tbl, dev);
 258         write_unlock_bh(&tbl->lock);
 259 }
 260 EXPORT_SYMBOL(neigh_changeaddr);
 261
 262 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
 263 {
 264         write_lock_bh(&tbl->lock);
 265         neigh_flush_dev(tbl, dev);
 266         pneigh_ifdown(tbl, dev);
 267         write_unlock_bh(&tbl->lock);
 268
 269         del_timer_sync(&tbl->proxy_timer);
 270         pneigh_queue_purge(&tbl->proxy_queue);
 271         return 0;
 272 }
 273 EXPORT_SYMBOL(neigh_ifdown);
 274
 275 static struct neighbour *neigh_alloc(struct neigh_table *tbl)
 276 {
 277         struct neighbour *n = NULL;
 278         unsigned long now = jiffies;
 279         int entries;
 280
 281         entries = atomic_inc_return(&tbl->entries) - 1;
 282         if (entries >= tbl->gc_thresh3 ||
 283             (entries >= tbl->gc_thresh2 &&
 284              time_after(now, tbl->last_flush + 5 * HZ))) {
 285                 if (!neigh_forced_gc(tbl) &&
 286                     entries >= tbl->gc_thresh3)
 287                         goto out_entries;
 288         }
 289
 290         n = kmem_cache_zalloc(tbl->kmem_cachep, GFP_ATOMIC);
 291         if (!n)
 292                 goto out_entries;
 293
 294         skb_queue_head_init(&n->arp_queue);
 295         rwlock_init(&n->lock);
 296         seqlock_init(&n->ha_lock);
 297         n->updated        = n->used = now;
 298         n->nud_state      = NUD_NONE;
 299         n->output         = neigh_blackhole;
 300         seqlock_init(&n->hh.hh_lock);
 301         n->parms          = neigh_parms_clone(&tbl->parms);
 302         setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n);
 303
 304         NEIGH_CACHE_STAT_INC(tbl, allocs);
 305         n->tbl            = tbl;
 306         atomic_set(&n->refcnt, 1);
 307         n->dead           = 1;
 308 out:
 309         return n;
 310
 311 out_entries:
 312         atomic_dec(&tbl->entries);
 313         goto out;
 314 }
 315
 316 static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift)
 317 {
 318         size_t size = (1 << shift) * sizeof(struct neighbour *);
 319         struct neigh_hash_table *ret;
 320         struct neighbour __rcu **buckets;
 321
 322         ret = kmalloc(sizeof(*ret), GFP_ATOMIC);
 323         if (!ret)
 324                 return NULL;
 325         if (size <= PAGE_SIZE)
 326                 buckets = kzalloc(size, GFP_ATOMIC);
 327         else
 328                 buckets = (struct neighbour __rcu **)
 329                           __get_free_pages(GFP_ATOMIC | __GFP_ZERO,
 330                                            get_order(size));
 331         if (!buckets) {
 332                 kfree(ret);
 333                 return NULL;
 334         }
 335         ret->hash_buckets = buckets;
 336         ret->hash_shift = shift;
 337         get_random_bytes(&ret->hash_rnd, sizeof(ret->hash_rnd));
 338         ret->hash_rnd |= 1;
 339         return ret;
 340 }
 341
 342 static void neigh_hash_free_rcu(struct rcu_head *head)
 343 {
 344         struct neigh_hash_table *nht = container_of(head,
 345                                                     struct neigh_hash_table,
 346                                                     rcu);
 347         size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *);
 348         struct neighbour __rcu **buckets = nht->hash_buckets;
 349
 350         if (size <= PAGE_SIZE)
 351                 kfree(buckets);
 352         else
 353                 free_pages((unsigned long)buckets, get_order(size));
 354         kfree(nht);
 355 }
 356
 357 static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl,
 358                                                 unsigned long new_shift)
 359 {
 360         unsigned int i, hash;
 361         struct neigh_hash_table *new_nht, *old_nht;
 362
 363         NEIGH_CACHE_STAT_INC(tbl, hash_grows);
 364
 365         old_nht = rcu_dereference_protected(tbl->nht,
 366                                             lockdep_is_held(&tbl->lock));
 367         new_nht = neigh_hash_alloc(new_shift);
 368         if (!new_nht)
 369                 return old_nht;
 370
 371         for (i = 0; i < (1 << old_nht->hash_shift); i++) {
 372                 struct neighbour *n, *next;
 373
 374                 for (n = rcu_dereference_protected(old_nht->hash_buckets[i],
 375                                                    lockdep_is_held(&tbl->lock));
 376                      n != NULL;
 377                      n = next) {
 378                         hash = tbl->hash(n->primary_key, n->dev,
 379                                          new_nht->hash_rnd);
 380
 381                         hash >>= (32 - new_nht->hash_shift);
 382                         next = rcu_dereference_protected(n->next,
 383                                                 lockdep_is_held(&tbl->lock));
 384
 385                         rcu_assign_pointer(n->next,
 386                                            rcu_dereference_protected(
 387                                                 new_nht->hash_buckets[hash],
 388                                                 lockdep_is_held(&tbl->lock)));
 389                         rcu_assign_pointer(new_nht->hash_buckets[hash], n);
 390                 }
 391         }
 392
 393         rcu_assign_pointer(tbl->nht, new_nht);
 394         call_rcu(&old_nht->rcu, neigh_hash_free_rcu);
 395         return new_nht;
 396 }
 397
 398 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
 399                                struct net_device *dev)
 400 {
 401         struct neighbour *n;
 402         int key_len = tbl->key_len;
 403         u32 hash_val;
 404         struct neigh_hash_table *nht;
 405
 406         NEIGH_CACHE_STAT_INC(tbl, lookups);
 407
 408         rcu_read_lock_bh();
 409         nht = rcu_dereference_bh(tbl->nht);
 410         hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
 411
 412         for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
 413              n != NULL;
 414              n = rcu_dereference_bh(n->next)) {
 415                 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
 416                         if (!atomic_inc_not_zero(&n->refcnt))
 417                                 n = NULL;
 418                         NEIGH_CACHE_STAT_INC(tbl, hits);
 419                         break;
 420                 }
 421         }
 422
 423         rcu_read_unlock_bh();
 424         return n;
 425 }
 426 EXPORT_SYMBOL(neigh_lookup);
 427
 428 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
 429                                      const void *pkey)
 430 {
 431         struct neighbour *n;
 432         int key_len = tbl->key_len;
 433         u32 hash_val;
 434         struct neigh_hash_table *nht;
 435
 436         NEIGH_CACHE_STAT_INC(tbl, lookups);
 437
 438         rcu_read_lock_bh();
 439         nht = rcu_dereference_bh(tbl->nht);
 440         hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift);
 441
 442         for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
 443              n != NULL;
 444              n = rcu_dereference_bh(n->next)) {
 445                 if (!memcmp(n->primary_key, pkey, key_len) &&
 446                     net_eq(dev_net(n->dev), net)) {
 447                         if (!atomic_inc_not_zero(&n->refcnt))
 448                                 n = NULL;
 449                         NEIGH_CACHE_STAT_INC(tbl, hits);
 450                         break;
 451                 }
 452         }
 453
 454         rcu_read_unlock_bh();
 455         return n;
 456 }
 457 EXPORT_SYMBOL(neigh_lookup_nodev);
 458
 459 struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey,
 460                                struct net_device *dev)
 461 {
 462         u32 hash_val;
 463         int key_len = tbl->key_len;
 464         int error;
 465         struct neighbour *n1, *rc, *n = neigh_alloc(tbl);
 466         struct neigh_hash_table *nht;
 467
 468         if (!n) {
 469                 rc = ERR_PTR(-ENOBUFS);
 470                 goto out;
 471         }
 472
 473         memcpy(n->primary_key, pkey, key_len);
 474         n->dev = dev;
 475         dev_hold(dev);
 476
 477         /* Protocol specific setup. */
 478         if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
 479                 rc = ERR_PTR(error);
 480                 goto out_neigh_release;
 481         }
 482
 483         /* Device specific setup. */
 484         if (n->parms->neigh_setup &&
 485             (error = n->parms->neigh_setup(n)) < 0) {
 486                 rc = ERR_PTR(error);
 487                 goto out_neigh_release;
 488         }
 489
 490         n->confirmed = jiffies - (n->parms->base_reachable_time << 1);
 491
 492         write_lock_bh(&tbl->lock);
 493         nht = rcu_dereference_protected(tbl->nht,
 494                                         lockdep_is_held(&tbl->lock));
 495
 496         if (atomic_read(&tbl->entries) > (1 << nht->hash_shift))
 497                 nht = neigh_hash_grow(tbl, nht->hash_shift + 1);
 498
 499         hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
 500
 501         if (n->parms->dead) {
 502                 rc = ERR_PTR(-EINVAL);
 503                 goto out_tbl_unlock;
 504         }
 505
 506         for (n1 = rcu_dereference_protected(nht->hash_buckets[hash_val],
 507                                             lockdep_is_held(&tbl->lock));
 508              n1 != NULL;
 509              n1 = rcu_dereference_protected(n1->next,
 510                         lockdep_is_held(&tbl->lock))) {
 511                 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
 512                         neigh_hold(n1);
 513                         rc = n1;
 514                         goto out_tbl_unlock;
 515                 }
 516         }
 517
 518         n->dead = 0;
 519         neigh_hold(n);
 520         rcu_assign_pointer(n->next,
 521                            rcu_dereference_protected(nht->hash_buckets[hash_val],
 522                                                      lockdep_is_held(&tbl->lock)));
 523         rcu_assign_pointer(nht->hash_buckets[hash_val], n);
 524         write_unlock_bh(&tbl->lock);
 525         NEIGH_PRINTK2("neigh %p is created.\n", n);
 526         rc = n;
 527 out:
 528         return rc;
 529 out_tbl_unlock:
 530         write_unlock_bh(&tbl->lock);
 531 out_neigh_release:
 532         neigh_release(n);
 533         goto out;
 534 }
 535 EXPORT_SYMBOL(neigh_create);
 536
 537 static u32 pneigh_hash(const void *pkey, int key_len)
 538 {
 539         u32 hash_val = *(u32 *)(pkey + key_len - 4);
 540         hash_val ^= (hash_val >> 16);
 541         hash_val ^= hash_val >> 8;
 542         hash_val ^= hash_val >> 4;
 543         hash_val &= PNEIGH_HASHMASK;
 544         return hash_val;
 545 }
 546
 547 static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n,
 548                                               struct net *net,
 549                                               const void *pkey,
 550                                               int key_len,
 551                                               struct net_device *dev)
 552 {
 553         while (n) {
 554                 if (!memcmp(n->key, pkey, key_len) &&
 555                     net_eq(pneigh_net(n), net) &&
 556                     (n->dev == dev || !n->dev))
 557                         return n;
 558                 n = n->next;
 559         }
 560         return NULL;
 561 }
 562
 563 struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl,
 564                 struct net *net, const void *pkey, struct net_device *dev)
 565 {
 566         int key_len = tbl->key_len;
 567         u32 hash_val = pneigh_hash(pkey, key_len);
 568
 569         return __pneigh_lookup_1(tbl->phash_buckets[hash_val],
 570                                  net, pkey, key_len, dev);
 571 }
 572 EXPORT_SYMBOL_GPL(__pneigh_lookup);
 573
 574 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl,
 575                                     struct net *net, const void *pkey,
 576                                     struct net_device *dev, int creat)
 577 {
 578         struct pneigh_entry *n;
 579         int key_len = tbl->key_len;
 580         u32 hash_val = pneigh_hash(pkey, key_len);
 581
 582         read_lock_bh(&tbl->lock);
 583         n = __pneigh_lookup_1(tbl->phash_buckets[hash_val],
 584                               net, pkey, key_len, dev);
 585         read_unlock_bh(&tbl->lock);
 586
 587         if (n || !creat)
 588                 goto out;
 589
 590         ASSERT_RTNL();
 591
 592         n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
 593         if (!n)
 594                 goto out;
 595
 596         write_pnet(&n->net, hold_net(net));
 597         memcpy(n->key, pkey, key_len);
 598         n->dev = dev;
 599         if (dev)
 600                 dev_hold(dev);
 601
 602         if (tbl->pconstructor && tbl->pconstructor(n)) {
 603                 if (dev)
 604                         dev_put(dev);
 605                 release_net(net);
 606                 kfree(n);
 607                 n = NULL;
 608                 goto out;
 609         }
 610
 611         write_lock_bh(&tbl->lock);
 612         n->next = tbl->phash_buckets[hash_val];
 613         tbl->phash_buckets[hash_val] = n;
 614         write_unlock_bh(&tbl->lock);
 615 out:
 616         return n;
 617 }
 618 EXPORT_SYMBOL(pneigh_lookup);
 619
 620
 621 int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey,
 622                   struct net_device *dev)
 623 {
 624         struct pneigh_entry *n, **np;
 625         int key_len = tbl->key_len;
 626         u32 hash_val = pneigh_hash(pkey, key_len);
 627
 628         write_lock_bh(&tbl->lock);
 629         for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
 630              np = &n->next) {
 631                 if (!memcmp(n->key, pkey, key_len) && n->dev == dev &&
 632                     net_eq(pneigh_net(n), net)) {
 633                         *np = n->next;
 634                         write_unlock_bh(&tbl->lock);
 635                         if (tbl->pdestructor)
 636                                 tbl->pdestructor(n);
 637                         if (n->dev)
 638                                 dev_put(n->dev);
 639                         release_net(pneigh_net(n));
 640                         kfree(n);
 641                         return 0;
 642                 }
 643         }
 644         write_unlock_bh(&tbl->lock);
 645         return -ENOENT;
 646 }
 647
 648 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
 649 {
 650         struct pneigh_entry *n, **np;
 651         u32 h;
 652
 653         for (h = 0; h <= PNEIGH_HASHMASK; h++) {
 654                 np = &tbl->phash_buckets[h];
 655                 while ((n = *np) != NULL) {
 656                         if (!dev || n->dev == dev) {
 657                                 *np = n->next;
 658                                 if (tbl->pdestructor)
 659                                         tbl->pdestructor(n);
 660                                 if (n->dev)
 661                                         dev_put(n->dev);
 662                                 release_net(pneigh_net(n));
 663                                 kfree(n);
 664                                 continue;
 665                         }
 666                         np = &n->next;
 667                 }
 668         }
 669         return -ENOENT;
 670 }
 671
 672 static void neigh_parms_destroy(struct neigh_parms *parms);
 673
 674 static inline void neigh_parms_put(struct neigh_parms *parms)
 675 {
 676         if (atomic_dec_and_test(&parms->refcnt))
 677                 neigh_parms_destroy(parms);
 678 }
 679
 680 static void neigh_destroy_rcu(struct rcu_head *head)
 681 {
 682         struct neighbour *neigh = container_of(head, struct neighbour, rcu);
 683
 684         kmem_cache_free(neigh->tbl->kmem_cachep, neigh);
 685 }
 686 /*
 687  *      neighbour must already be out of the table;
 688  *
 689  */
 690 void neigh_destroy(struct neighbour *neigh)
 691 {
 692         NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
 693
 694         if (!neigh->dead) {
 695                 printk(KERN_WARNING
 696                        "Destroying alive neighbour %p\n", neigh);
 697                 dump_stack();
 698                 return;
 699         }
 700
 701         if (neigh_del_timer(neigh))
 702                 printk(KERN_WARNING "Impossible event.\n");
 703
 704         skb_queue_purge(&neigh->arp_queue);
 705
 706         dev_put(neigh->dev);
 707         neigh_parms_put(neigh->parms);
 708
 709         NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh);
 710
 711         atomic_dec(&neigh->tbl->entries);
 712         call_rcu(&neigh->rcu, neigh_destroy_rcu);
 713 }
 714 EXPORT_SYMBOL(neigh_destroy);
 715
 716 /* Neighbour state is suspicious;
 717    disable fast path.
 718
 719    Called with write_locked neigh.
 720  */
 721 static void neigh_suspect(struct neighbour *neigh)
 722 {
 723         NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
 724
 725         neigh->output = neigh->ops->output;
 726 }
 727
 728 /* Neighbour state is OK;
 729    enable fast path.
 730
 731    Called with write_locked neigh.
 732  */
 733 static void neigh_connect(struct neighbour *neigh)
 734 {
 735         NEIGH_PRINTK2("neigh %p is connected.\n", neigh);
 736
 737         neigh->output = neigh->ops->connected_output;
 738 }
 739
 740 static void neigh_periodic_work(struct work_struct *work)
 741 {
 742         struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work);
 743         struct neighbour *n;
 744         struct neighbour __rcu **np;
 745         unsigned int i;
 746         struct neigh_hash_table *nht;
 747
 748         NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
 749
 750         write_lock_bh(&tbl->lock);
 751         nht = rcu_dereference_protected(tbl->nht,
 752                                         lockdep_is_held(&tbl->lock));
 753
 754         /*
 755          *      periodically recompute ReachableTime from random function
 756          */
 757
 758         if (time_after(jiffies, tbl->last_rand + 300 * HZ)) {
 759                 struct neigh_parms *p;
 760                 tbl->last_rand = jiffies;
 761                 for (p = &tbl->parms; p; p = p->next)
 762                         p->reachable_time =
 763                                 neigh_rand_reach_time(p->base_reachable_time);
 764         }
 765
 766         for (i = 0 ; i < (1 << nht->hash_shift); i++) {
 767                 np = &nht->hash_buckets[i];
 768
 769                 while ((n = rcu_dereference_protected(*np,
 770                                 lockdep_is_held(&tbl->lock))) != NULL) {
 771                         unsigned int state;
 772
 773                         write_lock(&n->lock);
 774
 775                         state = n->nud_state;
 776                         if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
 777                                 write_unlock(&n->lock);
 778                                 goto next_elt;
 779                         }
 780
 781                         if (time_before(n->used, n->confirmed))
 782                                 n->used = n->confirmed;
 783
 784                         if (atomic_read(&n->refcnt) == 1 &&
 785                             (state == NUD_FAILED ||
 786                              time_after(jiffies, n->used + n->parms->gc_staletime))) {
 787                                 *np = n->next;
 788                                 n->dead = 1;
 789                                 write_unlock(&n->lock);
 790                                 neigh_cleanup_and_release(n);
 791                                 continue;
 792                         }
 793                         write_unlock(&n->lock);
 794
 795 next_elt:
 796                         np = &n->next;
 797                 }
 798                 /*
 799                  * It's fine to release lock here, even if hash table
 800                  * grows while we are preempted.
 801                  */
 802                 write_unlock_bh(&tbl->lock);
 803                 cond_resched();
 804                 write_lock_bh(&tbl->lock);
 805         }
 806         /* Cycle through all hash buckets every base_reachable_time/2 ticks.
 807          * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
 808          * base_reachable_time.
 809          */
 810         schedule_delayed_work(&tbl->gc_work,
 811                               tbl->parms.base_reachable_time >> 1);
 812         write_unlock_bh(&tbl->lock);
 813 }
 814
 815 static __inline__ int neigh_max_probes(struct neighbour *n)
 816 {
 817         struct neigh_parms *p = n->parms;
 818         return (n->nud_state & NUD_PROBE) ?
 819                 p->ucast_probes :
 820                 p->ucast_probes + p->app_probes + p->mcast_probes;
 821 }
 822
 823 static void neigh_invalidate(struct neighbour *neigh)
 824         __releases(neigh->lock)
 825         __acquires(neigh->lock)
 826 {
 827         struct sk_buff *skb;
 828
 829         NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
 830         NEIGH_PRINTK2("neigh %p is failed.\n", neigh);
 831         neigh->updated = jiffies;
 832
 833         /* It is very thin place. report_unreachable is very complicated
 834            routine. Particularly, it can hit the same neighbour entry!
 835
 836            So that, we try to be accurate and avoid dead loop. --ANK
 837          */
 838         while (neigh->nud_state == NUD_FAILED &&
 839                (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
 840                 write_unlock(&neigh->lock);
 841                 neigh->ops->error_report(neigh, skb);
 842                 write_lock(&neigh->lock);
 843         }
 844         skb_queue_purge(&neigh->arp_queue);
 845 }
 846
 847 /* Called when a timer expires for a neighbour entry. */
 848
 849 static void neigh_timer_handler(unsigned long arg)
 850 {
 851         unsigned long now, next;
 852         struct neighbour *neigh = (struct neighbour *)arg;
 853         unsigned state;
 854         int notify = 0;
 855
 856         write_lock(&neigh->lock);
 857
 858         state = neigh->nud_state;
 859         now = jiffies;
 860         next = now + HZ;
 861
 862         if (!(state & NUD_IN_TIMER)) {
 863 #ifndef CONFIG_SMP
 864                 printk(KERN_WARNING "neigh: timer & !nud_in_timer\n");
 865 #endif
 866                 goto out;
 867         }
 868
 869         if (state & NUD_REACHABLE) {
 870                 if (time_before_eq(now,
 871                                    neigh->confirmed + neigh->parms->reachable_time)) {
 872                         NEIGH_PRINTK2("neigh %p is still alive.\n", neigh);
 873                         next = neigh->confirmed + neigh->parms->reachable_time;
 874                 } else if (time_before_eq(now,
 875                                           neigh->used + neigh->parms->delay_probe_time)) {
 876                         NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
 877                         neigh->nud_state = NUD_DELAY;
 878                         neigh->updated = jiffies;
 879                         neigh_suspect(neigh);
 880                         next = now + neigh->parms->delay_probe_time;
 881                 } else {
 882                         NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
 883                         neigh->nud_state = NUD_STALE;
 884                         neigh->updated = jiffies;
 885                         neigh_suspect(neigh);
 886                         notify = 1;
 887                 }
 888         } else if (state & NUD_DELAY) {
 889                 if (time_before_eq(now,
 890                                    neigh->confirmed + neigh->parms->delay_probe_time)) {
 891                         NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh);
 892                         neigh->nud_state = NUD_REACHABLE;
 893                         neigh->updated = jiffies;
 894                         neigh_connect(neigh);
 895                         notify = 1;
 896                         next = neigh->confirmed + neigh->parms->reachable_time;
 897                 } else {
 898                         NEIGH_PRINTK2("neigh %p is probed.\n", neigh);
 899                         neigh->nud_state = NUD_PROBE;
 900                         neigh->updated = jiffies;
 901                         atomic_set(&neigh->probes, 0);
 902                         next = now + neigh->parms->retrans_time;
 903                 }
 904         } else {
 905                 /* NUD_PROBE|NUD_INCOMPLETE */
 906                 next = now + neigh->parms->retrans_time;
 907         }
 908
 909         if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
 910             atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
 911                 neigh->nud_state = NUD_FAILED;
 912                 notify = 1;
 913                 neigh_invalidate(neigh);
 914         }
 915
 916         if (neigh->nud_state & NUD_IN_TIMER) {
 917                 if (time_before(next, jiffies + HZ/2))
 918                         next = jiffies + HZ/2;
 919                 if (!mod_timer(&neigh->timer, next))
 920                         neigh_hold(neigh);
 921         }
 922         if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
 923                 struct sk_buff *skb = skb_peek(&neigh->arp_queue);
 924                 /* keep skb alive even if arp_queue overflows */
 925                 if (skb)
 926                         skb = skb_copy(skb, GFP_ATOMIC);
 927                 write_unlock(&neigh->lock);
 928                 neigh->ops->solicit(neigh, skb);
 929                 atomic_inc(&neigh->probes);
 930                 kfree_skb(skb);
 931         } else {
 932 out:
 933                 write_unlock(&neigh->lock);
 934         }
 935
 936         if (notify)
 937                 neigh_update_notify(neigh);
 938
 939         neigh_release(neigh);
 940 }
 941
 942 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
 943 {
 944         int rc;
 945         unsigned long now;
 946
 947         write_lock_bh(&neigh->lock);
 948
 949         rc = 0;
 950         if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
 951                 goto out_unlock_bh;
 952
 953         now = jiffies;
 954
 955         if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
 956                 if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
 957                         atomic_set(&neigh->probes, neigh->parms->ucast_probes);
 958                         neigh->nud_state     = NUD_INCOMPLETE;
 959                         neigh->updated = jiffies;
 960                         neigh_add_timer(neigh, now + 1);
 961                 } else {
 962                         neigh->nud_state = NUD_FAILED;
 963                         neigh->updated = jiffies;
 964                         write_unlock_bh(&neigh->lock);
 965
 966                         kfree_skb(skb);
 967                         return 1;
 968                 }
 969         } else if (neigh->nud_state & NUD_STALE) {
 970                 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh);
 971                 neigh->nud_state = NUD_DELAY;
 972                 neigh->updated = jiffies;
 973                 neigh_add_timer(neigh,
 974                                 jiffies + neigh->parms->delay_probe_time);
 975         }
 976
 977         if (neigh->nud_state == NUD_INCOMPLETE) {
 978                 if (skb) {
 979                         if (skb_queue_len(&neigh->arp_queue) >=
 980                             neigh->parms->queue_len) {
 981                                 struct sk_buff *buff;
 982                                 buff = __skb_dequeue(&neigh->arp_queue);
 983                                 kfree_skb(buff);
 984                                 NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards);
 985                         }
 986                         skb_dst_force(skb);
 987                         __skb_queue_tail(&neigh->arp_queue, skb);
 988                 }
 989                 rc = 1;
 990         }
 991 out_unlock_bh:
 992         write_unlock_bh(&neigh->lock);
 993         return rc;
 994 }
 995 EXPORT_SYMBOL(__neigh_event_send);
 996
 997 static void neigh_update_hhs(struct neighbour *neigh)
 998 {
 999         struct hh_cache *hh;
1000         void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
1001                 = NULL;
1002
1003         if (neigh->dev->header_ops)
1004                 update = neigh->dev->header_ops->cache_update;
1005
1006         if (update) {
1007                 hh = &neigh->hh;
1008                 if (hh->hh_len) {
1009                         write_seqlock_bh(&hh->hh_lock);
1010                         update(hh, neigh->dev, neigh->ha);
1011                         write_sequnlock_bh(&hh->hh_lock);
1012                 }
1013         }
1014 }
1015
1016
1017
1018 /* Generic update routine.
1019    -- lladdr is new lladdr or NULL, if it is not supplied.
1020    -- new    is new state.
1021    -- flags
1022         NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
1023                                 if it is different.
1024         NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
1025                                 lladdr instead of overriding it
1026                                 if it is different.
1027                                 It also allows to retain current state
1028                                 if lladdr is unchanged.
1029         NEIGH_UPDATE_F_ADMIN    means that the change is administrative.
1030
1031         NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
1032                                 NTF_ROUTER flag.
1033         NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1034                                 a router.
1035
1036    Caller MUST hold reference count on the entry.
1037  */
1038
1039 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
1040                  u32 flags)
1041 {
1042         u8 old;
1043         int err;
1044         int notify = 0;
1045         struct net_device *dev;
1046         int update_isrouter = 0;
1047
1048         write_lock_bh(&neigh->lock);
1049
1050         dev    = neigh->dev;
1051         old    = neigh->nud_state;
1052         err    = -EPERM;
1053
1054         if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
1055             (old & (NUD_NOARP | NUD_PERMANENT)))
1056                 goto out;
1057
1058         if (!(new & NUD_VALID)) {
1059                 neigh_del_timer(neigh);
1060                 if (old & NUD_CONNECTED)
1061                         neigh_suspect(neigh);
1062                 neigh->nud_state = new;
1063                 err = 0;
1064                 notify = old & NUD_VALID;
1065                 if ((old & (NUD_INCOMPLETE | NUD_PROBE)) &&
1066                     (new & NUD_FAILED)) {
1067                         neigh_invalidate(neigh);
1068                         notify = 1;
1069                 }
1070                 goto out;
1071         }
1072
1073         /* Compare new lladdr with cached one */
1074         if (!dev->addr_len) {
1075                 /* First case: device needs no address. */
1076                 lladdr = neigh->ha;
1077         } else if (lladdr) {
1078                 /* The second case: if something is already cached
1079                    and a new address is proposed:
1080                    - compare new & old
1081                    - if they are different, check override flag
1082                  */
1083                 if ((old & NUD_VALID) &&
1084                     !memcmp(lladdr, neigh->ha, dev->addr_len))
1085                         lladdr = neigh->ha;
1086         } else {
1087                 /* No address is supplied; if we know something,
1088                    use it, otherwise discard the request.
1089                  */
1090                 err = -EINVAL;
1091                 if (!(old & NUD_VALID))
1092                         goto out;
1093                 lladdr = neigh->ha;
1094         }
1095
1096         if (new & NUD_CONNECTED)
1097                 neigh->confirmed = jiffies;
1098         neigh->updated = jiffies;
1099
1100         /* If entry was valid and address is not changed,
1101            do not change entry state, if new one is STALE.
1102          */
1103         err = 0;
1104         update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1105         if (old & NUD_VALID) {
1106                 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1107                         update_isrouter = 0;
1108                         if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1109                             (old & NUD_CONNECTED)) {
1110                                 lladdr = neigh->ha;
1111                                 new = NUD_STALE;
1112                         } else
1113                                 goto out;
1114                 } else {
1115                         if (lladdr == neigh->ha && new == NUD_STALE &&
1116                             ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1117                              (old & NUD_CONNECTED))
1118                             )
1119                                 new = old;
1120                 }
1121         }
1122
1123         if (new != old) {
1124                 neigh_del_timer(neigh);
1125                 if (new & NUD_IN_TIMER)
1126                         neigh_add_timer(neigh, (jiffies +
1127                                                 ((new & NUD_REACHABLE) ?
1128                                                  neigh->parms->reachable_time :
1129                                                  0)));
1130                 neigh->nud_state = new;
1131         }
1132
1133         if (lladdr != neigh->ha) {
1134                 write_seqlock(&neigh->ha_lock);
1135                 memcpy(&neigh->ha, lladdr, dev->addr_len);
1136                 write_sequnlock(&neigh->ha_lock);
1137                 neigh_update_hhs(neigh);
1138                 if (!(new & NUD_CONNECTED))
1139                         neigh->confirmed = jiffies -
1140                                       (neigh->parms->base_reachable_time << 1);
1141                 notify = 1;
1142         }
1143         if (new == old)
1144                 goto out;
1145         if (new & NUD_CONNECTED)
1146                 neigh_connect(neigh);
1147         else
1148                 neigh_suspect(neigh);
1149         if (!(old & NUD_VALID)) {
1150                 struct sk_buff *skb;
1151
1152                 /* Again: avoid dead loop if something went wrong */
1153
1154                 while (neigh->nud_state & NUD_VALID &&
1155                        (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1156                         struct dst_entry *dst = skb_dst(skb);
1157                         struct neighbour *n2, *n1 = neigh;
1158                         write_unlock_bh(&neigh->lock);
1159                         /* On shaper/eql skb->dst->neighbour != neigh :( */
1160                         if (dst && (n2 = dst_get_neighbour(dst)) != NULL)
1161                                 n1 = n2;
1162                         n1->output(n1, skb);
1163                         write_lock_bh(&neigh->lock);
1164                 }
1165                 skb_queue_purge(&neigh->arp_queue);
1166         }
1167 out:
1168         if (update_isrouter) {
1169                 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1170                         (neigh->flags | NTF_ROUTER) :
1171                         (neigh->flags & ~NTF_ROUTER);
1172         }
1173         write_unlock_bh(&neigh->lock);
1174
1175         if (notify)
1176                 neigh_update_notify(neigh);
1177
1178         return err;
1179 }
1180 EXPORT_SYMBOL(neigh_update);
1181
1182 struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1183                                  u8 *lladdr, void *saddr,
1184                                  struct net_device *dev)
1185 {
1186         struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1187                                                  lladdr || !dev->addr_len);
1188         if (neigh)
1189                 neigh_update(neigh, lladdr, NUD_STALE,
1190                              NEIGH_UPDATE_F_OVERRIDE);
1191         return neigh;
1192 }
1193 EXPORT_SYMBOL(neigh_event_ns);
1194
1195 /* called with read_lock_bh(&n->lock); */
1196 static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst)
1197 {
1198         struct net_device *dev = dst->dev;
1199         __be16 prot = dst->ops->protocol;
1200         struct hh_cache *hh = &n->hh;
1201
1202         write_lock_bh(&n->lock);
1203
1204         /* Only one thread can come in here and initialize the
1205          * hh_cache entry.
1206          */
1207         if (!hh->hh_len)
1208                 dev->header_ops->cache(n, hh, prot);
1209
1210         write_unlock_bh(&n->lock);
1211 }
1212
1213 /* This function can be used in contexts, where only old dev_queue_xmit
1214  * worked, f.e. if you want to override normal output path (eql, shaper),
1215  * but resolution is not made yet.
1216  */
1217
1218 int neigh_compat_output(struct neighbour *neigh, struct sk_buff *skb)
1219 {
1220         struct net_device *dev = skb->dev;
1221
1222         __skb_pull(skb, skb_network_offset(skb));
1223
1224         if (dev_hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
1225                             skb->len) < 0 &&
1226             dev->header_ops->rebuild(skb))
1227                 return 0;
1228
1229         return dev_queue_xmit(skb);
1230 }
1231 EXPORT_SYMBOL(neigh_compat_output);
1232
1233 /* Slow and careful. */
1234
1235 int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb)
1236 {
1237         struct dst_entry *dst = skb_dst(skb);
1238         int rc = 0;
1239
1240         if (!dst)
1241                 goto discard;
1242
1243         __skb_pull(skb, skb_network_offset(skb));
1244
1245         if (!neigh_event_send(neigh, skb)) {
1246                 int err;
1247                 struct net_device *dev = neigh->dev;
1248                 unsigned int seq;
1249
1250                 if (dev->header_ops->cache && !neigh->hh.hh_len)
1251                         neigh_hh_init(neigh, dst);
1252
1253                 do {
1254                         seq = read_seqbegin(&neigh->ha_lock);
1255                         err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1256                                               neigh->ha, NULL, skb->len);
1257                 } while (read_seqretry(&neigh->ha_lock, seq));
1258
1259                 if (err >= 0)
1260                         rc = dev_queue_xmit(skb);
1261                 else
1262                         goto out_kfree_skb;
1263         }
1264 out:
1265         return rc;
1266 discard:
1267         NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
1268                       dst, neigh);
1269 out_kfree_skb:
1270         rc = -EINVAL;
1271         kfree_skb(skb);
1272         goto out;
1273 }
1274 EXPORT_SYMBOL(neigh_resolve_output);
1275
1276 /* As fast as possible without hh cache */
1277
1278 int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb)
1279 {
1280         struct net_device *dev = neigh->dev;
1281         unsigned int seq;
1282         int err;
1283
1284         __skb_pull(skb, skb_network_offset(skb));
1285
1286         do {
1287                 seq = read_seqbegin(&neigh->ha_lock);
1288                 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1289                                       neigh->ha, NULL, skb->len);
1290         } while (read_seqretry(&neigh->ha_lock, seq));
1291
1292         if (err >= 0)
1293                 err = dev_queue_xmit(skb);
1294         else {
1295                 err = -EINVAL;
1296                 kfree_skb(skb);
1297         }
1298         return err;
1299 }
1300 EXPORT_SYMBOL(neigh_connected_output);
1301
1302 int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb)
1303 {
1304         return dev_queue_xmit(skb);
1305 }
1306 EXPORT_SYMBOL(neigh_direct_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         RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3));
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_sync(&tbl->gc_work);
1527         del_timer_sync(&tbl->proxy_timer);
1528         pneigh_queue_purge(&tbl->proxy_queue);
1529         neigh_ifdown(tbl, NULL);
1530         if (atomic_read(&tbl->entries))
1531                 printk(KERN_CRIT "neighbour leakage\n");
1532         write_lock(&neigh_tbl_lock);
1533         for (tp = &neigh_tables; *tp; tp = &(*tp)->next) {
1534                 if (*tp == tbl) {
1535                         *tp = tbl->next;
1536                         break;
1537                 }
1538         }
1539         write_unlock(&neigh_tbl_lock);
1540
1541         call_rcu(&rcu_dereference_protected(tbl->nht, 1)->rcu,
1542                  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 = ((1 << nht->hash_shift) - 1);
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                 char haddr[MAX_ADDR_LEN];
2097
2098                 neigh_ha_snapshot(haddr, neigh, neigh->dev);
2099                 if (nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, haddr) < 0) {
2100                         read_unlock_bh(&neigh->lock);
2101                         goto nla_put_failure;
2102                 }
2103         }
2104
2105         ci.ndm_used      = jiffies_to_clock_t(now - neigh->used);
2106         ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
2107         ci.ndm_updated   = jiffies_to_clock_t(now - neigh->updated);
2108         ci.ndm_refcnt    = atomic_read(&neigh->refcnt) - 1;
2109         read_unlock_bh(&neigh->lock);
2110
2111         NLA_PUT_U32(skb, NDA_PROBES, atomic_read(&neigh->probes));
2112         NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci);
2113
2114         return nlmsg_end(skb, nlh);
2115
2116 nla_put_failure:
2117         nlmsg_cancel(skb, nlh);
2118         return -EMSGSIZE;
2119 }
2120
2121 static void neigh_update_notify(struct neighbour *neigh)
2122 {
2123         call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2124         __neigh_notify(neigh, RTM_NEWNEIGH, 0);
2125 }
2126
2127 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2128                             struct netlink_callback *cb)
2129 {
2130         struct net *net = sock_net(skb->sk);
2131         struct neighbour *n;
2132         int rc, h, s_h = cb->args[1];
2133         int idx, s_idx = idx = cb->args[2];
2134         struct neigh_hash_table *nht;
2135
2136         rcu_read_lock_bh();
2137         nht = rcu_dereference_bh(tbl->nht);
2138
2139         for (h = 0; h < (1 << nht->hash_shift); h++) {
2140                 if (h < s_h)
2141                         continue;
2142                 if (h > s_h)
2143                         s_idx = 0;
2144                 for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0;
2145                      n != NULL;
2146                      n = rcu_dereference_bh(n->next)) {
2147                         if (!net_eq(dev_net(n->dev), net))
2148                                 continue;
2149                         if (idx < s_idx)
2150                                 goto next;
2151                         if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid,
2152                                             cb->nlh->nlmsg_seq,
2153                                             RTM_NEWNEIGH,
2154                                             NLM_F_MULTI) <= 0) {
2155                                 rc = -1;
2156                                 goto out;
2157                         }
2158 next:
2159                         idx++;
2160                 }
2161         }
2162         rc = skb->len;
2163 out:
2164         rcu_read_unlock_bh();
2165         cb->args[1] = h;
2166         cb->args[2] = idx;
2167         return rc;
2168 }
2169
2170 static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
2171 {
2172         struct neigh_table *tbl;
2173         int t, family, s_t;
2174
2175         read_lock(&neigh_tbl_lock);
2176         family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
2177         s_t = cb->args[0];
2178
2179         for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) {
2180                 if (t < s_t || (family && tbl->family != family))
2181                         continue;
2182                 if (t > s_t)
2183                         memset(&cb->args[1], 0, sizeof(cb->args) -
2184                                                 sizeof(cb->args[0]));
2185                 if (neigh_dump_table(tbl, skb, cb) < 0)
2186                         break;
2187         }
2188         read_unlock(&neigh_tbl_lock);
2189
2190         cb->args[0] = t;
2191         return skb->len;
2192 }
2193
2194 void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2195 {
2196         int chain;
2197         struct neigh_hash_table *nht;
2198
2199         rcu_read_lock_bh();
2200         nht = rcu_dereference_bh(tbl->nht);
2201
2202         read_lock(&tbl->lock); /* avoid resizes */
2203         for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
2204                 struct neighbour *n;
2205
2206                 for (n = rcu_dereference_bh(nht->hash_buckets[chain]);
2207                      n != NULL;
2208                      n = rcu_dereference_bh(n->next))
2209                         cb(n, cookie);
2210         }
2211         read_unlock(&tbl->lock);
2212         rcu_read_unlock_bh();
2213 }
2214 EXPORT_SYMBOL(neigh_for_each);
2215
2216 /* The tbl->lock must be held as a writer and BH disabled. */
2217 void __neigh_for_each_release(struct neigh_table *tbl,
2218                               int (*cb)(struct neighbour *))
2219 {
2220         int chain;
2221         struct neigh_hash_table *nht;
2222
2223         nht = rcu_dereference_protected(tbl->nht,
2224                                         lockdep_is_held(&tbl->lock));
2225         for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
2226                 struct neighbour *n;
2227                 struct neighbour __rcu **np;
2228
2229                 np = &nht->hash_buckets[chain];
2230                 while ((n = rcu_dereference_protected(*np,
2231                                         lockdep_is_held(&tbl->lock))) != NULL) {
2232                         int release;
2233
2234                         write_lock(&n->lock);
2235                         release = cb(n);
2236                         if (release) {
2237                                 rcu_assign_pointer(*np,
2238                                         rcu_dereference_protected(n->next,
2239                                                 lockdep_is_held(&tbl->lock)));
2240                                 n->dead = 1;
2241                         } else
2242                                 np = &n->next;
2243                         write_unlock(&n->lock);
2244                         if (release)
2245                                 neigh_cleanup_and_release(n);
2246                 }
2247         }
2248 }
2249 EXPORT_SYMBOL(__neigh_for_each_release);
2250
2251 #ifdef CONFIG_PROC_FS
2252
2253 static struct neighbour *neigh_get_first(struct seq_file *seq)
2254 {
2255         struct neigh_seq_state *state = seq->private;
2256         struct net *net = seq_file_net(seq);
2257         struct neigh_hash_table *nht = state->nht;
2258         struct neighbour *n = NULL;
2259         int bucket = state->bucket;
2260
2261         state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2262         for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) {
2263                 n = rcu_dereference_bh(nht->hash_buckets[bucket]);
2264
2265                 while (n) {
2266                         if (!net_eq(dev_net(n->dev), net))
2267                                 goto next;
2268                         if (state->neigh_sub_iter) {
2269                                 loff_t fakep = 0;
2270                                 void *v;
2271
2272                                 v = state->neigh_sub_iter(state, n, &fakep);
2273                                 if (!v)
2274                                         goto next;
2275                         }
2276                         if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2277                                 break;
2278                         if (n->nud_state & ~NUD_NOARP)
2279                                 break;
2280 next:
2281                         n = rcu_dereference_bh(n->next);
2282                 }
2283
2284                 if (n)
2285                         break;
2286         }
2287         state->bucket = bucket;
2288
2289         return n;
2290 }
2291
2292 static struct neighbour *neigh_get_next(struct seq_file *seq,
2293                                         struct neighbour *n,
2294                                         loff_t *pos)
2295 {
2296         struct neigh_seq_state *state = seq->private;
2297         struct net *net = seq_file_net(seq);
2298         struct neigh_hash_table *nht = state->nht;
2299
2300         if (state->neigh_sub_iter) {
2301                 void *v = state->neigh_sub_iter(state, n, pos);
2302                 if (v)
2303                         return n;
2304         }
2305         n = rcu_dereference_bh(n->next);
2306
2307         while (1) {
2308                 while (n) {
2309                         if (!net_eq(dev_net(n->dev), net))
2310                                 goto next;
2311                         if (state->neigh_sub_iter) {
2312                                 void *v = state->neigh_sub_iter(state, n, pos);
2313                                 if (v)
2314                                         return n;
2315                                 goto next;
2316                         }
2317                         if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2318                                 break;
2319
2320                         if (n->nud_state & ~NUD_NOARP)
2321                                 break;
2322 next:
2323                         n = rcu_dereference_bh(n->next);
2324                 }
2325
2326                 if (n)
2327                         break;
2328
2329                 if (++state->bucket >= (1 << nht->hash_shift))
2330                         break;
2331
2332                 n = rcu_dereference_bh(nht->hash_buckets[state->bucket]);
2333         }
2334
2335         if (n && pos)
2336                 --(*pos);
2337         return n;
2338 }
2339
2340 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2341 {
2342         struct neighbour *n = neigh_get_first(seq);
2343
2344         if (n) {
2345                 --(*pos);
2346                 while (*pos) {
2347                         n = neigh_get_next(seq, n, pos);
2348                         if (!n)
2349                                 break;
2350                 }
2351         }
2352         return *pos ? NULL : n;
2353 }
2354
2355 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2356 {
2357         struct neigh_seq_state *state = seq->private;
2358         struct net *net = seq_file_net(seq);
2359         struct neigh_table *tbl = state->tbl;
2360         struct pneigh_entry *pn = NULL;
2361         int bucket = state->bucket;
2362
2363         state->flags |= NEIGH_SEQ_IS_PNEIGH;
2364         for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2365                 pn = tbl->phash_buckets[bucket];
2366                 while (pn && !net_eq(pneigh_net(pn), net))
2367                         pn = pn->next;
2368                 if (pn)
2369                         break;
2370         }
2371         state->bucket = bucket;
2372
2373         return pn;
2374 }
2375
2376 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2377                                             struct pneigh_entry *pn,
2378                                             loff_t *pos)
2379 {
2380         struct neigh_seq_state *state = seq->private;
2381         struct net *net = seq_file_net(seq);
2382         struct neigh_table *tbl = state->tbl;
2383
2384         pn = pn->next;
2385         while (!pn) {
2386                 if (++state->bucket > PNEIGH_HASHMASK)
2387                         break;
2388                 pn = tbl->phash_buckets[state->bucket];
2389                 while (pn && !net_eq(pneigh_net(pn), net))
2390                         pn = pn->next;
2391                 if (pn)
2392                         break;
2393         }
2394
2395         if (pn && pos)
2396                 --(*pos);
2397
2398         return pn;
2399 }
2400
2401 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2402 {
2403         struct pneigh_entry *pn = pneigh_get_first(seq);
2404
2405         if (pn) {
2406                 --(*pos);
2407                 while (*pos) {
2408                         pn = pneigh_get_next(seq, pn, pos);
2409                         if (!pn)
2410                                 break;
2411                 }
2412         }
2413         return *pos ? NULL : pn;
2414 }
2415
2416 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2417 {
2418         struct neigh_seq_state *state = seq->private;
2419         void *rc;
2420         loff_t idxpos = *pos;
2421
2422         rc = neigh_get_idx(seq, &idxpos);
2423         if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2424                 rc = pneigh_get_idx(seq, &idxpos);
2425
2426         return rc;
2427 }
2428
2429 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
2430         __acquires(rcu_bh)
2431 {
2432         struct neigh_seq_state *state = seq->private;
2433
2434         state->tbl = tbl;
2435         state->bucket = 0;
2436         state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2437
2438         rcu_read_lock_bh();
2439         state->nht = rcu_dereference_bh(tbl->nht);
2440
2441         return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN;
2442 }
2443 EXPORT_SYMBOL(neigh_seq_start);
2444
2445 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2446 {
2447         struct neigh_seq_state *state;
2448         void *rc;
2449
2450         if (v == SEQ_START_TOKEN) {
2451                 rc = neigh_get_first(seq);
2452                 goto out;
2453         }
2454
2455         state = seq->private;
2456         if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2457                 rc = neigh_get_next(seq, v, NULL);
2458                 if (rc)
2459                         goto out;
2460                 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2461                         rc = pneigh_get_first(seq);
2462         } else {
2463                 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2464                 rc = pneigh_get_next(seq, v, NULL);
2465         }
2466 out:
2467         ++(*pos);
2468         return rc;
2469 }
2470 EXPORT_SYMBOL(neigh_seq_next);
2471
2472 void neigh_seq_stop(struct seq_file *seq, void *v)
2473         __releases(rcu_bh)
2474 {
2475         rcu_read_unlock_bh();
2476 }
2477 EXPORT_SYMBOL(neigh_seq_stop);
2478
2479 /* statistics via seq_file */
2480
2481 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2482 {
2483         struct neigh_table *tbl = seq->private;
2484         int cpu;
2485
2486         if (*pos == 0)
2487                 return SEQ_START_TOKEN;
2488
2489         for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
2490                 if (!cpu_possible(cpu))
2491                         continue;
2492                 *pos = cpu+1;
2493                 return per_cpu_ptr(tbl->stats, cpu);
2494         }
2495         return NULL;
2496 }
2497
2498 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2499 {
2500         struct neigh_table *tbl = seq->private;
2501         int cpu;
2502
2503         for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
2504                 if (!cpu_possible(cpu))
2505                         continue;
2506                 *pos = cpu+1;
2507                 return per_cpu_ptr(tbl->stats, cpu);
2508         }
2509         return NULL;
2510 }
2511
2512 static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2513 {
2514
2515 }
2516
2517 static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2518 {
2519         struct neigh_table *tbl = seq->private;
2520         struct neigh_statistics *st = v;
2521
2522         if (v == SEQ_START_TOKEN) {
2523                 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");
2524                 return 0;
2525         }
2526
2527         seq_printf(seq, "%08x  %08lx %08lx %08lx  %08lx %08lx  %08lx  "
2528                         "%08lx %08lx  %08lx %08lx %08lx\n",
2529                    atomic_read(&tbl->entries),
2530
2531                    st->allocs,
2532                    st->destroys,
2533                    st->hash_grows,
2534
2535                    st->lookups,
2536                    st->hits,
2537
2538                    st->res_failed,
2539
2540                    st->rcv_probes_mcast,
2541                    st->rcv_probes_ucast,
2542
2543                    st->periodic_gc_runs,
2544                    st->forced_gc_runs,
2545                    st->unres_discards
2546                    );
2547
2548         return 0;
2549 }
2550
2551 static const struct seq_operations neigh_stat_seq_ops = {
2552         .start  = neigh_stat_seq_start,
2553         .next   = neigh_stat_seq_next,
2554         .stop   = neigh_stat_seq_stop,
2555         .show   = neigh_stat_seq_show,
2556 };
2557
2558 static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2559 {
2560         int ret = seq_open(file, &neigh_stat_seq_ops);
2561
2562         if (!ret) {
2563                 struct seq_file *sf = file->private_data;
2564                 sf->private = PDE(inode)->data;
2565         }
2566         return ret;
2567 };
2568
2569 static const struct file_operations neigh_stat_seq_fops = {
2570         .owner   = THIS_MODULE,
2571         .open    = neigh_stat_seq_open,
2572         .read    = seq_read,
2573         .llseek  = seq_lseek,
2574         .release = seq_release,
2575 };
2576
2577 #endif /* CONFIG_PROC_FS */
2578
2579 static inline size_t neigh_nlmsg_size(void)
2580 {
2581         return NLMSG_ALIGN(sizeof(struct ndmsg))
2582                + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2583                + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2584                + nla_total_size(sizeof(struct nda_cacheinfo))
2585                + nla_total_size(4); /* NDA_PROBES */
2586 }
2587
2588 static void __neigh_notify(struct neighbour *n, int type, int flags)
2589 {
2590         struct net *net = dev_net(n->dev);
2591         struct sk_buff *skb;
2592         int err = -ENOBUFS;
2593
2594         skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
2595         if (skb == NULL)
2596                 goto errout;
2597
2598         err = neigh_fill_info(skb, n, 0, 0, type, flags);
2599         if (err < 0) {
2600                 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2601                 WARN_ON(err == -EMSGSIZE);
2602                 kfree_skb(skb);
2603                 goto errout;
2604         }
2605         rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
2606         return;
2607 errout:
2608         if (err < 0)
2609                 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
2610 }
2611
2612 #ifdef CONFIG_ARPD
2613 void neigh_app_ns(struct neighbour *n)
2614 {
2615         __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
2616 }
2617 EXPORT_SYMBOL(neigh_app_ns);
2618 #endif /* CONFIG_ARPD */
2619
2620 #ifdef CONFIG_SYSCTL
2621
2622 #define NEIGH_VARS_MAX 19
2623
2624 static struct neigh_sysctl_table {
2625         struct ctl_table_header *sysctl_header;
2626         struct ctl_table neigh_vars[NEIGH_VARS_MAX];
2627         char *dev_name;
2628 } neigh_sysctl_template __read_mostly = {
2629         .neigh_vars = {
2630                 {
2631                         .procname       = "mcast_solicit",
2632                         .maxlen         = sizeof(int),
2633                         .mode           = 0644,
2634                         .proc_handler   = proc_dointvec,
2635                 },
2636                 {
2637                         .procname       = "ucast_solicit",
2638                         .maxlen         = sizeof(int),
2639                         .mode           = 0644,
2640                         .proc_handler   = proc_dointvec,
2641                 },
2642                 {
2643                         .procname       = "app_solicit",
2644                         .maxlen         = sizeof(int),
2645                         .mode           = 0644,
2646                         .proc_handler   = proc_dointvec,
2647                 },
2648                 {
2649                         .procname       = "retrans_time",
2650                         .maxlen         = sizeof(int),
2651                         .mode           = 0644,
2652                         .proc_handler   = proc_dointvec_userhz_jiffies,
2653                 },
2654                 {
2655                         .procname       = "base_reachable_time",
2656                         .maxlen         = sizeof(int),
2657                         .mode           = 0644,
2658                         .proc_handler   = proc_dointvec_jiffies,
2659                 },
2660                 {
2661                         .procname       = "delay_first_probe_time",
2662                         .maxlen         = sizeof(int),
2663                         .mode           = 0644,
2664                         .proc_handler   = proc_dointvec_jiffies,
2665                 },
2666                 {
2667                         .procname       = "gc_stale_time",
2668                         .maxlen         = sizeof(int),
2669                         .mode           = 0644,
2670                         .proc_handler   = proc_dointvec_jiffies,
2671                 },
2672                 {
2673                         .procname       = "unres_qlen",
2674                         .maxlen         = sizeof(int),
2675                         .mode           = 0644,
2676                         .proc_handler   = proc_dointvec,
2677                 },
2678                 {
2679                         .procname       = "proxy_qlen",
2680                         .maxlen         = sizeof(int),
2681                         .mode           = 0644,
2682                         .proc_handler   = proc_dointvec,
2683                 },
2684                 {
2685                         .procname       = "anycast_delay",
2686                         .maxlen         = sizeof(int),
2687                         .mode           = 0644,
2688                         .proc_handler   = proc_dointvec_userhz_jiffies,
2689                 },
2690                 {
2691                         .procname       = "proxy_delay",
2692                         .maxlen         = sizeof(int),
2693                         .mode           = 0644,
2694                         .proc_handler   = proc_dointvec_userhz_jiffies,
2695                 },
2696                 {
2697                         .procname       = "locktime",
2698                         .maxlen         = sizeof(int),
2699                         .mode           = 0644,
2700                         .proc_handler   = proc_dointvec_userhz_jiffies,
2701                 },
2702                 {
2703                         .procname       = "retrans_time_ms",
2704                         .maxlen         = sizeof(int),
2705                         .mode           = 0644,
2706                         .proc_handler   = proc_dointvec_ms_jiffies,
2707                 },
2708                 {
2709                         .procname       = "base_reachable_time_ms",
2710                         .maxlen         = sizeof(int),
2711                         .mode           = 0644,
2712                         .proc_handler   = proc_dointvec_ms_jiffies,
2713                 },
2714                 {
2715                         .procname       = "gc_interval",
2716                         .maxlen         = sizeof(int),
2717                         .mode           = 0644,
2718                         .proc_handler   = proc_dointvec_jiffies,
2719                 },
2720                 {
2721                         .procname       = "gc_thresh1",
2722                         .maxlen         = sizeof(int),
2723                         .mode           = 0644,
2724                         .proc_handler   = proc_dointvec,
2725                 },
2726                 {
2727                         .procname       = "gc_thresh2",
2728                         .maxlen         = sizeof(int),
2729                         .mode           = 0644,
2730                         .proc_handler   = proc_dointvec,
2731                 },
2732                 {
2733                         .procname       = "gc_thresh3",
2734                         .maxlen         = sizeof(int),
2735                         .mode           = 0644,
2736                         .proc_handler   = proc_dointvec,
2737                 },
2738                 {},
2739         },
2740 };
2741
2742 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
2743                           char *p_name, proc_handler *handler)
2744 {
2745         struct neigh_sysctl_table *t;
2746         const char *dev_name_source = NULL;
2747
2748 #define NEIGH_CTL_PATH_ROOT     0
2749 #define NEIGH_CTL_PATH_PROTO    1
2750 #define NEIGH_CTL_PATH_NEIGH    2
2751 #define NEIGH_CTL_PATH_DEV      3
2752
2753         struct ctl_path neigh_path[] = {
2754                 { .procname = "net",     },
2755                 { .procname = "proto",   },
2756                 { .procname = "neigh",   },
2757                 { .procname = "default", },
2758                 { },
2759         };
2760
2761         t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
2762         if (!t)
2763                 goto err;
2764
2765         t->neigh_vars[0].data  = &p->mcast_probes;
2766         t->neigh_vars[1].data  = &p->ucast_probes;
2767         t->neigh_vars[2].data  = &p->app_probes;
2768         t->neigh_vars[3].data  = &p->retrans_time;
2769         t->neigh_vars[4].data  = &p->base_reachable_time;
2770         t->neigh_vars[5].data  = &p->delay_probe_time;
2771         t->neigh_vars[6].data  = &p->gc_staletime;
2772         t->neigh_vars[7].data  = &p->queue_len;
2773         t->neigh_vars[8].data  = &p->proxy_qlen;
2774         t->neigh_vars[9].data  = &p->anycast_delay;
2775         t->neigh_vars[10].data = &p->proxy_delay;
2776         t->neigh_vars[11].data = &p->locktime;
2777         t->neigh_vars[12].data  = &p->retrans_time;
2778         t->neigh_vars[13].data  = &p->base_reachable_time;
2779
2780         if (dev) {
2781                 dev_name_source = dev->name;
2782                 /* Terminate the table early */
2783                 memset(&t->neigh_vars[14], 0, sizeof(t->neigh_vars[14]));
2784         } else {
2785                 dev_name_source = neigh_path[NEIGH_CTL_PATH_DEV].procname;
2786                 t->neigh_vars[14].data = (int *)(p + 1);
2787                 t->neigh_vars[15].data = (int *)(p + 1) + 1;
2788                 t->neigh_vars[16].data = (int *)(p + 1) + 2;
2789                 t->neigh_vars[17].data = (int *)(p + 1) + 3;
2790         }
2791
2792
2793         if (handler) {
2794                 /* RetransTime */
2795                 t->neigh_vars[3].proc_handler = handler;
2796                 t->neigh_vars[3].extra1 = dev;
2797                 /* ReachableTime */
2798                 t->neigh_vars[4].proc_handler = handler;
2799                 t->neigh_vars[4].extra1 = dev;
2800                 /* RetransTime (in milliseconds)*/
2801                 t->neigh_vars[12].proc_handler = handler;
2802                 t->neigh_vars[12].extra1 = dev;
2803                 /* ReachableTime (in milliseconds) */
2804                 t->neigh_vars[13].proc_handler = handler;
2805                 t->neigh_vars[13].extra1 = dev;
2806         }
2807
2808         t->dev_name = kstrdup(dev_name_source, GFP_KERNEL);
2809         if (!t->dev_name)
2810                 goto free;
2811
2812         neigh_path[NEIGH_CTL_PATH_DEV].procname = t->dev_name;
2813         neigh_path[NEIGH_CTL_PATH_PROTO].procname = p_name;
2814
2815         t->sysctl_header =
2816                 register_net_sysctl_table(neigh_parms_net(p), neigh_path, t->neigh_vars);
2817         if (!t->sysctl_header)
2818                 goto free_procname;
2819
2820         p->sysctl_table = t;
2821         return 0;
2822
2823 free_procname:
2824         kfree(t->dev_name);
2825 free:
2826         kfree(t);
2827 err:
2828         return -ENOBUFS;
2829 }
2830 EXPORT_SYMBOL(neigh_sysctl_register);
2831
2832 void neigh_sysctl_unregister(struct neigh_parms *p)
2833 {
2834         if (p->sysctl_table) {
2835                 struct neigh_sysctl_table *t = p->sysctl_table;
2836                 p->sysctl_table = NULL;
2837                 unregister_sysctl_table(t->sysctl_header);
2838                 kfree(t->dev_name);
2839                 kfree(t);
2840         }
2841 }
2842 EXPORT_SYMBOL(neigh_sysctl_unregister);
2843
2844 #endif  /* CONFIG_SYSCTL */
2845
2846 static int __init neigh_init(void)
2847 {
2848         rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, NULL);
2849         rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, NULL);
2850         rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info, NULL);
2851
2852         rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info,
2853                       NULL);
2854         rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, NULL);
2855
2856         return 0;
2857 }
2858
2859 subsys_initcall(neigh_init);
2860