1177633Sdfr/* $NetBSD: svc.c,v 1.21 2000/07/06 03:10:35 christos Exp $ */ 2177633Sdfr 3261057Smav/*- 4261057Smav * Copyright (c) 2009, Sun Microsystems, Inc. 5261057Smav * All rights reserved. 6177633Sdfr * 7261057Smav * Redistribution and use in source and binary forms, with or without 8261057Smav * modification, are permitted provided that the following conditions are met: 9261057Smav * - Redistributions of source code must retain the above copyright notice, 10261057Smav * this list of conditions and the following disclaimer. 11261057Smav * - Redistributions in binary form must reproduce the above copyright notice, 12261057Smav * this list of conditions and the following disclaimer in the documentation 13261057Smav * and/or other materials provided with the distribution. 14261057Smav * - Neither the name of Sun Microsystems, Inc. nor the names of its 15261057Smav * contributors may be used to endorse or promote products derived 16261057Smav * from this software without specific prior written permission. 17261057Smav * 18261057Smav * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19261057Smav * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20261057Smav * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21261057Smav * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 22261057Smav * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23261057Smav * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24261057Smav * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25261057Smav * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26261057Smav * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27261057Smav * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28261057Smav * POSSIBILITY OF SUCH DAMAGE. 29177633Sdfr */ 30177633Sdfr 31177633Sdfr#if defined(LIBC_SCCS) && !defined(lint) 32177633Sdfrstatic char *sccsid2 = "@(#)svc.c 1.44 88/02/08 Copyr 1984 Sun Micro"; 33177633Sdfrstatic char *sccsid = "@(#)svc.c 2.4 88/08/11 4.0 RPCSRC"; 34177633Sdfr#endif 35177633Sdfr#include <sys/cdefs.h> 36177633Sdfr__FBSDID("$FreeBSD$"); 37177633Sdfr 38177633Sdfr/* 39177633Sdfr * svc.c, Server-side remote procedure call interface. 40177633Sdfr * 41177633Sdfr * There are two sets of procedures here. The xprt routines are 42177633Sdfr * for handling transport handles. The svc routines handle the 43177633Sdfr * list of service routines. 44177633Sdfr * 45177633Sdfr * Copyright (C) 1984, Sun Microsystems, Inc. 46177633Sdfr */ 47177633Sdfr 48177633Sdfr#include <sys/param.h> 49177633Sdfr#include <sys/lock.h> 50177633Sdfr#include <sys/kernel.h> 51184588Sdfr#include <sys/kthread.h> 52177633Sdfr#include <sys/malloc.h> 53184588Sdfr#include <sys/mbuf.h> 54177633Sdfr#include <sys/mutex.h> 55184588Sdfr#include <sys/proc.h> 56177633Sdfr#include <sys/queue.h> 57184588Sdfr#include <sys/socketvar.h> 58177633Sdfr#include <sys/systm.h> 59261067Smav#include <sys/sx.h> 60177633Sdfr#include <sys/ucred.h> 61177633Sdfr 62177633Sdfr#include <rpc/rpc.h> 63177633Sdfr#include <rpc/rpcb_clnt.h> 64184588Sdfr#include <rpc/replay.h> 65177633Sdfr 66177685Sdfr#include <rpc/rpc_com.h> 67177633Sdfr 68177633Sdfr#define SVC_VERSQUIET 0x0001 /* keep quiet about vers mismatch */ 69184588Sdfr#define version_keepquiet(xp) (SVC_EXT(xp)->xp_flags & SVC_VERSQUIET) 70177633Sdfr 71177633Sdfrstatic struct svc_callout *svc_find(SVCPOOL *pool, rpcprog_t, rpcvers_t, 72177633Sdfr char *); 73184588Sdfrstatic void svc_new_thread(SVCPOOL *pool); 74184588Sdfrstatic void xprt_unregister_locked(SVCXPRT *xprt); 75261066Smavstatic void svc_change_space_used(SVCPOOL *pool, int delta); 76261066Smavstatic bool_t svc_request_space_available(SVCPOOL *pool); 77177633Sdfr 78177633Sdfr/* *************** SVCXPRT related stuff **************** */ 79177633Sdfr 80184588Sdfrstatic int svcpool_minthread_sysctl(SYSCTL_HANDLER_ARGS); 81184588Sdfrstatic int svcpool_maxthread_sysctl(SYSCTL_HANDLER_ARGS); 82184588Sdfr 83177633SdfrSVCPOOL* 84184588Sdfrsvcpool_create(const char *name, struct sysctl_oid_list *sysctl_base) 85177633Sdfr{ 86177633Sdfr SVCPOOL *pool; 87177633Sdfr 88177633Sdfr pool = malloc(sizeof(SVCPOOL), M_RPC, M_WAITOK|M_ZERO); 89177633Sdfr 90177633Sdfr mtx_init(&pool->sp_lock, "sp_lock", NULL, MTX_DEF); 91184588Sdfr pool->sp_name = name; 92184588Sdfr pool->sp_state = SVCPOOL_INIT; 93184588Sdfr pool->sp_proc = NULL; 94177633Sdfr TAILQ_INIT(&pool->sp_xlist); 95177633Sdfr TAILQ_INIT(&pool->sp_active); 96177633Sdfr TAILQ_INIT(&pool->sp_callouts); 97261067Smav TAILQ_INIT(&pool->sp_lcallouts); 98184588Sdfr LIST_INIT(&pool->sp_threads); 99184588Sdfr LIST_INIT(&pool->sp_idlethreads); 100184588Sdfr pool->sp_minthreads = 1; 101184588Sdfr pool->sp_maxthreads = 1; 102184588Sdfr pool->sp_threadcount = 0; 103177633Sdfr 104184588Sdfr /* 105184588Sdfr * Don't use more than a quarter of mbuf clusters or more than 106184588Sdfr * 45Mb buffering requests. 107184588Sdfr */ 108184588Sdfr pool->sp_space_high = nmbclusters * MCLBYTES / 4; 109184588Sdfr if (pool->sp_space_high > 45 << 20) 110184588Sdfr pool->sp_space_high = 45 << 20; 111184588Sdfr pool->sp_space_low = 2 * pool->sp_space_high / 3; 112184588Sdfr 113184588Sdfr sysctl_ctx_init(&pool->sp_sysctl); 114184588Sdfr if (sysctl_base) { 115184588Sdfr SYSCTL_ADD_PROC(&pool->sp_sysctl, sysctl_base, OID_AUTO, 116184588Sdfr "minthreads", CTLTYPE_INT | CTLFLAG_RW, 117184588Sdfr pool, 0, svcpool_minthread_sysctl, "I", ""); 118184588Sdfr SYSCTL_ADD_PROC(&pool->sp_sysctl, sysctl_base, OID_AUTO, 119184588Sdfr "maxthreads", CTLTYPE_INT | CTLFLAG_RW, 120184588Sdfr pool, 0, svcpool_maxthread_sysctl, "I", ""); 121184588Sdfr SYSCTL_ADD_INT(&pool->sp_sysctl, sysctl_base, OID_AUTO, 122184588Sdfr "threads", CTLFLAG_RD, &pool->sp_threadcount, 0, ""); 123184588Sdfr 124184588Sdfr SYSCTL_ADD_UINT(&pool->sp_sysctl, sysctl_base, OID_AUTO, 125184588Sdfr "request_space_used", CTLFLAG_RD, 126184588Sdfr &pool->sp_space_used, 0, 127184588Sdfr "Space in parsed but not handled requests."); 128184588Sdfr 129184588Sdfr SYSCTL_ADD_UINT(&pool->sp_sysctl, sysctl_base, OID_AUTO, 130184588Sdfr "request_space_used_highest", CTLFLAG_RD, 131184588Sdfr &pool->sp_space_used_highest, 0, 132184588Sdfr "Highest space used since reboot."); 133184588Sdfr 134184588Sdfr SYSCTL_ADD_UINT(&pool->sp_sysctl, sysctl_base, OID_AUTO, 135184588Sdfr "request_space_high", CTLFLAG_RW, 136184588Sdfr &pool->sp_space_high, 0, 137184588Sdfr "Maximum space in parsed but not handled requests."); 138184588Sdfr 139184588Sdfr SYSCTL_ADD_UINT(&pool->sp_sysctl, sysctl_base, OID_AUTO, 140184588Sdfr "request_space_low", CTLFLAG_RW, 141184588Sdfr &pool->sp_space_low, 0, 142184588Sdfr "Low water mark for request space."); 143184588Sdfr 144217326Smdf SYSCTL_ADD_INT(&pool->sp_sysctl, sysctl_base, OID_AUTO, 145184588Sdfr "request_space_throttled", CTLFLAG_RD, 146184588Sdfr &pool->sp_space_throttled, 0, 147184588Sdfr "Whether nfs requests are currently throttled"); 148184588Sdfr 149217326Smdf SYSCTL_ADD_INT(&pool->sp_sysctl, sysctl_base, OID_AUTO, 150184588Sdfr "request_space_throttle_count", CTLFLAG_RD, 151184588Sdfr &pool->sp_space_throttle_count, 0, 152184588Sdfr "Count of times throttling based on request space has occurred"); 153184588Sdfr } 154184588Sdfr 155177633Sdfr return pool; 156177633Sdfr} 157177633Sdfr 158177633Sdfrvoid 159177633Sdfrsvcpool_destroy(SVCPOOL *pool) 160177633Sdfr{ 161184588Sdfr SVCXPRT *xprt, *nxprt; 162177633Sdfr struct svc_callout *s; 163261067Smav struct svc_loss_callout *sl; 164184588Sdfr struct svcxprt_list cleanup; 165177633Sdfr 166184588Sdfr TAILQ_INIT(&cleanup); 167177633Sdfr mtx_lock(&pool->sp_lock); 168177633Sdfr 169177633Sdfr while (TAILQ_FIRST(&pool->sp_xlist)) { 170177633Sdfr xprt = TAILQ_FIRST(&pool->sp_xlist); 171184588Sdfr xprt_unregister_locked(xprt); 172184588Sdfr TAILQ_INSERT_TAIL(&cleanup, xprt, xp_link); 173177633Sdfr } 174177633Sdfr 175261067Smav while ((s = TAILQ_FIRST(&pool->sp_callouts)) != NULL) { 176177633Sdfr mtx_unlock(&pool->sp_lock); 177177633Sdfr svc_unreg(pool, s->sc_prog, s->sc_vers); 178177633Sdfr mtx_lock(&pool->sp_lock); 179177633Sdfr } 180261067Smav while ((sl = TAILQ_FIRST(&pool->sp_lcallouts)) != NULL) { 181261067Smav mtx_unlock(&pool->sp_lock); 182261067Smav svc_loss_unreg(pool, sl->slc_dispatch); 183261067Smav mtx_lock(&pool->sp_lock); 184261067Smav } 185193603Srmacklem mtx_unlock(&pool->sp_lock); 186177633Sdfr 187184588Sdfr TAILQ_FOREACH_SAFE(xprt, &cleanup, xp_link, nxprt) { 188184588Sdfr SVC_RELEASE(xprt); 189184588Sdfr } 190184588Sdfr 191193436Srmacklem mtx_destroy(&pool->sp_lock); 192193436Srmacklem 193184588Sdfr if (pool->sp_rcache) 194184588Sdfr replay_freecache(pool->sp_rcache); 195184588Sdfr 196184588Sdfr sysctl_ctx_free(&pool->sp_sysctl); 197177633Sdfr free(pool, M_RPC); 198177633Sdfr} 199177633Sdfr 200184588Sdfrstatic bool_t 201184588Sdfrsvcpool_active(SVCPOOL *pool) 202184588Sdfr{ 203184588Sdfr enum svcpool_state state = pool->sp_state; 204184588Sdfr 205184588Sdfr if (state == SVCPOOL_INIT || state == SVCPOOL_CLOSING) 206184588Sdfr return (FALSE); 207184588Sdfr return (TRUE); 208184588Sdfr} 209184588Sdfr 210177633Sdfr/* 211184588Sdfr * Sysctl handler to set the minimum thread count on a pool 212184588Sdfr */ 213184588Sdfrstatic int 214184588Sdfrsvcpool_minthread_sysctl(SYSCTL_HANDLER_ARGS) 215184588Sdfr{ 216184588Sdfr SVCPOOL *pool; 217184588Sdfr int newminthreads, error, n; 218184588Sdfr 219184588Sdfr pool = oidp->oid_arg1; 220184588Sdfr newminthreads = pool->sp_minthreads; 221184588Sdfr error = sysctl_handle_int(oidp, &newminthreads, 0, req); 222184588Sdfr if (error == 0 && newminthreads != pool->sp_minthreads) { 223184588Sdfr if (newminthreads > pool->sp_maxthreads) 224184588Sdfr return (EINVAL); 225184588Sdfr mtx_lock(&pool->sp_lock); 226184588Sdfr if (newminthreads > pool->sp_minthreads 227184588Sdfr && svcpool_active(pool)) { 228184588Sdfr /* 229184588Sdfr * If the pool is running and we are 230184588Sdfr * increasing, create some more threads now. 231184588Sdfr */ 232184588Sdfr n = newminthreads - pool->sp_threadcount; 233184588Sdfr if (n > 0) { 234184588Sdfr mtx_unlock(&pool->sp_lock); 235184588Sdfr while (n--) 236184588Sdfr svc_new_thread(pool); 237184588Sdfr mtx_lock(&pool->sp_lock); 238184588Sdfr } 239184588Sdfr } 240184588Sdfr pool->sp_minthreads = newminthreads; 241184588Sdfr mtx_unlock(&pool->sp_lock); 242184588Sdfr } 243184588Sdfr return (error); 244184588Sdfr} 245184588Sdfr 246184588Sdfr/* 247184588Sdfr * Sysctl handler to set the maximum thread count on a pool 248184588Sdfr */ 249184588Sdfrstatic int 250184588Sdfrsvcpool_maxthread_sysctl(SYSCTL_HANDLER_ARGS) 251184588Sdfr{ 252184588Sdfr SVCPOOL *pool; 253184588Sdfr SVCTHREAD *st; 254184588Sdfr int newmaxthreads, error; 255184588Sdfr 256184588Sdfr pool = oidp->oid_arg1; 257184588Sdfr newmaxthreads = pool->sp_maxthreads; 258184588Sdfr error = sysctl_handle_int(oidp, &newmaxthreads, 0, req); 259184588Sdfr if (error == 0 && newmaxthreads != pool->sp_maxthreads) { 260184588Sdfr if (newmaxthreads < pool->sp_minthreads) 261184588Sdfr return (EINVAL); 262184588Sdfr mtx_lock(&pool->sp_lock); 263184588Sdfr if (newmaxthreads < pool->sp_maxthreads 264184588Sdfr && svcpool_active(pool)) { 265184588Sdfr /* 266184588Sdfr * If the pool is running and we are 267184588Sdfr * decreasing, wake up some idle threads to 268184588Sdfr * encourage them to exit. 269184588Sdfr */ 270184588Sdfr LIST_FOREACH(st, &pool->sp_idlethreads, st_ilink) 271184588Sdfr cv_signal(&st->st_cond); 272184588Sdfr } 273184588Sdfr pool->sp_maxthreads = newmaxthreads; 274184588Sdfr mtx_unlock(&pool->sp_lock); 275184588Sdfr } 276184588Sdfr return (error); 277184588Sdfr} 278184588Sdfr 279184588Sdfr/* 280177633Sdfr * Activate a transport handle. 281177633Sdfr */ 282177633Sdfrvoid 283177633Sdfrxprt_register(SVCXPRT *xprt) 284177633Sdfr{ 285177633Sdfr SVCPOOL *pool = xprt->xp_pool; 286177633Sdfr 287194407Srmacklem SVC_ACQUIRE(xprt); 288177633Sdfr mtx_lock(&pool->sp_lock); 289177633Sdfr xprt->xp_registered = TRUE; 290177633Sdfr xprt->xp_active = FALSE; 291177633Sdfr TAILQ_INSERT_TAIL(&pool->sp_xlist, xprt, xp_link); 292177633Sdfr mtx_unlock(&pool->sp_lock); 293177633Sdfr} 294177633Sdfr 295177633Sdfr/* 296184588Sdfr * De-activate a transport handle. Note: the locked version doesn't 297184588Sdfr * release the transport - caller must do that after dropping the pool 298184588Sdfr * lock. 299177633Sdfr */ 300177633Sdfrstatic void 301184588Sdfrxprt_unregister_locked(SVCXPRT *xprt) 302177633Sdfr{ 303177633Sdfr SVCPOOL *pool = xprt->xp_pool; 304177633Sdfr 305261060Smav mtx_assert(&pool->sp_lock, MA_OWNED); 306193649Srmacklem KASSERT(xprt->xp_registered == TRUE, 307193649Srmacklem ("xprt_unregister_locked: not registered")); 308261060Smav xprt_inactive_locked(xprt); 309177633Sdfr TAILQ_REMOVE(&pool->sp_xlist, xprt, xp_link); 310177633Sdfr xprt->xp_registered = FALSE; 311184588Sdfr} 312177633Sdfr 313184588Sdfrvoid 314184588Sdfrxprt_unregister(SVCXPRT *xprt) 315184588Sdfr{ 316184588Sdfr SVCPOOL *pool = xprt->xp_pool; 317184588Sdfr 318184588Sdfr mtx_lock(&pool->sp_lock); 319193649Srmacklem if (xprt->xp_registered == FALSE) { 320193649Srmacklem /* Already unregistered by another thread */ 321193649Srmacklem mtx_unlock(&pool->sp_lock); 322193649Srmacklem return; 323193649Srmacklem } 324184588Sdfr xprt_unregister_locked(xprt); 325184588Sdfr mtx_unlock(&pool->sp_lock); 326184588Sdfr 327184588Sdfr SVC_RELEASE(xprt); 328177633Sdfr} 329177633Sdfr 330261060Smav/* 331261060Smav * Attempt to assign a service thread to this transport. 332261060Smav */ 333261060Smavstatic int 334184588Sdfrxprt_assignthread(SVCXPRT *xprt) 335184588Sdfr{ 336184588Sdfr SVCPOOL *pool = xprt->xp_pool; 337184588Sdfr SVCTHREAD *st; 338184588Sdfr 339261060Smav mtx_assert(&pool->sp_lock, MA_OWNED); 340261060Smav st = LIST_FIRST(&pool->sp_idlethreads); 341184588Sdfr if (st) { 342261060Smav LIST_REMOVE(st, st_ilink); 343261060Smav st->st_idle = FALSE; 344184588Sdfr SVC_ACQUIRE(xprt); 345184588Sdfr xprt->xp_thread = st; 346184588Sdfr st->st_xprt = xprt; 347184588Sdfr cv_signal(&st->st_cond); 348261060Smav return (TRUE); 349184588Sdfr } else { 350184588Sdfr /* 351184588Sdfr * See if we can create a new thread. The 352184588Sdfr * actual thread creation happens in 353184588Sdfr * svc_run_internal because our locking state 354184588Sdfr * is poorly defined (we are typically called 355184588Sdfr * from a socket upcall). Don't create more 356184588Sdfr * than one thread per second. 357184588Sdfr */ 358184588Sdfr if (pool->sp_state == SVCPOOL_ACTIVE 359184588Sdfr && pool->sp_lastcreatetime < time_uptime 360184588Sdfr && pool->sp_threadcount < pool->sp_maxthreads) { 361184588Sdfr pool->sp_state = SVCPOOL_THREADWANTED; 362184588Sdfr } 363184588Sdfr } 364261060Smav return (FALSE); 365184588Sdfr} 366184588Sdfr 367177633Sdfrvoid 368177633Sdfrxprt_active(SVCXPRT *xprt) 369177633Sdfr{ 370177633Sdfr SVCPOOL *pool = xprt->xp_pool; 371177633Sdfr 372193436Srmacklem mtx_lock(&pool->sp_lock); 373193436Srmacklem 374184588Sdfr if (!xprt->xp_registered) { 375184588Sdfr /* 376184588Sdfr * Race with xprt_unregister - we lose. 377184588Sdfr */ 378193436Srmacklem mtx_unlock(&pool->sp_lock); 379184588Sdfr return; 380184588Sdfr } 381184588Sdfr 382177633Sdfr if (!xprt->xp_active) { 383177633Sdfr xprt->xp_active = TRUE; 384261060Smav if (xprt->xp_thread == NULL) { 385261066Smav if (!svc_request_space_available(pool) || 386261066Smav !xprt_assignthread(xprt)) 387261060Smav TAILQ_INSERT_TAIL(&pool->sp_active, xprt, 388261060Smav xp_alink); 389261060Smav } 390177633Sdfr } 391177633Sdfr 392177633Sdfr mtx_unlock(&pool->sp_lock); 393177633Sdfr} 394177633Sdfr 395177633Sdfrvoid 396184588Sdfrxprt_inactive_locked(SVCXPRT *xprt) 397177633Sdfr{ 398177633Sdfr SVCPOOL *pool = xprt->xp_pool; 399177633Sdfr 400261060Smav mtx_assert(&pool->sp_lock, MA_OWNED); 401177633Sdfr if (xprt->xp_active) { 402261060Smav if (xprt->xp_thread == NULL) 403261060Smav TAILQ_REMOVE(&pool->sp_active, xprt, xp_alink); 404177633Sdfr xprt->xp_active = FALSE; 405177633Sdfr } 406184588Sdfr} 407177633Sdfr 408184588Sdfrvoid 409184588Sdfrxprt_inactive(SVCXPRT *xprt) 410184588Sdfr{ 411184588Sdfr SVCPOOL *pool = xprt->xp_pool; 412184588Sdfr 413184588Sdfr mtx_lock(&pool->sp_lock); 414184588Sdfr xprt_inactive_locked(xprt); 415177633Sdfr mtx_unlock(&pool->sp_lock); 416177633Sdfr} 417177633Sdfr 418177633Sdfr/* 419261065Smav * Variant of xprt_inactive() for use only when sure that port is 420261065Smav * assigned to thread. For example, withing receive handlers. 421261065Smav */ 422261065Smavvoid 423261065Smavxprt_inactive_self(SVCXPRT *xprt) 424261065Smav{ 425261065Smav 426261065Smav KASSERT(xprt->xp_thread != NULL, 427261065Smav ("xprt_inactive_self(%p) with NULL xp_thread", xprt)); 428261065Smav xprt->xp_active = FALSE; 429261065Smav} 430261065Smav 431261065Smav/* 432177633Sdfr * Add a service program to the callout list. 433177633Sdfr * The dispatch routine will be called when a rpc request for this 434177633Sdfr * program number comes in. 435177633Sdfr */ 436177633Sdfrbool_t 437177633Sdfrsvc_reg(SVCXPRT *xprt, const rpcprog_t prog, const rpcvers_t vers, 438177633Sdfr void (*dispatch)(struct svc_req *, SVCXPRT *), 439177633Sdfr const struct netconfig *nconf) 440177633Sdfr{ 441177633Sdfr SVCPOOL *pool = xprt->xp_pool; 442177633Sdfr struct svc_callout *s; 443177633Sdfr char *netid = NULL; 444177633Sdfr int flag = 0; 445177633Sdfr 446177633Sdfr/* VARIABLES PROTECTED BY svc_lock: s, svc_head */ 447177633Sdfr 448177633Sdfr if (xprt->xp_netid) { 449177633Sdfr netid = strdup(xprt->xp_netid, M_RPC); 450177633Sdfr flag = 1; 451177633Sdfr } else if (nconf && nconf->nc_netid) { 452177633Sdfr netid = strdup(nconf->nc_netid, M_RPC); 453177633Sdfr flag = 1; 454177633Sdfr } /* must have been created with svc_raw_create */ 455177633Sdfr if ((netid == NULL) && (flag == 1)) { 456177633Sdfr return (FALSE); 457177633Sdfr } 458177633Sdfr 459177633Sdfr mtx_lock(&pool->sp_lock); 460177633Sdfr if ((s = svc_find(pool, prog, vers, netid)) != NULL) { 461177633Sdfr if (netid) 462177633Sdfr free(netid, M_RPC); 463177633Sdfr if (s->sc_dispatch == dispatch) 464177633Sdfr goto rpcb_it; /* he is registering another xptr */ 465177633Sdfr mtx_unlock(&pool->sp_lock); 466177633Sdfr return (FALSE); 467177633Sdfr } 468177633Sdfr s = malloc(sizeof (struct svc_callout), M_RPC, M_NOWAIT); 469177633Sdfr if (s == NULL) { 470177633Sdfr if (netid) 471177633Sdfr free(netid, M_RPC); 472177633Sdfr mtx_unlock(&pool->sp_lock); 473177633Sdfr return (FALSE); 474177633Sdfr } 475177633Sdfr 476177633Sdfr s->sc_prog = prog; 477177633Sdfr s->sc_vers = vers; 478177633Sdfr s->sc_dispatch = dispatch; 479177633Sdfr s->sc_netid = netid; 480177633Sdfr TAILQ_INSERT_TAIL(&pool->sp_callouts, s, sc_link); 481177633Sdfr 482177633Sdfr if ((xprt->xp_netid == NULL) && (flag == 1) && netid) 483177633Sdfr ((SVCXPRT *) xprt)->xp_netid = strdup(netid, M_RPC); 484177633Sdfr 485177633Sdfrrpcb_it: 486177633Sdfr mtx_unlock(&pool->sp_lock); 487177633Sdfr /* now register the information with the local binder service */ 488177633Sdfr if (nconf) { 489177633Sdfr bool_t dummy; 490177633Sdfr struct netconfig tnc; 491184588Sdfr struct netbuf nb; 492177633Sdfr tnc = *nconf; 493184588Sdfr nb.buf = &xprt->xp_ltaddr; 494184588Sdfr nb.len = xprt->xp_ltaddr.ss_len; 495184588Sdfr dummy = rpcb_set(prog, vers, &tnc, &nb); 496177633Sdfr return (dummy); 497177633Sdfr } 498177633Sdfr return (TRUE); 499177633Sdfr} 500177633Sdfr 501177633Sdfr/* 502177633Sdfr * Remove a service program from the callout list. 503177633Sdfr */ 504177633Sdfrvoid 505177633Sdfrsvc_unreg(SVCPOOL *pool, const rpcprog_t prog, const rpcvers_t vers) 506177633Sdfr{ 507177633Sdfr struct svc_callout *s; 508177633Sdfr 509177633Sdfr /* unregister the information anyway */ 510177633Sdfr (void) rpcb_unset(prog, vers, NULL); 511177633Sdfr mtx_lock(&pool->sp_lock); 512177633Sdfr while ((s = svc_find(pool, prog, vers, NULL)) != NULL) { 513177633Sdfr TAILQ_REMOVE(&pool->sp_callouts, s, sc_link); 514177633Sdfr if (s->sc_netid) 515177633Sdfr mem_free(s->sc_netid, sizeof (s->sc_netid) + 1); 516177633Sdfr mem_free(s, sizeof (struct svc_callout)); 517177633Sdfr } 518177633Sdfr mtx_unlock(&pool->sp_lock); 519177633Sdfr} 520177633Sdfr 521261067Smav/* 522261067Smav * Add a service connection loss program to the callout list. 523261067Smav * The dispatch routine will be called when some port in ths pool die. 524261067Smav */ 525261067Smavbool_t 526261067Smavsvc_loss_reg(SVCXPRT *xprt, void (*dispatch)(SVCXPRT *)) 527261067Smav{ 528261067Smav SVCPOOL *pool = xprt->xp_pool; 529261067Smav struct svc_loss_callout *s; 530261067Smav 531261067Smav mtx_lock(&pool->sp_lock); 532261067Smav TAILQ_FOREACH(s, &pool->sp_lcallouts, slc_link) { 533261067Smav if (s->slc_dispatch == dispatch) 534261067Smav break; 535261067Smav } 536261067Smav if (s != NULL) { 537261067Smav mtx_unlock(&pool->sp_lock); 538261067Smav return (TRUE); 539261067Smav } 540261067Smav s = malloc(sizeof (struct svc_callout), M_RPC, M_NOWAIT); 541261067Smav if (s == NULL) { 542261067Smav mtx_unlock(&pool->sp_lock); 543261067Smav return (FALSE); 544261067Smav } 545261067Smav s->slc_dispatch = dispatch; 546261067Smav TAILQ_INSERT_TAIL(&pool->sp_lcallouts, s, slc_link); 547261067Smav mtx_unlock(&pool->sp_lock); 548261067Smav return (TRUE); 549261067Smav} 550261067Smav 551261067Smav/* 552261067Smav * Remove a service connection loss program from the callout list. 553261067Smav */ 554261067Smavvoid 555261067Smavsvc_loss_unreg(SVCPOOL *pool, void (*dispatch)(SVCXPRT *)) 556261067Smav{ 557261067Smav struct svc_loss_callout *s; 558261067Smav 559261067Smav mtx_lock(&pool->sp_lock); 560261067Smav TAILQ_FOREACH(s, &pool->sp_lcallouts, slc_link) { 561261067Smav if (s->slc_dispatch == dispatch) { 562261067Smav TAILQ_REMOVE(&pool->sp_lcallouts, s, slc_link); 563261067Smav free(s, M_RPC); 564261067Smav break; 565261067Smav } 566261067Smav } 567261067Smav mtx_unlock(&pool->sp_lock); 568261067Smav} 569261067Smav 570177633Sdfr/* ********************** CALLOUT list related stuff ************* */ 571177633Sdfr 572177633Sdfr/* 573177633Sdfr * Search the callout list for a program number, return the callout 574177633Sdfr * struct. 575177633Sdfr */ 576177633Sdfrstatic struct svc_callout * 577177633Sdfrsvc_find(SVCPOOL *pool, rpcprog_t prog, rpcvers_t vers, char *netid) 578177633Sdfr{ 579177633Sdfr struct svc_callout *s; 580177633Sdfr 581177633Sdfr mtx_assert(&pool->sp_lock, MA_OWNED); 582177633Sdfr TAILQ_FOREACH(s, &pool->sp_callouts, sc_link) { 583177633Sdfr if (s->sc_prog == prog && s->sc_vers == vers 584177633Sdfr && (netid == NULL || s->sc_netid == NULL || 585177633Sdfr strcmp(netid, s->sc_netid) == 0)) 586177633Sdfr break; 587177633Sdfr } 588177633Sdfr 589177633Sdfr return (s); 590177633Sdfr} 591177633Sdfr 592177633Sdfr/* ******************* REPLY GENERATION ROUTINES ************ */ 593177633Sdfr 594184588Sdfrstatic bool_t 595184588Sdfrsvc_sendreply_common(struct svc_req *rqstp, struct rpc_msg *rply, 596184588Sdfr struct mbuf *body) 597184588Sdfr{ 598184588Sdfr SVCXPRT *xprt = rqstp->rq_xprt; 599184588Sdfr bool_t ok; 600184588Sdfr 601184588Sdfr if (rqstp->rq_args) { 602184588Sdfr m_freem(rqstp->rq_args); 603184588Sdfr rqstp->rq_args = NULL; 604184588Sdfr } 605184588Sdfr 606184588Sdfr if (xprt->xp_pool->sp_rcache) 607184588Sdfr replay_setreply(xprt->xp_pool->sp_rcache, 608184588Sdfr rply, svc_getrpccaller(rqstp), body); 609184588Sdfr 610184588Sdfr if (!SVCAUTH_WRAP(&rqstp->rq_auth, &body)) 611184588Sdfr return (FALSE); 612184588Sdfr 613261067Smav ok = SVC_REPLY(xprt, rply, rqstp->rq_addr, body, &rqstp->rq_reply_seq); 614184588Sdfr if (rqstp->rq_addr) { 615184588Sdfr free(rqstp->rq_addr, M_SONAME); 616184588Sdfr rqstp->rq_addr = NULL; 617184588Sdfr } 618184588Sdfr 619184588Sdfr return (ok); 620184588Sdfr} 621184588Sdfr 622177633Sdfr/* 623177633Sdfr * Send a reply to an rpc request 624177633Sdfr */ 625177633Sdfrbool_t 626184588Sdfrsvc_sendreply(struct svc_req *rqstp, xdrproc_t xdr_results, void * xdr_location) 627177633Sdfr{ 628177633Sdfr struct rpc_msg rply; 629184588Sdfr struct mbuf *m; 630184588Sdfr XDR xdrs; 631184588Sdfr bool_t ok; 632177633Sdfr 633184588Sdfr rply.rm_xid = rqstp->rq_xid; 634177633Sdfr rply.rm_direction = REPLY; 635177633Sdfr rply.rm_reply.rp_stat = MSG_ACCEPTED; 636184588Sdfr rply.acpted_rply.ar_verf = rqstp->rq_verf; 637177633Sdfr rply.acpted_rply.ar_stat = SUCCESS; 638184588Sdfr rply.acpted_rply.ar_results.where = NULL; 639184588Sdfr rply.acpted_rply.ar_results.proc = (xdrproc_t) xdr_void; 640177633Sdfr 641184588Sdfr MGET(m, M_WAIT, MT_DATA); 642184588Sdfr MCLGET(m, M_WAIT); 643184588Sdfr m->m_len = 0; 644184588Sdfr xdrmbuf_create(&xdrs, m, XDR_ENCODE); 645184588Sdfr ok = xdr_results(&xdrs, xdr_location); 646184588Sdfr XDR_DESTROY(&xdrs); 647184588Sdfr 648184588Sdfr if (ok) { 649184588Sdfr return (svc_sendreply_common(rqstp, &rply, m)); 650184588Sdfr } else { 651184588Sdfr m_freem(m); 652184588Sdfr return (FALSE); 653184588Sdfr } 654177633Sdfr} 655177633Sdfr 656184588Sdfrbool_t 657184588Sdfrsvc_sendreply_mbuf(struct svc_req *rqstp, struct mbuf *m) 658184588Sdfr{ 659184588Sdfr struct rpc_msg rply; 660184588Sdfr 661184588Sdfr rply.rm_xid = rqstp->rq_xid; 662184588Sdfr rply.rm_direction = REPLY; 663184588Sdfr rply.rm_reply.rp_stat = MSG_ACCEPTED; 664184588Sdfr rply.acpted_rply.ar_verf = rqstp->rq_verf; 665184588Sdfr rply.acpted_rply.ar_stat = SUCCESS; 666184588Sdfr rply.acpted_rply.ar_results.where = NULL; 667184588Sdfr rply.acpted_rply.ar_results.proc = (xdrproc_t) xdr_void; 668184588Sdfr 669184588Sdfr return (svc_sendreply_common(rqstp, &rply, m)); 670184588Sdfr} 671184588Sdfr 672177633Sdfr/* 673177633Sdfr * No procedure error reply 674177633Sdfr */ 675177633Sdfrvoid 676184588Sdfrsvcerr_noproc(struct svc_req *rqstp) 677177633Sdfr{ 678184588Sdfr SVCXPRT *xprt = rqstp->rq_xprt; 679177633Sdfr struct rpc_msg rply; 680177633Sdfr 681184588Sdfr rply.rm_xid = rqstp->rq_xid; 682177633Sdfr rply.rm_direction = REPLY; 683177633Sdfr rply.rm_reply.rp_stat = MSG_ACCEPTED; 684184588Sdfr rply.acpted_rply.ar_verf = rqstp->rq_verf; 685177633Sdfr rply.acpted_rply.ar_stat = PROC_UNAVAIL; 686177633Sdfr 687184588Sdfr if (xprt->xp_pool->sp_rcache) 688184588Sdfr replay_setreply(xprt->xp_pool->sp_rcache, 689184588Sdfr &rply, svc_getrpccaller(rqstp), NULL); 690184588Sdfr 691184588Sdfr svc_sendreply_common(rqstp, &rply, NULL); 692177633Sdfr} 693177633Sdfr 694177633Sdfr/* 695177633Sdfr * Can't decode args error reply 696177633Sdfr */ 697177633Sdfrvoid 698184588Sdfrsvcerr_decode(struct svc_req *rqstp) 699177633Sdfr{ 700184588Sdfr SVCXPRT *xprt = rqstp->rq_xprt; 701177633Sdfr struct rpc_msg rply; 702177633Sdfr 703184588Sdfr rply.rm_xid = rqstp->rq_xid; 704177633Sdfr rply.rm_direction = REPLY; 705177633Sdfr rply.rm_reply.rp_stat = MSG_ACCEPTED; 706184588Sdfr rply.acpted_rply.ar_verf = rqstp->rq_verf; 707177633Sdfr rply.acpted_rply.ar_stat = GARBAGE_ARGS; 708177633Sdfr 709184588Sdfr if (xprt->xp_pool->sp_rcache) 710184588Sdfr replay_setreply(xprt->xp_pool->sp_rcache, 711184588Sdfr &rply, (struct sockaddr *) &xprt->xp_rtaddr, NULL); 712184588Sdfr 713184588Sdfr svc_sendreply_common(rqstp, &rply, NULL); 714177633Sdfr} 715177633Sdfr 716177633Sdfr/* 717177633Sdfr * Some system error 718177633Sdfr */ 719177633Sdfrvoid 720184588Sdfrsvcerr_systemerr(struct svc_req *rqstp) 721177633Sdfr{ 722184588Sdfr SVCXPRT *xprt = rqstp->rq_xprt; 723177633Sdfr struct rpc_msg rply; 724177633Sdfr 725184588Sdfr rply.rm_xid = rqstp->rq_xid; 726177633Sdfr rply.rm_direction = REPLY; 727177633Sdfr rply.rm_reply.rp_stat = MSG_ACCEPTED; 728184588Sdfr rply.acpted_rply.ar_verf = rqstp->rq_verf; 729177633Sdfr rply.acpted_rply.ar_stat = SYSTEM_ERR; 730177633Sdfr 731184588Sdfr if (xprt->xp_pool->sp_rcache) 732184588Sdfr replay_setreply(xprt->xp_pool->sp_rcache, 733184588Sdfr &rply, svc_getrpccaller(rqstp), NULL); 734184588Sdfr 735184588Sdfr svc_sendreply_common(rqstp, &rply, NULL); 736177633Sdfr} 737177633Sdfr 738177633Sdfr/* 739177633Sdfr * Authentication error reply 740177633Sdfr */ 741177633Sdfrvoid 742184588Sdfrsvcerr_auth(struct svc_req *rqstp, enum auth_stat why) 743177633Sdfr{ 744184588Sdfr SVCXPRT *xprt = rqstp->rq_xprt; 745177633Sdfr struct rpc_msg rply; 746177633Sdfr 747184588Sdfr rply.rm_xid = rqstp->rq_xid; 748177633Sdfr rply.rm_direction = REPLY; 749177633Sdfr rply.rm_reply.rp_stat = MSG_DENIED; 750177633Sdfr rply.rjcted_rply.rj_stat = AUTH_ERROR; 751177633Sdfr rply.rjcted_rply.rj_why = why; 752177633Sdfr 753184588Sdfr if (xprt->xp_pool->sp_rcache) 754184588Sdfr replay_setreply(xprt->xp_pool->sp_rcache, 755184588Sdfr &rply, svc_getrpccaller(rqstp), NULL); 756184588Sdfr 757184588Sdfr svc_sendreply_common(rqstp, &rply, NULL); 758177633Sdfr} 759177633Sdfr 760177633Sdfr/* 761177633Sdfr * Auth too weak error reply 762177633Sdfr */ 763177633Sdfrvoid 764184588Sdfrsvcerr_weakauth(struct svc_req *rqstp) 765177633Sdfr{ 766177633Sdfr 767184588Sdfr svcerr_auth(rqstp, AUTH_TOOWEAK); 768177633Sdfr} 769177633Sdfr 770177633Sdfr/* 771177633Sdfr * Program unavailable error reply 772177633Sdfr */ 773177633Sdfrvoid 774184588Sdfrsvcerr_noprog(struct svc_req *rqstp) 775177633Sdfr{ 776184588Sdfr SVCXPRT *xprt = rqstp->rq_xprt; 777177633Sdfr struct rpc_msg rply; 778177633Sdfr 779184588Sdfr rply.rm_xid = rqstp->rq_xid; 780177633Sdfr rply.rm_direction = REPLY; 781177633Sdfr rply.rm_reply.rp_stat = MSG_ACCEPTED; 782184588Sdfr rply.acpted_rply.ar_verf = rqstp->rq_verf; 783177633Sdfr rply.acpted_rply.ar_stat = PROG_UNAVAIL; 784177633Sdfr 785184588Sdfr if (xprt->xp_pool->sp_rcache) 786184588Sdfr replay_setreply(xprt->xp_pool->sp_rcache, 787184588Sdfr &rply, svc_getrpccaller(rqstp), NULL); 788184588Sdfr 789184588Sdfr svc_sendreply_common(rqstp, &rply, NULL); 790177633Sdfr} 791177633Sdfr 792177633Sdfr/* 793177633Sdfr * Program version mismatch error reply 794177633Sdfr */ 795177633Sdfrvoid 796184588Sdfrsvcerr_progvers(struct svc_req *rqstp, rpcvers_t low_vers, rpcvers_t high_vers) 797177633Sdfr{ 798184588Sdfr SVCXPRT *xprt = rqstp->rq_xprt; 799177633Sdfr struct rpc_msg rply; 800177633Sdfr 801184588Sdfr rply.rm_xid = rqstp->rq_xid; 802177633Sdfr rply.rm_direction = REPLY; 803177633Sdfr rply.rm_reply.rp_stat = MSG_ACCEPTED; 804184588Sdfr rply.acpted_rply.ar_verf = rqstp->rq_verf; 805177633Sdfr rply.acpted_rply.ar_stat = PROG_MISMATCH; 806177633Sdfr rply.acpted_rply.ar_vers.low = (uint32_t)low_vers; 807177633Sdfr rply.acpted_rply.ar_vers.high = (uint32_t)high_vers; 808177633Sdfr 809184588Sdfr if (xprt->xp_pool->sp_rcache) 810184588Sdfr replay_setreply(xprt->xp_pool->sp_rcache, 811184588Sdfr &rply, svc_getrpccaller(rqstp), NULL); 812184588Sdfr 813184588Sdfr svc_sendreply_common(rqstp, &rply, NULL); 814177633Sdfr} 815177633Sdfr 816184588Sdfr/* 817184588Sdfr * Allocate a new server transport structure. All fields are 818184588Sdfr * initialized to zero and xp_p3 is initialized to point at an 819184588Sdfr * extension structure to hold various flags and authentication 820184588Sdfr * parameters. 821184588Sdfr */ 822184588SdfrSVCXPRT * 823184588Sdfrsvc_xprt_alloc() 824184588Sdfr{ 825184588Sdfr SVCXPRT *xprt; 826184588Sdfr SVCXPRT_EXT *ext; 827184588Sdfr 828184588Sdfr xprt = mem_alloc(sizeof(SVCXPRT)); 829184588Sdfr memset(xprt, 0, sizeof(SVCXPRT)); 830184588Sdfr ext = mem_alloc(sizeof(SVCXPRT_EXT)); 831184588Sdfr memset(ext, 0, sizeof(SVCXPRT_EXT)); 832184588Sdfr xprt->xp_p3 = ext; 833184588Sdfr refcount_init(&xprt->xp_refs, 1); 834184588Sdfr 835184588Sdfr return (xprt); 836184588Sdfr} 837184588Sdfr 838184588Sdfr/* 839184588Sdfr * Free a server transport structure. 840184588Sdfr */ 841184588Sdfrvoid 842184588Sdfrsvc_xprt_free(xprt) 843184588Sdfr SVCXPRT *xprt; 844184588Sdfr{ 845184588Sdfr 846184588Sdfr mem_free(xprt->xp_p3, sizeof(SVCXPRT_EXT)); 847184588Sdfr mem_free(xprt, sizeof(SVCXPRT)); 848184588Sdfr} 849184588Sdfr 850177633Sdfr/* ******************* SERVER INPUT STUFF ******************* */ 851177633Sdfr 852177633Sdfr/* 853184588Sdfr * Read RPC requests from a transport and queue them to be 854184588Sdfr * executed. We handle authentication and replay cache replies here. 855184588Sdfr * Actually dispatching the RPC is deferred till svc_executereq. 856177633Sdfr */ 857184588Sdfrstatic enum xprt_stat 858184588Sdfrsvc_getreq(SVCXPRT *xprt, struct svc_req **rqstp_ret) 859177633Sdfr{ 860177633Sdfr SVCPOOL *pool = xprt->xp_pool; 861184588Sdfr struct svc_req *r; 862177633Sdfr struct rpc_msg msg; 863184588Sdfr struct mbuf *args; 864261067Smav struct svc_loss_callout *s; 865177633Sdfr enum xprt_stat stat; 866177633Sdfr 867177633Sdfr /* now receive msgs from xprtprt (support batch calls) */ 868184588Sdfr r = malloc(sizeof(*r), M_RPC, M_WAITOK|M_ZERO); 869177633Sdfr 870184588Sdfr msg.rm_call.cb_cred.oa_base = r->rq_credarea; 871184588Sdfr msg.rm_call.cb_verf.oa_base = &r->rq_credarea[MAX_AUTH_BYTES]; 872184588Sdfr r->rq_clntcred = &r->rq_credarea[2*MAX_AUTH_BYTES]; 873184588Sdfr if (SVC_RECV(xprt, &msg, &r->rq_addr, &args)) { 874184588Sdfr enum auth_stat why; 875177633Sdfr 876184588Sdfr /* 877184588Sdfr * Handle replays and authenticate before queuing the 878184588Sdfr * request to be executed. 879184588Sdfr */ 880184588Sdfr SVC_ACQUIRE(xprt); 881184588Sdfr r->rq_xprt = xprt; 882184588Sdfr if (pool->sp_rcache) { 883184588Sdfr struct rpc_msg repmsg; 884184588Sdfr struct mbuf *repbody; 885184588Sdfr enum replay_state rs; 886184588Sdfr rs = replay_find(pool->sp_rcache, &msg, 887184588Sdfr svc_getrpccaller(r), &repmsg, &repbody); 888184588Sdfr switch (rs) { 889184588Sdfr case RS_NEW: 890184588Sdfr break; 891184588Sdfr case RS_DONE: 892184588Sdfr SVC_REPLY(xprt, &repmsg, r->rq_addr, 893261067Smav repbody, &r->rq_reply_seq); 894184588Sdfr if (r->rq_addr) { 895184588Sdfr free(r->rq_addr, M_SONAME); 896184588Sdfr r->rq_addr = NULL; 897184588Sdfr } 898205562Srmacklem m_freem(args); 899177633Sdfr goto call_done; 900184588Sdfr 901184588Sdfr default: 902205562Srmacklem m_freem(args); 903184588Sdfr goto call_done; 904177633Sdfr } 905184588Sdfr } 906184588Sdfr 907184588Sdfr r->rq_xid = msg.rm_xid; 908184588Sdfr r->rq_prog = msg.rm_call.cb_prog; 909184588Sdfr r->rq_vers = msg.rm_call.cb_vers; 910184588Sdfr r->rq_proc = msg.rm_call.cb_proc; 911184588Sdfr r->rq_size = sizeof(*r) + m_length(args, NULL); 912184588Sdfr r->rq_args = args; 913184588Sdfr if ((why = _authenticate(r, &msg)) != AUTH_OK) { 914177633Sdfr /* 915184588Sdfr * RPCSEC_GSS uses this return code 916184588Sdfr * for requests that form part of its 917184588Sdfr * context establishment protocol and 918184588Sdfr * should not be dispatched to the 919184588Sdfr * application. 920177633Sdfr */ 921184588Sdfr if (why != RPCSEC_GSS_NODISPATCH) 922184588Sdfr svcerr_auth(r, why); 923184588Sdfr goto call_done; 924177633Sdfr } 925184588Sdfr 926184588Sdfr if (!SVCAUTH_UNWRAP(&r->rq_auth, &r->rq_args)) { 927184588Sdfr svcerr_decode(r); 928184588Sdfr goto call_done; 929184588Sdfr } 930184588Sdfr 931177633Sdfr /* 932184588Sdfr * Everything checks out, return request to caller. 933177633Sdfr */ 934184588Sdfr *rqstp_ret = r; 935184588Sdfr r = NULL; 936184588Sdfr } 937177633Sdfrcall_done: 938184588Sdfr if (r) { 939184588Sdfr svc_freereq(r); 940184588Sdfr r = NULL; 941184588Sdfr } 942184588Sdfr if ((stat = SVC_STAT(xprt)) == XPRT_DIED) { 943261067Smav TAILQ_FOREACH(s, &pool->sp_lcallouts, slc_link) 944261067Smav (*s->slc_dispatch)(xprt); 945184588Sdfr xprt_unregister(xprt); 946184588Sdfr } 947184588Sdfr 948184588Sdfr return (stat); 949184588Sdfr} 950184588Sdfr 951184588Sdfrstatic void 952184588Sdfrsvc_executereq(struct svc_req *rqstp) 953184588Sdfr{ 954184588Sdfr SVCXPRT *xprt = rqstp->rq_xprt; 955184588Sdfr SVCPOOL *pool = xprt->xp_pool; 956184588Sdfr int prog_found; 957184588Sdfr rpcvers_t low_vers; 958184588Sdfr rpcvers_t high_vers; 959184588Sdfr struct svc_callout *s; 960184588Sdfr 961184588Sdfr /* now match message with a registered service*/ 962184588Sdfr prog_found = FALSE; 963184588Sdfr low_vers = (rpcvers_t) -1L; 964184588Sdfr high_vers = (rpcvers_t) 0L; 965184588Sdfr TAILQ_FOREACH(s, &pool->sp_callouts, sc_link) { 966184588Sdfr if (s->sc_prog == rqstp->rq_prog) { 967184588Sdfr if (s->sc_vers == rqstp->rq_vers) { 968184588Sdfr /* 969184588Sdfr * We hand ownership of r to the 970184588Sdfr * dispatch method - they must call 971184588Sdfr * svc_freereq. 972184588Sdfr */ 973184588Sdfr (*s->sc_dispatch)(rqstp, xprt); 974184588Sdfr return; 975184588Sdfr } /* found correct version */ 976184588Sdfr prog_found = TRUE; 977184588Sdfr if (s->sc_vers < low_vers) 978184588Sdfr low_vers = s->sc_vers; 979184588Sdfr if (s->sc_vers > high_vers) 980184588Sdfr high_vers = s->sc_vers; 981184588Sdfr } /* found correct program */ 982184588Sdfr } 983184588Sdfr 984184588Sdfr /* 985184588Sdfr * if we got here, the program or version 986184588Sdfr * is not served ... 987184588Sdfr */ 988184588Sdfr if (prog_found) 989184588Sdfr svcerr_progvers(rqstp, low_vers, high_vers); 990184588Sdfr else 991184588Sdfr svcerr_noprog(rqstp); 992184588Sdfr 993184588Sdfr svc_freereq(rqstp); 994184588Sdfr} 995184588Sdfr 996184588Sdfrstatic void 997184588Sdfrsvc_checkidle(SVCPOOL *pool) 998184588Sdfr{ 999184588Sdfr SVCXPRT *xprt, *nxprt; 1000184588Sdfr time_t timo; 1001184588Sdfr struct svcxprt_list cleanup; 1002184588Sdfr 1003184588Sdfr TAILQ_INIT(&cleanup); 1004184588Sdfr TAILQ_FOREACH_SAFE(xprt, &pool->sp_xlist, xp_link, nxprt) { 1005184588Sdfr /* 1006184588Sdfr * Only some transports have idle timers. Don't time 1007184588Sdfr * something out which is just waking up. 1008184588Sdfr */ 1009184588Sdfr if (!xprt->xp_idletimeout || xprt->xp_thread) 1010184588Sdfr continue; 1011184588Sdfr 1012184588Sdfr timo = xprt->xp_lastactive + xprt->xp_idletimeout; 1013184588Sdfr if (time_uptime > timo) { 1014184588Sdfr xprt_unregister_locked(xprt); 1015184588Sdfr TAILQ_INSERT_TAIL(&cleanup, xprt, xp_link); 1016177633Sdfr } 1017184588Sdfr } 1018184588Sdfr 1019184588Sdfr mtx_unlock(&pool->sp_lock); 1020184588Sdfr TAILQ_FOREACH_SAFE(xprt, &cleanup, xp_link, nxprt) { 1021184588Sdfr SVC_RELEASE(xprt); 1022184588Sdfr } 1023184588Sdfr mtx_lock(&pool->sp_lock); 1024184588Sdfr 1025177633Sdfr} 1026177633Sdfr 1027184588Sdfrstatic void 1028184588Sdfrsvc_assign_waiting_sockets(SVCPOOL *pool) 1029177633Sdfr{ 1030177633Sdfr SVCXPRT *xprt; 1031184588Sdfr 1032261066Smav mtx_lock(&pool->sp_lock); 1033261060Smav while ((xprt = TAILQ_FIRST(&pool->sp_active)) != NULL) { 1034261060Smav if (xprt_assignthread(xprt)) 1035261060Smav TAILQ_REMOVE(&pool->sp_active, xprt, xp_alink); 1036261060Smav else 1037261060Smav break; 1038184588Sdfr } 1039261066Smav mtx_unlock(&pool->sp_lock); 1040184588Sdfr} 1041184588Sdfr 1042261066Smavstatic void 1043261066Smavsvc_change_space_used(SVCPOOL *pool, int delta) 1044184588Sdfr{ 1045261066Smav unsigned int value; 1046184588Sdfr 1047261066Smav value = atomic_fetchadd_int(&pool->sp_space_used, delta) + delta; 1048261066Smav if (delta > 0) { 1049261066Smav if (value >= pool->sp_space_high && !pool->sp_space_throttled) { 1050261066Smav pool->sp_space_throttled = TRUE; 1051261066Smav pool->sp_space_throttle_count++; 1052261066Smav } 1053261066Smav if (value > pool->sp_space_used_highest) 1054261066Smav pool->sp_space_used_highest = value; 1055261066Smav } else { 1056261066Smav if (value < pool->sp_space_low && pool->sp_space_throttled) { 1057184588Sdfr pool->sp_space_throttled = FALSE; 1058184588Sdfr svc_assign_waiting_sockets(pool); 1059184588Sdfr } 1060184588Sdfr } 1061184588Sdfr} 1062184588Sdfr 1063261066Smavstatic bool_t 1064261066Smavsvc_request_space_available(SVCPOOL *pool) 1065261066Smav{ 1066261066Smav 1067261066Smav if (pool->sp_space_throttled) 1068261066Smav return (FALSE); 1069261066Smav return (TRUE); 1070261066Smav} 1071261066Smav 1072184588Sdfrstatic void 1073184588Sdfrsvc_run_internal(SVCPOOL *pool, bool_t ismaster) 1074184588Sdfr{ 1075261066Smav struct svc_reqlist reqs; 1076184588Sdfr SVCTHREAD *st, *stpref; 1077184588Sdfr SVCXPRT *xprt; 1078184588Sdfr enum xprt_stat stat; 1079184588Sdfr struct svc_req *rqstp; 1080261066Smav size_t sz; 1081177633Sdfr int error; 1082177633Sdfr 1083184588Sdfr st = mem_alloc(sizeof(*st)); 1084261066Smav st->st_pool = pool; 1085184588Sdfr st->st_xprt = NULL; 1086184588Sdfr STAILQ_INIT(&st->st_reqs); 1087184588Sdfr cv_init(&st->st_cond, "rpcsvc"); 1088261066Smav STAILQ_INIT(&reqs); 1089184588Sdfr 1090177633Sdfr mtx_lock(&pool->sp_lock); 1091184588Sdfr LIST_INSERT_HEAD(&pool->sp_threads, st, st_link); 1092177633Sdfr 1093184588Sdfr /* 1094184588Sdfr * If we are a new thread which was spawned to cope with 1095184588Sdfr * increased load, set the state back to SVCPOOL_ACTIVE. 1096184588Sdfr */ 1097184588Sdfr if (pool->sp_state == SVCPOOL_THREADSTARTING) 1098184588Sdfr pool->sp_state = SVCPOOL_ACTIVE; 1099177633Sdfr 1100184588Sdfr while (pool->sp_state != SVCPOOL_CLOSING) { 1101184588Sdfr /* 1102261056Smav * Create new thread if requested. 1103261056Smav */ 1104261056Smav if (pool->sp_state == SVCPOOL_THREADWANTED) { 1105261056Smav pool->sp_state = SVCPOOL_THREADSTARTING; 1106261056Smav pool->sp_lastcreatetime = time_uptime; 1107261056Smav mtx_unlock(&pool->sp_lock); 1108261056Smav svc_new_thread(pool); 1109261056Smav mtx_lock(&pool->sp_lock); 1110261056Smav continue; 1111261056Smav } 1112261056Smav 1113261056Smav /* 1114184588Sdfr * Check for idle transports once per second. 1115184588Sdfr */ 1116184588Sdfr if (time_uptime > pool->sp_lastidlecheck) { 1117184588Sdfr pool->sp_lastidlecheck = time_uptime; 1118184588Sdfr svc_checkidle(pool); 1119184588Sdfr } 1120184588Sdfr 1121184588Sdfr xprt = st->st_xprt; 1122184588Sdfr if (!xprt && STAILQ_EMPTY(&st->st_reqs)) { 1123184588Sdfr /* 1124184588Sdfr * Enforce maxthreads count. 1125184588Sdfr */ 1126184588Sdfr if (pool->sp_threadcount > pool->sp_maxthreads) 1127177633Sdfr break; 1128184588Sdfr 1129184588Sdfr /* 1130184588Sdfr * Before sleeping, see if we can find an 1131184588Sdfr * active transport which isn't being serviced 1132184588Sdfr * by a thread. 1133184588Sdfr */ 1134261060Smav if (svc_request_space_available(pool) && 1135261060Smav (xprt = TAILQ_FIRST(&pool->sp_active)) != NULL) { 1136261060Smav TAILQ_REMOVE(&pool->sp_active, xprt, xp_alink); 1137261060Smav SVC_ACQUIRE(xprt); 1138261060Smav xprt->xp_thread = st; 1139261060Smav st->st_xprt = xprt; 1140261060Smav continue; 1141184588Sdfr } 1142184588Sdfr 1143184588Sdfr LIST_INSERT_HEAD(&pool->sp_idlethreads, st, st_ilink); 1144261060Smav st->st_idle = TRUE; 1145261056Smav if (ismaster || (!ismaster && 1146261056Smav pool->sp_threadcount > pool->sp_minthreads)) 1147261056Smav error = cv_timedwait_sig(&st->st_cond, 1148261056Smav &pool->sp_lock, 5 * hz); 1149261056Smav else 1150261056Smav error = cv_wait_sig(&st->st_cond, 1151261056Smav &pool->sp_lock); 1152261060Smav if (st->st_idle) { 1153261060Smav LIST_REMOVE(st, st_ilink); 1154261060Smav st->st_idle = FALSE; 1155261060Smav } 1156184588Sdfr 1157184588Sdfr /* 1158184588Sdfr * Reduce worker thread count when idle. 1159184588Sdfr */ 1160184588Sdfr if (error == EWOULDBLOCK) { 1161184588Sdfr if (!ismaster 1162184588Sdfr && (pool->sp_threadcount 1163184588Sdfr > pool->sp_minthreads) 1164184588Sdfr && !st->st_xprt 1165184588Sdfr && STAILQ_EMPTY(&st->st_reqs)) 1166184588Sdfr break; 1167261056Smav } else if (error) { 1168184588Sdfr mtx_unlock(&pool->sp_lock); 1169261056Smav svc_exit(pool); 1170184588Sdfr mtx_lock(&pool->sp_lock); 1171261056Smav break; 1172184588Sdfr } 1173177633Sdfr continue; 1174177633Sdfr } 1175177633Sdfr 1176184588Sdfr if (xprt) { 1177184588Sdfr /* 1178184588Sdfr * Drain the transport socket and queue up any 1179184588Sdfr * RPCs. 1180184588Sdfr */ 1181184588Sdfr xprt->xp_lastactive = time_uptime; 1182184588Sdfr do { 1183184588Sdfr if (!svc_request_space_available(pool)) 1184184588Sdfr break; 1185261578Smav mtx_unlock(&pool->sp_lock); 1186184588Sdfr rqstp = NULL; 1187184588Sdfr stat = svc_getreq(xprt, &rqstp); 1188184588Sdfr if (rqstp) { 1189261066Smav svc_change_space_used(pool, rqstp->rq_size); 1190184588Sdfr /* 1191184588Sdfr * See if the application has 1192184588Sdfr * a preference for some other 1193184588Sdfr * thread. 1194184588Sdfr */ 1195184588Sdfr stpref = st; 1196184588Sdfr if (pool->sp_assign) 1197184588Sdfr stpref = pool->sp_assign(st, 1198184588Sdfr rqstp); 1199261066Smav else 1200261066Smav mtx_lock(&pool->sp_lock); 1201184588Sdfr 1202184588Sdfr rqstp->rq_thread = stpref; 1203184588Sdfr STAILQ_INSERT_TAIL(&stpref->st_reqs, 1204184588Sdfr rqstp, rq_link); 1205184588Sdfr 1206184588Sdfr /* 1207184588Sdfr * If we assigned the request 1208184588Sdfr * to another thread, make 1209184588Sdfr * sure its awake and continue 1210184588Sdfr * reading from the 1211184588Sdfr * socket. Otherwise, try to 1212184588Sdfr * find some other thread to 1213184588Sdfr * read from the socket and 1214184588Sdfr * execute the request 1215184588Sdfr * immediately. 1216184588Sdfr */ 1217261060Smav if (stpref == st) 1218261060Smav break; 1219261060Smav if (stpref->st_idle) { 1220261060Smav LIST_REMOVE(stpref, st_ilink); 1221261060Smav stpref->st_idle = FALSE; 1222184588Sdfr cv_signal(&stpref->st_cond); 1223184588Sdfr } 1224261066Smav } else 1225261066Smav mtx_lock(&pool->sp_lock); 1226184588Sdfr } while (stat == XPRT_MOREREQS 1227184588Sdfr && pool->sp_state != SVCPOOL_CLOSING); 1228184588Sdfr 1229184588Sdfr /* 1230184588Sdfr * Move this transport to the end of the 1231184588Sdfr * active list to ensure fairness when 1232184588Sdfr * multiple transports are active. If this was 1233184588Sdfr * the last queued request, svc_getreq will 1234184588Sdfr * end up calling xprt_inactive to remove from 1235184588Sdfr * the active list. 1236184588Sdfr */ 1237184588Sdfr xprt->xp_thread = NULL; 1238184588Sdfr st->st_xprt = NULL; 1239184588Sdfr if (xprt->xp_active) { 1240261066Smav if (!svc_request_space_available(pool) || 1241261066Smav !xprt_assignthread(xprt)) 1242261060Smav TAILQ_INSERT_TAIL(&pool->sp_active, 1243261060Smav xprt, xp_alink); 1244184588Sdfr } 1245261066Smav STAILQ_CONCAT(&reqs, &st->st_reqs); 1246184588Sdfr mtx_unlock(&pool->sp_lock); 1247184588Sdfr SVC_RELEASE(xprt); 1248261066Smav } else { 1249261066Smav STAILQ_CONCAT(&reqs, &st->st_reqs); 1250261066Smav mtx_unlock(&pool->sp_lock); 1251184588Sdfr } 1252184588Sdfr 1253177633Sdfr /* 1254184588Sdfr * Execute what we have queued. 1255177633Sdfr */ 1256261066Smav sz = 0; 1257261066Smav while ((rqstp = STAILQ_FIRST(&reqs)) != NULL) { 1258261066Smav STAILQ_REMOVE_HEAD(&reqs, rq_link); 1259261066Smav sz += rqstp->rq_size; 1260184588Sdfr svc_executereq(rqstp); 1261184588Sdfr } 1262261066Smav svc_change_space_used(pool, -sz); 1263261066Smav mtx_lock(&pool->sp_lock); 1264184588Sdfr } 1265177633Sdfr 1266184588Sdfr if (st->st_xprt) { 1267184588Sdfr xprt = st->st_xprt; 1268184588Sdfr st->st_xprt = NULL; 1269184588Sdfr SVC_RELEASE(xprt); 1270177633Sdfr } 1271177633Sdfr 1272184588Sdfr KASSERT(STAILQ_EMPTY(&st->st_reqs), ("stray reqs on exit")); 1273184588Sdfr LIST_REMOVE(st, st_link); 1274184588Sdfr pool->sp_threadcount--; 1275184588Sdfr 1276177633Sdfr mtx_unlock(&pool->sp_lock); 1277184588Sdfr 1278184588Sdfr cv_destroy(&st->st_cond); 1279184588Sdfr mem_free(st, sizeof(*st)); 1280184588Sdfr 1281184588Sdfr if (!ismaster) 1282184588Sdfr wakeup(pool); 1283177633Sdfr} 1284177633Sdfr 1285184588Sdfrstatic void 1286184588Sdfrsvc_thread_start(void *arg) 1287184588Sdfr{ 1288184588Sdfr 1289184588Sdfr svc_run_internal((SVCPOOL *) arg, FALSE); 1290184588Sdfr kthread_exit(); 1291184588Sdfr} 1292184588Sdfr 1293184588Sdfrstatic void 1294184588Sdfrsvc_new_thread(SVCPOOL *pool) 1295184588Sdfr{ 1296184588Sdfr struct thread *td; 1297184588Sdfr 1298184588Sdfr pool->sp_threadcount++; 1299184588Sdfr kthread_add(svc_thread_start, pool, 1300184588Sdfr pool->sp_proc, &td, 0, 0, 1301184588Sdfr "%s: service", pool->sp_name); 1302184588Sdfr} 1303184588Sdfr 1304177633Sdfrvoid 1305184588Sdfrsvc_run(SVCPOOL *pool) 1306184588Sdfr{ 1307184588Sdfr int i; 1308184588Sdfr struct proc *p; 1309184588Sdfr struct thread *td; 1310184588Sdfr 1311184588Sdfr p = curproc; 1312184588Sdfr td = curthread; 1313184588Sdfr snprintf(td->td_name, sizeof(td->td_name), 1314184588Sdfr "%s: master", pool->sp_name); 1315184588Sdfr pool->sp_state = SVCPOOL_ACTIVE; 1316184588Sdfr pool->sp_proc = p; 1317184588Sdfr pool->sp_lastcreatetime = time_uptime; 1318184588Sdfr pool->sp_threadcount = 1; 1319184588Sdfr 1320184588Sdfr for (i = 1; i < pool->sp_minthreads; i++) { 1321184588Sdfr svc_new_thread(pool); 1322184588Sdfr } 1323184588Sdfr 1324184588Sdfr svc_run_internal(pool, TRUE); 1325184588Sdfr 1326184588Sdfr mtx_lock(&pool->sp_lock); 1327184588Sdfr while (pool->sp_threadcount > 0) 1328184588Sdfr msleep(pool, &pool->sp_lock, 0, "svcexit", 0); 1329184588Sdfr mtx_unlock(&pool->sp_lock); 1330184588Sdfr} 1331184588Sdfr 1332184588Sdfrvoid 1333177633Sdfrsvc_exit(SVCPOOL *pool) 1334177633Sdfr{ 1335184588Sdfr SVCTHREAD *st; 1336184588Sdfr 1337177633Sdfr mtx_lock(&pool->sp_lock); 1338184588Sdfr 1339261056Smav if (pool->sp_state != SVCPOOL_CLOSING) { 1340261056Smav pool->sp_state = SVCPOOL_CLOSING; 1341261056Smav LIST_FOREACH(st, &pool->sp_idlethreads, st_ilink) 1342261056Smav cv_signal(&st->st_cond); 1343261056Smav } 1344184588Sdfr 1345177633Sdfr mtx_unlock(&pool->sp_lock); 1346177633Sdfr} 1347184588Sdfr 1348184588Sdfrbool_t 1349184588Sdfrsvc_getargs(struct svc_req *rqstp, xdrproc_t xargs, void *args) 1350184588Sdfr{ 1351184588Sdfr struct mbuf *m; 1352184588Sdfr XDR xdrs; 1353184588Sdfr bool_t stat; 1354184588Sdfr 1355184588Sdfr m = rqstp->rq_args; 1356184588Sdfr rqstp->rq_args = NULL; 1357184588Sdfr 1358184588Sdfr xdrmbuf_create(&xdrs, m, XDR_DECODE); 1359184588Sdfr stat = xargs(&xdrs, args); 1360184588Sdfr XDR_DESTROY(&xdrs); 1361184588Sdfr 1362184588Sdfr return (stat); 1363184588Sdfr} 1364184588Sdfr 1365184588Sdfrbool_t 1366184588Sdfrsvc_freeargs(struct svc_req *rqstp, xdrproc_t xargs, void *args) 1367184588Sdfr{ 1368184588Sdfr XDR xdrs; 1369184588Sdfr 1370184588Sdfr if (rqstp->rq_addr) { 1371184588Sdfr free(rqstp->rq_addr, M_SONAME); 1372184588Sdfr rqstp->rq_addr = NULL; 1373184588Sdfr } 1374184588Sdfr 1375184588Sdfr xdrs.x_op = XDR_FREE; 1376184588Sdfr return (xargs(&xdrs, args)); 1377184588Sdfr} 1378184588Sdfr 1379184588Sdfrvoid 1380184588Sdfrsvc_freereq(struct svc_req *rqstp) 1381184588Sdfr{ 1382184588Sdfr SVCTHREAD *st; 1383184588Sdfr SVCPOOL *pool; 1384184588Sdfr 1385184588Sdfr st = rqstp->rq_thread; 1386184588Sdfr if (st) { 1387261066Smav pool = st->st_pool; 1388184588Sdfr if (pool->sp_done) 1389184588Sdfr pool->sp_done(st, rqstp); 1390184588Sdfr } 1391184588Sdfr 1392184588Sdfr if (rqstp->rq_auth.svc_ah_ops) 1393184588Sdfr SVCAUTH_RELEASE(&rqstp->rq_auth); 1394184588Sdfr 1395184588Sdfr if (rqstp->rq_xprt) { 1396184588Sdfr SVC_RELEASE(rqstp->rq_xprt); 1397184588Sdfr } 1398184588Sdfr 1399184588Sdfr if (rqstp->rq_addr) 1400184588Sdfr free(rqstp->rq_addr, M_SONAME); 1401184588Sdfr 1402184588Sdfr if (rqstp->rq_args) 1403184588Sdfr m_freem(rqstp->rq_args); 1404184588Sdfr 1405184588Sdfr free(rqstp, M_RPC); 1406184588Sdfr} 1407