usr/src/uts/common/klm/nlm_rpc_handle.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  24  * Copyright (c) 2012 by Delphix. All rights reserved.
  25  */
  26
  27 #include <sys/param.h>
  28 #include <sys/systm.h>
  29 #include <sys/socket.h>
  30 #include <sys/syslog.h>
  31 #include <sys/systm.h>
  32 #include <sys/unistd.h>
  33 #include <sys/queue.h>
  34 #include <sys/sdt.h>
  35 #include <netinet/in.h>
  36
  37 #include <rpc/rpc.h>
  38 #include <rpc/xdr.h>
  39 #include <rpc/pmap_prot.h>
  40 #include <rpc/pmap_clnt.h>
  41 #include <rpc/rpcb_prot.h>
  42
  43 #include <rpcsvc/nlm_prot.h>
  44 #include <rpcsvc/sm_inter.h>
  45
  46 #include "nlm_impl.h"
  47
  48 /*
  49  * The following errors codes from nlm_null_rpc indicate that the port we have
  50  * cached for the client's NLM service is stale and that we need to establish
  51  * a new RPC client.
  52  */
  53 #define NLM_STALE_CLNT(_status)                 \
  54         ((_status) == RPC_PROGUNAVAIL ||        \
  55         (_status) == RPC_PROGVERSMISMATCH ||    \
  56         (_status) == RPC_PROCUNAVAIL ||         \
  57         (_status) == RPC_CANTCONNECT ||         \
  58         (_status) == RPC_XPRTFAILED)
  59
  60 static struct kmem_cache *nlm_rpch_cache = NULL;
  61
  62 static int nlm_rpch_ctor(void *, void *, int);
  63 static void nlm_rpch_dtor(void *, void *);
  64 static void destroy_rpch(nlm_rpc_t *);
  65 static nlm_rpc_t *get_nlm_rpc_fromcache(struct nlm_host *, int);
  66 static void update_host_rpcbinding(struct nlm_host *, int);
  67 static int refresh_nlm_rpc(struct nlm_host *, nlm_rpc_t *);
  68 static void nlm_host_rele_rpc_locked(struct nlm_host *, nlm_rpc_t *);
  69
  70 static nlm_rpc_t *
  71 get_nlm_rpc_fromcache(struct nlm_host *hostp, int vers)
  72 {
  73         nlm_rpc_t *rpcp;
  74         bool_t found = FALSE;
  75
  76         ASSERT(MUTEX_HELD(&hostp->nh_lock));
  77         if (TAILQ_EMPTY(&hostp->nh_rpchc))
  78                 return (NULL);
  79
  80         TAILQ_FOREACH(rpcp, &hostp->nh_rpchc, nr_link) {
  81                 if (rpcp->nr_vers == vers) {
  82                         found = TRUE;
  83                         break;
  84                 }
  85         }
  86
  87         if (!found)
  88                 return (NULL);
  89
  90         TAILQ_REMOVE(&hostp->nh_rpchc, rpcp, nr_link);
  91         return (rpcp);
  92 }
  93
  94 /*
  95  * Update host's RPC binding (host->nh_addr).
  96  * The function is executed by only one thread at time.
  97  */
  98 static void
  99 update_host_rpcbinding(struct nlm_host *hostp, int vers)
 100 {
 101         enum clnt_stat stat;
 102
 103         ASSERT(MUTEX_HELD(&hostp->nh_lock));
 104
 105         /*
 106          * Mark RPC binding state as "update in progress" in order
 107          * to say other threads that they need to wait until binding
 108          * is fully updated.
 109          */
 110         hostp->nh_rpcb_state = NRPCB_UPDATE_INPROGRESS;
 111         hostp->nh_rpcb_ustat = RPC_SUCCESS;
 112         mutex_exit(&hostp->nh_lock);
 113
 114         stat = rpcbind_getaddr(&hostp->nh_knc, NLM_PROG, vers, &hostp->nh_addr);
 115         mutex_enter(&hostp->nh_lock);
 116
 117         hostp->nh_rpcb_state = ((stat == RPC_SUCCESS) ?
 118             NRPCB_UPDATED : NRPCB_NEED_UPDATE);
 119
 120         hostp->nh_rpcb_ustat = stat;
 121         cv_broadcast(&hostp->nh_rpcb_cv);
 122 }
 123
 124 /*
 125  * Refresh RPC handle taken from host handles cache.
 126  * This function is called when an RPC handle is either
 127  * uninitialized or was initialized using a binding that's
 128  * no longer current.
 129  */
 130 static int
 131 refresh_nlm_rpc(struct nlm_host *hostp, nlm_rpc_t *rpcp)
 132 {
 133         int ret;
 134
 135         if (rpcp->nr_handle == NULL) {
 136                 bool_t clset = TRUE;
 137
 138                 ret = clnt_tli_kcreate(&hostp->nh_knc, &hostp->nh_addr,
 139                     NLM_PROG, rpcp->nr_vers, 0, NLM_RPC_RETRIES,
 140                     CRED(), &rpcp->nr_handle);
 141
 142                 /*
 143                  * Set the client's CLSET_NODELAYONERR option to true. The
 144                  * RPC clnt_call interface creates an artificial delay for
 145                  * certain call errors in order to prevent RPC consumers
 146                  * from getting into tight retry loops. Since this function is
 147                  * called by the NLM service routines we would like to avoid
 148                  * this artificial delay when possible. We do not retry if the
 149                  * NULL request fails so it is safe for us to turn this option
 150                  * on.
 151                  */
 152                 if (clnt_control(rpcp->nr_handle, CLSET_NODELAYONERR,
 153                     (char *)&clset) == FALSE) {
 154                         NLM_ERR("Unable to set CLSET_NODELAYONERR\n");
 155                 }
 156         } else {
 157                 ret = clnt_tli_kinit(rpcp->nr_handle, &hostp->nh_knc,
 158                     &hostp->nh_addr, 0, NLM_RPC_RETRIES, CRED());
 159                 if (ret == 0) {
 160                         enum clnt_stat stat;
 161
 162                         /*
 163                          * Check whether host's RPC binding is still
 164                          * fresh, i.e. if remote program is still sits
 165                          * on the same port we assume. Call NULL proc
 166                          * to do it.
 167                          *
 168                          * Note: Even though we set no delay on error on the
 169                          * client handle the call to nlm_null_rpc can still
 170                          * delay for 10 seconds before returning an error. For
 171                          * example the no delay on error option is not honored
 172                          * for RPC_XPRTFAILED errors (see clnt_cots_kcallit).
 173                          */
 174                         stat = nlm_null_rpc(rpcp->nr_handle, rpcp->nr_vers);
 175                         if (NLM_STALE_CLNT(stat)) {
 176                                 ret = ESTALE;
 177                         }
 178                 }
 179         }
 180
 181         return (ret);
 182 }
 183
 184 /*
 185  * Get RPC handle that can be used to talk to the NLM
 186  * of given version running on given host.
 187  * Saves obtained RPC handle to rpcpp argument.
 188  *
 189  * If error occures, return nonzero error code.
 190  */
 191 int
 192 nlm_host_get_rpc(struct nlm_host *hostp, int vers, nlm_rpc_t **rpcpp)
 193 {
 194         nlm_rpc_t *rpcp = NULL;
 195         int rc;
 196
 197         mutex_enter(&hostp->nh_lock);
 198
 199         /*
 200          * If this handle is either uninitialized, or was
 201          * initialized using binding that's now stale
 202          * do the init or re-init.
 203          * See comments to enum nlm_rpcb_state for more
 204          * details.
 205          */
 206 again:
 207         while (hostp->nh_rpcb_state != NRPCB_UPDATED) {
 208                 if (hostp->nh_rpcb_state == NRPCB_UPDATE_INPROGRESS) {
 209                         rc = cv_wait_sig(&hostp->nh_rpcb_cv, &hostp->nh_lock);
 210                         if (rc == 0) {
 211                                 mutex_exit(&hostp->nh_lock);
 212                                 return (EINTR);
 213                         }
 214                 }
 215
 216                 /*
 217                  * Check if RPC binding was marked for update.
 218                  * If so, start RPC binding update operation.
 219                  * NOTE: the operation can be executed by only
 220                  * one thread at time.
 221                  */
 222                 if (hostp->nh_rpcb_state == NRPCB_NEED_UPDATE)
 223                         update_host_rpcbinding(hostp, vers);
 224
 225                 /*
 226                  * Check if RPC error occured during RPC binding
 227                  * update operation. If so, report a correspoding
 228                  * error.
 229                  */
 230                 if (hostp->nh_rpcb_ustat != RPC_SUCCESS) {
 231                         mutex_exit(&hostp->nh_lock);
 232                         return (ENOENT);
 233                 }
 234         }
 235
 236         rpcp = get_nlm_rpc_fromcache(hostp, vers);
 237         mutex_exit(&hostp->nh_lock);
 238         if (rpcp == NULL) {
 239                 /*
 240                  * There weren't any RPC handles in a host
 241                  * cache. No luck, just create a new one.
 242                  */
 243                 rpcp = kmem_cache_alloc(nlm_rpch_cache, KM_SLEEP);
 244                 rpcp->nr_vers = vers;
 245         }
 246
 247         /*
 248          * Refresh RPC binding
 249          */
 250         rc = refresh_nlm_rpc(hostp, rpcp);
 251         if (rc != 0) {
 252                 if (rc == ESTALE) {
 253                         /*
 254                          * Host's RPC binding is stale, we have
 255                          * to update it. Put the RPC handle back
 256                          * to the cache and mark the host as
 257                          * "need update".
 258                          */
 259                         mutex_enter(&hostp->nh_lock);
 260                         hostp->nh_rpcb_state = NRPCB_NEED_UPDATE;
 261                         nlm_host_rele_rpc_locked(hostp, rpcp);
 262                         goto again;
 263                 }
 264
 265                 destroy_rpch(rpcp);
 266                 return (rc);
 267         }
 268
 269         DTRACE_PROBE2(end, struct nlm_host *, hostp,
 270             nlm_rpc_t *, rpcp);
 271
 272         *rpcpp = rpcp;
 273         return (0);
 274 }
 275
 276 void
 277 nlm_host_rele_rpc(struct nlm_host *hostp, nlm_rpc_t *rpcp)
 278 {
 279         mutex_enter(&hostp->nh_lock);
 280         nlm_host_rele_rpc_locked(hostp, rpcp);
 281         mutex_exit(&hostp->nh_lock);
 282 }
 283
 284 static void
 285 nlm_host_rele_rpc_locked(struct nlm_host *hostp, nlm_rpc_t *rpcp)
 286 {
 287         ASSERT(mutex_owned(&hostp->nh_lock));
 288         TAILQ_INSERT_HEAD(&hostp->nh_rpchc, rpcp, nr_link);
 289 }
 290
 291 /*
 292  * The function invalidates host's RPC binding by marking it
 293  * as not fresh. In this case another time thread tries to
 294  * get RPC handle from host's handles cache, host's RPC binding
 295  * will be updated.
 296  *
 297  * The function should be executed when RPC call invoked via
 298  * handle taken from RPC cache returns RPC_PROCUNAVAIL.
 299  */
 300 void
 301 nlm_host_invalidate_binding(struct nlm_host *hostp)
 302 {
 303         mutex_enter(&hostp->nh_lock);
 304         hostp->nh_rpcb_state = NRPCB_NEED_UPDATE;
 305         mutex_exit(&hostp->nh_lock);
 306 }
 307
 308 void
 309 nlm_rpc_init(void)
 310 {
 311         nlm_rpch_cache = kmem_cache_create("nlm_rpch_cache",
 312             sizeof (nlm_rpc_t), 0, nlm_rpch_ctor, nlm_rpch_dtor,
 313             NULL, NULL, NULL, 0);
 314 }
 315
 316 void
 317 nlm_rpc_cache_destroy(struct nlm_host *hostp)
 318 {
 319         nlm_rpc_t *rpcp;
 320
 321         /*
 322          * There's no need to lock host's mutex here,
 323          * nlm_rpc_cache_destroy() should be called from
 324          * only one place: nlm_host_destroy, when all
 325          * resources host owns are already cleaned up.
 326          * So there shouldn't be any raises.
 327          */
 328         while ((rpcp = TAILQ_FIRST(&hostp->nh_rpchc)) != NULL) {
 329                 TAILQ_REMOVE(&hostp->nh_rpchc, rpcp, nr_link);
 330                 destroy_rpch(rpcp);
 331         }
 332 }
 333
 334 /* ARGSUSED */
 335 static int
 336 nlm_rpch_ctor(void *datap, void *cdrarg, int kmflags)
 337 {
 338         nlm_rpc_t *rpcp = (nlm_rpc_t *)datap;
 339
 340         bzero(rpcp, sizeof (*rpcp));
 341         return (0);
 342 }
 343
 344 /* ARGSUSED */
 345 static void
 346 nlm_rpch_dtor(void *datap, void *cdrarg)
 347 {
 348         nlm_rpc_t *rpcp = (nlm_rpc_t *)datap;
 349         ASSERT(rpcp->nr_handle == NULL);
 350 }
 351
 352 static void
 353 destroy_rpch(nlm_rpc_t *rpcp)
 354 {
 355         if (rpcp->nr_handle != NULL) {
 356                 AUTH_DESTROY(rpcp->nr_handle->cl_auth);
 357                 CLNT_DESTROY(rpcp->nr_handle);
 358                 rpcp->nr_handle = NULL;
 359         }
 360
 361         kmem_cache_free(nlm_rpch_cache, rpcp);
 362 }