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