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
76extern "C" {
77#endif
78
79/*
80 * Server-side transport handles.
81 * The actual type definitions are below.
82 */
83#ifdef	_KERNEL
84typedef struct __svcmasterxprt	SVCMASTERXPRT;	/* Master transport handle */
85typedef struct __svcxprt	SVCXPRT;	/* Per-thread clone handle */
86typedef	struct __svcpool	SVCPOOL;	/* Kernel thread pool	   */
87#else	/* _KERNEL */
88typedef struct __svcxprt	SVCXPRT;	/* Server transport handle */
89#endif	/* _KERNEL */
90
91/*
92 *  Prototype of error handler callback
93 */
94#ifndef _KERNEL
95typedef 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 */
106struct 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
117struct 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 */
142typedef 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 */
150typedef 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 */
162typedef 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
168struct 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
216enum xprt_stat {
217	XPRT_DIED,
218	XPRT_MOREREQS,
219	XPRT_IDLE
220};
221
222struct 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 */
255typedef struct __svcxprt_qnode __SVCXPRT_QNODE;	/* Defined in svc.c */
256
257struct __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 */
398typedef 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
422struct __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
460struct __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 */
483struct __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
663struct 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 */
678extern int	svc_xprt_register(SVCMASTERXPRT *, int);
679extern void	svc_xprt_unregister(SVCMASTERXPRT *);
680extern int	svc_pool_create(struct svcpool_args *);
681extern int	svc_wait(int);
682extern int	svc_do_run(int);
683#define	SVCPSET_SHUTDOWN_PROC	1
684#define	SVCPSET_UNREGISTER_PROC	2
685extern int	svc_pool_control(int, int, void *);
686#else	/* _KERNEL */
687#ifdef	__STDC__
688extern 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 */
702extern 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 */
713extern 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 */
722extern 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 */
733extern void	xprt_register(const SVCXPRT *);
734extern void	xprt_unregister(const SVCXPRT *);
735#else	/* __STDC__ */
736extern bool_t	rpc_reg();
737extern bool_t	svc_reg();
738extern bool_t	svc_auth_reg();
739extern void	svc_unreg();
740extern void	xprt_register();
741extern void	xprt_unregister();
742#endif /* __STDC__ */
743#endif	/* _KERNEL */
744
745#ifdef _KERNEL
746/*
747 * Transport hold and release.
748 */
749extern void rpcmod_hold(queue_t *);
750extern void rpcmod_release(queue_t *, mblk_t *, bool_t);
751extern void mir_svc_hold(queue_t *);
752extern 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__
781extern bool_t	svc_sendreply(const SVCXPRT *, const xdrproc_t,	const caddr_t);
782extern void	svcerr_decode(const SVCXPRT *);
783extern void	svcerr_weakauth(const SVCXPRT *);
784extern void	svcerr_noproc(const SVCXPRT *);
785extern void	svcerr_progvers(const SVCXPRT *, const rpcvers_t,
786    const rpcvers_t);
787extern void	svcerr_auth(const SVCXPRT *, const enum auth_stat);
788extern void	svcerr_noprog(const SVCXPRT *);
789extern void	svcerr_systemerr(const SVCXPRT *);
790extern void	svcerr_badcred(const SVCXPRT *);
791#else	/* __STDC__ */
792extern bool_t	svc_sendreply();
793extern void	svcerr_decode();
794extern void	svcerr_weakauth();
795extern void	svcerr_noproc();
796extern void	svcerr_progvers();
797extern void	svcerr_auth();
798extern void	svcerr_noprog();
799extern void	svcerr_systemerr();
800extern void	svcerr_badcred();
801#endif	/* __STDC__ */
802
803#ifdef	_KERNEL
804/*
805 * Kernel RPC functions.
806 */
807extern void	svc_init(void);
808extern void	svc_cots_init(void);
809extern void	svc_clts_init(void);
810extern void	mt_kstat_init(void);
811extern void	mt_kstat_fini(void);
812extern 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);
817extern int	svc_clts_kcreate(struct file *, uint_t, struct T_info_ack *,
818				SVCMASTERXPRT **);
819extern int	svc_cots_kcreate(struct file *, uint_t, struct T_info_ack *,
820				SVCMASTERXPRT **);
821extern bool_t	svc_queuereq(queue_t *, mblk_t *, bool_t);
822extern void	svc_queueclean(queue_t *);
823extern void	svc_queueclose(queue_t *);
824extern int	svc_reserve_thread(SVCXPRT *);
825extern void	svc_unreserve_thread(SVCXPRT *);
826extern 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 */
836typedef struct rdma_xprt_record		rdma_xprt_record_t;
837struct 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
843typedef 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
849extern int	svc_rdma_kcreate(char *, SVC_CALLOUT_TABLE *, int,
850			rdma_xprt_group_t *);
851extern void	svc_rdma_kstop(SVCMASTERXPRT *);
852extern void	svc_rdma_kdestroy(SVCMASTERXPRT *);
853extern void	rdma_stop(rdma_xprt_group_t *);
854
855/*
856 * GSS cleanup method.
857 */
858extern 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 */
875extern pollfd_t	*svc_pollfd;
876extern int	svc_max_pollfd;
877extern 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__
885extern void	svc_getreq(int);
886extern void	svc_getreq_common(const int);
887extern void	svc_getreqset(fd_set *); /* takes fdset instead of int */
888extern void	svc_getreq_poll(struct pollfd *, const int);
889extern void	svc_run(void);
890extern void	svc_exit(void);
891#else	/* __STDC__ */
892extern void	rpctest_service();
893extern void	svc_getreqset();
894extern void	svc_getreq();
895extern void	svc_getreq_common();
896extern void	svc_getreqset();	 /* takes fdset instead of int */
897extern void	svc_getreq_poll();
898extern void	svc_run();
899extern void	svc_exit();
900#endif	/* __STDC__ */
901
902/*
903 *  Functions used to manage user file descriptors
904 */
905typedef int svc_input_id_t;
906typedef void (*svc_callback_t)(svc_input_id_t id, int fd,
907				unsigned int events, void* cookie);
908
909#ifdef __STDC__
910extern svc_input_id_t svc_add_input(int fd, unsigned int events,
911				svc_callback_t user_callback,
912				void* cookie);
913extern int svc_remove_input(svc_input_id_t id);
914#else	/* __STDC__ */
915extern svc_input_id_t svc_add_input();
916extern 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__
925extern 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 */
939extern 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 */
953extern 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 */
968extern  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 */
982extern 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
989extern 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 */
1000extern  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 */
1010extern SVCXPRT	*svc_raw_create(void);
1011
1012/*
1013 * Creation of service over doors transport.
1014 */
1015extern 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 */
1028extern	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 */
1038extern int svc_dg_enablecache(SVCXPRT *, const uint_t);
1039#else	/* __STDC__ */
1040extern int	svc_create();
1041extern SVCXPRT	*svc_tp_create();
1042extern SVCXPRT	*svc_tli_create();
1043extern SVCXPRT	*svc_vc_create();
1044extern SVCXPRT	*svc_dg_create();
1045extern SVCXPRT	*svc_fd_create();
1046extern SVCXPRT	*svc_raw_create();
1047extern SVCXPRT	*svc_door_create();
1048extern int svc_dg_enablecache();
1049#endif	/* __STDC__ */
1050
1051extern 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__
1070extern void	svc_done(SVCXPRT *);
1071#else
1072extern void	svc_done();
1073#endif	/* __STDC__ */
1074
1075/*
1076 * Obtaining local credentials.
1077 */
1078typedef 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__
1087struct ucred_s;
1088extern void	svc_fd_negotiate_ucred(int);
1089extern int	svc_getcallerucred(const SVCXPRT *, struct ucred_s **);
1090extern bool_t	svc_get_local_cred(SVCXPRT *, svc_local_cred_t *);
1091#else
1092extern void	svc_fd_negotiate_ucred();
1093extern int	svc_getcallerucred();
1094extern 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 */
1102struct 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__
1135extern bool_t	__svc_dupcache_init(void *, int, char **);
1136extern int	__svc_dup(struct svc_req *, caddr_t *, uint_t *, char *);
1137extern int	__svc_dupdone(struct svc_req *, caddr_t, uint_t, int, char *);
1138extern bool_t	__svc_vc_dupcache_init(SVCXPRT *, void *, int);
1139extern int	__svc_vc_dup(struct svc_req *, caddr_t *, uint_t *);
1140extern int	__svc_vc_dupdone(struct svc_req *, caddr_t, uint_t, int);
1141#else
1142extern bool_t	__svc_dupcache_init();
1143extern int	__svc_dup();
1144extern int	__svc_dupdone();
1145extern bool_t	__svc_vc_dupcache_init();
1146extern int	__svc_vc_dup();
1147extern 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 */
1157extern SVCXPRT *svc_clone_init(void);
1158extern void svc_clone_free(SVCXPRT *);
1159extern void svc_clone_link(SVCMASTERXPRT *, SVCXPRT *, SVCXPRT *);
1160extern void svc_clone_unlink(SVCXPRT *);
1161#endif	/* _KERNEL */
1162
1163#ifdef	__cplusplus
1164}
1165#endif
1166
1167#endif	/* !_RPC_SVC_H */
1168