fs/lockd/host.c

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