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 } 363