1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 27 /* All Rights Reserved */ 28 /* 29 * Portions of this source code were derived from Berkeley 30 * 4.3 BSD under license from the Regents of the University of 31 * California. 32 */ 33 34 /* 35 * svc.h, Server-side remote procedure call interface. 36 */ 37 38 #ifndef _RPC_SVC_H 39 #define _RPC_SVC_H 40 41 #pragma ident "%Z%%M% %I% %E% SMI" 42 43 #include <rpc/rpc_com.h> 44 #include <rpc/rpc_msg.h> 45 #include <sys/tihdr.h> 46 #include <sys/poll.h> 47 48 #ifdef _KERNEL 49 #include <rpc/svc_auth.h> 50 #include <sys/callb.h> 51 #endif /* _KERNEL */ 52 53 /* 54 * This interface must manage two items concerning remote procedure calling: 55 * 56 * 1) An arbitrary number of transport connections upon which rpc requests 57 * are received. They are created and registered by routines in svc_generic.c, 58 * svc_vc.c and svc_dg.c; they in turn call xprt_register and 59 * xprt_unregister. 60 * 61 * 2) An arbitrary number of locally registered services. Services are 62 * described by the following four data: program number, version number, 63 * "service dispatch" function, a transport handle, and a boolean that 64 * indicates whether or not the exported program should be registered with a 65 * local binder service; if true the program's number and version and the 66 * address from the transport handle are registered with the binder. 67 * These data are registered with rpcbind via svc_reg(). 68 * 69 * A service's dispatch function is called whenever an rpc request comes in 70 * on a transport. The request's program and version numbers must match 71 * those of the registered service. The dispatch function is passed two 72 * parameters, struct svc_req * and SVCXPRT *, defined below. 73 */ 74 75 #ifdef __cplusplus 76 extern "C" { 77 #endif 78 79 /* 80 * Server-side transport handles. 81 * The actual type definitions are below. 82 */ 83 #ifdef _KERNEL 84 typedef struct __svcmasterxprt SVCMASTERXPRT; /* Master transport handle */ 85 typedef struct __svcxprt SVCXPRT; /* Per-thread clone handle */ 86 typedef struct __svcpool SVCPOOL; /* Kernel thread pool */ 87 #else /* _KERNEL */ 88 typedef struct __svcxprt SVCXPRT; /* Server transport handle */ 89 #endif /* _KERNEL */ 90 91 /* 92 * Prototype of error handler callback 93 */ 94 #ifndef _KERNEL 95 typedef void (*svc_errorhandler_t)(const SVCXPRT* svc, const bool_t isAConn); 96 #endif 97 98 /* 99 * Service request. 100 * 101 * PSARC 2003/523 Contract Private Interface 102 * svc_req 103 * Changes must be reviewed by Solaris File Sharing 104 * Changes must be communicated to contract-2003-523@sun.com 105 */ 106 struct svc_req { 107 rpcprog_t rq_prog; /* service program number */ 108 rpcvers_t rq_vers; /* service protocol version */ 109 rpcproc_t rq_proc; /* the desired procedure */ 110 struct opaque_auth rq_cred; /* raw creds from the wire */ 111 caddr_t rq_clntcred; /* read only cooked cred */ 112 SVCXPRT *rq_xprt; /* associated transport */ 113 }; 114 115 #ifdef _KERNEL 116 struct dupreq { 117 uint32_t dr_xid; 118 rpcproc_t dr_proc; 119 rpcvers_t dr_vers; 120 rpcprog_t dr_prog; 121 struct netbuf dr_addr; 122 struct netbuf dr_resp; 123 void (*dr_resfree)(); 124 int dr_status; 125 struct dupreq *dr_next; 126 struct dupreq *dr_chain; 127 }; 128 129 /* 130 * States of requests for duplicate request caching. 131 */ 132 #define DUP_NEW 0x00 /* new entry */ 133 #define DUP_INPROGRESS 0x01 /* request already going */ 134 #define DUP_DONE 0x02 /* request done */ 135 #define DUP_DROP 0x03 /* request dropped */ 136 #define DUP_ERROR 0x04 /* error in dup req cache */ 137 138 /* 139 * Prototype for a service dispatch routine. 140 */ 141 typedef void (SVC_DISPATCH)(struct svc_req *, SVCXPRT *); 142 143 /* 144 * The service provider callout. 145 * Each entry identifies a dispatch routine to be called 146 * for a given RPC program number and a version fitting 147 * into the registered range. 148 */ 149 typedef struct { 150 rpcprog_t sc_prog; /* RPC Program number */ 151 rpcvers_t sc_versmin; /* Min version number */ 152 rpcvers_t sc_versmax; /* Max version number */ 153 SVC_DISPATCH *sc_dispatch; /* Dispatch routine */ 154 } SVC_CALLOUT; 155 156 /* 157 * Table of service provider `callouts' for an RPC 158 * transport handle. If sct_free is TRUE then transport 159 * destructor is supposed to deallocate this table. 160 */ 161 typedef struct { 162 size_t sct_size; /* Number of entries */ 163 bool_t sct_free; /* Deallocate if true */ 164 SVC_CALLOUT *sct_sc; /* Callout entries */ 165 } SVC_CALLOUT_TABLE; 166 167 struct svc_ops { 168 bool_t (*xp_recv)(SVCXPRT *, mblk_t *, struct rpc_msg *); 169 /* receive incoming requests */ 170 bool_t (*xp_getargs)(SVCXPRT *, xdrproc_t, caddr_t); 171 /* get arguments */ 172 bool_t (*xp_reply)(SVCXPRT *, struct rpc_msg *); 173 /* send reply */ 174 bool_t (*xp_freeargs)(SVCXPRT *, xdrproc_t, caddr_t); 175 /* free mem allocated for args */ 176 void (*xp_destroy)(SVCMASTERXPRT *); 177 /* destroy this struct */ 178 int (*xp_dup)(struct svc_req *, caddr_t, int, 179 struct dupreq **, bool_t *); 180 /* check for dup */ 181 void (*xp_dupdone)(struct dupreq *, caddr_t, void (*)(), int, int); 182 /* mark dup entry as completed */ 183 int32_t *(*xp_getres)(SVCXPRT *, int); 184 /* get pointer to response buffer */ 185 void (*xp_freeres)(SVCXPRT *); 186 /* destroy pre-serialized response */ 187 void (*xp_clone_destroy)(SVCXPRT *); 188 /* destroy a clone xprt */ 189 void (*xp_start)(SVCMASTERXPRT *); 190 /* `ready-to-receive' */ 191 }; 192 #else /* _KERNEL */ 193 /* 194 * Service control requests 195 */ 196 #define SVCGET_VERSQUIET 1 197 #define SVCSET_VERSQUIET 2 198 #define SVCGET_XID 4 199 #define SVCSET_KEEPALIVE 5 200 #define SVCSET_CONNMAXREC 6 201 #define SVCGET_CONNMAXREC 7 202 #define SVCGET_RECVERRHANDLER 8 203 #define SVCSET_RECVERRHANDLER 9 204 205 enum xprt_stat { 206 XPRT_DIED, 207 XPRT_MOREREQS, 208 XPRT_IDLE 209 }; 210 211 struct xp_ops { 212 #ifdef __STDC__ 213 bool_t (*xp_recv)(SVCXPRT *, struct rpc_msg *); 214 /* receive incoming requests */ 215 enum xprt_stat (*xp_stat)(SVCXPRT *); 216 /* get transport status */ 217 bool_t (*xp_getargs)(SVCXPRT *, xdrproc_t, caddr_t); 218 /* get arguments */ 219 bool_t (*xp_reply)(SVCXPRT *, struct rpc_msg *); 220 /* send reply */ 221 bool_t (*xp_freeargs)(SVCXPRT *, xdrproc_t, caddr_t); 222 /* free mem allocated for args */ 223 void (*xp_destroy)(SVCXPRT *); 224 /* destroy this struct */ 225 bool_t (*xp_control)(SVCXPRT *, const uint_t, void *); 226 /* catch-all control function */ 227 #else /* __STDC__ */ 228 bool_t (*xp_recv)(); /* receive incoming requests */ 229 enum xprt_stat (*xp_stat)(); /* get transport status */ 230 bool_t (*xp_getargs)(); /* get arguments */ 231 bool_t (*xp_reply)(); /* send reply */ 232 bool_t (*xp_freeargs)(); /* free mem allocated for args */ 233 void (*xp_destroy)(); /* destroy this struct */ 234 bool_t (*xp_control)(); /* catch-all control function */ 235 #endif /* __STDC__ */ 236 }; 237 #endif /* _KERNEL */ 238 239 #ifdef _KERNEL 240 /* 241 * SVCPOOL 242 * Kernel RPC server-side thread pool structure. 243 */ 244 typedef struct __svcxprt_qnode __SVCXPRT_QNODE; /* Defined in svc.c */ 245 246 struct __svcpool { 247 /* 248 * Thread pool variables. 249 * 250 * The pool's thread lock p_thread_lock protects: 251 * - p_threads, p_detached_threads, p_reserved_threads and p_closing 252 * The pool's request lock protects: 253 * - p_asleep, p_drowsy, p_reqs, p_walkers, p_req_cv. 254 * The following fields are `initialized constants': 255 * - p_id, p_stksize, p_timeout. 256 * Access to p_next and p_prev is protected by the pool 257 * list lock. 258 */ 259 SVCPOOL *p_next; /* Next pool in the list */ 260 SVCPOOL *p_prev; /* Prev pool in the list */ 261 int p_id; /* Pool id */ 262 int p_threads; /* Non-detached threads */ 263 int p_detached_threads; /* Detached threads */ 264 int p_maxthreads; /* Max threads in the pool */ 265 int p_redline; /* `Redline' for the pool */ 266 int p_reserved_threads; /* Reserved threads */ 267 kmutex_t p_thread_lock; /* Thread lock */ 268 int p_asleep; /* Asleep threads */ 269 int p_drowsy; /* Drowsy flag */ 270 kcondvar_t p_req_cv; /* svc_poll() sleep var. */ 271 clock_t p_timeout; /* svc_poll() timeout */ 272 kmutex_t p_req_lock; /* Request lock */ 273 int p_reqs; /* Pending requests */ 274 int p_walkers; /* Walking threads */ 275 int p_max_same_xprt; /* Max reqs from the xprt */ 276 int p_stksize; /* Stack size for svc_run */ 277 bool_t p_closing : 1; /* Pool is closing */ 278 279 /* 280 * Thread creator variables. 281 * The `creator signaled' flag is turned on when a signal is send 282 * to the creator thread (to create a new service thread). The 283 * creator clears when the thread is created. The protocol is not 284 * to signal the creator thread when the flag is on. However, 285 * a new thread should signal the creator if there are more 286 * requests in the queue. 287 * 288 * When the pool is closing (ie it has been already unregistered from 289 * the pool list) the last thread on the last transport should turn 290 * the p_creator_exit flag on. This tells the creator thread to 291 * free the pool structure and exit. 292 */ 293 bool_t p_creator_signaled : 1; /* Create requested flag */ 294 bool_t p_creator_exit : 1; /* If true creator exits */ 295 kcondvar_t p_creator_cv; /* Creator cond. variable */ 296 kmutex_t p_creator_lock; /* Creator lock */ 297 298 /* 299 * Doubly linked list containing `registered' master transport handles. 300 * There is no special structure for a list node. Instead the 301 * SVCMASTERXPRT structure has the xp_next and xp_prev fields. 302 * 303 * The p_lrwlock protects access to xprt->xp_next and xprt->xp_prev. 304 * A service thread should also acquire a reader lock before accessing 305 * any transports it is no longer linked to (to prevent them from 306 * being destroyed). 307 * 308 * The list lock governs also the `pool is closing' flag. 309 */ 310 size_t p_lcount; /* Current count */ 311 SVCMASTERXPRT *p_lhead; /* List head */ 312 krwlock_t p_lrwlock; /* R/W lock */ 313 314 /* 315 * Circular linked list for the `xprt-ready' queue (FIFO). 316 * Must be initialized with svc_xprt_qinit() before it is used. 317 * 318 * The writer's end is protected by the pool's request lock 319 * (pool->p_req_lock). The reader's end is protected by q_end_lock. 320 * 321 * When the queue is full the p_qoverflow flag is raised. It stays 322 * on until all the pending request are drained. 323 */ 324 size_t p_qsize; /* Number of queue nodes */ 325 int p_qoverflow : 1; /* Overflow flag */ 326 __SVCXPRT_QNODE *p_qbody; /* Queue body (array) */ 327 __SVCXPRT_QNODE *p_qtop; /* Writer's end of FIFO */ 328 __SVCXPRT_QNODE *p_qend; /* Reader's end of FIFO */ 329 kmutex_t p_qend_lock; /* Reader's end lock */ 330 331 /* 332 * Userspace thread creator variables. 333 * Thread creation is actually done in userland, via a thread 334 * that is parked in the kernel. When that thread is signaled, 335 * it returns back down to the daemon from whence it came and 336 * does the lwp create. 337 * 338 * A parallel "creator" thread runs in the kernel. That is the 339 * thread that will signal for the user thread to return to 340 * userland and do its work. 341 * 342 * Since the thread doesn't always exist (there could be a race 343 * if two threads are created in rapid succession), we set 344 * p_signal_create_thread to FALSE when we're ready to accept work. 345 * 346 * p_user_exit is set to true when the service pool is about 347 * to close. This is done so that the user creation thread 348 * can be informed and cleanup any userland state. 349 */ 350 351 bool_t p_signal_create_thread : 1; /* Create requested flag */ 352 bool_t p_user_exit : 1; /* If true creator exits */ 353 bool_t p_user_waiting : 1; /* Thread waiting for work */ 354 kcondvar_t p_user_cv; /* Creator cond. variable */ 355 kmutex_t p_user_lock; /* Creator lock */ 356 void (*p_offline)(); /* callout for unregister */ 357 void (*p_shutdown)(); /* callout for shutdown */ 358 }; 359 360 /* 361 * Server side transport handle (SVCMASTERXPRT). 362 * xprt->xp_req_lock governs the following fields in xprt: 363 * xp_req_head, xp_req_tail. 364 * xprt->xp_thread_lock governs the following fields in xprt: 365 * xp_threads, xp_detached_threads. 366 * 367 * xp_req_tail is only valid if xp_req_head is non-NULL 368 * 369 * The xp_threads count is the number of attached threads. These threads 370 * are able to handle new requests, and it is expected that they will not 371 * block for a very long time handling a given request. The 372 * xp_detached_threads count is the number of threads that have detached 373 * themselves from the transport. These threads can block indefinitely 374 * while handling a request. Once they complete the request, they exit. 375 * 376 * A kernel service provider may register a callback function "closeproc" 377 * for a transport. When the transport is closing the last exiting attached 378 * thread - xp_threads goes to zero - it calls the callback function, passing 379 * it a reference to the transport. This call is made with xp_thread_lock 380 * held, so any cleanup bookkeeping it does should be done quickly. 381 * 382 * When the transport is closing the last exiting thread is supposed 383 * to destroy/free the data structure. 384 */ 385 typedef struct __svcxprt_common { 386 struct file *xpc_fp; 387 struct svc_ops *xpc_ops; 388 queue_t *xpc_wq; /* queue to write onto */ 389 cred_t *xpc_cred; /* cached cred for server to use */ 390 int32_t xpc_type; /* transport type */ 391 int xpc_msg_size; /* TSDU or TIDU size */ 392 struct netbuf xpc_rtaddr; /* remote transport address */ 393 SVC_CALLOUT_TABLE *xpc_sct; 394 } __SVCXPRT_COMMON; 395 396 #define xp_fp xp_xpc.xpc_fp 397 #define xp_ops xp_xpc.xpc_ops 398 #define xp_wq xp_xpc.xpc_wq 399 #define xp_cred xp_xpc.xpc_cred 400 #define xp_type xp_xpc.xpc_type 401 #define xp_msg_size xp_xpc.xpc_msg_size 402 #define xp_rtaddr xp_xpc.xpc_rtaddr 403 #define xp_sct xp_xpc.xpc_sct 404 405 struct __svcmasterxprt { 406 SVCMASTERXPRT *xp_next; /* Next transport in the list */ 407 SVCMASTERXPRT *xp_prev; /* Prev transport in the list */ 408 __SVCXPRT_COMMON xp_xpc; /* Fields common with the clone */ 409 SVCPOOL *xp_pool; /* Pointer to the pool */ 410 mblk_t *xp_req_head; /* Request queue head */ 411 mblk_t *xp_req_tail; /* Request queue tail */ 412 kmutex_t xp_req_lock; /* Request lock */ 413 int xp_threads; /* Current num. of attached threads */ 414 int xp_detached_threads; /* num. of detached threads */ 415 kmutex_t xp_thread_lock; /* Thread count lock */ 416 void (*xp_closeproc)(const SVCMASTERXPRT *); 417 /* optional; see comments above */ 418 char *xp_netid; /* network token */ 419 struct netbuf xp_addrmask; /* address mask */ 420 421 caddr_t xp_p2; /* private: for use by svc ops */ 422 }; 423 424 /* 425 * Service thread `clone' transport handle (SVCXPRT) 426 * 427 * PSARC 2003/523 Contract Private Interface 428 * SVCXPRT 429 * Changes must be reviewed by Solaris File Sharing 430 * Changes must be communicated to contract-2003-523@sun.com 431 * 432 * The xp_p2buf buffer is used as the storage for a transport type 433 * specific structure. It is private for the svc ops for a given 434 * transport type. 435 */ 436 437 #define SVC_P2LEN 64 438 439 struct __svcxprt { 440 __SVCXPRT_COMMON xp_xpc; 441 SVCMASTERXPRT *xp_master; /* back ptr to master */ 442 443 /* The following fileds are on a per-thread basis */ 444 callb_cpr_t *xp_cprp; /* unused padding for Contract */ 445 bool_t xp_reserved : 1; /* is thread reserved? */ 446 bool_t xp_detached : 1; /* is thread detached? */ 447 int xp_same_xprt; /* Reqs from the same xprt */ 448 449 /* The following fields are used on a per-request basis */ 450 struct opaque_auth xp_verf; /* raw response verifier */ 451 SVCAUTH xp_auth; /* auth flavor of current req */ 452 void *xp_cookie; /* a cookie */ 453 uint32_t xp_xid; /* id */ 454 XDR xp_xdrin; /* input xdr stream */ 455 XDR xp_xdrout; /* output xdr stream */ 456 457 /* Private for svc ops */ 458 char xp_p2buf[SVC_P2LEN]; /* udp_data or cots_data_t */ 459 /* or clone_rdma_data_t */ 460 }; 461 #else /* _KERNEL */ 462 struct __svcxprt { 463 int xp_fd; 464 #define xp_sock xp_fd 465 ushort_t xp_port; 466 /* 467 * associated port number. 468 * Obsolete, but still used to 469 * specify whether rendezvouser 470 * or normal connection 471 */ 472 struct xp_ops *xp_ops; 473 int xp_addrlen; /* length of remote addr. Obsoleted */ 474 char *xp_tp; /* transport provider device name */ 475 char *xp_netid; /* network token */ 476 struct netbuf xp_ltaddr; /* local transport address */ 477 struct netbuf xp_rtaddr; /* remote transport address */ 478 char xp_raddr[16]; /* remote address. Now obsoleted */ 479 struct opaque_auth xp_verf; /* raw response verifier */ 480 caddr_t xp_p1; /* private: for use by svc ops */ 481 caddr_t xp_p2; /* private: for use by svc ops */ 482 caddr_t xp_p3; /* private: for use by svc lib */ 483 int xp_type; /* transport type */ 484 /* 485 * callback on client death 486 * First parameter is the current structure, 487 * Second parameter : 488 * - FALSE for the service listener 489 * - TRUE for a real connected socket 490 */ 491 svc_errorhandler_t xp_closeclnt; 492 }; 493 #endif /* _KERNEL */ 494 495 /* 496 * Approved way of getting address of caller, 497 * address mask, and netid of transport. 498 */ 499 #define svc_getrpccaller(x) (&(x)->xp_rtaddr) 500 #ifdef _KERNEL 501 #define svc_getcaller(x) (&(x)->xp_rtaddr.buf) 502 #define svc_getaddrmask(x) (&(x)->xp_master->xp_addrmask) 503 #define svc_getnetid(x) ((x)->xp_master->xp_netid) 504 #endif /* _KERNEL */ 505 506 /* 507 * Operations defined on an SVCXPRT handle 508 */ 509 510 #ifdef _KERNEL 511 #define SVC_RECV(clone_xprt, mp, msg) \ 512 (*(clone_xprt)->xp_ops->xp_recv)((clone_xprt), (mp), (msg)) 513 514 /* 515 * PSARC 2003/523 Contract Private Interface 516 * SVC_GETARGS 517 * Changes must be reviewed by Solaris File Sharing 518 * Changes must be communicated to contract-2003-523@sun.com 519 */ 520 #define SVC_GETARGS(clone_xprt, xargs, argsp) \ 521 (*(clone_xprt)->xp_ops->xp_getargs)((clone_xprt), (xargs), (argsp)) 522 523 #define SVC_REPLY(clone_xprt, msg) \ 524 (*(clone_xprt)->xp_ops->xp_reply) ((clone_xprt), (msg)) 525 526 #define SVC_FREEARGS(clone_xprt, xargs, argsp) \ 527 (*(clone_xprt)->xp_ops->xp_freeargs)((clone_xprt), (xargs), (argsp)) 528 529 #define SVC_GETRES(clone_xprt, size) \ 530 (*(clone_xprt)->xp_ops->xp_getres)((clone_xprt), (size)) 531 532 #define SVC_FREERES(clone_xprt) \ 533 (*(clone_xprt)->xp_ops->xp_freeres)(clone_xprt) 534 535 #define SVC_DESTROY(xprt) \ 536 (*(xprt)->xp_ops->xp_destroy)(xprt) 537 538 /* 539 * PSARC 2003/523 Contract Private Interfaces 540 * SVC_DUP, SVC_DUPDONE, SVC_DUP_EXT, SVC_DUPDONE_EXT 541 * Changes must be reviewed by Solaris File Sharing 542 * Changes must be communicated to contract-2003-523@sun.com 543 * 544 * SVC_DUP and SVC_DUPDONE are defined here for backward compatibility. 545 */ 546 #define SVC_DUP_EXT(clone_xprt, req, res, size, drpp, dupcachedp) \ 547 (*(clone_xprt)->xp_ops->xp_dup)(req, res, size, drpp, dupcachedp) 548 549 #define SVC_DUPDONE_EXT(clone_xprt, dr, res, resfree, size, status) \ 550 (*(clone_xprt)->xp_ops->xp_dupdone)(dr, res, resfree, size, status) 551 552 #define SVC_DUP(clone_xprt, req, res, size, drpp) \ 553 (*(clone_xprt)->xp_ops->xp_dup)(req, res, size, drpp, NULL) 554 555 #define SVC_DUPDONE(clone_xprt, dr, res, size, status) \ 556 (*(clone_xprt)->xp_ops->xp_dupdone)(dr, res, NULL, size, status) 557 558 #define SVC_CLONE_DESTROY(clone_xprt) \ 559 (*(clone_xprt)->xp_ops->xp_clone_destroy)(clone_xprt) 560 561 562 #define SVC_START(xprt) \ 563 (*(xprt)->xp_ops->xp_start)(xprt) 564 565 #else /* _KERNEL */ 566 567 #define SVC_RECV(xprt, msg) \ 568 (*(xprt)->xp_ops->xp_recv)((xprt), (msg)) 569 #define svc_recv(xprt, msg) \ 570 (*(xprt)->xp_ops->xp_recv)((xprt), (msg)) 571 572 #define SVC_STAT(xprt) \ 573 (*(xprt)->xp_ops->xp_stat)(xprt) 574 #define svc_stat(xprt) \ 575 (*(xprt)->xp_ops->xp_stat)(xprt) 576 577 #define SVC_GETARGS(xprt, xargs, argsp) \ 578 (*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp)) 579 #define svc_getargs(xprt, xargs, argsp) \ 580 (*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp)) 581 582 #define SVC_REPLY(xprt, msg) \ 583 (*(xprt)->xp_ops->xp_reply) ((xprt), (msg)) 584 #define svc_reply(xprt, msg) \ 585 (*(xprt)->xp_ops->xp_reply) ((xprt), (msg)) 586 587 #define SVC_FREEARGS(xprt, xargs, argsp) \ 588 (*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp)) 589 #define svc_freeargs(xprt, xargs, argsp) \ 590 (*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp)) 591 592 #define SVC_GETRES(xprt, size) \ 593 (*(xprt)->xp_ops->xp_getres)((xprt), (size)) 594 #define svc_getres(xprt, size) \ 595 (*(xprt)->xp_ops->xp_getres)((xprt), (size)) 596 597 #define SVC_FREERES(xprt) \ 598 (*(xprt)->xp_ops->xp_freeres)(xprt) 599 #define svc_freeres(xprt) \ 600 (*(xprt)->xp_ops->xp_freeres)(xprt) 601 602 #define SVC_DESTROY(xprt) \ 603 (*(xprt)->xp_ops->xp_destroy)(xprt) 604 #define svc_destroy(xprt) \ 605 (*(xprt)->xp_ops->xp_destroy)(xprt) 606 607 /* 608 * PSARC 2003/523 Contract Private Interface 609 * SVC_CONTROL 610 * Changes must be reviewed by Solaris File Sharing 611 * Changes must be communicated to contract-2003-523@sun.com 612 */ 613 #define SVC_CONTROL(xprt, rq, in) \ 614 (*(xprt)->xp_ops->xp_control)((xprt), (rq), (in)) 615 #endif /* _KERNEL */ 616 617 /* 618 * Pool id's reserved for NFS, NLM, and the NFSv4 callback program. 619 */ 620 #define NFS_SVCPOOL_ID 0x01 621 #define NLM_SVCPOOL_ID 0x02 622 #define NFS_CB_SVCPOOL_ID 0x03 623 #define RDC_SVCPOOL_ID 0x05 /* SNDR, PSARC 2001/699 */ 624 625 struct svcpool_args { 626 uint32_t id; /* Pool id */ 627 uint32_t maxthreads; /* Max threads in the pool */ 628 uint32_t redline; /* `Redline' for the pool */ 629 uint32_t qsize; /* `xprt-ready' queue size */ 630 uint32_t timeout; /* svc_poll() timeout */ 631 uint32_t stksize; /* svc_run() stack size */ 632 uint32_t max_same_xprt; /* Max reqs from the same xprt */ 633 }; 634 635 636 #ifdef _KERNEL 637 /* 638 * Transport registration and thread pool creation. 639 */ 640 extern int svc_xprt_register(SVCMASTERXPRT *, int); 641 extern void svc_xprt_unregister(SVCMASTERXPRT *); 642 extern int svc_pool_create(struct svcpool_args *); 643 extern int svc_wait(int); 644 extern int svc_do_run(int); 645 #define SVCPSET_SHUTDOWN_PROC 1 646 #define SVCPSET_UNREGISTER_PROC 2 647 extern int svc_pool_control(int, int, void *); 648 #else /* _KERNEL */ 649 #ifdef __STDC__ 650 extern bool_t rpc_reg(const rpcprog_t, const rpcvers_t, const rpcproc_t, 651 char *(*)(char *), const xdrproc_t, const xdrproc_t, 652 const char *); 653 654 /* 655 * Service registration 656 * 657 * svc_reg(xprt, prog, vers, dispatch, nconf) 658 * const SVCXPRT *xprt; 659 * const rpcprog_t prog; 660 * const rpcvers_t vers; 661 * const void (*dispatch)(); 662 * const struct netconfig *nconf; 663 */ 664 extern bool_t svc_reg(const SVCXPRT *, const rpcprog_t, const rpcvers_t, 665 void (*)(struct svc_req *, SVCXPRT *), 666 const struct netconfig *); 667 668 /* 669 * Service authentication registration 670 * 671 * svc_auth_reg(cred_flavor, handler) 672 * int cred_flavor; 673 * enum auth_stat (*handler)(); 674 */ 675 extern int svc_auth_reg(int, enum auth_stat (*)()); 676 677 /* 678 * Service un-registration 679 * 680 * svc_unreg(prog, vers) 681 * const rpcprog_t prog; 682 * const rpcvers_t vers; 683 */ 684 extern void svc_unreg(const rpcprog_t, const rpcvers_t); 685 686 /* 687 * Transport registration/unregistration. 688 * 689 * xprt_register(xprt) 690 * const SVCXPRT *xprt; 691 * 692 * xprt_unregister(xprt) 693 * const SVCXPRT *xprt; 694 */ 695 extern void xprt_register(const SVCXPRT *); 696 extern void xprt_unregister(const SVCXPRT *); 697 #else /* __STDC__ */ 698 extern bool_t rpc_reg(); 699 extern bool_t svc_reg(); 700 extern bool_t svc_auth_reg(); 701 extern void svc_unreg(); 702 extern void xprt_register(); 703 extern void xprt_unregister(); 704 #endif /* __STDC__ */ 705 #endif /* _KERNEL */ 706 707 708 /* 709 * When the service routine is called, it must first check to see if it 710 * knows about the procedure; if not, it should call svcerr_noproc 711 * and return. If so, it should deserialize its arguments via 712 * SVC_GETARGS (defined above). If the deserialization does not work, 713 * svcerr_decode should be called followed by a return. Successful 714 * decoding of the arguments should be followed the execution of the 715 * procedure's code and a call to svc_sendreply. 716 * 717 * Also, if the service refuses to execute the procedure due to too- 718 * weak authentication parameters, svcerr_weakauth should be called. 719 * Note: do not confuse access-control failure with weak authentication! 720 * 721 * NB: In pure implementations of rpc, the caller always waits for a reply 722 * msg. This message is sent when svc_sendreply is called. 723 * Therefore pure service implementations should always call 724 * svc_sendreply even if the function logically returns void; use 725 * xdr.h - xdr_void for the xdr routine. HOWEVER, connectionful rpc allows 726 * for the abuse of pure rpc via batched calling or pipelining. In the 727 * case of a batched call, svc_sendreply should NOT be called since 728 * this would send a return message, which is what batching tries to avoid. 729 * It is the service/protocol writer's responsibility to know which calls are 730 * batched and which are not. Warning: responding to batch calls may 731 * deadlock the caller and server processes! 732 */ 733 #ifdef __STDC__ 734 extern bool_t svc_sendreply(const SVCXPRT *, const xdrproc_t, const caddr_t); 735 extern void svcerr_decode(const SVCXPRT *); 736 extern void svcerr_weakauth(const SVCXPRT *); 737 extern void svcerr_noproc(const SVCXPRT *); 738 extern void svcerr_progvers(const SVCXPRT *, const rpcvers_t, 739 const rpcvers_t); 740 extern void svcerr_auth(const SVCXPRT *, const enum auth_stat); 741 extern void svcerr_noprog(const SVCXPRT *); 742 extern void svcerr_systemerr(const SVCXPRT *); 743 #else /* __STDC__ */ 744 extern bool_t svc_sendreply(); 745 extern void svcerr_decode(); 746 extern void svcerr_weakauth(); 747 extern void svcerr_noproc(); 748 extern void svcerr_progvers(); 749 extern void svcerr_auth(); 750 extern void svcerr_noprog(); 751 extern void svcerr_systemerr(); 752 #endif /* __STDC__ */ 753 754 #ifdef _KERNEL 755 /* 756 * Kernel RPC functions. 757 */ 758 extern void svc_init(void); 759 extern void svc_cots_init(void); 760 extern void svc_clts_init(void); 761 extern void mt_kstat_init(void); 762 extern void mt_kstat_fini(void); 763 extern int svc_tli_kcreate(struct file *, uint_t, char *, 764 struct netbuf *, SVCMASTERXPRT **, 765 SVC_CALLOUT_TABLE *, 766 void (*closeproc)(const SVCMASTERXPRT *), 767 int, bool_t); 768 extern int svc_clts_kcreate(struct file *, uint_t, struct T_info_ack *, 769 SVCMASTERXPRT **); 770 extern int svc_cots_kcreate(struct file *, uint_t, struct T_info_ack *, 771 SVCMASTERXPRT **); 772 extern void svc_queuereq(queue_t *, mblk_t *); 773 extern void svc_queueclean(queue_t *); 774 extern void svc_queueclose(queue_t *); 775 extern int svc_reserve_thread(SVCXPRT *); 776 extern void svc_unreserve_thread(SVCXPRT *); 777 extern callb_cpr_t *svc_detach_thread(SVCXPRT *); 778 779 /* 780 * For RDMA based kRPC. 781 * "rdma_xprt_record" is a reference to master transport handles 782 * in kRPC thread pools. This is an easy way of tracking and shuting 783 * down rdma based kRPC transports on demand. 784 * "rdma_xprt_group" is a list of RDMA based mster transport handles 785 * or records in a kRPC thread pool. 786 */ 787 typedef struct rdma_xprt_record rdma_xprt_record_t; 788 struct rdma_xprt_record { 789 int rtr_type; /* Type of rdma; IB/VI/RDDP */ 790 SVCMASTERXPRT *rtr_xprt_ptr; /* Ptr to master xprt handle */ 791 rdma_xprt_record_t *rtr_next; /* Ptr to next record */ 792 }; 793 794 typedef struct { 795 int rtg_count; /* Number transport records */ 796 int rtg_poolid; /* Pool Id for this group */ 797 rdma_xprt_record_t *rtg_listhead; /* Head of the records list */ 798 } rdma_xprt_group_t; 799 800 extern int svc_rdma_kcreate(char *, SVC_CALLOUT_TABLE *, int, 801 rdma_xprt_group_t *); 802 extern void svc_rdma_kstop(SVCMASTERXPRT *); 803 extern void svc_rdma_kdestroy(SVCMASTERXPRT *); 804 extern void rdma_stop(rdma_xprt_group_t); 805 806 /* 807 * GSS cleanup method. 808 */ 809 extern void rpc_gss_cleanup(SVCXPRT *); 810 #else /* _KERNEL */ 811 /* 812 * Lowest level dispatching -OR- who owns this process anyway. 813 * Somebody has to wait for incoming requests and then call the correct 814 * service routine. The routine svc_run does infinite waiting; i.e., 815 * svc_run never returns. 816 * Since another (co-existant) package may wish to selectively wait for 817 * incoming calls or other events outside of the rpc architecture, the 818 * routine svc_getreq_poll is provided. It must be passed pollfds, the 819 * "in-place" results of a poll call (see poll, section 2). 820 */ 821 822 /* 823 * Global keeper of rpc service descriptors in use 824 * dynamic; must be inspected before each call to select or poll 825 */ 826 extern pollfd_t *svc_pollfd; 827 extern int svc_max_pollfd; 828 extern fd_set svc_fdset; 829 #if !defined(_LP64) && FD_SETSIZE > 1024 830 extern fd_set _new_svc_fdset; 831 #ifdef __PRAGMA_REDEFINE_EXTNAME 832 #pragma redefine_extname svc_fdset _new_svc_fdset 833 #else /* __PRAGMA_REDEFINE_EXTNAME */ 834 #define svc_fdset _new_svc_fdset 835 #endif /* __PRAGMA_REDEFINE_EXTNAME */ 836 #endif /* LP64 && FD_SETSIZE > 1024 */ 837 #define svc_fds svc_fdset.fds_bits[0] /* compatibility */ 838 839 /* 840 * A small program implemented by the svc_rpc implementation itself. 841 * Also see clnt.h for protocol numbers. 842 */ 843 #ifdef __STDC__ 844 extern void svc_getreq(int); 845 extern void svc_getreq_common(const int); 846 extern void svc_getreqset(fd_set *); /* takes fdset instead of int */ 847 extern void svc_getreq_poll(struct pollfd *, const int); 848 extern void svc_run(void); 849 extern void svc_exit(void); 850 #else /* __STDC__ */ 851 extern void rpctest_service(); 852 extern void svc_getreqset(); 853 extern void svc_getreq(); 854 extern void svc_getreq_common(); 855 extern void svc_getreqset(); /* takes fdset instead of int */ 856 extern void svc_getreq_poll(); 857 extern void svc_run(); 858 extern void svc_exit(); 859 #endif /* __STDC__ */ 860 861 /* 862 * Functions used to manage user file descriptors 863 */ 864 typedef int svc_input_id_t; 865 typedef void (*svc_callback_t)(svc_input_id_t id, int fd, 866 unsigned int events, void* cookie); 867 868 #ifdef __STDC__ 869 extern svc_input_id_t svc_add_input(int fd, unsigned int events, 870 svc_callback_t user_callback, 871 void* cookie); 872 extern int svc_remove_input(svc_input_id_t id); 873 #else /* __STDC__ */ 874 extern svc_input_id_t svc_add_input(); 875 extern int svc_remove_input(); 876 #endif 877 878 /* 879 * These are the existing service side transport implementations. 880 * 881 * Transport independent svc_create routine. 882 */ 883 #ifdef __STDC__ 884 extern int svc_create(void (*)(struct svc_req *, SVCXPRT *), 885 const rpcprog_t, const rpcvers_t, 886 const char *); 887 /* 888 * void (*dispatch)(); -- dispatch routine 889 * const rpcprog_t prognum; -- program number 890 * const rpcvers_t versnum; -- version number 891 * const char *nettype; -- network type 892 */ 893 894 /* 895 * Generic server creation routine. It takes a netconfig structure 896 * instead of a nettype. 897 */ 898 extern SVCXPRT *svc_tp_create(void (*)(struct svc_req *, SVCXPRT *), 899 const rpcprog_t, const rpcvers_t, 900 const struct netconfig *); 901 /* 902 * void (*dispatch)(); -- dispatch routine 903 * const rpcprog_t prognum; -- program number 904 * const rpcvers_t versnum; -- version number 905 * const struct netconfig *nconf; -- netconfig structure 906 */ 907 908 /* 909 * Generic TLI create routine 910 */ 911 extern SVCXPRT *svc_tli_create(const int, const struct netconfig *, 912 const struct t_bind *, const uint_t, 913 const uint_t); 914 /* 915 * const int fd; -- connection end point 916 * const struct netconfig *nconf; -- netconfig structure 917 * const struct t_bind *bindaddr; -- local bind address 918 * const uint_t sendsz; -- max sendsize 919 * const uint_t recvsz; -- max recvsize 920 */ 921 922 /* 923 * Connectionless and connectionful create routines. 924 */ 925 extern SVCXPRT *svc_vc_create(const int, const uint_t, const uint_t); 926 /* 927 * const int fd; -- open connection end point 928 * const uint_t sendsize; -- max send size 929 * const uint_t recvsize; -- max recv size 930 */ 931 932 extern SVCXPRT *svc_dg_create(const int, const uint_t, const uint_t); 933 /* 934 * const int fd; -- open connection 935 * const uint_t sendsize; -- max send size 936 * const uint_t recvsize; -- max recv size 937 */ 938 939 /* 940 * the routine takes any *open* TLI file 941 * descriptor as its first input and is used for open connections. 942 */ 943 extern SVCXPRT *svc_fd_create(const int, const uint_t, const uint_t); 944 /* 945 * const int fd; -- open connection end point 946 * const uint_t sendsize; -- max send size 947 * const uint_t recvsize; -- max recv size 948 */ 949 950 /* 951 * Memory based rpc (for speed check and testing) 952 */ 953 extern SVCXPRT *svc_raw_create(void); 954 955 /* 956 * Creation of service over doors transport. 957 */ 958 extern SVCXPRT *svc_door_create(void (*)(struct svc_req *, SVCXPRT *), 959 const rpcprog_t, const rpcvers_t, 960 const uint_t); 961 /* 962 * void (*dispatch)(); -- dispatch routine 963 * const rpcprog_t prognum; -- program number 964 * const rpcvers_t versnum; -- version number 965 * const uint_t sendsize; -- send buffer size 966 */ 967 968 /* 969 * Service control interface 970 */ 971 extern bool_t svc_control(SVCXPRT *, const uint_t, void *); 972 /* 973 * SVCXPRT *svc; -- service to manipulate 974 * const uint_t req; -- request 975 * void *info; -- argument to request 976 */ 977 978 /* 979 * svc_dg_enable_cache() enables the cache on dg transports. 980 */ 981 extern int svc_dg_enablecache(SVCXPRT *, const uint_t); 982 #else /* __STDC__ */ 983 extern int svc_create(); 984 extern SVCXPRT *svc_tp_create(); 985 extern SVCXPRT *svc_tli_create(); 986 extern SVCXPRT *svc_vc_create(); 987 extern SVCXPRT *svc_dg_create(); 988 extern SVCXPRT *svc_fd_create(); 989 extern SVCXPRT *svc_raw_create(); 990 extern SVCXPRT *svc_door_create(); 991 extern int svc_dg_enablecache(); 992 #endif /* __STDC__ */ 993 994 #ifdef PORTMAP 995 /* For backward compatibility */ 996 #include <rpc/svc_soc.h> 997 #endif /* PORTMAP */ 998 999 /* 1000 * For user level MT hot server functions 1001 */ 1002 1003 /* 1004 * Different MT modes 1005 */ 1006 #define RPC_SVC_MT_NONE 0 /* default, single-threaded */ 1007 #define RPC_SVC_MT_AUTO 1 /* automatic MT mode */ 1008 #define RPC_SVC_MT_USER 2 /* user MT mode */ 1009 1010 #ifdef __STDC__ 1011 extern void svc_done(SVCXPRT *); 1012 #else 1013 extern void svc_done(); 1014 #endif /* __STDC__ */ 1015 1016 /* 1017 * Obtaining local credentials. 1018 */ 1019 typedef struct __svc_local_cred_t { 1020 uid_t euid; /* effective uid */ 1021 gid_t egid; /* effective gid */ 1022 uid_t ruid; /* real uid */ 1023 gid_t rgid; /* real gid */ 1024 pid_t pid; /* caller's pid, or -1 if not available */ 1025 } svc_local_cred_t; 1026 1027 #ifdef __STDC__ 1028 struct ucred_s; 1029 extern void svc_fd_negotiate_ucred(int); 1030 extern int svc_getcallerucred(const SVCXPRT *, struct ucred_s **); 1031 extern bool_t svc_get_local_cred(SVCXPRT *, svc_local_cred_t *); 1032 #else 1033 extern void svc_fd_negotiate_ucred(); 1034 extern int svc_getcallerucred(); 1035 extern bool_t svc_get_local_cred(); 1036 #endif /* __STDC__ */ 1037 1038 /* 1039 * Private interfaces and structures for user level duplicate request caching. 1040 * The interfaces and data structures are not committed and subject to 1041 * change in future releases. Currently only intended for use by automountd. 1042 */ 1043 struct dupreq { 1044 uint32_t dr_xid; 1045 rpcproc_t dr_proc; 1046 rpcvers_t dr_vers; 1047 rpcprog_t dr_prog; 1048 struct netbuf dr_addr; 1049 struct netbuf dr_resp; 1050 int dr_status; 1051 time_t dr_time; 1052 uint_t dr_hash; 1053 struct dupreq *dr_next; 1054 struct dupreq *dr_prev; 1055 struct dupreq *dr_chain; 1056 struct dupreq *dr_prevchain; 1057 }; 1058 1059 /* 1060 * The fixedtime state is defined if we want to expand the routines to 1061 * handle and encompass fixed size caches. 1062 */ 1063 #define DUPCACHE_FIXEDTIME 0 1064 1065 /* 1066 * States of requests for duplicate request caching. 1067 * These are the same as defined for the kernel. 1068 */ 1069 #define DUP_NEW 0x00 /* new entry */ 1070 #define DUP_INPROGRESS 0x01 /* request already going */ 1071 #define DUP_DONE 0x02 /* request done */ 1072 #define DUP_DROP 0x03 /* request dropped */ 1073 #define DUP_ERROR 0x04 /* error in dup req cache */ 1074 1075 #ifdef __STDC__ 1076 extern bool_t __svc_dupcache_init(void *, int, char **); 1077 extern int __svc_dup(struct svc_req *, caddr_t *, uint_t *, char *); 1078 extern int __svc_dupdone(struct svc_req *, caddr_t, uint_t, int, char *); 1079 extern bool_t __svc_vc_dupcache_init(SVCXPRT *, void *, int); 1080 extern int __svc_vc_dup(struct svc_req *, caddr_t *, uint_t *); 1081 extern int __svc_vc_dupdone(struct svc_req *, caddr_t, uint_t, int); 1082 #else 1083 extern bool_t __svc_dupcache_init(); 1084 extern int __svc_dup(); 1085 extern int __svc_dupdone(); 1086 extern bool_t __svc_vc_dupcache_init(); 1087 extern int __svc_vc_dup(); 1088 extern int __svc_vc_dupdone(); 1089 #endif /* __STDC__ */ 1090 #endif /* _KERNEL */ 1091 1092 #ifdef __cplusplus 1093 } 1094 #endif 1095 1096 #endif /* !_RPC_SVC_H */ 1097