1 /*- 2 * Copyright (c) 2008 Isilon Inc http://www.isilon.com/ 3 * Authors: Doug Rabson <dfr@rabson.org> 4 * Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org> 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/kernel.h> 34 #include <sys/limits.h> 35 #include <sys/lock.h> 36 #include <sys/malloc.h> 37 #include <sys/mbuf.h> 38 #include <sys/mutex.h> 39 #include <sys/pcpu.h> 40 #include <sys/proc.h> 41 #include <sys/socket.h> 42 #include <sys/socketvar.h> 43 #include <sys/time.h> 44 #include <sys/uio.h> 45 46 #include <rpc/rpc.h> 47 #include <rpc/rpc_com.h> 48 49 static enum clnt_stat clnt_reconnect_call(CLIENT *, struct rpc_callextra *, 50 rpcproc_t, struct mbuf *, struct mbuf **, struct timeval); 51 static void clnt_reconnect_geterr(CLIENT *, struct rpc_err *); 52 static bool_t clnt_reconnect_freeres(CLIENT *, xdrproc_t, void *); 53 static void clnt_reconnect_abort(CLIENT *); 54 static bool_t clnt_reconnect_control(CLIENT *, u_int, void *); 55 static void clnt_reconnect_close(CLIENT *); 56 static void clnt_reconnect_destroy(CLIENT *); 57 58 static struct clnt_ops clnt_reconnect_ops = { 59 .cl_call = clnt_reconnect_call, 60 .cl_abort = clnt_reconnect_abort, 61 .cl_geterr = clnt_reconnect_geterr, 62 .cl_freeres = clnt_reconnect_freeres, 63 .cl_close = clnt_reconnect_close, 64 .cl_destroy = clnt_reconnect_destroy, 65 .cl_control = clnt_reconnect_control 66 }; 67 68 static int fake_wchan; 69 70 struct rc_data { 71 struct mtx rc_lock; 72 struct sockaddr_storage rc_addr; /* server address */ 73 struct netconfig* rc_nconf; /* network type */ 74 rpcprog_t rc_prog; /* program number */ 75 rpcvers_t rc_vers; /* version number */ 76 size_t rc_sendsz; 77 size_t rc_recvsz; 78 struct timeval rc_timeout; 79 struct timeval rc_retry; 80 int rc_retries; 81 int rc_privport; 82 char *rc_waitchan; 83 int rc_intr; 84 int rc_connecting; 85 int rc_closed; 86 struct ucred *rc_ucred; 87 CLIENT* rc_client; /* underlying RPC client */ 88 struct rpc_err rc_err; 89 }; 90 91 CLIENT * 92 clnt_reconnect_create( 93 struct netconfig *nconf, /* network type */ 94 struct sockaddr *svcaddr, /* servers address */ 95 rpcprog_t program, /* program number */ 96 rpcvers_t version, /* version number */ 97 size_t sendsz, /* buffer recv size */ 98 size_t recvsz) /* buffer send size */ 99 { 100 CLIENT *cl = NULL; /* client handle */ 101 struct rc_data *rc = NULL; /* private data */ 102 103 if (svcaddr == NULL) { 104 rpc_createerr.cf_stat = RPC_UNKNOWNADDR; 105 return (NULL); 106 } 107 108 cl = mem_alloc(sizeof (CLIENT)); 109 rc = mem_alloc(sizeof (*rc)); 110 mtx_init(&rc->rc_lock, "rc->rc_lock", NULL, MTX_DEF); 111 (void) memcpy(&rc->rc_addr, svcaddr, (size_t)svcaddr->sa_len); 112 rc->rc_nconf = nconf; 113 rc->rc_prog = program; 114 rc->rc_vers = version; 115 rc->rc_sendsz = sendsz; 116 rc->rc_recvsz = recvsz; 117 rc->rc_timeout.tv_sec = -1; 118 rc->rc_timeout.tv_usec = -1; 119 rc->rc_retry.tv_sec = 3; 120 rc->rc_retry.tv_usec = 0; 121 rc->rc_retries = INT_MAX; 122 rc->rc_privport = FALSE; 123 rc->rc_waitchan = "rpcrecv"; 124 rc->rc_intr = 0; 125 rc->rc_connecting = FALSE; 126 rc->rc_closed = FALSE; 127 rc->rc_ucred = crdup(curthread->td_ucred); 128 rc->rc_client = NULL; 129 130 cl->cl_refs = 1; 131 cl->cl_ops = &clnt_reconnect_ops; 132 cl->cl_private = (caddr_t)(void *)rc; 133 cl->cl_auth = authnone_create(); 134 cl->cl_tp = NULL; 135 cl->cl_netid = NULL; 136 return (cl); 137 } 138 139 static enum clnt_stat 140 clnt_reconnect_connect(CLIENT *cl) 141 { 142 struct thread *td = curthread; 143 struct rc_data *rc = (struct rc_data *)cl->cl_private; 144 struct socket *so; 145 enum clnt_stat stat; 146 int error; 147 int one = 1; 148 struct ucred *oldcred; 149 CLIENT *newclient = NULL; 150 151 mtx_lock(&rc->rc_lock); 152 while (rc->rc_connecting) { 153 error = msleep(rc, &rc->rc_lock, 154 rc->rc_intr ? PCATCH : 0, "rpcrecon", 0); 155 if (error) { 156 mtx_unlock(&rc->rc_lock); 157 return (RPC_INTR); 158 } 159 } 160 if (rc->rc_closed) { 161 mtx_unlock(&rc->rc_lock); 162 return (RPC_CANTSEND); 163 } 164 if (rc->rc_client) { 165 mtx_unlock(&rc->rc_lock); 166 return (RPC_SUCCESS); 167 } 168 169 /* 170 * My turn to attempt a connect. The rc_connecting variable 171 * serializes the following code sequence, so it is guaranteed 172 * that rc_client will still be NULL after it is re-locked below, 173 * since that is the only place it is set non-NULL. 174 */ 175 rc->rc_connecting = TRUE; 176 mtx_unlock(&rc->rc_lock); 177 178 oldcred = td->td_ucred; 179 td->td_ucred = rc->rc_ucred; 180 so = __rpc_nconf2socket(rc->rc_nconf); 181 if (!so) { 182 stat = rpc_createerr.cf_stat = RPC_TLIERROR; 183 rpc_createerr.cf_error.re_errno = 0; 184 td->td_ucred = oldcred; 185 goto out; 186 } 187 188 if (rc->rc_privport) 189 bindresvport(so, NULL); 190 191 if (rc->rc_nconf->nc_semantics == NC_TPI_CLTS) 192 newclient = clnt_dg_create(so, 193 (struct sockaddr *) &rc->rc_addr, rc->rc_prog, rc->rc_vers, 194 rc->rc_sendsz, rc->rc_recvsz); 195 else 196 newclient = clnt_vc_create(so, 197 (struct sockaddr *) &rc->rc_addr, rc->rc_prog, rc->rc_vers, 198 rc->rc_sendsz, rc->rc_recvsz); 199 td->td_ucred = oldcred; 200 201 if (!newclient) { 202 soclose(so); 203 rc->rc_err = rpc_createerr.cf_error; 204 stat = rpc_createerr.cf_stat; 205 goto out; 206 } 207 208 CLNT_CONTROL(newclient, CLSET_FD_CLOSE, 0); 209 CLNT_CONTROL(newclient, CLSET_CONNECT, &one); 210 CLNT_CONTROL(newclient, CLSET_TIMEOUT, &rc->rc_timeout); 211 CLNT_CONTROL(newclient, CLSET_RETRY_TIMEOUT, &rc->rc_retry); 212 CLNT_CONTROL(newclient, CLSET_WAITCHAN, rc->rc_waitchan); 213 CLNT_CONTROL(newclient, CLSET_INTERRUPTIBLE, &rc->rc_intr); 214 stat = RPC_SUCCESS; 215 216 out: 217 mtx_lock(&rc->rc_lock); 218 KASSERT(rc->rc_client == NULL, ("rc_client not null")); 219 if (!rc->rc_closed) { 220 rc->rc_client = newclient; 221 newclient = NULL; 222 } 223 rc->rc_connecting = FALSE; 224 wakeup(rc); 225 mtx_unlock(&rc->rc_lock); 226 227 if (newclient) { 228 /* 229 * It has been closed, so discard the new client. 230 * nb: clnt_[dg|vc]_close()/clnt_[dg|vc]_destroy() cannot 231 * be called with the rc_lock mutex held, since they may 232 * msleep() while holding a different mutex. 233 */ 234 CLNT_CLOSE(newclient); 235 CLNT_RELEASE(newclient); 236 } 237 238 return (stat); 239 } 240 241 static enum clnt_stat 242 clnt_reconnect_call( 243 CLIENT *cl, /* client handle */ 244 struct rpc_callextra *ext, /* call metadata */ 245 rpcproc_t proc, /* procedure number */ 246 struct mbuf *args, /* pointer to args */ 247 struct mbuf **resultsp, /* pointer to results */ 248 struct timeval utimeout) 249 { 250 struct rc_data *rc = (struct rc_data *)cl->cl_private; 251 CLIENT *client; 252 enum clnt_stat stat; 253 int tries, error; 254 255 tries = 0; 256 do { 257 mtx_lock(&rc->rc_lock); 258 if (rc->rc_closed) { 259 mtx_unlock(&rc->rc_lock); 260 return (RPC_CANTSEND); 261 } 262 263 if (!rc->rc_client) { 264 mtx_unlock(&rc->rc_lock); 265 stat = clnt_reconnect_connect(cl); 266 if (stat == RPC_SYSTEMERROR) { 267 error = tsleep(&fake_wchan, 268 rc->rc_intr ? PCATCH | PBDRY : 0, "rpccon", 269 hz); 270 if (error == EINTR || error == ERESTART) 271 return (RPC_INTR); 272 tries++; 273 if (tries >= rc->rc_retries) 274 return (stat); 275 continue; 276 } 277 if (stat != RPC_SUCCESS) 278 return (stat); 279 mtx_lock(&rc->rc_lock); 280 } 281 282 if (!rc->rc_client) { 283 mtx_unlock(&rc->rc_lock); 284 stat = RPC_FAILED; 285 continue; 286 } 287 CLNT_ACQUIRE(rc->rc_client); 288 client = rc->rc_client; 289 mtx_unlock(&rc->rc_lock); 290 stat = CLNT_CALL_MBUF(client, ext, proc, args, 291 resultsp, utimeout); 292 293 if (stat != RPC_SUCCESS) { 294 if (!ext) 295 CLNT_GETERR(client, &rc->rc_err); 296 } 297 298 if (stat == RPC_TIMEDOUT) { 299 /* 300 * Check for async send misfeature for NLM 301 * protocol. 302 */ 303 if ((rc->rc_timeout.tv_sec == 0 304 && rc->rc_timeout.tv_usec == 0) 305 || (rc->rc_timeout.tv_sec == -1 306 && utimeout.tv_sec == 0 307 && utimeout.tv_usec == 0)) { 308 CLNT_RELEASE(client); 309 break; 310 } 311 } 312 313 if (stat == RPC_TIMEDOUT || stat == RPC_CANTSEND 314 || stat == RPC_CANTRECV) { 315 tries++; 316 if (tries >= rc->rc_retries) { 317 CLNT_RELEASE(client); 318 break; 319 } 320 321 if (ext && ext->rc_feedback) 322 ext->rc_feedback(FEEDBACK_RECONNECT, proc, 323 ext->rc_feedback_arg); 324 325 mtx_lock(&rc->rc_lock); 326 /* 327 * Make sure that someone else hasn't already 328 * reconnected by checking if rc_client has changed. 329 * If not, we are done with the client and must 330 * do CLNT_RELEASE(client) twice to dispose of it, 331 * because there is both an initial refcnt and one 332 * acquired by CLNT_ACQUIRE() above. 333 */ 334 if (rc->rc_client == client) { 335 rc->rc_client = NULL; 336 mtx_unlock(&rc->rc_lock); 337 CLNT_RELEASE(client); 338 } else { 339 mtx_unlock(&rc->rc_lock); 340 } 341 CLNT_RELEASE(client); 342 } else { 343 CLNT_RELEASE(client); 344 break; 345 } 346 } while (stat != RPC_SUCCESS); 347 348 KASSERT(stat != RPC_SUCCESS || *resultsp, 349 ("RPC_SUCCESS without reply")); 350 351 return (stat); 352 } 353 354 static void 355 clnt_reconnect_geterr(CLIENT *cl, struct rpc_err *errp) 356 { 357 struct rc_data *rc = (struct rc_data *)cl->cl_private; 358 359 *errp = rc->rc_err; 360 } 361 362 /* 363 * Since this function requires that rc_client be valid, it can 364 * only be called when that is guaranteed to be the case. 365 */ 366 static bool_t 367 clnt_reconnect_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr) 368 { 369 struct rc_data *rc = (struct rc_data *)cl->cl_private; 370 371 return (CLNT_FREERES(rc->rc_client, xdr_res, res_ptr)); 372 } 373 374 /*ARGSUSED*/ 375 static void 376 clnt_reconnect_abort(CLIENT *h) 377 { 378 } 379 380 /* 381 * CLNT_CONTROL() on the client returned by clnt_reconnect_create() must 382 * always be called before CLNT_CALL_MBUF() by a single thread only. 383 */ 384 static bool_t 385 clnt_reconnect_control(CLIENT *cl, u_int request, void *info) 386 { 387 struct rc_data *rc = (struct rc_data *)cl->cl_private; 388 389 if (info == NULL) { 390 return (FALSE); 391 } 392 switch (request) { 393 case CLSET_TIMEOUT: 394 rc->rc_timeout = *(struct timeval *)info; 395 if (rc->rc_client) 396 CLNT_CONTROL(rc->rc_client, request, info); 397 break; 398 399 case CLGET_TIMEOUT: 400 *(struct timeval *)info = rc->rc_timeout; 401 break; 402 403 case CLSET_RETRY_TIMEOUT: 404 rc->rc_retry = *(struct timeval *)info; 405 if (rc->rc_client) 406 CLNT_CONTROL(rc->rc_client, request, info); 407 break; 408 409 case CLGET_RETRY_TIMEOUT: 410 *(struct timeval *)info = rc->rc_retry; 411 break; 412 413 case CLGET_VERS: 414 *(uint32_t *)info = rc->rc_vers; 415 break; 416 417 case CLSET_VERS: 418 rc->rc_vers = *(uint32_t *) info; 419 if (rc->rc_client) 420 CLNT_CONTROL(rc->rc_client, CLSET_VERS, info); 421 break; 422 423 case CLGET_PROG: 424 *(uint32_t *)info = rc->rc_prog; 425 break; 426 427 case CLSET_PROG: 428 rc->rc_prog = *(uint32_t *) info; 429 if (rc->rc_client) 430 CLNT_CONTROL(rc->rc_client, request, info); 431 break; 432 433 case CLSET_WAITCHAN: 434 rc->rc_waitchan = (char *)info; 435 if (rc->rc_client) 436 CLNT_CONTROL(rc->rc_client, request, info); 437 break; 438 439 case CLGET_WAITCHAN: 440 *(const char **) info = rc->rc_waitchan; 441 break; 442 443 case CLSET_INTERRUPTIBLE: 444 rc->rc_intr = *(int *) info; 445 if (rc->rc_client) 446 CLNT_CONTROL(rc->rc_client, request, info); 447 break; 448 449 case CLGET_INTERRUPTIBLE: 450 *(int *) info = rc->rc_intr; 451 break; 452 453 case CLSET_RETRIES: 454 rc->rc_retries = *(int *) info; 455 break; 456 457 case CLGET_RETRIES: 458 *(int *) info = rc->rc_retries; 459 break; 460 461 case CLSET_PRIVPORT: 462 rc->rc_privport = *(int *) info; 463 break; 464 465 case CLGET_PRIVPORT: 466 *(int *) info = rc->rc_privport; 467 break; 468 469 default: 470 return (FALSE); 471 } 472 473 return (TRUE); 474 } 475 476 static void 477 clnt_reconnect_close(CLIENT *cl) 478 { 479 struct rc_data *rc = (struct rc_data *)cl->cl_private; 480 CLIENT *client; 481 482 mtx_lock(&rc->rc_lock); 483 484 if (rc->rc_closed) { 485 mtx_unlock(&rc->rc_lock); 486 return; 487 } 488 489 rc->rc_closed = TRUE; 490 client = rc->rc_client; 491 rc->rc_client = NULL; 492 493 mtx_unlock(&rc->rc_lock); 494 495 if (client) { 496 CLNT_CLOSE(client); 497 CLNT_RELEASE(client); 498 } 499 } 500 501 static void 502 clnt_reconnect_destroy(CLIENT *cl) 503 { 504 struct rc_data *rc = (struct rc_data *)cl->cl_private; 505 506 if (rc->rc_client) 507 CLNT_DESTROY(rc->rc_client); 508 crfree(rc->rc_ucred); 509 mtx_destroy(&rc->rc_lock); 510 mem_free(rc, sizeof(*rc)); 511 mem_free(cl, sizeof (CLIENT)); 512 } 513