The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/rpc/clnt_rc.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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: releng/10.1/sys/rpc/clnt_rc.c 248255 2013-03-13 21:06:03Z jhb $");
   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 #include <rpc/krpc.h>
   49 
   50 static enum clnt_stat clnt_reconnect_call(CLIENT *, struct rpc_callextra *,
   51     rpcproc_t, struct mbuf *, struct mbuf **, struct timeval);
   52 static void clnt_reconnect_geterr(CLIENT *, struct rpc_err *);
   53 static bool_t clnt_reconnect_freeres(CLIENT *, xdrproc_t, void *);
   54 static void clnt_reconnect_abort(CLIENT *);
   55 static bool_t clnt_reconnect_control(CLIENT *, u_int, void *);
   56 static void clnt_reconnect_close(CLIENT *);
   57 static void clnt_reconnect_destroy(CLIENT *);
   58 
   59 static struct clnt_ops clnt_reconnect_ops = {
   60         .cl_call =      clnt_reconnect_call,
   61         .cl_abort =     clnt_reconnect_abort,
   62         .cl_geterr =    clnt_reconnect_geterr,
   63         .cl_freeres =   clnt_reconnect_freeres,
   64         .cl_close =     clnt_reconnect_close,
   65         .cl_destroy =   clnt_reconnect_destroy,
   66         .cl_control =   clnt_reconnect_control
   67 };
   68 
   69 static int      fake_wchan;
   70 
   71 CLIENT *
   72 clnt_reconnect_create(
   73         struct netconfig *nconf,        /* network type */
   74         struct sockaddr *svcaddr,       /* servers address */
   75         rpcprog_t program,              /* program number */
   76         rpcvers_t version,              /* version number */
   77         size_t sendsz,                  /* buffer recv size */
   78         size_t recvsz)                  /* buffer send size */
   79 {
   80         CLIENT *cl = NULL;              /* client handle */
   81         struct rc_data *rc = NULL;      /* private data */
   82 
   83         if (svcaddr == NULL) {
   84                 rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
   85                 return (NULL);
   86         }
   87 
   88         cl = mem_alloc(sizeof (CLIENT));
   89         rc = mem_alloc(sizeof (*rc));
   90         mtx_init(&rc->rc_lock, "rc->rc_lock", NULL, MTX_DEF);
   91         (void) memcpy(&rc->rc_addr, svcaddr, (size_t)svcaddr->sa_len);
   92         rc->rc_nconf = nconf;
   93         rc->rc_prog = program;
   94         rc->rc_vers = version;
   95         rc->rc_sendsz = sendsz;
   96         rc->rc_recvsz = recvsz;
   97         rc->rc_timeout.tv_sec = -1;
   98         rc->rc_timeout.tv_usec = -1;
   99         rc->rc_retry.tv_sec = 3;
  100         rc->rc_retry.tv_usec = 0;
  101         rc->rc_retries = INT_MAX;
  102         rc->rc_privport = FALSE;
  103         rc->rc_waitchan = "rpcrecv";
  104         rc->rc_intr = 0;
  105         rc->rc_connecting = FALSE;
  106         rc->rc_closed = FALSE;
  107         rc->rc_ucred = crdup(curthread->td_ucred);
  108         rc->rc_client = NULL;
  109 
  110         cl->cl_refs = 1;
  111         cl->cl_ops = &clnt_reconnect_ops;
  112         cl->cl_private = (caddr_t)(void *)rc;
  113         cl->cl_auth = authnone_create();
  114         cl->cl_tp = NULL;
  115         cl->cl_netid = NULL;
  116         return (cl);
  117 }
  118 
  119 static enum clnt_stat
  120 clnt_reconnect_connect(CLIENT *cl)
  121 {
  122         struct thread *td = curthread;
  123         struct rc_data *rc = (struct rc_data *)cl->cl_private;
  124         struct socket *so;
  125         enum clnt_stat stat;
  126         int error;
  127         int one = 1;
  128         struct ucred *oldcred;
  129         CLIENT *newclient = NULL;
  130 
  131         mtx_lock(&rc->rc_lock);
  132         while (rc->rc_connecting) {
  133                 error = msleep(rc, &rc->rc_lock,
  134                     rc->rc_intr ? PCATCH : 0, "rpcrecon", 0);
  135                 if (error) {
  136                         mtx_unlock(&rc->rc_lock);
  137                         return (RPC_INTR);
  138                 }
  139         }
  140         if (rc->rc_closed) {
  141                 mtx_unlock(&rc->rc_lock);
  142                 return (RPC_CANTSEND);
  143         }
  144         if (rc->rc_client) {
  145                 mtx_unlock(&rc->rc_lock);
  146                 return (RPC_SUCCESS);
  147         }
  148 
  149         /*
  150          * My turn to attempt a connect. The rc_connecting variable
  151          * serializes the following code sequence, so it is guaranteed
  152          * that rc_client will still be NULL after it is re-locked below,
  153          * since that is the only place it is set non-NULL.
  154          */
  155         rc->rc_connecting = TRUE;
  156         mtx_unlock(&rc->rc_lock);
  157 
  158         oldcred = td->td_ucred;
  159         td->td_ucred = rc->rc_ucred;
  160         so = __rpc_nconf2socket(rc->rc_nconf);
  161         if (!so) {
  162                 stat = rpc_createerr.cf_stat = RPC_TLIERROR;
  163                 rpc_createerr.cf_error.re_errno = 0;
  164                 td->td_ucred = oldcred;
  165                 goto out;
  166         }
  167 
  168         if (rc->rc_privport)
  169                 bindresvport(so, NULL);
  170 
  171         if (rc->rc_nconf->nc_semantics == NC_TPI_CLTS)
  172                 newclient = clnt_dg_create(so,
  173                     (struct sockaddr *) &rc->rc_addr, rc->rc_prog, rc->rc_vers,
  174                     rc->rc_sendsz, rc->rc_recvsz);
  175         else
  176                 newclient = clnt_vc_create(so,
  177                     (struct sockaddr *) &rc->rc_addr, rc->rc_prog, rc->rc_vers,
  178                     rc->rc_sendsz, rc->rc_recvsz, rc->rc_intr);
  179         td->td_ucred = oldcred;
  180 
  181         if (!newclient) {
  182                 soclose(so);
  183                 rc->rc_err = rpc_createerr.cf_error;
  184                 stat = rpc_createerr.cf_stat;
  185                 goto out;
  186         }
  187 
  188         CLNT_CONTROL(newclient, CLSET_FD_CLOSE, 0);
  189         CLNT_CONTROL(newclient, CLSET_CONNECT, &one);
  190         CLNT_CONTROL(newclient, CLSET_TIMEOUT, &rc->rc_timeout);
  191         CLNT_CONTROL(newclient, CLSET_RETRY_TIMEOUT, &rc->rc_retry);
  192         CLNT_CONTROL(newclient, CLSET_WAITCHAN, rc->rc_waitchan);
  193         CLNT_CONTROL(newclient, CLSET_INTERRUPTIBLE, &rc->rc_intr);
  194         if (rc->rc_backchannel != NULL)
  195                 CLNT_CONTROL(newclient, CLSET_BACKCHANNEL, rc->rc_backchannel);
  196         stat = RPC_SUCCESS;
  197 
  198 out:
  199         mtx_lock(&rc->rc_lock);
  200         KASSERT(rc->rc_client == NULL, ("rc_client not null"));
  201         if (!rc->rc_closed) {
  202                 rc->rc_client = newclient;
  203                 newclient = NULL;
  204         }
  205         rc->rc_connecting = FALSE;
  206         wakeup(rc);
  207         mtx_unlock(&rc->rc_lock);
  208 
  209         if (newclient) {
  210                 /*
  211                  * It has been closed, so discard the new client.
  212                  * nb: clnt_[dg|vc]_close()/clnt_[dg|vc]_destroy() cannot
  213                  * be called with the rc_lock mutex held, since they may
  214                  * msleep() while holding a different mutex.
  215                  */
  216                 CLNT_CLOSE(newclient);
  217                 CLNT_RELEASE(newclient);
  218         }
  219 
  220         return (stat);
  221 }
  222 
  223 static enum clnt_stat
  224 clnt_reconnect_call(
  225         CLIENT          *cl,            /* client handle */
  226         struct rpc_callextra *ext,      /* call metadata */
  227         rpcproc_t       proc,           /* procedure number */
  228         struct mbuf     *args,          /* pointer to args */
  229         struct mbuf     **resultsp,     /* pointer to results */
  230         struct timeval  utimeout)
  231 {
  232         struct rc_data *rc = (struct rc_data *)cl->cl_private;
  233         CLIENT *client;
  234         enum clnt_stat stat;
  235         int tries, error;
  236 
  237         tries = 0;
  238         do {
  239                 mtx_lock(&rc->rc_lock);
  240                 if (rc->rc_closed) {
  241                         mtx_unlock(&rc->rc_lock);
  242                         return (RPC_CANTSEND);
  243                 }
  244 
  245                 if (!rc->rc_client) {
  246                         mtx_unlock(&rc->rc_lock);
  247                         stat = clnt_reconnect_connect(cl);
  248                         if (stat == RPC_SYSTEMERROR) {
  249                                 error = tsleep(&fake_wchan,
  250                                     rc->rc_intr ? PCATCH : 0, "rpccon", hz);
  251                                 if (error == EINTR || error == ERESTART)
  252                                         return (RPC_INTR);
  253                                 tries++;
  254                                 if (tries >= rc->rc_retries)
  255                                         return (stat);
  256                                 continue;
  257                         }
  258                         if (stat != RPC_SUCCESS)
  259                                 return (stat);
  260                         mtx_lock(&rc->rc_lock);
  261                 }
  262 
  263                 if (!rc->rc_client) {
  264                         mtx_unlock(&rc->rc_lock);
  265                         stat = RPC_FAILED;
  266                         continue;
  267                 }
  268                 CLNT_ACQUIRE(rc->rc_client);
  269                 client = rc->rc_client;
  270                 mtx_unlock(&rc->rc_lock);
  271                 stat = CLNT_CALL_MBUF(client, ext, proc, args,
  272                     resultsp, utimeout);
  273 
  274                 if (stat != RPC_SUCCESS) {
  275                         if (!ext)
  276                                 CLNT_GETERR(client, &rc->rc_err);
  277                 }
  278 
  279                 if (stat == RPC_TIMEDOUT) {
  280                         /*
  281                          * Check for async send misfeature for NLM
  282                          * protocol.
  283                          */
  284                         if ((rc->rc_timeout.tv_sec == 0
  285                                 && rc->rc_timeout.tv_usec == 0)
  286                             || (rc->rc_timeout.tv_sec == -1
  287                                 && utimeout.tv_sec == 0
  288                                 && utimeout.tv_usec == 0)) {
  289                                 CLNT_RELEASE(client);
  290                                 break;
  291                         }
  292                 }
  293 
  294                 if (stat == RPC_TIMEDOUT || stat == RPC_CANTSEND
  295                     || stat == RPC_CANTRECV) {
  296                         tries++;
  297                         if (tries >= rc->rc_retries) {
  298                                 CLNT_RELEASE(client);
  299                                 break;
  300                         }
  301 
  302                         if (ext && ext->rc_feedback)
  303                                 ext->rc_feedback(FEEDBACK_RECONNECT, proc,
  304                                     ext->rc_feedback_arg);
  305 
  306                         mtx_lock(&rc->rc_lock);
  307                         /*
  308                          * Make sure that someone else hasn't already
  309                          * reconnected by checking if rc_client has changed.
  310                          * If not, we are done with the client and must
  311                          * do CLNT_RELEASE(client) twice to dispose of it,
  312                          * because there is both an initial refcnt and one
  313                          * acquired by CLNT_ACQUIRE() above.
  314                          */
  315                         if (rc->rc_client == client) {
  316                                 rc->rc_client = NULL;
  317                                 mtx_unlock(&rc->rc_lock);
  318                                 CLNT_RELEASE(client);
  319                         } else {
  320                                 mtx_unlock(&rc->rc_lock);
  321                         }
  322                         CLNT_RELEASE(client);
  323                 } else {
  324                         CLNT_RELEASE(client);
  325                         break;
  326                 }
  327         } while (stat != RPC_SUCCESS);
  328 
  329         KASSERT(stat != RPC_SUCCESS || *resultsp,
  330             ("RPC_SUCCESS without reply"));
  331 
  332         return (stat);
  333 }
  334 
  335 static void
  336 clnt_reconnect_geterr(CLIENT *cl, struct rpc_err *errp)
  337 {
  338         struct rc_data *rc = (struct rc_data *)cl->cl_private;
  339 
  340         *errp = rc->rc_err;
  341 }
  342 
  343 /*
  344  * Since this function requires that rc_client be valid, it can
  345  * only be called when that is guaranteed to be the case.
  346  */
  347 static bool_t
  348 clnt_reconnect_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr)
  349 {
  350         struct rc_data *rc = (struct rc_data *)cl->cl_private;
  351 
  352         return (CLNT_FREERES(rc->rc_client, xdr_res, res_ptr));
  353 }
  354 
  355 /*ARGSUSED*/
  356 static void
  357 clnt_reconnect_abort(CLIENT *h)
  358 {
  359 }
  360 
  361 /*
  362  * CLNT_CONTROL() on the client returned by clnt_reconnect_create() must
  363  * always be called before CLNT_CALL_MBUF() by a single thread only.
  364  */
  365 static bool_t
  366 clnt_reconnect_control(CLIENT *cl, u_int request, void *info)
  367 {
  368         struct rc_data *rc = (struct rc_data *)cl->cl_private;
  369         SVCXPRT *xprt;
  370 
  371         if (info == NULL) {
  372                 return (FALSE);
  373         }
  374         switch (request) {
  375         case CLSET_TIMEOUT:
  376                 rc->rc_timeout = *(struct timeval *)info;
  377                 if (rc->rc_client)
  378                         CLNT_CONTROL(rc->rc_client, request, info);
  379                 break;
  380 
  381         case CLGET_TIMEOUT:
  382                 *(struct timeval *)info = rc->rc_timeout;
  383                 break;
  384 
  385         case CLSET_RETRY_TIMEOUT:
  386                 rc->rc_retry = *(struct timeval *)info;
  387                 if (rc->rc_client)
  388                         CLNT_CONTROL(rc->rc_client, request, info);
  389                 break;
  390 
  391         case CLGET_RETRY_TIMEOUT:
  392                 *(struct timeval *)info = rc->rc_retry;
  393                 break;
  394 
  395         case CLGET_VERS:
  396                 *(uint32_t *)info = rc->rc_vers;
  397                 break;
  398 
  399         case CLSET_VERS:
  400                 rc->rc_vers = *(uint32_t *) info;
  401                 if (rc->rc_client)
  402                         CLNT_CONTROL(rc->rc_client, CLSET_VERS, info);
  403                 break;
  404 
  405         case CLGET_PROG:
  406                 *(uint32_t *)info = rc->rc_prog;
  407                 break;
  408 
  409         case CLSET_PROG:
  410                 rc->rc_prog = *(uint32_t *) info;
  411                 if (rc->rc_client)
  412                         CLNT_CONTROL(rc->rc_client, request, info);
  413                 break;
  414 
  415         case CLSET_WAITCHAN:
  416                 rc->rc_waitchan = (char *)info;
  417                 if (rc->rc_client)
  418                         CLNT_CONTROL(rc->rc_client, request, info);
  419                 break;
  420 
  421         case CLGET_WAITCHAN:
  422                 *(const char **) info = rc->rc_waitchan;
  423                 break;
  424 
  425         case CLSET_INTERRUPTIBLE:
  426                 rc->rc_intr = *(int *) info;
  427                 if (rc->rc_client)
  428                         CLNT_CONTROL(rc->rc_client, request, info);
  429                 break;
  430 
  431         case CLGET_INTERRUPTIBLE:
  432                 *(int *) info = rc->rc_intr;
  433                 break;
  434 
  435         case CLSET_RETRIES:
  436                 rc->rc_retries = *(int *) info;
  437                 break;
  438 
  439         case CLGET_RETRIES:
  440                 *(int *) info = rc->rc_retries;
  441                 break;
  442 
  443         case CLSET_PRIVPORT:
  444                 rc->rc_privport = *(int *) info;
  445                 break;
  446 
  447         case CLGET_PRIVPORT:
  448                 *(int *) info = rc->rc_privport;
  449                 break;
  450 
  451         case CLSET_BACKCHANNEL:
  452                 xprt = (SVCXPRT *)info;
  453                 SVC_ACQUIRE(xprt);
  454                 xprt_register(xprt);
  455                 rc->rc_backchannel = info;
  456                 break;
  457 
  458         default:
  459                 return (FALSE);
  460         }
  461 
  462         return (TRUE);
  463 }
  464 
  465 static void
  466 clnt_reconnect_close(CLIENT *cl)
  467 {
  468         struct rc_data *rc = (struct rc_data *)cl->cl_private;
  469         CLIENT *client;
  470 
  471         mtx_lock(&rc->rc_lock);
  472 
  473         if (rc->rc_closed) {
  474                 mtx_unlock(&rc->rc_lock);
  475                 return;
  476         }
  477 
  478         rc->rc_closed = TRUE;
  479         client = rc->rc_client;
  480         rc->rc_client = NULL;
  481 
  482         mtx_unlock(&rc->rc_lock);
  483 
  484         if (client) {
  485                 CLNT_CLOSE(client);
  486                 CLNT_RELEASE(client);
  487         }
  488 }
  489 
  490 static void
  491 clnt_reconnect_destroy(CLIENT *cl)
  492 {
  493         struct rc_data *rc = (struct rc_data *)cl->cl_private;
  494         SVCXPRT *xprt;
  495 
  496         if (rc->rc_client)
  497                 CLNT_DESTROY(rc->rc_client);
  498         if (rc->rc_backchannel) {
  499                 xprt = (SVCXPRT *)rc->rc_backchannel;
  500                 xprt_unregister(xprt);
  501                 SVC_RELEASE(xprt);
  502         }
  503         crfree(rc->rc_ucred);
  504         mtx_destroy(&rc->rc_lock);
  505         mem_free(rc, sizeof(*rc));
  506         mem_free(cl, sizeof (CLIENT));
  507 }

Cache object: 983cde045b1724133c2ea52b1984ff19


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.