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