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