linux/fs/lockd/host.c
<<
>>
Prefs
   1/*
   2 * linux/fs/lockd/host.c
   3 *
   4 * Management for NLM peer hosts. The nlm_host struct is shared
   5 * between client and server implementation. The only reason to
   6 * do so is to reduce code bloat.
   7 *
   8 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
   9 */
  10
  11#include <linux/types.h>
  12#include <linux/slab.h>
  13#include <linux/in.h>
  14#include <linux/in6.h>
  15#include <linux/sunrpc/clnt.h>
  16#include <linux/sunrpc/svc.h>
  17#include <linux/lockd/lockd.h>
  18#include <linux/mutex.h>
  19
  20#include <linux/sunrpc/svc_xprt.h>
  21
  22#include <net/ipv6.h>
  23
  24#include "netns.h"
  25
  26#define NLMDBG_FACILITY         NLMDBG_HOSTCACHE
  27#define NLM_HOST_NRHASH         32
  28#define NLM_HOST_REBIND         (60 * HZ)
  29#define NLM_HOST_EXPIRE         (300 * HZ)
  30#define NLM_HOST_COLLECT        (120 * HZ)
  31
  32static struct hlist_head        nlm_server_hosts[NLM_HOST_NRHASH];
  33static struct hlist_head        nlm_client_hosts[NLM_HOST_NRHASH];
  34
  35#define for_each_host(host, pos, chain, table) \
  36        for ((chain) = (table); \
  37             (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
  38                hlist_for_each_entry((host), (pos), (chain), h_hash)
  39
  40#define for_each_host_safe(host, pos, next, chain, table) \
  41        for ((chain) = (table); \
  42             (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
  43                hlist_for_each_entry_safe((host), (pos), (next), \
  44                                                (chain), h_hash)
  45
  46static unsigned long            nrhosts;
  47static DEFINE_MUTEX(nlm_host_mutex);
  48
  49static void                     nlm_gc_hosts(struct net *net);
  50
  51struct nlm_lookup_host_info {
  52        const int               server;         /* search for server|client */
  53        const struct sockaddr   *sap;           /* address to search for */
  54        const size_t            salen;          /* it's length */
  55        const unsigned short    protocol;       /* transport to search for*/
  56        const u32               version;        /* NLM version to search for */
  57        const char              *hostname;      /* remote's hostname */
  58        const size_t            hostname_len;   /* it's length */
  59        const int               noresvport;     /* use non-priv port */
  60        struct net              *net;           /* network namespace to bind */
  61};
  62
  63/*
  64 * Hash function must work well on big- and little-endian platforms
  65 */
  66static unsigned int __nlm_hash32(const __be32 n)
  67{
  68        unsigned int hash = (__force u32)n ^ ((__force u32)n >> 16);
  69        return hash ^ (hash >> 8);
  70}
  71
  72static unsigned int __nlm_hash_addr4(const struct sockaddr *sap)
  73{
  74        const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
  75        return __nlm_hash32(sin->sin_addr.s_addr);
  76}
  77
  78static unsigned int __nlm_hash_addr6(const struct sockaddr *sap)
  79{
  80        const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
  81        const struct in6_addr addr = sin6->sin6_addr;
  82        return __nlm_hash32(addr.s6_addr32[0]) ^
  83               __nlm_hash32(addr.s6_addr32[1]) ^
  84               __nlm_hash32(addr.s6_addr32[2]) ^
  85               __nlm_hash32(addr.s6_addr32[3]);
  86}
  87
  88static unsigned int nlm_hash_address(const struct sockaddr *sap)
  89{
  90        unsigned int hash;
  91
  92        switch (sap->sa_family) {
  93        case AF_INET:
  94                hash = __nlm_hash_addr4(sap);
  95                break;
  96        case AF_INET6:
  97                hash = __nlm_hash_addr6(sap);
  98                break;
  99        default:
 100                hash = 0;
 101        }
 102        return hash & (NLM_HOST_NRHASH - 1);
 103}
 104
 105/*
 106 * Allocate and initialize an nlm_host.  Common to both client and server.
 107 */
 108static struct nlm_host *nlm_alloc_host(struct nlm_lookup_host_info *ni,
 109                                       struct nsm_handle *nsm)
 110{
 111        struct nlm_host *host = NULL;
 112        unsigned long now = jiffies;
 113
 114        if (nsm != NULL)
 115                atomic_inc(&nsm->sm_count);
 116        else {
 117                host = NULL;
 118                nsm = nsm_get_handle(ni->sap, ni->salen,
 119                                        ni->hostname, ni->hostname_len);
 120                if (unlikely(nsm == NULL)) {
 121                        dprintk("lockd: %s failed; no nsm handle\n",
 122                                __func__);
 123                        goto out;
 124                }
 125        }
 126
 127        host = kmalloc(sizeof(*host), GFP_KERNEL);
 128        if (unlikely(host == NULL)) {
 129                dprintk("lockd: %s failed; no memory\n", __func__);
 130                nsm_release(nsm);
 131                goto out;
 132        }
 133
 134        memcpy(nlm_addr(host), ni->sap, ni->salen);
 135        host->h_addrlen    = ni->salen;
 136        rpc_set_port(nlm_addr(host), 0);
 137        host->h_srcaddrlen = 0;
 138
 139        host->h_rpcclnt    = NULL;
 140        host->h_name       = nsm->sm_name;
 141        host->h_version    = ni->version;
 142        host->h_proto      = ni->protocol;
 143        host->h_reclaiming = 0;
 144        host->h_server     = ni->server;
 145        host->h_noresvport = ni->noresvport;
 146        host->h_inuse      = 0;
 147        init_waitqueue_head(&host->h_gracewait);
 148        init_rwsem(&host->h_rwsem);
 149        host->h_state      = 0;
 150        host->h_nsmstate   = 0;
 151        host->h_pidcount   = 0;
 152        atomic_set(&host->h_count, 1);
 153        mutex_init(&host->h_mutex);
 154        host->h_nextrebind = now + NLM_HOST_REBIND;
 155        host->h_expires    = now + NLM_HOST_EXPIRE;
 156        INIT_LIST_HEAD(&host->h_lockowners);
 157        spin_lock_init(&host->h_lock);
 158        INIT_LIST_HEAD(&host->h_granted);
 159        INIT_LIST_HEAD(&host->h_reclaim);
 160        host->h_nsmhandle  = nsm;
 161        host->h_addrbuf    = nsm->sm_addrbuf;
 162        host->net          = ni->net;
 163
 164out:
 165        return host;
 166}
 167
 168/*
 169 * Destroy an nlm_host and free associated resources
 170 *
 171 * Caller must hold nlm_host_mutex.
 172 */
 173static void nlm_destroy_host_locked(struct nlm_host *host)
 174{
 175        struct rpc_clnt *clnt;
 176        struct lockd_net *ln = net_generic(host->net, lockd_net_id);
 177
 178        dprintk("lockd: destroy host %s\n", host->h_name);
 179
 180        BUG_ON(!list_empty(&host->h_lockowners));
 181        BUG_ON(atomic_read(&host->h_count));
 182
 183        hlist_del_init(&host->h_hash);
 184
 185        nsm_unmonitor(host);
 186        nsm_release(host->h_nsmhandle);
 187
 188        clnt = host->h_rpcclnt;
 189        if (clnt != NULL)
 190                rpc_shutdown_client(clnt);
 191        kfree(host);
 192
 193        ln->nrhosts--;
 194        nrhosts--;
 195}
 196
 197/**
 198 * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
 199 * @sap: network address of server
 200 * @salen: length of server address
 201 * @protocol: transport protocol to use
 202 * @version: NLM protocol version
 203 * @hostname: '\0'-terminated hostname of server
 204 * @noresvport: 1 if non-privileged port should be used
 205 *
 206 * Returns an nlm_host structure that matches the passed-in
 207 * [server address, transport protocol, NLM version, server hostname].
 208 * If one doesn't already exist in the host cache, a new handle is
 209 * created and returned.
 210 */
 211struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
 212                                     const size_t salen,
 213                                     const unsigned short protocol,
 214                                     const u32 version,
 215                                     const char *hostname,
 216                                     int noresvport,
 217                                     struct net *net)
 218{
 219        struct nlm_lookup_host_info ni = {
 220                .server         = 0,
 221                .sap            = sap,
 222                .salen          = salen,
 223                .protocol       = protocol,
 224                .version        = version,
 225                .hostname       = hostname,
 226                .hostname_len   = strlen(hostname),
 227                .noresvport     = noresvport,
 228                .net            = net,
 229        };
 230        struct hlist_head *chain;
 231        struct hlist_node *pos;
 232        struct nlm_host *host;
 233        struct nsm_handle *nsm = NULL;
 234        struct lockd_net *ln = net_generic(net, lockd_net_id);
 235
 236        dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__,
 237                        (hostname ? hostname : "<none>"), version,
 238                        (protocol == IPPROTO_UDP ? "udp" : "tcp"));
 239
 240        mutex_lock(&nlm_host_mutex);
 241
 242        chain = &nlm_client_hosts[nlm_hash_address(sap)];
 243        hlist_for_each_entry(host, pos, chain, h_hash) {
 244                if (host->net != net)
 245                        continue;
 246                if (!rpc_cmp_addr(nlm_addr(host), sap))
 247                        continue;
 248
 249                /* Same address. Share an NSM handle if we already have one */
 250                if (nsm == NULL)
 251                        nsm = host->h_nsmhandle;
 252
 253                if (host->h_proto != protocol)
 254                        continue;
 255                if (host->h_version != version)
 256                        continue;
 257
 258                nlm_get_host(host);
 259                dprintk("lockd: %s found host %s (%s)\n", __func__,
 260                        host->h_name, host->h_addrbuf);
 261                goto out;
 262        }
 263
 264        host = nlm_alloc_host(&ni, nsm);
 265        if (unlikely(host == NULL))
 266                goto out;
 267
 268        hlist_add_head(&host->h_hash, chain);
 269        ln->nrhosts++;
 270        nrhosts++;
 271
 272        dprintk("lockd: %s created host %s (%s)\n", __func__,
 273                host->h_name, host->h_addrbuf);
 274
 275out:
 276        mutex_unlock(&nlm_host_mutex);
 277        return host;
 278}
 279
 280/**
 281 * nlmclnt_release_host - release client nlm_host
 282 * @host: nlm_host to release
 283 *
 284 */
 285void nlmclnt_release_host(struct nlm_host *host)
 286{
 287        if (host == NULL)
 288                return;
 289
 290        dprintk("lockd: release client host %s\n", host->h_name);
 291
 292        BUG_ON(atomic_read(&host->h_count) < 0);
 293        BUG_ON(host->h_server);
 294
 295        if (atomic_dec_and_test(&host->h_count)) {
 296                BUG_ON(!list_empty(&host->h_lockowners));
 297                BUG_ON(!list_empty(&host->h_granted));
 298                BUG_ON(!list_empty(&host->h_reclaim));
 299
 300                mutex_lock(&nlm_host_mutex);
 301                nlm_destroy_host_locked(host);
 302                mutex_unlock(&nlm_host_mutex);
 303        }
 304}
 305
 306/**
 307 * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
 308 * @rqstp: incoming NLM request
 309 * @hostname: name of client host
 310 * @hostname_len: length of client hostname
 311 *
 312 * Returns an nlm_host structure that matches the [client address,
 313 * transport protocol, NLM version, client hostname] of the passed-in
 314 * NLM request.  If one doesn't already exist in the host cache, a
 315 * new handle is created and returned.
 316 *
 317 * Before possibly creating a new nlm_host, construct a sockaddr
 318 * for a specific source address in case the local system has
 319 * multiple network addresses.  The family of the address in
 320 * rq_daddr is guaranteed to be the same as the family of the
 321 * address in rq_addr, so it's safe to use the same family for
 322 * the source address.
 323 */
 324struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
 325                                    const char *hostname,
 326                                    const size_t hostname_len)
 327{
 328        struct hlist_head *chain;
 329        struct hlist_node *pos;
 330        struct nlm_host *host = NULL;
 331        struct nsm_handle *nsm = NULL;
 332        struct sockaddr *src_sap = svc_daddr(rqstp);
 333        size_t src_len = rqstp->rq_daddrlen;
 334        struct net *net = SVC_NET(rqstp);
 335        struct nlm_lookup_host_info ni = {
 336                .server         = 1,
 337                .sap            = svc_addr(rqstp),
 338                .salen          = rqstp->rq_addrlen,
 339                .protocol       = rqstp->rq_prot,
 340                .version        = rqstp->rq_vers,
 341                .hostname       = hostname,
 342                .hostname_len   = hostname_len,
 343                .net            = net,
 344        };
 345        struct lockd_net *ln = net_generic(net, lockd_net_id);
 346
 347        dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__,
 348                        (int)hostname_len, hostname, rqstp->rq_vers,
 349                        (rqstp->rq_prot == IPPROTO_UDP ? "udp" : "tcp"));
 350
 351        mutex_lock(&nlm_host_mutex);
 352
 353        if (time_after_eq(jiffies, ln->next_gc))
 354                nlm_gc_hosts(net);
 355
 356        chain = &nlm_server_hosts[nlm_hash_address(ni.sap)];
 357        hlist_for_each_entry(host, pos, chain, h_hash) {
 358                if (host->net != net)
 359                        continue;
 360                if (!rpc_cmp_addr(nlm_addr(host), ni.sap))
 361                        continue;
 362
 363                /* Same address. Share an NSM handle if we already have one */
 364                if (nsm == NULL)
 365                        nsm = host->h_nsmhandle;
 366
 367                if (host->h_proto != ni.protocol)
 368                        continue;
 369                if (host->h_version != ni.version)
 370                        continue;
 371                if (!rpc_cmp_addr(nlm_srcaddr(host), src_sap))
 372                        continue;
 373
 374                /* Move to head of hash chain. */
 375                hlist_del(&host->h_hash);
 376                hlist_add_head(&host->h_hash, chain);
 377
 378                nlm_get_host(host);
 379                dprintk("lockd: %s found host %s (%s)\n",
 380                        __func__, host->h_name, host->h_addrbuf);
 381                goto out;
 382        }
 383
 384        host = nlm_alloc_host(&ni, nsm);
 385        if (unlikely(host == NULL))
 386                goto out;
 387
 388        memcpy(nlm_srcaddr(host), src_sap, src_len);
 389        host->h_srcaddrlen = src_len;
 390        hlist_add_head(&host->h_hash, chain);
 391        ln->nrhosts++;
 392        nrhosts++;
 393
 394        dprintk("lockd: %s created host %s (%s)\n",
 395                __func__, host->h_name, host->h_addrbuf);
 396
 397out:
 398        mutex_unlock(&nlm_host_mutex);
 399        return host;
 400}
 401
 402/**
 403 * nlmsvc_release_host - release server nlm_host
 404 * @host: nlm_host to release
 405 *
 406 * Host is destroyed later in nlm_gc_host().
 407 */
 408void nlmsvc_release_host(struct nlm_host *host)
 409{
 410        if (host == NULL)
 411                return;
 412
 413        dprintk("lockd: release server host %s\n", host->h_name);
 414
 415        BUG_ON(atomic_read(&host->h_count) < 0);
 416        BUG_ON(!host->h_server);
 417        atomic_dec(&host->h_count);
 418}
 419
 420/*
 421 * Create the NLM RPC client for an NLM peer
 422 */
 423struct rpc_clnt *
 424nlm_bind_host(struct nlm_host *host)
 425{
 426        struct rpc_clnt *clnt;
 427
 428        dprintk("lockd: nlm_bind_host %s (%s)\n",
 429                        host->h_name, host->h_addrbuf);
 430
 431        /* Lock host handle */
 432        mutex_lock(&host->h_mutex);
 433
 434        /* If we've already created an RPC client, check whether
 435         * RPC rebind is required
 436         */
 437        if ((clnt = host->h_rpcclnt) != NULL) {
 438                if (time_after_eq(jiffies, host->h_nextrebind)) {
 439                        rpc_force_rebind(clnt);
 440                        host->h_nextrebind = jiffies + NLM_HOST_REBIND;
 441                        dprintk("lockd: next rebind in %lu jiffies\n",
 442                                        host->h_nextrebind - jiffies);
 443                }
 444        } else {
 445                unsigned long increment = nlmsvc_timeout;
 446                struct rpc_timeout timeparms = {
 447                        .to_initval     = increment,
 448                        .to_increment   = increment,
 449                        .to_maxval      = increment * 6UL,
 450                        .to_retries     = 5U,
 451                };
 452                struct rpc_create_args args = {
 453                        .net            = host->net,
 454                        .protocol       = host->h_proto,
 455                        .address        = nlm_addr(host),
 456                        .addrsize       = host->h_addrlen,
 457                        .timeout        = &timeparms,
 458                        .servername     = host->h_name,
 459                        .program        = &nlm_program,
 460                        .version        = host->h_version,
 461                        .authflavor     = RPC_AUTH_UNIX,
 462                        .flags          = (RPC_CLNT_CREATE_NOPING |
 463                                           RPC_CLNT_CREATE_AUTOBIND),
 464                };
 465
 466                /*
 467                 * lockd retries server side blocks automatically so we want
 468                 * those to be soft RPC calls. Client side calls need to be
 469                 * hard RPC tasks.
 470                 */
 471                if (!host->h_server)
 472                        args.flags |= RPC_CLNT_CREATE_HARDRTRY;
 473                if (host->h_noresvport)
 474                        args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
 475                if (host->h_srcaddrlen)
 476                        args.saddress = nlm_srcaddr(host);
 477
 478                clnt = rpc_create(&args);
 479                if (!IS_ERR(clnt))
 480                        host->h_rpcclnt = clnt;
 481                else {
 482                        printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
 483                        clnt = NULL;
 484                }
 485        }
 486
 487        mutex_unlock(&host->h_mutex);
 488        return clnt;
 489}
 490
 491/*
 492 * Force a portmap lookup of the remote lockd port
 493 */
 494void
 495nlm_rebind_host(struct nlm_host *host)
 496{
 497        dprintk("lockd: rebind host %s\n", host->h_name);
 498        if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
 499                rpc_force_rebind(host->h_rpcclnt);
 500                host->h_nextrebind = jiffies + NLM_HOST_REBIND;
 501        }
 502}
 503
 504/*
 505 * Increment NLM host count
 506 */
 507struct nlm_host * nlm_get_host(struct nlm_host *host)
 508{
 509        if (host) {
 510                dprintk("lockd: get host %s\n", host->h_name);
 511                atomic_inc(&host->h_count);
 512                host->h_expires = jiffies + NLM_HOST_EXPIRE;
 513        }
 514        return host;
 515}
 516
 517static struct nlm_host *next_host_state(struct hlist_head *cache,
 518                                        struct nsm_handle *nsm,
 519                                        const struct nlm_reboot *info)
 520{
 521        struct nlm_host *host;
 522        struct hlist_head *chain;
 523        struct hlist_node *pos;
 524
 525        mutex_lock(&nlm_host_mutex);
 526        for_each_host(host, pos, chain, cache) {
 527                if (host->h_nsmhandle == nsm
 528                    && host->h_nsmstate != info->state) {
 529                        host->h_nsmstate = info->state;
 530                        host->h_state++;
 531
 532                        nlm_get_host(host);
 533                        mutex_unlock(&nlm_host_mutex);
 534                        return host;
 535                }
 536        }
 537
 538        mutex_unlock(&nlm_host_mutex);
 539        return NULL;
 540}
 541
 542/**
 543 * nlm_host_rebooted - Release all resources held by rebooted host
 544 * @info: pointer to decoded results of NLM_SM_NOTIFY call
 545 *
 546 * We were notified that the specified host has rebooted.  Release
 547 * all resources held by that peer.
 548 */
 549void nlm_host_rebooted(const struct nlm_reboot *info)
 550{
 551        struct nsm_handle *nsm;
 552        struct nlm_host *host;
 553
 554        nsm = nsm_reboot_lookup(info);
 555        if (unlikely(nsm == NULL))
 556                return;
 557
 558        /* Mark all hosts tied to this NSM state as having rebooted.
 559         * We run the loop repeatedly, because we drop the host table
 560         * lock for this.
 561         * To avoid processing a host several times, we match the nsmstate.
 562         */
 563        while ((host = next_host_state(nlm_server_hosts, nsm, info)) != NULL) {
 564                nlmsvc_free_host_resources(host);
 565                nlmsvc_release_host(host);
 566        }
 567        while ((host = next_host_state(nlm_client_hosts, nsm, info)) != NULL) {
 568                nlmclnt_recovery(host);
 569                nlmclnt_release_host(host);
 570        }
 571
 572        nsm_release(nsm);
 573}
 574
 575static void nlm_complain_hosts(struct net *net)
 576{
 577        struct hlist_head *chain;
 578        struct hlist_node *pos;
 579        struct nlm_host *host;
 580
 581        if (net) {
 582                struct lockd_net *ln = net_generic(net, lockd_net_id);
 583
 584                if (ln->nrhosts == 0)
 585                        return;
 586                printk(KERN_WARNING "lockd: couldn't shutdown host module for net %p!\n", net);
 587                dprintk("lockd: %lu hosts left in net %p:\n", ln->nrhosts, net);
 588        } else {
 589                if (nrhosts == 0)
 590                        return;
 591                printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
 592                dprintk("lockd: %lu hosts left:\n", nrhosts);
 593        }
 594
 595        for_each_host(host, pos, chain, nlm_server_hosts) {
 596                if (net && host->net != net)
 597                        continue;
 598                dprintk("       %s (cnt %d use %d exp %ld net %p)\n",
 599                        host->h_name, atomic_read(&host->h_count),
 600                        host->h_inuse, host->h_expires, host->net);
 601        }
 602}
 603
 604void
 605nlm_shutdown_hosts_net(struct net *net)
 606{
 607        struct hlist_head *chain;
 608        struct hlist_node *pos;
 609        struct nlm_host *host;
 610
 611        mutex_lock(&nlm_host_mutex);
 612
 613        /* First, make all hosts eligible for gc */
 614        dprintk("lockd: nuking all hosts in net %p...\n", net);
 615        for_each_host(host, pos, chain, nlm_server_hosts) {
 616                if (net && host->net != net)
 617                        continue;
 618                host->h_expires = jiffies - 1;
 619                if (host->h_rpcclnt) {
 620                        rpc_shutdown_client(host->h_rpcclnt);
 621                        host->h_rpcclnt = NULL;
 622                }
 623        }
 624
 625        /* Then, perform a garbage collection pass */
 626        nlm_gc_hosts(net);
 627        mutex_unlock(&nlm_host_mutex);
 628
 629        nlm_complain_hosts(net);
 630}
 631
 632/*
 633 * Shut down the hosts module.
 634 * Note that this routine is called only at server shutdown time.
 635 */
 636void
 637nlm_shutdown_hosts(void)
 638{
 639        dprintk("lockd: shutting down host module\n");
 640        nlm_shutdown_hosts_net(NULL);
 641}
 642
 643/*
 644 * Garbage collect any unused NLM hosts.
 645 * This GC combines reference counting for async operations with
 646 * mark & sweep for resources held by remote clients.
 647 */
 648static void
 649nlm_gc_hosts(struct net *net)
 650{
 651        struct hlist_head *chain;
 652        struct hlist_node *pos, *next;
 653        struct nlm_host *host;
 654
 655        dprintk("lockd: host garbage collection for net %p\n", net);
 656        for_each_host(host, pos, chain, nlm_server_hosts) {
 657                if (net && host->net != net)
 658                        continue;
 659                host->h_inuse = 0;
 660        }
 661
 662        /* Mark all hosts that hold locks, blocks or shares */
 663        nlmsvc_mark_resources(net);
 664
 665        for_each_host_safe(host, pos, next, chain, nlm_server_hosts) {
 666                if (net && host->net != net)
 667                        continue;
 668                if (atomic_read(&host->h_count) || host->h_inuse
 669                 || time_before(jiffies, host->h_expires)) {
 670                        dprintk("nlm_gc_hosts skipping %s "
 671                                "(cnt %d use %d exp %ld net %p)\n",
 672                                host->h_name, atomic_read(&host->h_count),
 673                                host->h_inuse, host->h_expires, host->net);
 674                        continue;
 675                }
 676                nlm_destroy_host_locked(host);
 677        }
 678
 679        if (net) {
 680                struct lockd_net *ln = net_generic(net, lockd_net_id);
 681
 682                ln->next_gc = jiffies + NLM_HOST_COLLECT;
 683        }
 684}
 685
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.