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