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