sys/rpc/svc.c

   1 /*      $NetBSD: svc.c,v 1.21 2000/07/06 03:10:35 christos Exp $        */
   2
   3 /*
   4  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   5  * unrestricted use provided that this legend is included on all tape
   6  * media and as a part of the software program in whole or part.  Users
   7  * may copy or modify Sun RPC without charge, but are not authorized
   8  * to license or distribute it to anyone else except as part of a product or
   9  * program developed by the user.
  10  *
  11  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  12  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  13  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  14  *
  15  * Sun RPC is provided with no support and without any obligation on the
  16  * part of Sun Microsystems, Inc. to assist in its use, correction,
  17  * modification or enhancement.
  18  *
  19  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  20  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  21  * OR ANY PART THEREOF.
  22  *
  23  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  24  * or profits or other special, indirect and consequential damages, even if
  25  * Sun has been advised of the possibility of such damages.
  26  *
  27  * Sun Microsystems, Inc.
  28  * 2550 Garcia Avenue
  29  * Mountain View, California  94043
  30  */
  31
  32 #if defined(LIBC_SCCS) && !defined(lint)
  33 static char *sccsid2 = "@(#)svc.c 1.44 88/02/08 Copyr 1984 Sun Micro";
  34 static char *sccsid = "@(#)svc.c        2.4 88/08/11 4.0 RPCSRC";
  35 #endif
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 /*
  40  * svc.c, Server-side remote procedure call interface.
  41  *
  42  * There are two sets of procedures here.  The xprt routines are
  43  * for handling transport handles.  The svc routines handle the
  44  * list of service routines.
  45  *
  46  * Copyright (C) 1984, Sun Microsystems, Inc.
  47  */
  48
  49 #include <sys/param.h>
  50 #include <sys/lock.h>
  51 #include <sys/kernel.h>
  52 #include <sys/kthread.h>
  53 #include <sys/malloc.h>
  54 #include <sys/mbuf.h>
  55 #include <sys/mutex.h>
  56 #include <sys/proc.h>
  57 #include <sys/queue.h>
  58 #include <sys/socketvar.h>
  59 #include <sys/systm.h>
  60 #include <sys/ucred.h>
  61
  62 #include <rpc/rpc.h>
  63 #include <rpc/rpcb_clnt.h>
  64 #include <rpc/replay.h>
  65
  66 #include <rpc/rpc_com.h>
  67
  68 #define SVC_VERSQUIET 0x0001            /* keep quiet about vers mismatch */
  69 #define version_keepquiet(xp) (SVC_EXT(xp)->xp_flags & SVC_VERSQUIET)
  70
  71 static struct svc_callout *svc_find(SVCPOOL *pool, rpcprog_t, rpcvers_t,
  72     char *);
  73 static void svc_new_thread(SVCPOOL *pool);
  74 static void xprt_unregister_locked(SVCXPRT *xprt);
  75
  76 /* ***************  SVCXPRT related stuff **************** */
  77
  78 static int svcpool_minthread_sysctl(SYSCTL_HANDLER_ARGS);
  79 static int svcpool_maxthread_sysctl(SYSCTL_HANDLER_ARGS);
  80
  81 SVCPOOL*
  82 svcpool_create(const char *name, struct sysctl_oid_list *sysctl_base)
  83 {
  84         SVCPOOL *pool;
  85
  86         pool = malloc(sizeof(SVCPOOL), M_RPC, M_WAITOK|M_ZERO);
  87
  88         mtx_init(&pool->sp_lock, "sp_lock", NULL, MTX_DEF);
  89         pool->sp_name = name;
  90         pool->sp_state = SVCPOOL_INIT;
  91         pool->sp_proc = NULL;
  92         TAILQ_INIT(&pool->sp_xlist);
  93         TAILQ_INIT(&pool->sp_active);
  94         TAILQ_INIT(&pool->sp_callouts);
  95         LIST_INIT(&pool->sp_threads);
  96         LIST_INIT(&pool->sp_idlethreads);
  97         pool->sp_minthreads = 1;
  98         pool->sp_maxthreads = 1;
  99         pool->sp_threadcount = 0;
 100
 101         /*
 102          * Don't use more than a quarter of mbuf clusters or more than
 103          * 45Mb buffering requests.
 104          */
 105         pool->sp_space_high = nmbclusters * MCLBYTES / 4;
 106         if (pool->sp_space_high > 45 << 20)
 107                 pool->sp_space_high = 45 << 20;
 108         pool->sp_space_low = 2 * pool->sp_space_high / 3;
 109
 110         sysctl_ctx_init(&pool->sp_sysctl);
 111         if (sysctl_base) {
 112                 SYSCTL_ADD_PROC(&pool->sp_sysctl, sysctl_base, OID_AUTO,
 113                     "minthreads", CTLTYPE_INT | CTLFLAG_RW,
 114                     pool, 0, svcpool_minthread_sysctl, "I", "");
 115                 SYSCTL_ADD_PROC(&pool->sp_sysctl, sysctl_base, OID_AUTO,
 116                     "maxthreads", CTLTYPE_INT | CTLFLAG_RW,
 117                     pool, 0, svcpool_maxthread_sysctl, "I", "");
 118                 SYSCTL_ADD_INT(&pool->sp_sysctl, sysctl_base, OID_AUTO,
 119                     "threads", CTLFLAG_RD, &pool->sp_threadcount, 0, "");
 120
 121                 SYSCTL_ADD_UINT(&pool->sp_sysctl, sysctl_base, OID_AUTO,
 122                     "request_space_used", CTLFLAG_RD,
 123                     &pool->sp_space_used, 0,
 124                     "Space in parsed but not handled requests.");
 125
 126                 SYSCTL_ADD_UINT(&pool->sp_sysctl, sysctl_base, OID_AUTO,
 127                     "request_space_used_highest", CTLFLAG_RD,
 128                     &pool->sp_space_used_highest, 0,
 129                     "Highest space used since reboot.");
 130
 131                 SYSCTL_ADD_UINT(&pool->sp_sysctl, sysctl_base, OID_AUTO,
 132                     "request_space_high", CTLFLAG_RW,
 133                     &pool->sp_space_high, 0,
 134                     "Maximum space in parsed but not handled requests.");
 135
 136                 SYSCTL_ADD_UINT(&pool->sp_sysctl, sysctl_base, OID_AUTO,
 137                     "request_space_low", CTLFLAG_RW,
 138                     &pool->sp_space_low, 0,
 139                     "Low water mark for request space.");
 140
 141                 SYSCTL_ADD_INT(&pool->sp_sysctl, sysctl_base, OID_AUTO,
 142                     "request_space_throttled", CTLFLAG_RD,
 143                     &pool->sp_space_throttled, 0,
 144                     "Whether nfs requests are currently throttled");
 145
 146                 SYSCTL_ADD_INT(&pool->sp_sysctl, sysctl_base, OID_AUTO,
 147                     "request_space_throttle_count", CTLFLAG_RD,
 148                     &pool->sp_space_throttle_count, 0,
 149                     "Count of times throttling based on request space has occurred");
 150         }
 151
 152         return pool;
 153 }
 154
 155 void
 156 svcpool_destroy(SVCPOOL *pool)
 157 {
 158         SVCXPRT *xprt, *nxprt;
 159         struct svc_callout *s;
 160         struct svcxprt_list cleanup;
 161
 162         TAILQ_INIT(&cleanup);
 163         mtx_lock(&pool->sp_lock);
 164
 165         while (TAILQ_FIRST(&pool->sp_xlist)) {
 166                 xprt = TAILQ_FIRST(&pool->sp_xlist);
 167                 xprt_unregister_locked(xprt);
 168                 TAILQ_INSERT_TAIL(&cleanup, xprt, xp_link);
 169         }
 170
 171         while (TAILQ_FIRST(&pool->sp_callouts)) {
 172                 s = TAILQ_FIRST(&pool->sp_callouts);
 173                 mtx_unlock(&pool->sp_lock);
 174                 svc_unreg(pool, s->sc_prog, s->sc_vers);
 175                 mtx_lock(&pool->sp_lock);
 176         }
 177         mtx_unlock(&pool->sp_lock);
 178
 179         TAILQ_FOREACH_SAFE(xprt, &cleanup, xp_link, nxprt) {
 180                 SVC_RELEASE(xprt);
 181         }
 182
 183         mtx_destroy(&pool->sp_lock);
 184
 185         if (pool->sp_rcache)
 186                 replay_freecache(pool->sp_rcache);
 187
 188         sysctl_ctx_free(&pool->sp_sysctl);
 189         free(pool, M_RPC);
 190 }
 191
 192 static bool_t
 193 svcpool_active(SVCPOOL *pool)
 194 {
 195         enum svcpool_state state = pool->sp_state;
 196
 197         if (state == SVCPOOL_INIT || state == SVCPOOL_CLOSING)
 198                 return (FALSE);
 199         return (TRUE);
 200 }
 201
 202 /*
 203  * Sysctl handler to set the minimum thread count on a pool
 204  */
 205 static int
 206 svcpool_minthread_sysctl(SYSCTL_HANDLER_ARGS)
 207 {
 208         SVCPOOL *pool;
 209         int newminthreads, error, n;
 210
 211         pool = oidp->oid_arg1;
 212         newminthreads = pool->sp_minthreads;
 213         error = sysctl_handle_int(oidp, &newminthreads, 0, req);
 214         if (error == 0 && newminthreads != pool->sp_minthreads) {
 215                 if (newminthreads > pool->sp_maxthreads)
 216                         return (EINVAL);
 217                 mtx_lock(&pool->sp_lock);
 218                 if (newminthreads > pool->sp_minthreads
 219                     && svcpool_active(pool)) {
 220                         /*
 221                          * If the pool is running and we are
 222                          * increasing, create some more threads now.
 223                          */
 224                         n = newminthreads - pool->sp_threadcount;
 225                         if (n > 0) {
 226                                 mtx_unlock(&pool->sp_lock);
 227                                 while (n--)
 228                                         svc_new_thread(pool);
 229                                 mtx_lock(&pool->sp_lock);
 230                         }
 231                 }
 232                 pool->sp_minthreads = newminthreads;
 233                 mtx_unlock(&pool->sp_lock);
 234         }
 235         return (error);
 236 }
 237
 238 /*
 239  * Sysctl handler to set the maximum thread count on a pool
 240  */
 241 static int
 242 svcpool_maxthread_sysctl(SYSCTL_HANDLER_ARGS)
 243 {
 244         SVCPOOL *pool;
 245         SVCTHREAD *st;
 246         int newmaxthreads, error;
 247
 248         pool = oidp->oid_arg1;
 249         newmaxthreads = pool->sp_maxthreads;
 250         error = sysctl_handle_int(oidp, &newmaxthreads, 0, req);
 251         if (error == 0 && newmaxthreads != pool->sp_maxthreads) {
 252                 if (newmaxthreads < pool->sp_minthreads)
 253                         return (EINVAL);
 254                 mtx_lock(&pool->sp_lock);
 255                 if (newmaxthreads < pool->sp_maxthreads
 256                     && svcpool_active(pool)) {
 257                         /*
 258                          * If the pool is running and we are
 259                          * decreasing, wake up some idle threads to
 260                          * encourage them to exit.
 261                          */
 262                         LIST_FOREACH(st, &pool->sp_idlethreads, st_ilink)
 263                                 cv_signal(&st->st_cond);
 264                 }
 265                 pool->sp_maxthreads = newmaxthreads;
 266                 mtx_unlock(&pool->sp_lock);
 267         }
 268         return (error);
 269 }
 270
 271 /*
 272  * Activate a transport handle.
 273  */
 274 void
 275 xprt_register(SVCXPRT *xprt)
 276 {
 277         SVCPOOL *pool = xprt->xp_pool;
 278
 279         SVC_ACQUIRE(xprt);
 280         mtx_lock(&pool->sp_lock);
 281         xprt->xp_registered = TRUE;
 282         xprt->xp_active = FALSE;
 283         TAILQ_INSERT_TAIL(&pool->sp_xlist, xprt, xp_link);
 284         mtx_unlock(&pool->sp_lock);
 285 }
 286
 287 /*
 288  * De-activate a transport handle. Note: the locked version doesn't
 289  * release the transport - caller must do that after dropping the pool
 290  * lock.
 291  */
 292 static void
 293 xprt_unregister_locked(SVCXPRT *xprt)
 294 {
 295         SVCPOOL *pool = xprt->xp_pool;
 296
 297         KASSERT(xprt->xp_registered == TRUE,
 298             ("xprt_unregister_locked: not registered"));
 299         if (xprt->xp_active) {
 300                 TAILQ_REMOVE(&pool->sp_active, xprt, xp_alink);
 301                 xprt->xp_active = FALSE;
 302         }
 303         TAILQ_REMOVE(&pool->sp_xlist, xprt, xp_link);
 304         xprt->xp_registered = FALSE;
 305 }
 306
 307 void
 308 xprt_unregister(SVCXPRT *xprt)
 309 {
 310         SVCPOOL *pool = xprt->xp_pool;
 311
 312         mtx_lock(&pool->sp_lock);
 313         if (xprt->xp_registered == FALSE) {
 314                 /* Already unregistered by another thread */
 315                 mtx_unlock(&pool->sp_lock);
 316                 return;
 317         }
 318         xprt_unregister_locked(xprt);
 319         mtx_unlock(&pool->sp_lock);
 320
 321         SVC_RELEASE(xprt);
 322 }
 323
 324 static void
 325 xprt_assignthread(SVCXPRT *xprt)
 326 {
 327         SVCPOOL *pool = xprt->xp_pool;
 328         SVCTHREAD *st;
 329
 330         /*
 331          * Attempt to assign a service thread to this
 332          * transport.
 333          */
 334         LIST_FOREACH(st, &pool->sp_idlethreads, st_ilink) {
 335                 if (st->st_xprt == NULL && STAILQ_EMPTY(&st->st_reqs))
 336                         break;
 337         }
 338         if (st) {
 339                 SVC_ACQUIRE(xprt);
 340                 xprt->xp_thread = st;
 341                 st->st_xprt = xprt;
 342                 cv_signal(&st->st_cond);
 343         } else {
 344                 /*
 345                  * See if we can create a new thread. The
 346                  * actual thread creation happens in
 347                  * svc_run_internal because our locking state
 348                  * is poorly defined (we are typically called
 349                  * from a socket upcall). Don't create more
 350                  * than one thread per second.
 351                  */
 352                 if (pool->sp_state == SVCPOOL_ACTIVE
 353                     && pool->sp_lastcreatetime < time_uptime
 354                     && pool->sp_threadcount < pool->sp_maxthreads) {
 355                         pool->sp_state = SVCPOOL_THREADWANTED;
 356                 }
 357         }
 358 }
 359
 360 void
 361 xprt_active(SVCXPRT *xprt)
 362 {
 363         SVCPOOL *pool = xprt->xp_pool;
 364
 365         mtx_lock(&pool->sp_lock);
 366
 367         if (!xprt->xp_registered) {
 368                 /*
 369                  * Race with xprt_unregister - we lose.
 370                  */
 371                 mtx_unlock(&pool->sp_lock);
 372                 return;
 373         }
 374
 375         if (!xprt->xp_active) {
 376                 TAILQ_INSERT_TAIL(&pool->sp_active, xprt, xp_alink);
 377                 xprt->xp_active = TRUE;
 378                 xprt_assignthread(xprt);
 379         }
 380
 381         mtx_unlock(&pool->sp_lock);
 382 }
 383
 384 void
 385 xprt_inactive_locked(SVCXPRT *xprt)
 386 {
 387         SVCPOOL *pool = xprt->xp_pool;
 388
 389         if (xprt->xp_active) {
 390                 TAILQ_REMOVE(&pool->sp_active, xprt, xp_alink);
 391                 xprt->xp_active = FALSE;
 392         }
 393 }
 394
 395 void
 396 xprt_inactive(SVCXPRT *xprt)
 397 {
 398         SVCPOOL *pool = xprt->xp_pool;
 399
 400         mtx_lock(&pool->sp_lock);
 401         xprt_inactive_locked(xprt);
 402         mtx_unlock(&pool->sp_lock);
 403 }
 404
 405 /*
 406  * Add a service program to the callout list.
 407  * The dispatch routine will be called when a rpc request for this
 408  * program number comes in.
 409  */
 410 bool_t
 411 svc_reg(SVCXPRT *xprt, const rpcprog_t prog, const rpcvers_t vers,
 412     void (*dispatch)(struct svc_req *, SVCXPRT *),
 413     const struct netconfig *nconf)
 414 {
 415         SVCPOOL *pool = xprt->xp_pool;
 416         struct svc_callout *s;
 417         char *netid = NULL;
 418         int flag = 0;
 419
 420 /* VARIABLES PROTECTED BY svc_lock: s, svc_head */
 421
 422         if (xprt->xp_netid) {
 423                 netid = strdup(xprt->xp_netid, M_RPC);
 424                 flag = 1;
 425         } else if (nconf && nconf->nc_netid) {
 426                 netid = strdup(nconf->nc_netid, M_RPC);
 427                 flag = 1;
 428         } /* must have been created with svc_raw_create */
 429         if ((netid == NULL) && (flag == 1)) {
 430                 return (FALSE);
 431         }
 432
 433         mtx_lock(&pool->sp_lock);
 434         if ((s = svc_find(pool, prog, vers, netid)) != NULL) {
 435                 if (netid)
 436                         free(netid, M_RPC);
 437                 if (s->sc_dispatch == dispatch)
 438                         goto rpcb_it; /* he is registering another xptr */
 439                 mtx_unlock(&pool->sp_lock);
 440                 return (FALSE);
 441         }
 442         s = malloc(sizeof (struct svc_callout), M_RPC, M_NOWAIT);
 443         if (s == NULL) {
 444                 if (netid)
 445                         free(netid, M_RPC);
 446                 mtx_unlock(&pool->sp_lock);
 447                 return (FALSE);
 448         }
 449
 450         s->sc_prog = prog;
 451         s->sc_vers = vers;
 452         s->sc_dispatch = dispatch;
 453         s->sc_netid = netid;
 454         TAILQ_INSERT_TAIL(&pool->sp_callouts, s, sc_link);
 455
 456         if ((xprt->xp_netid == NULL) && (flag == 1) && netid)
 457                 ((SVCXPRT *) xprt)->xp_netid = strdup(netid, M_RPC);
 458
 459 rpcb_it:
 460         mtx_unlock(&pool->sp_lock);
 461         /* now register the information with the local binder service */
 462         if (nconf) {
 463                 bool_t dummy;
 464                 struct netconfig tnc;
 465                 struct netbuf nb;
 466                 tnc = *nconf;
 467                 nb.buf = &xprt->xp_ltaddr;
 468                 nb.len = xprt->xp_ltaddr.ss_len;
 469                 dummy = rpcb_set(prog, vers, &tnc, &nb);
 470                 return (dummy);
 471         }
 472         return (TRUE);
 473 }
 474
 475 /*
 476  * Remove a service program from the callout list.
 477  */
 478 void
 479 svc_unreg(SVCPOOL *pool, const rpcprog_t prog, const rpcvers_t vers)
 480 {
 481         struct svc_callout *s;
 482
 483         /* unregister the information anyway */
 484         (void) rpcb_unset(prog, vers, NULL);
 485         mtx_lock(&pool->sp_lock);
 486         while ((s = svc_find(pool, prog, vers, NULL)) != NULL) {
 487                 TAILQ_REMOVE(&pool->sp_callouts, s, sc_link);
 488                 if (s->sc_netid)
 489                         mem_free(s->sc_netid, sizeof (s->sc_netid) + 1);
 490                 mem_free(s, sizeof (struct svc_callout));
 491         }
 492         mtx_unlock(&pool->sp_lock);
 493 }
 494
 495 /* ********************** CALLOUT list related stuff ************* */
 496
 497 /*
 498  * Search the callout list for a program number, return the callout
 499  * struct.
 500  */
 501 static struct svc_callout *
 502 svc_find(SVCPOOL *pool, rpcprog_t prog, rpcvers_t vers, char *netid)
 503 {
 504         struct svc_callout *s;
 505
 506         mtx_assert(&pool->sp_lock, MA_OWNED);
 507         TAILQ_FOREACH(s, &pool->sp_callouts, sc_link) {
 508                 if (s->sc_prog == prog && s->sc_vers == vers
 509                     && (netid == NULL || s->sc_netid == NULL ||
 510                         strcmp(netid, s->sc_netid) == 0))
 511                         break;
 512         }
 513
 514         return (s);
 515 }
 516
 517 /* ******************* REPLY GENERATION ROUTINES  ************ */
 518
 519 static bool_t
 520 svc_sendreply_common(struct svc_req *rqstp, struct rpc_msg *rply,
 521     struct mbuf *body)
 522 {
 523         SVCXPRT *xprt = rqstp->rq_xprt;
 524         bool_t ok;
 525
 526         if (rqstp->rq_args) {
 527                 m_freem(rqstp->rq_args);
 528                 rqstp->rq_args = NULL;
 529         }
 530
 531         if (xprt->xp_pool->sp_rcache)
 532                 replay_setreply(xprt->xp_pool->sp_rcache,
 533                     rply, svc_getrpccaller(rqstp), body);
 534
 535         if (!SVCAUTH_WRAP(&rqstp->rq_auth, &body))
 536                 return (FALSE);
 537
 538         ok = SVC_REPLY(xprt, rply, rqstp->rq_addr, body);
 539         if (rqstp->rq_addr) {
 540                 free(rqstp->rq_addr, M_SONAME);
 541                 rqstp->rq_addr = NULL;
 542         }
 543
 544         return (ok);
 545 }
 546
 547 /*
 548  * Send a reply to an rpc request
 549  */
 550 bool_t
 551 svc_sendreply(struct svc_req *rqstp, xdrproc_t xdr_results, void * xdr_location)
 552 {
 553         struct rpc_msg rply;
 554         struct mbuf *m;
 555         XDR xdrs;
 556         bool_t ok;
 557
 558         rply.rm_xid = rqstp->rq_xid;
 559         rply.rm_direction = REPLY;
 560         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 561         rply.acpted_rply.ar_verf = rqstp->rq_verf;
 562         rply.acpted_rply.ar_stat = SUCCESS;
 563         rply.acpted_rply.ar_results.where = NULL;
 564         rply.acpted_rply.ar_results.proc = (xdrproc_t) xdr_void;
 565
 566         MGET(m, M_WAIT, MT_DATA);
 567         MCLGET(m, M_WAIT);
 568         m->m_len = 0;
 569         xdrmbuf_create(&xdrs, m, XDR_ENCODE);
 570         ok = xdr_results(&xdrs, xdr_location);
 571         XDR_DESTROY(&xdrs);
 572
 573         if (ok) {
 574                 return (svc_sendreply_common(rqstp, &rply, m));
 575         } else {
 576                 m_freem(m);
 577                 return (FALSE);
 578         }
 579 }
 580
 581 bool_t
 582 svc_sendreply_mbuf(struct svc_req *rqstp, struct mbuf *m)
 583 {
 584         struct rpc_msg rply;
 585
 586         rply.rm_xid = rqstp->rq_xid;
 587         rply.rm_direction = REPLY;
 588         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 589         rply.acpted_rply.ar_verf = rqstp->rq_verf;
 590         rply.acpted_rply.ar_stat = SUCCESS;
 591         rply.acpted_rply.ar_results.where = NULL;
 592         rply.acpted_rply.ar_results.proc = (xdrproc_t) xdr_void;
 593
 594         return (svc_sendreply_common(rqstp, &rply, m));
 595 }
 596
 597 /*
 598  * No procedure error reply
 599  */
 600 void
 601 svcerr_noproc(struct svc_req *rqstp)
 602 {
 603         SVCXPRT *xprt = rqstp->rq_xprt;
 604         struct rpc_msg rply;
 605
 606         rply.rm_xid = rqstp->rq_xid;
 607         rply.rm_direction = REPLY;
 608         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 609         rply.acpted_rply.ar_verf = rqstp->rq_verf;
 610         rply.acpted_rply.ar_stat = PROC_UNAVAIL;
 611
 612         if (xprt->xp_pool->sp_rcache)
 613                 replay_setreply(xprt->xp_pool->sp_rcache,
 614                     &rply, svc_getrpccaller(rqstp), NULL);
 615
 616         svc_sendreply_common(rqstp, &rply, NULL);
 617 }
 618
 619 /*
 620  * Can't decode args error reply
 621  */
 622 void
 623 svcerr_decode(struct svc_req *rqstp)
 624 {
 625         SVCXPRT *xprt = rqstp->rq_xprt;
 626         struct rpc_msg rply;
 627
 628         rply.rm_xid = rqstp->rq_xid;
 629         rply.rm_direction = REPLY;
 630         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 631         rply.acpted_rply.ar_verf = rqstp->rq_verf;
 632         rply.acpted_rply.ar_stat = GARBAGE_ARGS;
 633
 634         if (xprt->xp_pool->sp_rcache)
 635                 replay_setreply(xprt->xp_pool->sp_rcache,
 636                     &rply, (struct sockaddr *) &xprt->xp_rtaddr, NULL);
 637
 638         svc_sendreply_common(rqstp, &rply, NULL);
 639 }
 640
 641 /*
 642  * Some system error
 643  */
 644 void
 645 svcerr_systemerr(struct svc_req *rqstp)
 646 {
 647         SVCXPRT *xprt = rqstp->rq_xprt;
 648         struct rpc_msg rply;
 649
 650         rply.rm_xid = rqstp->rq_xid;
 651         rply.rm_direction = REPLY;
 652         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 653         rply.acpted_rply.ar_verf = rqstp->rq_verf;
 654         rply.acpted_rply.ar_stat = SYSTEM_ERR;
 655
 656         if (xprt->xp_pool->sp_rcache)
 657                 replay_setreply(xprt->xp_pool->sp_rcache,
 658                     &rply, svc_getrpccaller(rqstp), NULL);
 659
 660         svc_sendreply_common(rqstp, &rply, NULL);
 661 }
 662
 663 /*
 664  * Authentication error reply
 665  */
 666 void
 667 svcerr_auth(struct svc_req *rqstp, enum auth_stat why)
 668 {
 669         SVCXPRT *xprt = rqstp->rq_xprt;
 670         struct rpc_msg rply;
 671
 672         rply.rm_xid = rqstp->rq_xid;
 673         rply.rm_direction = REPLY;
 674         rply.rm_reply.rp_stat = MSG_DENIED;
 675         rply.rjcted_rply.rj_stat = AUTH_ERROR;
 676         rply.rjcted_rply.rj_why = why;
 677
 678         if (xprt->xp_pool->sp_rcache)
 679                 replay_setreply(xprt->xp_pool->sp_rcache,
 680                     &rply, svc_getrpccaller(rqstp), NULL);
 681
 682         svc_sendreply_common(rqstp, &rply, NULL);
 683 }
 684
 685 /*
 686  * Auth too weak error reply
 687  */
 688 void
 689 svcerr_weakauth(struct svc_req *rqstp)
 690 {
 691
 692         svcerr_auth(rqstp, AUTH_TOOWEAK);
 693 }
 694
 695 /*
 696  * Program unavailable error reply
 697  */
 698 void
 699 svcerr_noprog(struct svc_req *rqstp)
 700 {
 701         SVCXPRT *xprt = rqstp->rq_xprt;
 702         struct rpc_msg rply;
 703
 704         rply.rm_xid = rqstp->rq_xid;
 705         rply.rm_direction = REPLY;
 706         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 707         rply.acpted_rply.ar_verf = rqstp->rq_verf;
 708         rply.acpted_rply.ar_stat = PROG_UNAVAIL;
 709
 710         if (xprt->xp_pool->sp_rcache)
 711                 replay_setreply(xprt->xp_pool->sp_rcache,
 712                     &rply, svc_getrpccaller(rqstp), NULL);
 713
 714         svc_sendreply_common(rqstp, &rply, NULL);
 715 }
 716
 717 /*
 718  * Program version mismatch error reply
 719  */
 720 void
 721 svcerr_progvers(struct svc_req *rqstp, rpcvers_t low_vers, rpcvers_t high_vers)
 722 {
 723         SVCXPRT *xprt = rqstp->rq_xprt;
 724         struct rpc_msg rply;
 725
 726         rply.rm_xid = rqstp->rq_xid;
 727         rply.rm_direction = REPLY;
 728         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 729         rply.acpted_rply.ar_verf = rqstp->rq_verf;
 730         rply.acpted_rply.ar_stat = PROG_MISMATCH;
 731         rply.acpted_rply.ar_vers.low = (uint32_t)low_vers;
 732         rply.acpted_rply.ar_vers.high = (uint32_t)high_vers;
 733
 734         if (xprt->xp_pool->sp_rcache)
 735                 replay_setreply(xprt->xp_pool->sp_rcache,
 736                     &rply, svc_getrpccaller(rqstp), NULL);
 737
 738         svc_sendreply_common(rqstp, &rply, NULL);
 739 }
 740
 741 /*
 742  * Allocate a new server transport structure. All fields are
 743  * initialized to zero and xp_p3 is initialized to point at an
 744  * extension structure to hold various flags and authentication
 745  * parameters.
 746  */
 747 SVCXPRT *
 748 svc_xprt_alloc()
 749 {
 750         SVCXPRT *xprt;
 751         SVCXPRT_EXT *ext;
 752
 753         xprt = mem_alloc(sizeof(SVCXPRT));
 754         memset(xprt, 0, sizeof(SVCXPRT));
 755         ext = mem_alloc(sizeof(SVCXPRT_EXT));
 756         memset(ext, 0, sizeof(SVCXPRT_EXT));
 757         xprt->xp_p3 = ext;
 758         refcount_init(&xprt->xp_refs, 1);
 759
 760         return (xprt);
 761 }
 762
 763 /*
 764  * Free a server transport structure.
 765  */
 766 void
 767 svc_xprt_free(xprt)
 768         SVCXPRT *xprt;
 769 {
 770
 771         mem_free(xprt->xp_p3, sizeof(SVCXPRT_EXT));
 772         mem_free(xprt, sizeof(SVCXPRT));
 773 }
 774
 775 /* ******************* SERVER INPUT STUFF ******************* */
 776
 777 /*
 778  * Read RPC requests from a transport and queue them to be
 779  * executed. We handle authentication and replay cache replies here.
 780  * Actually dispatching the RPC is deferred till svc_executereq.
 781  */
 782 static enum xprt_stat
 783 svc_getreq(SVCXPRT *xprt, struct svc_req **rqstp_ret)
 784 {
 785         SVCPOOL *pool = xprt->xp_pool;
 786         struct svc_req *r;
 787         struct rpc_msg msg;
 788         struct mbuf *args;
 789         enum xprt_stat stat;
 790
 791         /* now receive msgs from xprtprt (support batch calls) */
 792         r = malloc(sizeof(*r), M_RPC, M_WAITOK|M_ZERO);
 793
 794         msg.rm_call.cb_cred.oa_base = r->rq_credarea;
 795         msg.rm_call.cb_verf.oa_base = &r->rq_credarea[MAX_AUTH_BYTES];
 796         r->rq_clntcred = &r->rq_credarea[2*MAX_AUTH_BYTES];
 797         if (SVC_RECV(xprt, &msg, &r->rq_addr, &args)) {
 798                 enum auth_stat why;
 799
 800                 /*
 801                  * Handle replays and authenticate before queuing the
 802                  * request to be executed.
 803                  */
 804                 SVC_ACQUIRE(xprt);
 805                 r->rq_xprt = xprt;
 806                 if (pool->sp_rcache) {
 807                         struct rpc_msg repmsg;
 808                         struct mbuf *repbody;
 809                         enum replay_state rs;
 810                         rs = replay_find(pool->sp_rcache, &msg,
 811                             svc_getrpccaller(r), &repmsg, &repbody);
 812                         switch (rs) {
 813                         case RS_NEW:
 814                                 break;
 815                         case RS_DONE:
 816                                 SVC_REPLY(xprt, &repmsg, r->rq_addr,
 817                                     repbody);
 818                                 if (r->rq_addr) {
 819                                         free(r->rq_addr, M_SONAME);
 820                                         r->rq_addr = NULL;
 821                                 }
 822                                 m_freem(args);
 823                                 goto call_done;
 824
 825                         default:
 826                                 m_freem(args);
 827                                 goto call_done;
 828                         }
 829                 }
 830
 831                 r->rq_xid = msg.rm_xid;
 832                 r->rq_prog = msg.rm_call.cb_prog;
 833                 r->rq_vers = msg.rm_call.cb_vers;
 834                 r->rq_proc = msg.rm_call.cb_proc;
 835                 r->rq_size = sizeof(*r) + m_length(args, NULL);
 836                 r->rq_args = args;
 837                 if ((why = _authenticate(r, &msg)) != AUTH_OK) {
 838                         /*
 839                          * RPCSEC_GSS uses this return code
 840                          * for requests that form part of its
 841                          * context establishment protocol and
 842                          * should not be dispatched to the
 843                          * application.
 844                          */
 845                         if (why != RPCSEC_GSS_NODISPATCH)
 846                                 svcerr_auth(r, why);
 847                         goto call_done;
 848                 }
 849
 850                 if (!SVCAUTH_UNWRAP(&r->rq_auth, &r->rq_args)) {
 851                         svcerr_decode(r);
 852                         goto call_done;
 853                 }
 854
 855                 /*
 856                  * Everything checks out, return request to caller.
 857                  */
 858                 *rqstp_ret = r;
 859                 r = NULL;
 860         }
 861 call_done:
 862         if (r) {
 863                 svc_freereq(r);
 864                 r = NULL;
 865         }
 866         if ((stat = SVC_STAT(xprt)) == XPRT_DIED) {
 867                 xprt_unregister(xprt);
 868         }
 869
 870         return (stat);
 871 }
 872
 873 static void
 874 svc_executereq(struct svc_req *rqstp)
 875 {
 876         SVCXPRT *xprt = rqstp->rq_xprt;
 877         SVCPOOL *pool = xprt->xp_pool;
 878         int prog_found;
 879         rpcvers_t low_vers;
 880         rpcvers_t high_vers;
 881         struct svc_callout *s;
 882
 883         /* now match message with a registered service*/
 884         prog_found = FALSE;
 885         low_vers = (rpcvers_t) -1L;
 886         high_vers = (rpcvers_t) 0L;
 887         TAILQ_FOREACH(s, &pool->sp_callouts, sc_link) {
 888                 if (s->sc_prog == rqstp->rq_prog) {
 889                         if (s->sc_vers == rqstp->rq_vers) {
 890                                 /*
 891                                  * We hand ownership of r to the
 892                                  * dispatch method - they must call
 893                                  * svc_freereq.
 894                                  */
 895                                 (*s->sc_dispatch)(rqstp, xprt);
 896                                 return;
 897                         }  /* found correct version */
 898                         prog_found = TRUE;
 899                         if (s->sc_vers < low_vers)
 900                                 low_vers = s->sc_vers;
 901                         if (s->sc_vers > high_vers)
 902                                 high_vers = s->sc_vers;
 903                 }   /* found correct program */
 904         }
 905
 906         /*
 907          * if we got here, the program or version
 908          * is not served ...
 909          */
 910         if (prog_found)
 911                 svcerr_progvers(rqstp, low_vers, high_vers);
 912         else
 913                 svcerr_noprog(rqstp);
 914
 915         svc_freereq(rqstp);
 916 }
 917
 918 static void
 919 svc_checkidle(SVCPOOL *pool)
 920 {
 921         SVCXPRT *xprt, *nxprt;
 922         time_t timo;
 923         struct svcxprt_list cleanup;
 924
 925         TAILQ_INIT(&cleanup);
 926         TAILQ_FOREACH_SAFE(xprt, &pool->sp_xlist, xp_link, nxprt) {
 927                 /*
 928                  * Only some transports have idle timers. Don't time
 929                  * something out which is just waking up.
 930                  */
 931                 if (!xprt->xp_idletimeout || xprt->xp_thread)
 932                         continue;
 933
 934                 timo = xprt->xp_lastactive + xprt->xp_idletimeout;
 935                 if (time_uptime > timo) {
 936                         xprt_unregister_locked(xprt);
 937                         TAILQ_INSERT_TAIL(&cleanup, xprt, xp_link);
 938                 }
 939         }
 940
 941         mtx_unlock(&pool->sp_lock);
 942         TAILQ_FOREACH_SAFE(xprt, &cleanup, xp_link, nxprt) {
 943                 SVC_RELEASE(xprt);
 944         }
 945         mtx_lock(&pool->sp_lock);
 946
 947 }
 948
 949 static void
 950 svc_assign_waiting_sockets(SVCPOOL *pool)
 951 {
 952         SVCXPRT *xprt;
 953
 954         TAILQ_FOREACH(xprt, &pool->sp_active, xp_alink) {
 955                 if (!xprt->xp_thread) {
 956                         xprt_assignthread(xprt);
 957                 }
 958         }
 959 }
 960
 961 static bool_t
 962 svc_request_space_available(SVCPOOL *pool)
 963 {
 964
 965         mtx_assert(&pool->sp_lock, MA_OWNED);
 966
 967         if (pool->sp_space_throttled) {
 968                 /*
 969                  * Below the low-water yet? If so, assign any waiting sockets.
 970                  */
 971                 if (pool->sp_space_used < pool->sp_space_low) {
 972                         pool->sp_space_throttled = FALSE;
 973                         svc_assign_waiting_sockets(pool);
 974                         return TRUE;
 975                 }
 976
 977                 return FALSE;
 978         } else {
 979                 if (pool->sp_space_used
 980                     >= pool->sp_space_high) {
 981                         pool->sp_space_throttled = TRUE;
 982                         pool->sp_space_throttle_count++;
 983                         return FALSE;
 984                 }
 985
 986                 return TRUE;
 987         }
 988 }
 989
 990 static void
 991 svc_run_internal(SVCPOOL *pool, bool_t ismaster)
 992 {
 993         SVCTHREAD *st, *stpref;
 994         SVCXPRT *xprt;
 995         enum xprt_stat stat;
 996         struct svc_req *rqstp;
 997         int error;
 998
 999         st = mem_alloc(sizeof(*st));
1000         st->st_xprt = NULL;
1001         STAILQ_INIT(&st->st_reqs);
1002         cv_init(&st->st_cond, "rpcsvc");
1003
1004         mtx_lock(&pool->sp_lock);
1005         LIST_INSERT_HEAD(&pool->sp_threads, st, st_link);
1006
1007         /*
1008          * If we are a new thread which was spawned to cope with
1009          * increased load, set the state back to SVCPOOL_ACTIVE.
1010          */
1011         if (pool->sp_state == SVCPOOL_THREADSTARTING)
1012                 pool->sp_state = SVCPOOL_ACTIVE;
1013
1014         while (pool->sp_state != SVCPOOL_CLOSING) {
1015                 /*
1016                  * Check for idle transports once per second.
1017                  */
1018                 if (time_uptime > pool->sp_lastidlecheck) {
1019                         pool->sp_lastidlecheck = time_uptime;
1020                         svc_checkidle(pool);
1021                 }
1022
1023                 xprt = st->st_xprt;
1024                 if (!xprt && STAILQ_EMPTY(&st->st_reqs)) {
1025                         /*
1026                          * Enforce maxthreads count.
1027                          */
1028                         if (pool->sp_threadcount > pool->sp_maxthreads)
1029                                 break;
1030
1031                         /*
1032                          * Before sleeping, see if we can find an
1033                          * active transport which isn't being serviced
1034                          * by a thread.
1035                          */
1036                         if (svc_request_space_available(pool)) {
1037                                 TAILQ_FOREACH(xprt, &pool->sp_active,
1038                                     xp_alink) {
1039                                         if (!xprt->xp_thread) {
1040                                                 SVC_ACQUIRE(xprt);
1041                                                 xprt->xp_thread = st;
1042                                                 st->st_xprt = xprt;
1043                                                 break;
1044                                         }
1045                                 }
1046                         }
1047                         if (st->st_xprt)
1048                                 continue;
1049
1050                         LIST_INSERT_HEAD(&pool->sp_idlethreads, st, st_ilink);
1051                         error = cv_timedwait_sig(&st->st_cond, &pool->sp_lock,
1052                                 5 * hz);
1053                         LIST_REMOVE(st, st_ilink);
1054
1055                         /*
1056                          * Reduce worker thread count when idle.
1057                          */
1058                         if (error == EWOULDBLOCK) {
1059                                 if (!ismaster
1060                                     && (pool->sp_threadcount
1061                                         > pool->sp_minthreads)
1062                                         && !st->st_xprt
1063                                         && STAILQ_EMPTY(&st->st_reqs))
1064                                         break;
1065                         }
1066                         if (error == EWOULDBLOCK)
1067                                 continue;
1068                         if (error) {
1069                                 if (pool->sp_state != SVCPOOL_CLOSING) {
1070                                         mtx_unlock(&pool->sp_lock);
1071                                         svc_exit(pool);
1072                                         mtx_lock(&pool->sp_lock);
1073                                 }
1074                                 break;
1075                         }
1076
1077                         if (pool->sp_state == SVCPOOL_THREADWANTED) {
1078                                 pool->sp_state = SVCPOOL_THREADSTARTING;
1079                                 pool->sp_lastcreatetime = time_uptime;
1080                                 mtx_unlock(&pool->sp_lock);
1081                                 svc_new_thread(pool);
1082                                 mtx_lock(&pool->sp_lock);
1083                         }
1084                         continue;
1085                 }
1086
1087                 if (xprt) {
1088                         /*
1089                          * Drain the transport socket and queue up any
1090                          * RPCs.
1091                          */
1092                         xprt->xp_lastactive = time_uptime;
1093                         stat = XPRT_IDLE;
1094                         do {
1095                                 if (!svc_request_space_available(pool))
1096                                         break;
1097                                 rqstp = NULL;
1098                                 mtx_unlock(&pool->sp_lock);
1099                                 stat = svc_getreq(xprt, &rqstp);
1100                                 mtx_lock(&pool->sp_lock);
1101                                 if (rqstp) {
1102                                         /*
1103                                          * See if the application has
1104                                          * a preference for some other
1105                                          * thread.
1106                                          */
1107                                         stpref = st;
1108                                         if (pool->sp_assign)
1109                                                 stpref = pool->sp_assign(st,
1110                                                     rqstp);
1111
1112                                         pool->sp_space_used +=
1113                                                 rqstp->rq_size;
1114                                         if (pool->sp_space_used
1115                                             > pool->sp_space_used_highest)
1116                                                 pool->sp_space_used_highest =
1117                                                         pool->sp_space_used;
1118                                         rqstp->rq_thread = stpref;
1119                                         STAILQ_INSERT_TAIL(&stpref->st_reqs,
1120                                             rqstp, rq_link);
1121                                         stpref->st_reqcount++;
1122
1123                                         /*
1124                                          * If we assigned the request
1125                                          * to another thread, make
1126                                          * sure its awake and continue
1127                                          * reading from the
1128                                          * socket. Otherwise, try to
1129                                          * find some other thread to
1130                                          * read from the socket and
1131                                          * execute the request
1132                                          * immediately.
1133                                          */
1134                                         if (stpref != st) {
1135                                                 cv_signal(&stpref->st_cond);
1136                                                 continue;
1137                                         } else {
1138                                                 break;
1139                                         }
1140                                 }
1141                         } while (stat == XPRT_MOREREQS
1142                             && pool->sp_state != SVCPOOL_CLOSING);
1143
1144                         /*
1145                          * Move this transport to the end of the
1146                          * active list to ensure fairness when
1147                          * multiple transports are active. If this was
1148                          * the last queued request, svc_getreq will
1149                          * end up calling xprt_inactive to remove from
1150                          * the active list.
1151                          */
1152                         xprt->xp_thread = NULL;
1153                         st->st_xprt = NULL;
1154                         if (xprt->xp_active) {
1155                                 xprt_assignthread(xprt);
1156                                 TAILQ_REMOVE(&pool->sp_active, xprt, xp_alink);
1157                                 TAILQ_INSERT_TAIL(&pool->sp_active, xprt,
1158                                     xp_alink);
1159                         }
1160                         mtx_unlock(&pool->sp_lock);
1161                         SVC_RELEASE(xprt);
1162                         mtx_lock(&pool->sp_lock);
1163                 }
1164
1165                 /*
1166                  * Execute what we have queued.
1167                  */
1168                 while ((rqstp = STAILQ_FIRST(&st->st_reqs)) != NULL) {
1169                         size_t sz = rqstp->rq_size;
1170                         mtx_unlock(&pool->sp_lock);
1171                         svc_executereq(rqstp);
1172                         mtx_lock(&pool->sp_lock);
1173                         pool->sp_space_used -= sz;
1174                 }
1175         }
1176
1177         if (st->st_xprt) {
1178                 xprt = st->st_xprt;
1179                 st->st_xprt = NULL;
1180                 SVC_RELEASE(xprt);
1181         }
1182
1183         KASSERT(STAILQ_EMPTY(&st->st_reqs), ("stray reqs on exit"));
1184         LIST_REMOVE(st, st_link);
1185         pool->sp_threadcount--;
1186
1187         mtx_unlock(&pool->sp_lock);
1188
1189         cv_destroy(&st->st_cond);
1190         mem_free(st, sizeof(*st));
1191
1192         if (!ismaster)
1193                 wakeup(pool);
1194 }
1195
1196 static void
1197 svc_thread_start(void *arg)
1198 {
1199
1200         svc_run_internal((SVCPOOL *) arg, FALSE);
1201         kthread_exit();
1202 }
1203
1204 static void
1205 svc_new_thread(SVCPOOL *pool)
1206 {
1207         struct thread *td;
1208
1209         pool->sp_threadcount++;
1210         kthread_add(svc_thread_start, pool,
1211             pool->sp_proc, &td, 0, 0,
1212             "%s: service", pool->sp_name);
1213 }
1214
1215 void
1216 svc_run(SVCPOOL *pool)
1217 {
1218         int i;
1219         struct proc *p;
1220         struct thread *td;
1221
1222         p = curproc;
1223         td = curthread;
1224         snprintf(td->td_name, sizeof(td->td_name),
1225             "%s: master", pool->sp_name);
1226         pool->sp_state = SVCPOOL_ACTIVE;
1227         pool->sp_proc = p;
1228         pool->sp_lastcreatetime = time_uptime;
1229         pool->sp_threadcount = 1;
1230
1231         for (i = 1; i < pool->sp_minthreads; i++) {
1232                 svc_new_thread(pool);
1233         }
1234
1235         svc_run_internal(pool, TRUE);
1236
1237         mtx_lock(&pool->sp_lock);
1238         while (pool->sp_threadcount > 0)
1239                 msleep(pool, &pool->sp_lock, 0, "svcexit", 0);
1240         mtx_unlock(&pool->sp_lock);
1241 }
1242
1243 void
1244 svc_exit(SVCPOOL *pool)
1245 {
1246         SVCTHREAD *st;
1247
1248         mtx_lock(&pool->sp_lock);
1249
1250         pool->sp_state = SVCPOOL_CLOSING;
1251         LIST_FOREACH(st, &pool->sp_idlethreads, st_ilink)
1252                 cv_signal(&st->st_cond);
1253
1254         mtx_unlock(&pool->sp_lock);
1255 }
1256
1257 bool_t
1258 svc_getargs(struct svc_req *rqstp, xdrproc_t xargs, void *args)
1259 {
1260         struct mbuf *m;
1261         XDR xdrs;
1262         bool_t stat;
1263
1264         m = rqstp->rq_args;
1265         rqstp->rq_args = NULL;
1266
1267         xdrmbuf_create(&xdrs, m, XDR_DECODE);
1268         stat = xargs(&xdrs, args);
1269         XDR_DESTROY(&xdrs);
1270
1271         return (stat);
1272 }
1273
1274 bool_t
1275 svc_freeargs(struct svc_req *rqstp, xdrproc_t xargs, void *args)
1276 {
1277         XDR xdrs;
1278
1279         if (rqstp->rq_addr) {
1280                 free(rqstp->rq_addr, M_SONAME);
1281                 rqstp->rq_addr = NULL;
1282         }
1283
1284         xdrs.x_op = XDR_FREE;
1285         return (xargs(&xdrs, args));
1286 }
1287
1288 void
1289 svc_freereq(struct svc_req *rqstp)
1290 {
1291         SVCTHREAD *st;
1292         SVCXPRT *xprt;
1293         SVCPOOL *pool;
1294
1295         st = rqstp->rq_thread;
1296         xprt = rqstp->rq_xprt;
1297         if (xprt)
1298                 pool = xprt->xp_pool;
1299         else
1300                 pool = NULL;
1301         if (st) {
1302                 mtx_lock(&pool->sp_lock);
1303                 KASSERT(rqstp == STAILQ_FIRST(&st->st_reqs),
1304                     ("Freeing request out of order"));
1305                 STAILQ_REMOVE_HEAD(&st->st_reqs, rq_link);
1306                 st->st_reqcount--;
1307                 if (pool->sp_done)
1308                         pool->sp_done(st, rqstp);
1309                 mtx_unlock(&pool->sp_lock);
1310         }
1311
1312         if (rqstp->rq_auth.svc_ah_ops)
1313                 SVCAUTH_RELEASE(&rqstp->rq_auth);
1314
1315         if (rqstp->rq_xprt) {
1316                 SVC_RELEASE(rqstp->rq_xprt);
1317         }
1318
1319         if (rqstp->rq_addr)
1320                 free(rqstp->rq_addr, M_SONAME);
1321
1322         if (rqstp->rq_args)
1323                 m_freem(rqstp->rq_args);
1324
1325         free(rqstp, M_RPC);
1326 }