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