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 && ni->src_len != 0 &&
 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_srcaddrlen = ni->src_len;
 171         host->h_version    = ni->version;
 172         host->h_proto      = ni->protocol;
 173         host->h_rpcclnt    = NULL;
 174         mutex_init(&host->h_mutex);
 175         host->h_nextrebind = jiffies + NLM_HOST_REBIND;
 176         host->h_expires    = jiffies + NLM_HOST_EXPIRE;
 177         atomic_set(&host->h_count, 1);
 178         init_waitqueue_head(&host->h_gracewait);
 179         init_rwsem(&host->h_rwsem);
 180         host->h_state      = 0;                 /* pseudo NSM state */
 181         host->h_nsmstate   = 0;                 /* real NSM state */
 182         host->h_nsmhandle  = nsm;
 183         host->h_server     = ni->server;
 184         host->h_noresvport = ni->noresvport;
 185         hlist_add_head(&host->h_hash, chain);
 186         INIT_LIST_HEAD(&host->h_lockowners);
 187         spin_lock_init(&host->h_lock);
 188         INIT_LIST_HEAD(&host->h_granted);
 189         INIT_LIST_HEAD(&host->h_reclaim);
 190
 191         nrhosts++;
 192
 193         dprintk("lockd: nlm_lookup_host created host %s\n",
 194                         host->h_name);
 195
 196 out:
 197         mutex_unlock(&nlm_host_mutex);
 198         return host;
 199 }
 200
 201 /*
 202  * Destroy a host
 203  */
 204 static void
 205 nlm_destroy_host(struct nlm_host *host)
 206 {
 207         struct rpc_clnt *clnt;
 208
 209         BUG_ON(!list_empty(&host->h_lockowners));
 210         BUG_ON(atomic_read(&host->h_count));
 211
 212         nsm_unmonitor(host);
 213         nsm_release(host->h_nsmhandle);
 214
 215         clnt = host->h_rpcclnt;
 216         if (clnt != NULL)
 217                 rpc_shutdown_client(clnt);
 218         kfree(host);
 219 }
 220
 221 /**
 222  * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
 223  * @sap: network address of server
 224  * @salen: length of server address
 225  * @protocol: transport protocol to use
 226  * @version: NLM protocol version
 227  * @hostname: '\0'-terminated hostname of server
 228  * @noresvport: 1 if non-privileged port should be used
 229  *
 230  * Returns an nlm_host structure that matches the passed-in
 231  * [server address, transport protocol, NLM version, server hostname].
 232  * If one doesn't already exist in the host cache, a new handle is
 233  * created and returned.
 234  */
 235 struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
 236                                      const size_t salen,
 237                                      const unsigned short protocol,
 238                                      const u32 version,
 239                                      const char *hostname,
 240                                      int noresvport)
 241 {
 242         struct nlm_lookup_host_info ni = {
 243                 .server         = 0,
 244                 .sap            = sap,
 245                 .salen          = salen,
 246                 .protocol       = protocol,
 247                 .version        = version,
 248                 .hostname       = hostname,
 249                 .hostname_len   = strlen(hostname),
 250                 .noresvport     = noresvport,
 251         };
 252
 253         dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__,
 254                         (hostname ? hostname : "<none>"), version,
 255                         (protocol == IPPROTO_UDP ? "udp" : "tcp"));
 256
 257         return nlm_lookup_host(&ni);
 258 }
 259
 260 /**
 261  * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
 262  * @rqstp: incoming NLM request
 263  * @hostname: name of client host
 264  * @hostname_len: length of client hostname
 265  *
 266  * Returns an nlm_host structure that matches the [client address,
 267  * transport protocol, NLM version, client hostname] of the passed-in
 268  * NLM request.  If one doesn't already exist in the host cache, a
 269  * new handle is created and returned.
 270  *
 271  * Before possibly creating a new nlm_host, construct a sockaddr
 272  * for a specific source address in case the local system has
 273  * multiple network addresses.  The family of the address in
 274  * rq_daddr is guaranteed to be the same as the family of the
 275  * address in rq_addr, so it's safe to use the same family for
 276  * the source address.
 277  */
 278 struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
 279                                     const char *hostname,
 280                                     const size_t hostname_len)
 281 {
 282         struct sockaddr_in sin = {
 283                 .sin_family     = AF_INET,
 284         };
 285         struct sockaddr_in6 sin6 = {
 286                 .sin6_family    = AF_INET6,
 287         };
 288         struct nlm_lookup_host_info ni = {
 289                 .server         = 1,
 290                 .sap            = svc_addr(rqstp),
 291                 .salen          = rqstp->rq_addrlen,
 292                 .protocol       = rqstp->rq_prot,
 293                 .version        = rqstp->rq_vers,
 294                 .hostname       = hostname,
 295                 .hostname_len   = hostname_len,
 296                 .src_len        = rqstp->rq_addrlen,
 297         };
 298
 299         dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__,
 300                         (int)hostname_len, hostname, rqstp->rq_vers,
 301                         (rqstp->rq_prot == IPPROTO_UDP ? "udp" : "tcp"));
 302
 303         switch (ni.sap->sa_family) {
 304         case AF_INET:
 305                 sin.sin_addr.s_addr = rqstp->rq_daddr.addr.s_addr;
 306                 ni.src_sap = (struct sockaddr *)&sin;
 307                 break;
 308         case AF_INET6:
 309                 ipv6_addr_copy(&sin6.sin6_addr, &rqstp->rq_daddr.addr6);
 310                 ni.src_sap = (struct sockaddr *)&sin6;
 311                 break;
 312         default:
 313                 return NULL;
 314         }
 315
 316         return nlm_lookup_host(&ni);
 317 }
 318
 319 /*
 320  * Create the NLM RPC client for an NLM peer
 321  */
 322 struct rpc_clnt *
 323 nlm_bind_host(struct nlm_host *host)
 324 {
 325         struct rpc_clnt *clnt;
 326
 327         dprintk("lockd: nlm_bind_host %s (%s)\n",
 328                         host->h_name, host->h_addrbuf);
 329
 330         /* Lock host handle */
 331         mutex_lock(&host->h_mutex);
 332
 333         /* If we've already created an RPC client, check whether
 334          * RPC rebind is required
 335          */
 336         if ((clnt = host->h_rpcclnt) != NULL) {
 337                 if (time_after_eq(jiffies, host->h_nextrebind)) {
 338                         rpc_force_rebind(clnt);
 339                         host->h_nextrebind = jiffies + NLM_HOST_REBIND;
 340                         dprintk("lockd: next rebind in %lu jiffies\n",
 341                                         host->h_nextrebind - jiffies);
 342                 }
 343         } else {
 344                 unsigned long increment = nlmsvc_timeout;
 345                 struct rpc_timeout timeparms = {
 346                         .to_initval     = increment,
 347                         .to_increment   = increment,
 348                         .to_maxval      = increment * 6UL,
 349                         .to_retries     = 5U,
 350                 };
 351                 struct rpc_create_args args = {
 352                         .net            = &init_net,
 353                         .protocol       = host->h_proto,
 354                         .address        = nlm_addr(host),
 355                         .addrsize       = host->h_addrlen,
 356                         .timeout        = &timeparms,
 357                         .servername     = host->h_name,
 358                         .program        = &nlm_program,
 359                         .version        = host->h_version,
 360                         .authflavor     = RPC_AUTH_UNIX,
 361                         .flags          = (RPC_CLNT_CREATE_NOPING |
 362                                            RPC_CLNT_CREATE_AUTOBIND),
 363                 };
 364
 365                 /*
 366                  * lockd retries server side blocks automatically so we want
 367                  * those to be soft RPC calls. Client side calls need to be
 368                  * hard RPC tasks.
 369                  */
 370                 if (!host->h_server)
 371                         args.flags |= RPC_CLNT_CREATE_HARDRTRY;
 372                 if (host->h_noresvport)
 373                         args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
 374                 if (host->h_srcaddrlen)
 375                         args.saddress = nlm_srcaddr(host);
 376
 377                 clnt = rpc_create(&args);
 378                 if (!IS_ERR(clnt))
 379                         host->h_rpcclnt = clnt;
 380                 else {
 381                         printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
 382                         clnt = NULL;
 383                 }
 384         }
 385
 386         mutex_unlock(&host->h_mutex);
 387         return clnt;
 388 }
 389
 390 /*
 391  * Force a portmap lookup of the remote lockd port
 392  */
 393 void
 394 nlm_rebind_host(struct nlm_host *host)
 395 {
 396         dprintk("lockd: rebind host %s\n", host->h_name);
 397         if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
 398                 rpc_force_rebind(host->h_rpcclnt);
 399                 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
 400         }
 401 }
 402
 403 /*
 404  * Increment NLM host count
 405  */
 406 struct nlm_host * nlm_get_host(struct nlm_host *host)
 407 {
 408         if (host) {
 409                 dprintk("lockd: get host %s\n", host->h_name);
 410                 atomic_inc(&host->h_count);
 411                 host->h_expires = jiffies + NLM_HOST_EXPIRE;
 412         }
 413         return host;
 414 }
 415
 416 /*
 417  * Release NLM host after use
 418  */
 419 void nlm_release_host(struct nlm_host *host)
 420 {
 421         if (host != NULL) {
 422                 dprintk("lockd: release host %s\n", host->h_name);
 423                 BUG_ON(atomic_read(&host->h_count) < 0);
 424                 if (atomic_dec_and_test(&host->h_count)) {
 425                         BUG_ON(!list_empty(&host->h_lockowners));
 426                         BUG_ON(!list_empty(&host->h_granted));
 427                         BUG_ON(!list_empty(&host->h_reclaim));
 428                 }
 429         }
 430 }
 431
 432 /**
 433  * nlm_host_rebooted - Release all resources held by rebooted host
 434  * @info: pointer to decoded results of NLM_SM_NOTIFY call
 435  *
 436  * We were notified that the specified host has rebooted.  Release
 437  * all resources held by that peer.
 438  */
 439 void nlm_host_rebooted(const struct nlm_reboot *info)
 440 {
 441         struct hlist_head *chain;
 442         struct hlist_node *pos;
 443         struct nsm_handle *nsm;
 444         struct nlm_host *host;
 445
 446         nsm = nsm_reboot_lookup(info);
 447         if (unlikely(nsm == NULL))
 448                 return;
 449
 450         /* Mark all hosts tied to this NSM state as having rebooted.
 451          * We run the loop repeatedly, because we drop the host table
 452          * lock for this.
 453          * To avoid processing a host several times, we match the nsmstate.
 454          */
 455 again:  mutex_lock(&nlm_host_mutex);
 456         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
 457                 hlist_for_each_entry(host, pos, chain, h_hash) {
 458                         if (host->h_nsmhandle == nsm
 459                          && host->h_nsmstate != info->state) {
 460                                 host->h_nsmstate = info->state;
 461                                 host->h_state++;
 462
 463                                 nlm_get_host(host);
 464                                 mutex_unlock(&nlm_host_mutex);
 465
 466                                 if (host->h_server) {
 467                                         /* We're server for this guy, just ditch
 468                                          * all the locks he held. */
 469                                         nlmsvc_free_host_resources(host);
 470                                 } else {
 471                                         /* He's the server, initiate lock recovery. */
 472                                         nlmclnt_recovery(host);
 473                                 }
 474
 475                                 nlm_release_host(host);
 476                                 goto again;
 477                         }
 478                 }
 479         }
 480         mutex_unlock(&nlm_host_mutex);
 481         nsm_release(nsm);
 482 }
 483
 484 /*
 485  * Shut down the hosts module.
 486  * Note that this routine is called only at server shutdown time.
 487  */
 488 void
 489 nlm_shutdown_hosts(void)
 490 {
 491         struct hlist_head *chain;
 492         struct hlist_node *pos;
 493         struct nlm_host *host;
 494
 495         dprintk("lockd: shutting down host module\n");
 496         mutex_lock(&nlm_host_mutex);
 497
 498         /* First, make all hosts eligible for gc */
 499         dprintk("lockd: nuking all hosts...\n");
 500         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
 501                 hlist_for_each_entry(host, pos, chain, h_hash) {
 502                         host->h_expires = jiffies - 1;
 503                         if (host->h_rpcclnt) {
 504                                 rpc_shutdown_client(host->h_rpcclnt);
 505                                 host->h_rpcclnt = NULL;
 506                         }
 507                 }
 508         }
 509
 510         /* Then, perform a garbage collection pass */
 511         nlm_gc_hosts();
 512         mutex_unlock(&nlm_host_mutex);
 513
 514         /* complain if any hosts are left */
 515         if (nrhosts) {
 516                 printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
 517                 dprintk("lockd: %d hosts left:\n", nrhosts);
 518                 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
 519                         hlist_for_each_entry(host, pos, chain, h_hash) {
 520                                 dprintk("       %s (cnt %d use %d exp %ld)\n",
 521                                         host->h_name, atomic_read(&host->h_count),
 522                                         host->h_inuse, host->h_expires);
 523                         }
 524                 }
 525         }
 526 }
 527
 528 /*
 529  * Garbage collect any unused NLM hosts.
 530  * This GC combines reference counting for async operations with
 531  * mark & sweep for resources held by remote clients.
 532  */
 533 static void
 534 nlm_gc_hosts(void)
 535 {
 536         struct hlist_head *chain;
 537         struct hlist_node *pos, *next;
 538         struct nlm_host *host;
 539
 540         dprintk("lockd: host garbage collection\n");
 541         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
 542                 hlist_for_each_entry(host, pos, chain, h_hash)
 543                         host->h_inuse = 0;
 544         }
 545
 546         /* Mark all hosts that hold locks, blocks or shares */
 547         nlmsvc_mark_resources();
 548
 549         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
 550                 hlist_for_each_entry_safe(host, pos, next, chain, h_hash) {
 551                         if (atomic_read(&host->h_count) || host->h_inuse
 552                          || time_before(jiffies, host->h_expires)) {
 553                                 dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n",
 554                                         host->h_name, atomic_read(&host->h_count),
 555                                         host->h_inuse, host->h_expires);
 556                                 continue;
 557                         }
 558                         dprintk("lockd: delete host %s\n", host->h_name);
 559                         hlist_del_init(&host->h_hash);
 560
 561                         nlm_destroy_host(host);
 562                         nrhosts--;
 563                 }
 564         }
 565
 566         next_gc = jiffies + NLM_HOST_COLLECT;
 567 }