xref: /titanic_41/usr/src/uts/common/rpc/clnt_clts.c (revision 0d6bb4c6728fd20087fe25f4028a3838250e6e9c)
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 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T
28  * All Rights Reserved
29  */
30 
31 /*
32  * Portions of this source code were derived from Berkeley 4.3 BSD
33  * under license from the Regents of the University of California.
34  */
35 
36 
37 /*
38  * Implements a kernel based, client side RPC.
39  */
40 
41 #include <sys/param.h>
42 #include <sys/types.h>
43 #include <sys/systm.h>
44 #include <sys/sysmacros.h>
45 #include <sys/stream.h>
46 #include <sys/strsubr.h>
47 #include <sys/ddi.h>
48 #include <sys/tiuser.h>
49 #include <sys/tihdr.h>
50 #include <sys/t_kuser.h>
51 #include <sys/errno.h>
52 #include <sys/kmem.h>
53 #include <sys/debug.h>
54 #include <sys/kstat.h>
55 #include <sys/t_lock.h>
56 #include <sys/cmn_err.h>
57 #include <sys/conf.h>
58 #include <sys/disp.h>
59 #include <sys/taskq.h>
60 #include <sys/list.h>
61 #include <sys/atomic.h>
62 #include <sys/zone.h>
63 #include <netinet/in.h>
64 #include <rpc/types.h>
65 #include <rpc/xdr.h>
66 #include <rpc/auth.h>
67 #include <rpc/clnt.h>
68 #include <rpc/rpc_msg.h>
69 
70 #include <sys/sdt.h>
71 
72 static enum clnt_stat clnt_clts_kcallit(CLIENT *, rpcproc_t, xdrproc_t,
73 		    caddr_t, xdrproc_t, caddr_t, struct timeval);
74 static void	clnt_clts_kabort(CLIENT *);
75 static void	clnt_clts_kerror(CLIENT *, struct rpc_err *);
76 static bool_t	clnt_clts_kfreeres(CLIENT *, xdrproc_t, caddr_t);
77 static bool_t	clnt_clts_kcontrol(CLIENT *, int, char *);
78 static void	clnt_clts_kdestroy(CLIENT *);
79 static int	clnt_clts_ksettimers(CLIENT *, struct rpc_timers *,
80 		    struct rpc_timers *, int, void (*)(), caddr_t, uint32_t);
81 
82 /*
83  * Operations vector for CLTS based RPC
84  */
85 static struct clnt_ops clts_ops = {
86 	clnt_clts_kcallit,	/* do rpc call */
87 	clnt_clts_kabort,	/* abort call */
88 	clnt_clts_kerror,	/* return error status */
89 	clnt_clts_kfreeres,	/* free results */
90 	clnt_clts_kdestroy,	/* destroy rpc handle */
91 	clnt_clts_kcontrol,	/* the ioctl() of rpc */
92 	clnt_clts_ksettimers	/* set retry timers */
93 };
94 
95 /*
96  * Endpoint for CLTS (INET, INET6, loopback, etc.)
97  */
98 typedef struct endpnt_type {
99 	struct endpnt_type *e_next;	/* pointer to next endpoint type */
100 	list_t		e_pool;		/* list of available endpoints */
101 	list_t		e_ilist;	/* list of idle endpoints */
102 	struct endpnt	*e_pcurr;	/* pointer to current endpoint */
103 	char		e_protofmly[KNC_STRSIZE];	/* protocol family */
104 	dev_t		e_rdev;		/* device */
105 	kmutex_t	e_plock;	/* pool lock */
106 	kmutex_t	e_ilock;	/* idle list lock */
107 	timeout_id_t	e_itimer;	/* timer to dispatch the taskq */
108 	uint_t		e_cnt;		/* number of endpoints in the pool */
109 	zoneid_t	e_zoneid;	/* zoneid of endpoint type */
110 	kcondvar_t	e_async_cv;	/* cv for asynchronous reap threads */
111 	uint_t		e_async_count;	/* count of asynchronous reap threads */
112 } endpnt_type_t;
113 
114 typedef struct endpnt {
115 	list_node_t	e_node;		/* link to the pool */
116 	list_node_t	e_idle;		/* link to the idle list */
117 	endpnt_type_t	*e_type;	/* back pointer to endpoint type */
118 	TIUSER		*e_tiptr;	/* pointer to transport endpoint */
119 	queue_t		*e_wq;		/* write queue */
120 	uint_t		e_flags;	/* endpoint flags */
121 	uint_t		e_ref;		/* ref count on endpoint */
122 	kcondvar_t	e_cv;		/* condition variable */
123 	kmutex_t	e_lock;		/* protects cv and flags */
124 	time_t		e_itime;	/* time when rele'd */
125 } endpnt_t;
126 
127 #define	ENDPNT_ESTABLISHED	0x1	/* endpoint is established */
128 #define	ENDPNT_WAITING		0x2	/* thread waiting for endpoint */
129 #define	ENDPNT_BOUND		0x4	/* endpoint is bound */
130 #define	ENDPNT_STALE		0x8	/* endpoint is dead */
131 #define	ENDPNT_ONIDLE		0x10	/* endpoint is on the idle list */
132 
133 static krwlock_t	endpnt_type_lock; /* protects endpnt_type_list */
134 static endpnt_type_t	*endpnt_type_list = NULL; /* list of CLTS endpoints */
135 static struct kmem_cache	*endpnt_cache; /* cache of endpnt_t's */
136 static taskq_t			*endpnt_taskq; /* endpnt_t reaper thread */
137 static bool_t			taskq_created; /* flag for endpnt_taskq */
138 static kmutex_t			endpnt_taskq_lock; /* taskq lock */
139 static zone_key_t		endpnt_destructor_key;
140 
141 #define	DEFAULT_ENDPOINT_REAP_INTERVAL 60 /* 1 minute */
142 #define	DEFAULT_INTERVAL_SHIFT 30 /* 30 seconds */
143 
144 /*
145  * Endpoint tunables
146  */
147 static int	clnt_clts_max_endpoints = -1;
148 static int	clnt_clts_hash_size = DEFAULT_HASH_SIZE;
149 static time_t	clnt_clts_endpoint_reap_interval = -1;
150 static clock_t	clnt_clts_taskq_dispatch_interval;
151 
152 /*
153  * Response completion hash queue
154  */
155 static call_table_t *clts_call_ht;
156 
157 /*
158  * Routines for the endpoint manager
159  */
160 static struct endpnt_type *endpnt_type_create(struct knetconfig *);
161 static void endpnt_type_free(struct endpnt_type *);
162 static int check_endpnt(struct endpnt *, struct endpnt **);
163 static struct endpnt *endpnt_get(struct knetconfig *, int);
164 static void endpnt_rele(struct endpnt *);
165 static void endpnt_reap_settimer(endpnt_type_t *);
166 static void endpnt_reap(endpnt_type_t *);
167 static void endpnt_reap_dispatch(void *);
168 static void endpnt_reclaim(zoneid_t);
169 
170 
171 /*
172  * Request dipatching function.
173  */
174 static int clnt_clts_dispatch_send(queue_t *q, mblk_t *, struct netbuf *addr,
175 					calllist_t *, uint_t, cred_t *);
176 
177 /*
178  * The size of the preserialized RPC header information.
179  */
180 #define	CKU_HDRSIZE	20
181 /*
182  * The initial allocation size.  It is small to reduce space requirements.
183  */
184 #define	CKU_INITSIZE	2048
185 /*
186  * The size of additional allocations, if required.  It is larger to
187  * reduce the number of actual allocations.
188  */
189 #define	CKU_ALLOCSIZE	8192
190 
191 /*
192  * Private data per rpc handle.  This structure is allocated by
193  * clnt_clts_kcreate, and freed by clnt_clts_kdestroy.
194  */
195 struct cku_private {
196 	CLIENT			 cku_client;	/* client handle */
197 	int			 cku_retrys;	/* request retrys */
198 	calllist_t		 cku_call;
199 	struct endpnt		*cku_endpnt;	/* open end point */
200 	struct knetconfig	 cku_config;
201 	struct netbuf		 cku_addr;	/* remote address */
202 	struct rpc_err		 cku_err;	/* error status */
203 	XDR			 cku_outxdr;	/* xdr stream for output */
204 	XDR			 cku_inxdr;	/* xdr stream for input */
205 	char			 cku_rpchdr[CKU_HDRSIZE + 4]; /* rpc header */
206 	struct cred		*cku_cred;	/* credentials */
207 	struct rpc_timers	*cku_timers;	/* for estimating RTT */
208 	struct rpc_timers	*cku_timeall;	/* for estimating RTT */
209 	void			 (*cku_feedback)(int, int, caddr_t);
210 						/* ptr to feedback rtn */
211 	caddr_t			 cku_feedarg;	/* argument for feedback func */
212 	uint32_t		 cku_xid;	/* current XID */
213 	bool_t			 cku_bcast;	/* RPC broadcast hint */
214 	int			cku_useresvport; /* Use reserved port */
215 	struct rpc_clts_client	*cku_stats;	/* counters for the zone */
216 };
217 
218 static const struct rpc_clts_client {
219 	kstat_named_t	rccalls;
220 	kstat_named_t	rcbadcalls;
221 	kstat_named_t	rcretrans;
222 	kstat_named_t	rcbadxids;
223 	kstat_named_t	rctimeouts;
224 	kstat_named_t	rcnewcreds;
225 	kstat_named_t	rcbadverfs;
226 	kstat_named_t	rctimers;
227 	kstat_named_t	rcnomem;
228 	kstat_named_t	rccantsend;
229 } clts_rcstat_tmpl = {
230 	{ "calls",	KSTAT_DATA_UINT64 },
231 	{ "badcalls",	KSTAT_DATA_UINT64 },
232 	{ "retrans",	KSTAT_DATA_UINT64 },
233 	{ "badxids",	KSTAT_DATA_UINT64 },
234 	{ "timeouts",	KSTAT_DATA_UINT64 },
235 	{ "newcreds",	KSTAT_DATA_UINT64 },
236 	{ "badverfs",	KSTAT_DATA_UINT64 },
237 	{ "timers",	KSTAT_DATA_UINT64 },
238 	{ "nomem",	KSTAT_DATA_UINT64 },
239 	{ "cantsend",	KSTAT_DATA_UINT64 },
240 };
241 
242 static uint_t clts_rcstat_ndata =
243 	sizeof (clts_rcstat_tmpl) / sizeof (kstat_named_t);
244 
245 #define	RCSTAT_INCR(s, x)			\
246 	atomic_inc_64(&(s)->x.value.ui64)
247 
248 #define	ptoh(p)		(&((p)->cku_client))
249 #define	htop(h)		((struct cku_private *)((h)->cl_private))
250 
251 /*
252  * Times to retry
253  */
254 #define	SNDTRIES	4
255 #define	REFRESHES	2	/* authentication refreshes */
256 
257 /*
258  * The following is used to determine the global default behavior for
259  * CLTS when binding to a local port.
260  *
261  * If the value is set to 1 the default will be to select a reserved
262  * (aka privileged) port, if the value is zero the default will be to
263  * use non-reserved ports.  Users of kRPC may override this by using
264  * CLNT_CONTROL() and CLSET_BINDRESVPORT.
265  */
266 static int clnt_clts_do_bindresvport = 1;
267 
268 #define	BINDRESVPORT_RETRIES 5
269 
270 void
clnt_clts_stats_init(zoneid_t zoneid,struct rpc_clts_client ** statsp)271 clnt_clts_stats_init(zoneid_t zoneid, struct rpc_clts_client **statsp)
272 {
273 	kstat_t *ksp;
274 	kstat_named_t *knp;
275 
276 	knp = rpcstat_zone_init_common(zoneid, "unix", "rpc_clts_client",
277 	    (const kstat_named_t *)&clts_rcstat_tmpl,
278 	    sizeof (clts_rcstat_tmpl));
279 	/*
280 	 * Backwards compatibility for old kstat clients
281 	 */
282 	ksp = kstat_create_zone("unix", 0, "rpc_client", "rpc",
283 	    KSTAT_TYPE_NAMED, clts_rcstat_ndata,
284 	    KSTAT_FLAG_VIRTUAL | KSTAT_FLAG_WRITABLE, zoneid);
285 	if (ksp) {
286 		ksp->ks_data = knp;
287 		kstat_install(ksp);
288 	}
289 	*statsp = (struct rpc_clts_client *)knp;
290 }
291 
292 void
clnt_clts_stats_fini(zoneid_t zoneid,struct rpc_clts_client ** statsp)293 clnt_clts_stats_fini(zoneid_t zoneid, struct rpc_clts_client **statsp)
294 {
295 	rpcstat_zone_fini_common(zoneid, "unix", "rpc_clts_client");
296 	kstat_delete_byname_zone("unix", 0, "rpc_client", zoneid);
297 	kmem_free(*statsp, sizeof (clts_rcstat_tmpl));
298 }
299 
300 /*
301  * Create an rpc handle for a clts rpc connection.
302  * Allocates space for the handle structure and the private data.
303  */
304 /* ARGSUSED */
305 int
clnt_clts_kcreate(struct knetconfig * config,struct netbuf * addr,rpcprog_t pgm,rpcvers_t vers,int retrys,struct cred * cred,CLIENT ** cl)306 clnt_clts_kcreate(struct knetconfig *config, struct netbuf *addr,
307 	rpcprog_t pgm, rpcvers_t vers, int retrys, struct cred *cred,
308 	CLIENT **cl)
309 {
310 	CLIENT *h;
311 	struct cku_private *p;
312 	struct rpc_msg call_msg;
313 	int error;
314 	int plen;
315 
316 	if (cl == NULL)
317 		return (EINVAL);
318 
319 	*cl = NULL;
320 	error = 0;
321 
322 	p = kmem_zalloc(sizeof (*p), KM_SLEEP);
323 
324 	h = ptoh(p);
325 
326 	/* handle */
327 	h->cl_ops = &clts_ops;
328 	h->cl_private = (caddr_t)p;
329 	h->cl_auth = authkern_create();
330 
331 	/* call message, just used to pre-serialize below */
332 	call_msg.rm_xid = 0;
333 	call_msg.rm_direction = CALL;
334 	call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
335 	call_msg.rm_call.cb_prog = pgm;
336 	call_msg.rm_call.cb_vers = vers;
337 
338 	/* private */
339 	clnt_clts_kinit(h, addr, retrys, cred);
340 
341 	xdrmem_create(&p->cku_outxdr, p->cku_rpchdr, CKU_HDRSIZE, XDR_ENCODE);
342 
343 	/* pre-serialize call message header */
344 	if (!xdr_callhdr(&p->cku_outxdr, &call_msg)) {
345 		error = EINVAL;		/* XXX */
346 		goto bad;
347 	}
348 
349 	p->cku_config.knc_rdev = config->knc_rdev;
350 	p->cku_config.knc_semantics = config->knc_semantics;
351 	plen = strlen(config->knc_protofmly) + 1;
352 	p->cku_config.knc_protofmly = kmem_alloc(plen, KM_SLEEP);
353 	bcopy(config->knc_protofmly, p->cku_config.knc_protofmly, plen);
354 	p->cku_useresvport = -1; /* value is has not been set */
355 
356 	cv_init(&p->cku_call.call_cv, NULL, CV_DEFAULT, NULL);
357 	mutex_init(&p->cku_call.call_lock, NULL, MUTEX_DEFAULT, NULL);
358 
359 	*cl = h;
360 	return (0);
361 
362 bad:
363 	auth_destroy(h->cl_auth);
364 	kmem_free(p->cku_addr.buf, addr->maxlen);
365 	kmem_free(p, sizeof (struct cku_private));
366 
367 	return (error);
368 }
369 
370 void
clnt_clts_kinit(CLIENT * h,struct netbuf * addr,int retrys,cred_t * cred)371 clnt_clts_kinit(CLIENT *h, struct netbuf *addr, int retrys, cred_t *cred)
372 {
373 	/* LINTED pointer alignment */
374 	struct cku_private *p = htop(h);
375 	struct rpcstat *rsp;
376 
377 	rsp = zone_getspecific(rpcstat_zone_key, rpc_zone());
378 	ASSERT(rsp != NULL);
379 
380 	p->cku_retrys = retrys;
381 
382 	if (p->cku_addr.maxlen < addr->len) {
383 		if (p->cku_addr.maxlen != 0 && p->cku_addr.buf != NULL)
384 			kmem_free(p->cku_addr.buf, p->cku_addr.maxlen);
385 
386 		p->cku_addr.buf = kmem_zalloc(addr->maxlen, KM_SLEEP);
387 		p->cku_addr.maxlen = addr->maxlen;
388 	}
389 
390 	p->cku_addr.len = addr->len;
391 	bcopy(addr->buf, p->cku_addr.buf, addr->len);
392 
393 	p->cku_cred = cred;
394 	p->cku_xid = 0;
395 	p->cku_timers = NULL;
396 	p->cku_timeall = NULL;
397 	p->cku_feedback = NULL;
398 	p->cku_bcast = FALSE;
399 	p->cku_call.call_xid = 0;
400 	p->cku_call.call_hash = 0;
401 	p->cku_call.call_notified = FALSE;
402 	p->cku_call.call_next = NULL;
403 	p->cku_call.call_prev = NULL;
404 	p->cku_call.call_reply = NULL;
405 	p->cku_call.call_wq = NULL;
406 	p->cku_stats = rsp->rpc_clts_client;
407 }
408 
409 /*
410  * set the timers.  Return current retransmission timeout.
411  */
412 static int
clnt_clts_ksettimers(CLIENT * h,struct rpc_timers * t,struct rpc_timers * all,int minimum,void (* feedback)(int,int,caddr_t),caddr_t arg,uint32_t xid)413 clnt_clts_ksettimers(CLIENT *h, struct rpc_timers *t, struct rpc_timers *all,
414 	int minimum, void (*feedback)(int, int, caddr_t), caddr_t arg,
415 	uint32_t xid)
416 {
417 	/* LINTED pointer alignment */
418 	struct cku_private *p = htop(h);
419 	int value;
420 
421 	p->cku_feedback = feedback;
422 	p->cku_feedarg = arg;
423 	p->cku_timers = t;
424 	p->cku_timeall = all;
425 	if (xid)
426 		p->cku_xid = xid;
427 	value = all->rt_rtxcur;
428 	value += t->rt_rtxcur;
429 	if (value < minimum)
430 		return (minimum);
431 	RCSTAT_INCR(p->cku_stats, rctimers);
432 	return (value);
433 }
434 
435 /*
436  * Time out back off function. tim is in HZ
437  */
438 #define	MAXTIMO	(20 * hz)
439 #define	backoff(tim)	(((tim) < MAXTIMO) ? dobackoff(tim) : (tim))
440 #define	dobackoff(tim)	((((tim) << 1) > MAXTIMO) ? MAXTIMO : ((tim) << 1))
441 
442 #define	RETRY_POLL_TIMO	30
443 
444 /*
445  * Call remote procedure.
446  * Most of the work of rpc is done here.  We serialize what is left
447  * of the header (some was pre-serialized in the handle), serialize
448  * the arguments, and send it off.  We wait for a reply or a time out.
449  * Timeout causes an immediate return, other packet problems may cause
450  * a retry on the receive.  When a good packet is received we deserialize
451  * it, and check verification.  A bad reply code will cause one retry
452  * with full (longhand) credentials.
453  */
454 enum clnt_stat
clnt_clts_kcallit_addr(CLIENT * h,rpcproc_t procnum,xdrproc_t xdr_args,caddr_t argsp,xdrproc_t xdr_results,caddr_t resultsp,struct timeval wait,struct netbuf * sin)455 clnt_clts_kcallit_addr(CLIENT *h, rpcproc_t procnum, xdrproc_t xdr_args,
456 	caddr_t argsp, xdrproc_t xdr_results, caddr_t resultsp,
457 	struct timeval wait, struct netbuf *sin)
458 {
459 	/* LINTED pointer alignment */
460 	struct cku_private *p = htop(h);
461 	XDR *xdrs;
462 	int stries = p->cku_retrys;
463 	int refreshes = REFRESHES;	/* number of times to refresh cred */
464 	int round_trip;			/* time the RPC */
465 	int error;
466 	mblk_t *mp;
467 	mblk_t *mpdup;
468 	mblk_t *resp = NULL;
469 	mblk_t *tmp;
470 	calllist_t *call = &p->cku_call;
471 	clock_t ori_timout, timout;
472 	bool_t interrupted;
473 	enum clnt_stat status;
474 	struct rpc_msg reply_msg;
475 	enum clnt_stat re_status;
476 	endpnt_t *endpt;
477 
478 	RCSTAT_INCR(p->cku_stats, rccalls);
479 
480 	RPCLOG(2, "clnt_clts_kcallit_addr: wait.tv_sec: %ld\n", wait.tv_sec);
481 	RPCLOG(2, "clnt_clts_kcallit_addr: wait.tv_usec: %ld\n", wait.tv_usec);
482 
483 	timout = TIMEVAL_TO_TICK(&wait);
484 	ori_timout = timout;
485 
486 	if (p->cku_xid == 0) {
487 		p->cku_xid = alloc_xid();
488 		if (p->cku_endpnt != NULL)
489 			endpnt_rele(p->cku_endpnt);
490 		p->cku_endpnt = NULL;
491 	}
492 	call->call_zoneid = rpc_zoneid();
493 
494 	mpdup = NULL;
495 call_again:
496 
497 	if (mpdup == NULL) {
498 
499 		while ((mp = allocb(CKU_INITSIZE, BPRI_LO)) == NULL) {
500 			if (strwaitbuf(CKU_INITSIZE, BPRI_LO)) {
501 				p->cku_err.re_status = RPC_SYSTEMERROR;
502 				p->cku_err.re_errno = ENOSR;
503 				goto done;
504 			}
505 		}
506 
507 		xdrs = &p->cku_outxdr;
508 		xdrmblk_init(xdrs, mp, XDR_ENCODE, CKU_ALLOCSIZE);
509 
510 		if (h->cl_auth->ah_cred.oa_flavor != RPCSEC_GSS) {
511 			/*
512 			 * Copy in the preserialized RPC header
513 			 * information.
514 			 */
515 			bcopy(p->cku_rpchdr, mp->b_rptr, CKU_HDRSIZE);
516 
517 			/*
518 			 * transaction id is the 1st thing in the output
519 			 * buffer.
520 			 */
521 			/* LINTED pointer alignment */
522 			(*(uint32_t *)(mp->b_rptr)) = p->cku_xid;
523 
524 			/* Skip the preserialized stuff. */
525 			XDR_SETPOS(xdrs, CKU_HDRSIZE);
526 
527 			/* Serialize dynamic stuff into the output buffer. */
528 			if ((!XDR_PUTINT32(xdrs, (int32_t *)&procnum)) ||
529 			    (!AUTH_MARSHALL(h->cl_auth, xdrs, p->cku_cred)) ||
530 			    (!(*xdr_args)(xdrs, argsp))) {
531 				freemsg(mp);
532 				p->cku_err.re_status = RPC_CANTENCODEARGS;
533 				p->cku_err.re_errno = EIO;
534 				goto done;
535 			}
536 		} else {
537 			uint32_t *uproc = (uint32_t *)
538 			    &p->cku_rpchdr[CKU_HDRSIZE];
539 			IXDR_PUT_U_INT32(uproc, procnum);
540 
541 			(*(uint32_t *)(&p->cku_rpchdr[0])) = p->cku_xid;
542 			XDR_SETPOS(xdrs, 0);
543 
544 			/* Serialize the procedure number and the arguments. */
545 			if (!AUTH_WRAP(h->cl_auth, (caddr_t)p->cku_rpchdr,
546 			    CKU_HDRSIZE+4, xdrs, xdr_args, argsp)) {
547 				freemsg(mp);
548 				p->cku_err.re_status = RPC_CANTENCODEARGS;
549 				p->cku_err.re_errno = EIO;
550 				goto done;
551 			}
552 		}
553 	} else
554 		mp = mpdup;
555 
556 	mpdup = dupmsg(mp);
557 	if (mpdup == NULL) {
558 		freemsg(mp);
559 		p->cku_err.re_status = RPC_SYSTEMERROR;
560 		p->cku_err.re_errno = ENOSR;
561 		goto done;
562 	}
563 
564 	/*
565 	 * Grab an endpnt only if the endpoint is NULL.  We could be retrying
566 	 * the request and in this case we want to go through the same
567 	 * source port, so that the duplicate request cache may detect a
568 	 * retry.
569 	 */
570 
571 	if (p->cku_endpnt == NULL)
572 		p->cku_endpnt = endpnt_get(&p->cku_config, p->cku_useresvport);
573 
574 	if (p->cku_endpnt == NULL) {
575 		freemsg(mp);
576 		p->cku_err.re_status = RPC_SYSTEMERROR;
577 		p->cku_err.re_errno = ENOSR;
578 		goto done;
579 	}
580 
581 	round_trip = ddi_get_lbolt();
582 
583 	error = clnt_clts_dispatch_send(p->cku_endpnt->e_wq, mp,
584 	    &p->cku_addr, call, p->cku_xid, p->cku_cred);
585 
586 	if (error != 0) {
587 		freemsg(mp);
588 		p->cku_err.re_status = RPC_CANTSEND;
589 		p->cku_err.re_errno = error;
590 		RCSTAT_INCR(p->cku_stats, rccantsend);
591 		goto done1;
592 	}
593 
594 	RPCLOG(64, "clnt_clts_kcallit_addr: sent call for xid 0x%x\n",
595 	    p->cku_xid);
596 
597 	/*
598 	 * There are two reasons for which we go back to to tryread.
599 	 *
600 	 * a) In case the status is RPC_PROCUNAVAIL and we sent out a
601 	 *    broadcast we should not get any invalid messages with the
602 	 *    RPC_PROCUNAVAIL error back. Some broken RPC implementations
603 	 *    send them and for this we have to ignore them ( as we would
604 	 *    have never received them ) and look for another message
605 	 *    which might contain the valid response because we don't know
606 	 *    how many broken implementations are in the network. So we are
607 	 *    going to loop until
608 	 *    - we received a valid response
609 	 *    - we have processed all invalid responses and
610 	 *	got a time out when we try to receive again a
611 	 *	message.
612 	 *
613 	 * b) We will jump back to tryread also in case we failed
614 	 *    within the AUTH_VALIDATE. In this case we should move
615 	 *    on and loop until we received a valid response or we
616 	 *    have processed all responses with broken authentication
617 	 *    and we got a time out when we try to receive a message.
618 	 */
619 tryread:
620 	mutex_enter(&call->call_lock);
621 	interrupted = FALSE;
622 	if (call->call_notified == FALSE) {
623 		klwp_t *lwp = ttolwp(curthread);
624 		clock_t cv_wait_ret = 1; /* init to > 0 */
625 		clock_t cv_timout = timout;
626 
627 		if (lwp != NULL)
628 			lwp->lwp_nostop++;
629 
630 		cv_timout += ddi_get_lbolt();
631 
632 		if (h->cl_nosignal)
633 			while ((cv_wait_ret =
634 			    cv_timedwait(&call->call_cv,
635 			    &call->call_lock, cv_timout)) > 0 &&
636 			    call->call_notified == FALSE)
637 				;
638 		else
639 			while ((cv_wait_ret =
640 			    cv_timedwait_sig(&call->call_cv,
641 			    &call->call_lock, cv_timout)) > 0 &&
642 			    call->call_notified == FALSE)
643 				;
644 
645 		if (cv_wait_ret == 0)
646 			interrupted = TRUE;
647 
648 		if (lwp != NULL)
649 			lwp->lwp_nostop--;
650 	}
651 	resp = call->call_reply;
652 	call->call_reply = NULL;
653 	status = call->call_status;
654 	/*
655 	 * We have to reset the call_notified here. In case we have
656 	 * to do a retry ( e.g. in case we got a RPC_PROCUNAVAIL
657 	 * error ) we need to set this to false to ensure that
658 	 * we will wait for the next message. When the next message
659 	 * is going to arrive the function clnt_clts_dispatch_notify
660 	 * will set this to true again.
661 	 */
662 	call->call_notified = FALSE;
663 	call->call_status = RPC_TIMEDOUT;
664 	mutex_exit(&call->call_lock);
665 
666 	if (status == RPC_TIMEDOUT) {
667 		if (interrupted) {
668 			/*
669 			 * We got interrupted, bail out
670 			 */
671 			p->cku_err.re_status = RPC_INTR;
672 			p->cku_err.re_errno = EINTR;
673 			goto done1;
674 		} else {
675 			RPCLOG(8, "clnt_clts_kcallit_addr: "
676 			    "request w/xid 0x%x timedout "
677 			    "waiting for reply\n", p->cku_xid);
678 #if 0 /* XXX not yet */
679 			/*
680 			 * Timeout may be due to a dead gateway. Send
681 			 * an ioctl downstream advising deletion of
682 			 * route when we reach the half-way point to
683 			 * timing out.
684 			 */
685 			if (stries == p->cku_retrys/2) {
686 				t_kadvise(p->cku_endpnt->e_tiptr,
687 				    (uchar_t *)p->cku_addr.buf,
688 				    p->cku_addr.len);
689 			}
690 #endif /* not yet */
691 			p->cku_err.re_status = RPC_TIMEDOUT;
692 			p->cku_err.re_errno = ETIMEDOUT;
693 			RCSTAT_INCR(p->cku_stats, rctimeouts);
694 			goto done1;
695 		}
696 	}
697 
698 	ASSERT(resp != NULL);
699 
700 	/*
701 	 * Prepare the message for further processing.  We need to remove
702 	 * the datagram header and copy the source address if necessary.  No
703 	 * need to verify the header since rpcmod took care of that.
704 	 */
705 	/*
706 	 * Copy the source address if the caller has supplied a netbuf.
707 	 */
708 	if (sin != NULL) {
709 		union T_primitives *pptr;
710 
711 		pptr = (union T_primitives *)resp->b_rptr;
712 		bcopy(resp->b_rptr + pptr->unitdata_ind.SRC_offset, sin->buf,
713 		    pptr->unitdata_ind.SRC_length);
714 		sin->len = pptr->unitdata_ind.SRC_length;
715 	}
716 
717 	/*
718 	 * Pop off the datagram header.
719 	 * It was retained in rpcmodrput().
720 	 */
721 	tmp = resp;
722 	resp = resp->b_cont;
723 	tmp->b_cont = NULL;
724 	freeb(tmp);
725 
726 	round_trip = ddi_get_lbolt() - round_trip;
727 	/*
728 	 * Van Jacobson timer algorithm here, only if NOT a retransmission.
729 	 */
730 	if (p->cku_timers != NULL && stries == p->cku_retrys) {
731 		int rt;
732 
733 		rt = round_trip;
734 		rt -= (p->cku_timers->rt_srtt >> 3);
735 		p->cku_timers->rt_srtt += rt;
736 		if (rt < 0)
737 			rt = - rt;
738 		rt -= (p->cku_timers->rt_deviate >> 2);
739 		p->cku_timers->rt_deviate += rt;
740 		p->cku_timers->rt_rtxcur =
741 		    (clock_t)((p->cku_timers->rt_srtt >> 2) +
742 		    p->cku_timers->rt_deviate) >> 1;
743 
744 		rt = round_trip;
745 		rt -= (p->cku_timeall->rt_srtt >> 3);
746 		p->cku_timeall->rt_srtt += rt;
747 		if (rt < 0)
748 			rt = - rt;
749 		rt -= (p->cku_timeall->rt_deviate >> 2);
750 		p->cku_timeall->rt_deviate += rt;
751 		p->cku_timeall->rt_rtxcur =
752 		    (clock_t)((p->cku_timeall->rt_srtt >> 2) +
753 		    p->cku_timeall->rt_deviate) >> 1;
754 		if (p->cku_feedback != NULL) {
755 			(*p->cku_feedback)(FEEDBACK_OK, procnum,
756 			    p->cku_feedarg);
757 		}
758 	}
759 
760 	/*
761 	 * Process reply
762 	 */
763 	xdrs = &(p->cku_inxdr);
764 	xdrmblk_init(xdrs, resp, XDR_DECODE, 0);
765 
766 	reply_msg.rm_direction = REPLY;
767 	reply_msg.rm_reply.rp_stat = MSG_ACCEPTED;
768 	reply_msg.acpted_rply.ar_stat = SUCCESS;
769 	reply_msg.acpted_rply.ar_verf = _null_auth;
770 	/*
771 	 *  xdr_results will be done in AUTH_UNWRAP.
772 	 */
773 	reply_msg.acpted_rply.ar_results.where = NULL;
774 	reply_msg.acpted_rply.ar_results.proc = xdr_void;
775 
776 	/*
777 	 * Decode and validate the response.
778 	 */
779 	if (!xdr_replymsg(xdrs, &reply_msg)) {
780 		p->cku_err.re_status = RPC_CANTDECODERES;
781 		p->cku_err.re_errno = EIO;
782 		(void) xdr_rpc_free_verifier(xdrs, &reply_msg);
783 		goto done1;
784 	}
785 
786 	_seterr_reply(&reply_msg, &(p->cku_err));
787 
788 	re_status = p->cku_err.re_status;
789 	if (re_status == RPC_SUCCESS) {
790 		/*
791 		 * Reply is good, check auth.
792 		 */
793 		if (!AUTH_VALIDATE(h->cl_auth,
794 		    &reply_msg.acpted_rply.ar_verf)) {
795 			p->cku_err.re_status = RPC_AUTHERROR;
796 			p->cku_err.re_why = AUTH_INVALIDRESP;
797 			RCSTAT_INCR(p->cku_stats, rcbadverfs);
798 			(void) xdr_rpc_free_verifier(xdrs, &reply_msg);
799 			goto tryread;
800 		}
801 		if (!AUTH_UNWRAP(h->cl_auth, xdrs, xdr_results, resultsp)) {
802 			p->cku_err.re_status = RPC_CANTDECODERES;
803 			p->cku_err.re_errno = EIO;
804 		}
805 		(void) xdr_rpc_free_verifier(xdrs, &reply_msg);
806 		goto done1;
807 	}
808 	/* set errno in case we can't recover */
809 	if (re_status != RPC_VERSMISMATCH &&
810 	    re_status != RPC_AUTHERROR && re_status != RPC_PROGVERSMISMATCH)
811 		p->cku_err.re_errno = EIO;
812 	/*
813 	 * Determine whether or not we're doing an RPC
814 	 * broadcast. Some server implementations don't
815 	 * follow RFC 1050, section 7.4.2 in that they
816 	 * don't remain silent when they see a proc
817 	 * they don't support. Therefore we keep trying
818 	 * to receive on RPC_PROCUNAVAIL, hoping to get
819 	 * a valid response from a compliant server.
820 	 */
821 	if (re_status == RPC_PROCUNAVAIL && p->cku_bcast) {
822 		(void) xdr_rpc_free_verifier(xdrs, &reply_msg);
823 		goto tryread;
824 	}
825 	if (re_status == RPC_AUTHERROR) {
826 
827 		(void) xdr_rpc_free_verifier(xdrs, &reply_msg);
828 		call_table_remove(call);
829 		if (call->call_reply != NULL) {
830 			freemsg(call->call_reply);
831 			call->call_reply = NULL;
832 		}
833 
834 		/*
835 		 * Maybe our credential need to be refreshed
836 		 */
837 		if (refreshes > 0 &&
838 		    AUTH_REFRESH(h->cl_auth, &reply_msg, p->cku_cred)) {
839 			/*
840 			 * The credential is refreshed. Try the request again.
841 			 * Even if stries == 0, we still retry as long as
842 			 * refreshes > 0. This prevents a soft authentication
843 			 * error turning into a hard one at an upper level.
844 			 */
845 			refreshes--;
846 			RCSTAT_INCR(p->cku_stats, rcbadcalls);
847 			RCSTAT_INCR(p->cku_stats, rcnewcreds);
848 
849 			freemsg(mpdup);
850 			mpdup = NULL;
851 			freemsg(resp);
852 			resp = NULL;
853 			goto call_again;
854 		}
855 		/*
856 		 * We have used the client handle to do an AUTH_REFRESH
857 		 * and the RPC status may be set to RPC_SUCCESS;
858 		 * Let's make sure to set it to RPC_AUTHERROR.
859 		 */
860 		p->cku_err.re_status = RPC_CANTDECODERES;
861 
862 		/*
863 		 * Map recoverable and unrecoverable
864 		 * authentication errors to appropriate errno
865 		 */
866 		switch (p->cku_err.re_why) {
867 		case AUTH_TOOWEAK:
868 			/*
869 			 * Could be an nfsportmon failure, set
870 			 * useresvport and try again.
871 			 */
872 			if (p->cku_useresvport != 1) {
873 				p->cku_useresvport = 1;
874 
875 				freemsg(mpdup);
876 				mpdup = NULL;
877 				freemsg(resp);
878 				resp = NULL;
879 
880 				endpt = p->cku_endpnt;
881 				if (endpt->e_tiptr != NULL) {
882 					mutex_enter(&endpt->e_lock);
883 					endpt->e_flags &= ~ENDPNT_BOUND;
884 					(void) t_kclose(endpt->e_tiptr, 1);
885 					endpt->e_tiptr = NULL;
886 					mutex_exit(&endpt->e_lock);
887 
888 				}
889 
890 				p->cku_xid = alloc_xid();
891 				endpnt_rele(p->cku_endpnt);
892 				p->cku_endpnt = NULL;
893 				goto call_again;
894 			}
895 			/* FALLTHRU */
896 		case AUTH_BADCRED:
897 		case AUTH_BADVERF:
898 		case AUTH_INVALIDRESP:
899 		case AUTH_FAILED:
900 		case RPCSEC_GSS_NOCRED:
901 		case RPCSEC_GSS_FAILED:
902 			p->cku_err.re_errno = EACCES;
903 			break;
904 		case AUTH_REJECTEDCRED:
905 		case AUTH_REJECTEDVERF:
906 		default:
907 			p->cku_err.re_errno = EIO;
908 			break;
909 		}
910 		RPCLOG(1, "clnt_clts_kcallit : authentication failed "
911 		    "with RPC_AUTHERROR of type %d\n",
912 		    p->cku_err.re_why);
913 		goto done;
914 	}
915 
916 	(void) xdr_rpc_free_verifier(xdrs, &reply_msg);
917 
918 done1:
919 	call_table_remove(call);
920 	if (call->call_reply != NULL) {
921 		freemsg(call->call_reply);
922 		call->call_reply = NULL;
923 	}
924 	RPCLOG(64, "clnt_clts_kcallit_addr: xid 0x%x taken off dispatch list",
925 	    p->cku_xid);
926 
927 done:
928 	if (resp != NULL) {
929 		freemsg(resp);
930 		resp = NULL;
931 	}
932 
933 	if ((p->cku_err.re_status != RPC_SUCCESS) &&
934 	    (p->cku_err.re_status != RPC_INTR) &&
935 	    (p->cku_err.re_status != RPC_UDERROR) &&
936 	    !IS_UNRECOVERABLE_RPC(p->cku_err.re_status)) {
937 		if (p->cku_feedback != NULL && stries == p->cku_retrys) {
938 			(*p->cku_feedback)(FEEDBACK_REXMIT1, procnum,
939 			    p->cku_feedarg);
940 		}
941 
942 		timout = backoff(timout);
943 		if (p->cku_timeall != (struct rpc_timers *)0)
944 			p->cku_timeall->rt_rtxcur = timout;
945 
946 		if (p->cku_err.re_status == RPC_SYSTEMERROR ||
947 		    p->cku_err.re_status == RPC_CANTSEND) {
948 			/*
949 			 * Errors due to lack of resources, wait a bit
950 			 * and try again.
951 			 */
952 			(void) delay(hz/10);
953 		}
954 		if (stries-- > 0) {
955 			RCSTAT_INCR(p->cku_stats, rcretrans);
956 			goto call_again;
957 		}
958 	}
959 
960 	if (mpdup != NULL)
961 		freemsg(mpdup);
962 
963 	if (p->cku_err.re_status != RPC_SUCCESS) {
964 		RCSTAT_INCR(p->cku_stats, rcbadcalls);
965 	}
966 
967 	/*
968 	 * Allow the endpoint to be held by the client handle in case this
969 	 * RPC was not successful.  A retry may occur at a higher level and
970 	 * in this case we may want to send the request over the same
971 	 * source port.
972 	 * Endpoint is also released for one-way RPC: no reply, nor retransmit
973 	 * is expected.
974 	 */
975 	if ((p->cku_err.re_status == RPC_SUCCESS ||
976 	    (p->cku_err.re_status == RPC_TIMEDOUT && ori_timout == 0)) &&
977 	    p->cku_endpnt != NULL) {
978 		endpnt_rele(p->cku_endpnt);
979 		p->cku_endpnt = NULL;
980 	} else {
981 		DTRACE_PROBE2(clnt_clts_kcallit_done, int, p->cku_err.re_status,
982 		    struct endpnt *, p->cku_endpnt);
983 	}
984 
985 	return (p->cku_err.re_status);
986 }
987 
988 static enum clnt_stat
clnt_clts_kcallit(CLIENT * h,rpcproc_t procnum,xdrproc_t xdr_args,caddr_t argsp,xdrproc_t xdr_results,caddr_t resultsp,struct timeval wait)989 clnt_clts_kcallit(CLIENT *h, rpcproc_t procnum, xdrproc_t xdr_args,
990 	caddr_t argsp, xdrproc_t xdr_results, caddr_t resultsp,
991 	struct timeval wait)
992 {
993 	return (clnt_clts_kcallit_addr(h, procnum, xdr_args, argsp,
994 	    xdr_results, resultsp, wait, NULL));
995 }
996 
997 /*
998  * Return error info on this handle.
999  */
1000 static void
clnt_clts_kerror(CLIENT * h,struct rpc_err * err)1001 clnt_clts_kerror(CLIENT *h, struct rpc_err *err)
1002 {
1003 	/* LINTED pointer alignment */
1004 	struct cku_private *p = htop(h);
1005 
1006 	*err = p->cku_err;
1007 }
1008 
1009 static bool_t
clnt_clts_kfreeres(CLIENT * h,xdrproc_t xdr_res,caddr_t res_ptr)1010 clnt_clts_kfreeres(CLIENT *h, xdrproc_t xdr_res, caddr_t res_ptr)
1011 {
1012 	/* LINTED pointer alignment */
1013 	struct cku_private *p = htop(h);
1014 	XDR *xdrs;
1015 
1016 	xdrs = &(p->cku_outxdr);
1017 	xdrs->x_op = XDR_FREE;
1018 	return ((*xdr_res)(xdrs, res_ptr));
1019 }
1020 
1021 /*ARGSUSED*/
1022 static void
clnt_clts_kabort(CLIENT * h)1023 clnt_clts_kabort(CLIENT *h)
1024 {
1025 }
1026 
1027 static bool_t
clnt_clts_kcontrol(CLIENT * h,int cmd,char * arg)1028 clnt_clts_kcontrol(CLIENT *h, int cmd, char *arg)
1029 {
1030 	/* LINTED pointer alignment */
1031 	struct cku_private *p = htop(h);
1032 
1033 	switch (cmd) {
1034 	case CLSET_XID:
1035 		p->cku_xid = *((uint32_t *)arg);
1036 		return (TRUE);
1037 
1038 	case CLGET_XID:
1039 		*((uint32_t *)arg) = p->cku_xid;
1040 		return (TRUE);
1041 
1042 	case CLSET_BCAST:
1043 		p->cku_bcast = *((uint32_t *)arg);
1044 		return (TRUE);
1045 
1046 	case CLGET_BCAST:
1047 		*((uint32_t *)arg) = p->cku_bcast;
1048 		return (TRUE);
1049 	case CLSET_BINDRESVPORT:
1050 		if (arg == NULL)
1051 			return (FALSE);
1052 
1053 		if (*(int *)arg != 1 && *(int *)arg != 0)
1054 			return (FALSE);
1055 
1056 		p->cku_useresvport = *(int *)arg;
1057 
1058 		return (TRUE);
1059 
1060 	case CLGET_BINDRESVPORT:
1061 		if (arg == NULL)
1062 			return (FALSE);
1063 
1064 		*(int *)arg = p->cku_useresvport;
1065 
1066 		return (TRUE);
1067 
1068 	default:
1069 		return (FALSE);
1070 	}
1071 }
1072 
1073 /*
1074  * Destroy rpc handle.
1075  * Frees the space used for output buffer, private data, and handle
1076  * structure, and the file pointer/TLI data on last reference.
1077  */
1078 static void
clnt_clts_kdestroy(CLIENT * h)1079 clnt_clts_kdestroy(CLIENT *h)
1080 {
1081 	/* LINTED pointer alignment */
1082 	struct cku_private *p = htop(h);
1083 	calllist_t *call = &p->cku_call;
1084 
1085 	int plen;
1086 
1087 	RPCLOG(8, "clnt_clts_kdestroy h: %p\n", (void *)h);
1088 	RPCLOG(8, "clnt_clts_kdestroy h: xid=0x%x\n", p->cku_xid);
1089 
1090 	if (p->cku_endpnt != NULL)
1091 		endpnt_rele(p->cku_endpnt);
1092 
1093 	cv_destroy(&call->call_cv);
1094 	mutex_destroy(&call->call_lock);
1095 
1096 	plen = strlen(p->cku_config.knc_protofmly) + 1;
1097 	kmem_free(p->cku_config.knc_protofmly, plen);
1098 	kmem_free(p->cku_addr.buf, p->cku_addr.maxlen);
1099 	kmem_free(p, sizeof (*p));
1100 }
1101 
1102 /*
1103  * The connectionless (CLTS) kRPC endpoint management subsystem.
1104  *
1105  * Because endpoints are potentially shared among threads making RPC calls,
1106  * they are managed in a pool according to type (endpnt_type_t).  Each
1107  * endpnt_type_t points to a list of usable endpoints through the e_pool
1108  * field, which is of type list_t.  list_t is a doubly-linked list.
1109  * The number of endpoints in the pool is stored in the e_cnt field of
1110  * endpnt_type_t and the endpoints are reference counted using the e_ref field
1111  * in the endpnt_t structure.
1112  *
1113  * As an optimization, endpoints that have no references are also linked
1114  * to an idle list via e_ilist which is also of type list_t.  When a thread
1115  * calls endpnt_get() to obtain a transport endpoint, the idle list is first
1116  * consulted and if such an endpoint exists, it is removed from the idle list
1117  * and returned to the caller.
1118  *
1119  * If the idle list is empty, then a check is made to see if more endpoints
1120  * can be created.  If so, we proceed and create a new endpoint which is added
1121  * to the pool and returned to the caller.  If we have reached the limit and
1122  * cannot make a new endpoint then one is returned to the caller via round-
1123  * robin policy.
1124  *
1125  * When an endpoint is placed on the idle list by a thread calling
1126  * endpnt_rele(), it is timestamped and then a reaper taskq is scheduled to
1127  * be dispatched if one hasn't already been.  When the timer fires, the
1128  * taskq traverses the idle list and checks to see which endpoints are
1129  * eligible to be closed.  It determines this by checking if the timestamp
1130  * when the endpoint was released has exceeded the the threshold for how long
1131  * it should stay alive.
1132  *
1133  * endpnt_t structures remain persistent until the memory reclaim callback,
1134  * endpnt_reclaim(), is invoked.
1135  *
1136  * Here is an example of how the data structures would be laid out by the
1137  * subsystem:
1138  *
1139  *       endpnt_type_t
1140  *
1141  *	 loopback		                  inet
1142  *	 _______________	                  ______________
1143  *	| e_next        |----------------------->| e_next       |---->>
1144  *	| e_pool        |<---+                   | e_pool       |<----+
1145  *	| e_ilist       |<---+--+                | e_ilist      |<----+--+
1146  *   +->| e_pcurr       |----+--+--+	      +->| e_pcurr      |-----+--+--+
1147  *   |	| ...           |    |  |  |	      |	 | ...	        |     |  |  |
1148  *   |	| e_itimer (90) |    |  |  |	      |	 | e_itimer (0) |     |  |  |
1149  *   |	| e_cnt (1)     |    |  |  |	      |	 | e_cnt (3)    |     |  |  |
1150  *   |	+---------------+    |  |  |	      |	 +--------------+     |  |  |
1151  *   |			     |  |  |	      |			      |  |  |
1152  *   |   endpnt_t            |  |  |          |	                      |  |  |
1153  *   |	 ____________        |  |  |	      |	  ____________        |  |  |
1154  *   |	| e_node     |<------+  |  |	      |	 | e_node     |<------+  |  |
1155  *   |	| e_idle     |<---------+  |	      |	 | e_idle     |       |  |  |
1156  *   +--| e_type     |<------------+	      +--| e_type     |       |  |  |
1157  *	| e_tiptr    |                        |  | e_tiptr    |       |  |  |
1158  *      | ...	     |		              |	 | ...	      |       |  |  |
1159  *	| e_lock     |		              |	 | e_lock     |       |  |  |
1160  *	| ...        |		              |	 | ...	      |       |  |  |
1161  *      | e_ref (0)  |		              |	 | e_ref (2)  |       |  |  |
1162  *	| e_itime    |	                      |	 | e_itime    |       |  |  |
1163  *	+------------+		              |	 +------------+       |  |  |
1164  *					      |			      |  |  |
1165  *					      |			      |  |  |
1166  *					      |	  ____________        |  |  |
1167  *					      |	 | e_node     |<------+  |  |
1168  *					      |	 | e_idle     |<------+--+  |
1169  *					      +--| e_type     |       |     |
1170  *					      |	 | e_tiptr    |       |     |
1171  *					      |	 | ...	      |       |     |
1172  *					      |	 | e_lock     |       |     |
1173  *					      |	 | ...	      |       |     |
1174  *					      |	 | e_ref (0)  |       |     |
1175  *					      |	 | e_itime    |       |     |
1176  *					      |	 +------------+       |     |
1177  *					      |			      |     |
1178  *					      |			      |     |
1179  *					      |	  ____________        |     |
1180  *					      |	 | e_node     |<------+     |
1181  *					      |	 | e_idle     |             |
1182  *					      +--| e_type     |<------------+
1183  *						 | e_tiptr    |
1184  *						 | ...	      |
1185  *						 | e_lock     |
1186  *						 | ...	      |
1187  *						 | e_ref (1)  |
1188  *						 | e_itime    |
1189  *						 +------------+
1190  *
1191  * Endpoint locking strategy:
1192  *
1193  * The following functions manipulate lists which hold the endpoint and the
1194  * endpoints themselves:
1195  *
1196  * endpnt_get()/check_endpnt()/endpnt_rele()/endpnt_reap()/do_endpnt_reclaim()
1197  *
1198  * Lock description follows:
1199  *
1200  * endpnt_type_lock: Global reader/writer lock which protects accesses to the
1201  *		     endpnt_type_list.
1202  *
1203  * e_plock: Lock defined in the endpnt_type_t.  It is intended to
1204  *	    protect accesses to the pool of endopints (e_pool) for a given
1205  *	    endpnt_type_t.
1206  *
1207  * e_ilock: Lock defined in endpnt_type_t.  It is intended to protect accesses
1208  *	    to the idle list (e_ilist) of available endpoints for a given
1209  *	    endpnt_type_t.  It also protects access to the e_itimer, e_async_cv,
1210  *	    and e_async_count fields in endpnt_type_t.
1211  *
1212  * e_lock: Lock defined in the endpnt structure.  It is intended to protect
1213  *	   flags, cv, and ref count.
1214  *
1215  * The order goes as follows so as not to induce deadlock.
1216  *
1217  * endpnt_type_lock -> e_plock -> e_ilock -> e_lock
1218  *
1219  * Interaction with Zones and shutting down:
1220  *
1221  * endpnt_type_ts are uniquely identified by the (e_zoneid, e_rdev, e_protofmly)
1222  * tuple, which means that a zone may not reuse another zone's idle endpoints
1223  * without first doing a t_kclose().
1224  *
1225  * A zone's endpnt_type_ts are destroyed when a zone is shut down; e_async_cv
1226  * and e_async_count are used to keep track of the threads in endpnt_taskq
1227  * trying to reap endpnt_ts in the endpnt_type_t.
1228  */
1229 
1230 /*
1231  * Allocate and initialize an endpnt_type_t
1232  */
1233 static struct endpnt_type *
endpnt_type_create(struct knetconfig * config)1234 endpnt_type_create(struct knetconfig *config)
1235 {
1236 	struct endpnt_type	*etype;
1237 
1238 	/*
1239 	 * Allocate a new endpoint type to hang a list of
1240 	 * endpoints off of it.
1241 	 */
1242 	etype = kmem_alloc(sizeof (struct endpnt_type), KM_SLEEP);
1243 	etype->e_next = NULL;
1244 	etype->e_pcurr = NULL;
1245 	etype->e_itimer = 0;
1246 	etype->e_cnt = 0;
1247 
1248 	(void) strncpy(etype->e_protofmly, config->knc_protofmly, KNC_STRSIZE);
1249 	mutex_init(&etype->e_plock, NULL, MUTEX_DEFAULT, NULL);
1250 	mutex_init(&etype->e_ilock, NULL, MUTEX_DEFAULT, NULL);
1251 	etype->e_rdev = config->knc_rdev;
1252 	etype->e_zoneid = rpc_zoneid();
1253 	etype->e_async_count = 0;
1254 	cv_init(&etype->e_async_cv, NULL, CV_DEFAULT, NULL);
1255 
1256 	list_create(&etype->e_pool, sizeof (endpnt_t),
1257 	    offsetof(endpnt_t, e_node));
1258 	list_create(&etype->e_ilist, sizeof (endpnt_t),
1259 	    offsetof(endpnt_t, e_idle));
1260 
1261 	/*
1262 	 * Check to see if we need to create a taskq for endpoint
1263 	 * reaping
1264 	 */
1265 	mutex_enter(&endpnt_taskq_lock);
1266 	if (taskq_created == FALSE) {
1267 		taskq_created = TRUE;
1268 		mutex_exit(&endpnt_taskq_lock);
1269 		ASSERT(endpnt_taskq == NULL);
1270 		endpnt_taskq = taskq_create("clts_endpnt_taskq", 1,
1271 		    minclsyspri, 200, INT_MAX, 0);
1272 	} else
1273 		mutex_exit(&endpnt_taskq_lock);
1274 
1275 	return (etype);
1276 }
1277 
1278 /*
1279  * Free an endpnt_type_t
1280  */
1281 static void
endpnt_type_free(struct endpnt_type * etype)1282 endpnt_type_free(struct endpnt_type *etype)
1283 {
1284 	mutex_destroy(&etype->e_plock);
1285 	mutex_destroy(&etype->e_ilock);
1286 	list_destroy(&etype->e_pool);
1287 	list_destroy(&etype->e_ilist);
1288 	kmem_free(etype, sizeof (endpnt_type_t));
1289 }
1290 
1291 /*
1292  * Check the endpoint to ensure that it is suitable for use.
1293  *
1294  * Possible return values:
1295  *
1296  * return (1) - Endpoint is established, but needs to be re-opened.
1297  * return (0) && *newp == NULL - Endpoint is established, but unusable.
1298  * return (0) && *newp != NULL - Endpoint is established and usable.
1299  */
1300 static int
check_endpnt(struct endpnt * endp,struct endpnt ** newp)1301 check_endpnt(struct endpnt *endp, struct endpnt **newp)
1302 {
1303 	*newp = endp;
1304 
1305 	mutex_enter(&endp->e_lock);
1306 	ASSERT(endp->e_ref >= 1);
1307 
1308 	/*
1309 	 * The first condition we check for is if the endpoint has been
1310 	 * allocated, but is unusable either because it has been closed or
1311 	 * has been marked stale.  Only *one* thread will be allowed to
1312 	 * execute the then clause.  This is enforced because the first thread
1313 	 * to check this condition will clear the flags, so that subsequent
1314 	 * thread(s) checking this endpoint will move on.
1315 	 */
1316 	if ((endp->e_flags & ENDPNT_ESTABLISHED) &&
1317 	    (!(endp->e_flags & ENDPNT_BOUND) ||
1318 	    (endp->e_flags & ENDPNT_STALE))) {
1319 		/*
1320 		 * Clear the flags here since they will be
1321 		 * set again by this thread.  They need to be
1322 		 * individually cleared because we want to maintain
1323 		 * the state for ENDPNT_ONIDLE.
1324 		 */
1325 		endp->e_flags &= ~(ENDPNT_ESTABLISHED |
1326 		    ENDPNT_WAITING | ENDPNT_BOUND | ENDPNT_STALE);
1327 		mutex_exit(&endp->e_lock);
1328 		return (1);
1329 	}
1330 
1331 	/*
1332 	 * The second condition is meant for any thread that is waiting for
1333 	 * an endpoint to become established.  It will cv_wait() until
1334 	 * the condition for the endpoint has been changed to ENDPNT_BOUND or
1335 	 * ENDPNT_STALE.
1336 	 */
1337 	while (!(endp->e_flags & ENDPNT_BOUND) &&
1338 	    !(endp->e_flags & ENDPNT_STALE)) {
1339 		endp->e_flags |= ENDPNT_WAITING;
1340 		cv_wait(&endp->e_cv, &endp->e_lock);
1341 	}
1342 
1343 	ASSERT(endp->e_flags & ENDPNT_ESTABLISHED);
1344 
1345 	/*
1346 	 * The last case we check for is if the endpoint has been marked stale.
1347 	 * If this is the case then set *newp to NULL and return, so that the
1348 	 * caller is notified of the error and can take appropriate action.
1349 	 */
1350 	if (endp->e_flags & ENDPNT_STALE) {
1351 		endp->e_ref--;
1352 		*newp = NULL;
1353 	}
1354 	mutex_exit(&endp->e_lock);
1355 	return (0);
1356 }
1357 
1358 #ifdef DEBUG
1359 /*
1360  * Provide a fault injection setting to test error conditions.
1361  */
1362 static int endpnt_get_return_null = 0;
1363 #endif
1364 
1365 /*
1366  * Returns a handle (struct endpnt *) to an open and bound endpoint
1367  * specified by the knetconfig passed in.  Returns NULL if no valid endpoint
1368  * can be obtained.
1369  */
1370 static struct endpnt *
endpnt_get(struct knetconfig * config,int useresvport)1371 endpnt_get(struct knetconfig *config, int useresvport)
1372 {
1373 	struct endpnt_type	*n_etype = NULL;
1374 	struct endpnt_type	*np = NULL;
1375 	struct endpnt		*new = NULL;
1376 	struct endpnt		*endp = NULL;
1377 	struct endpnt		*next = NULL;
1378 	TIUSER			*tiptr = NULL;
1379 	int			rtries = BINDRESVPORT_RETRIES;
1380 	int			i = 0;
1381 	int			error;
1382 	int			retval;
1383 	zoneid_t		zoneid = rpc_zoneid();
1384 	cred_t			*cr;
1385 
1386 	RPCLOG(1, "endpnt_get: protofmly %s, ", config->knc_protofmly);
1387 	RPCLOG(1, "rdev %ld\n", config->knc_rdev);
1388 
1389 #ifdef DEBUG
1390 	/*
1391 	 * Inject fault if desired.  Pretend we have a stale endpoint
1392 	 * and return NULL.
1393 	 */
1394 	if (endpnt_get_return_null > 0) {
1395 		endpnt_get_return_null--;
1396 		return (NULL);
1397 	}
1398 #endif
1399 	rw_enter(&endpnt_type_lock, RW_READER);
1400 
1401 top:
1402 	for (np = endpnt_type_list; np != NULL; np = np->e_next)
1403 		if ((np->e_zoneid == zoneid) &&
1404 		    (np->e_rdev == config->knc_rdev) &&
1405 		    (strcmp(np->e_protofmly,
1406 		    config->knc_protofmly) == 0))
1407 			break;
1408 
1409 	if (np == NULL && n_etype != NULL) {
1410 		ASSERT(rw_write_held(&endpnt_type_lock));
1411 
1412 		/*
1413 		 * Link the endpoint type onto the list
1414 		 */
1415 		n_etype->e_next = endpnt_type_list;
1416 		endpnt_type_list = n_etype;
1417 		np = n_etype;
1418 		n_etype = NULL;
1419 	}
1420 
1421 	if (np == NULL) {
1422 		/*
1423 		 * The logic here is that we were unable to find an
1424 		 * endpnt_type_t that matched our criteria, so we allocate a
1425 		 * new one.  Because kmem_alloc() needs to be called with
1426 		 * KM_SLEEP, we drop our locks so that we don't induce
1427 		 * deadlock.  After allocating and initializing the
1428 		 * endpnt_type_t, we reaquire the lock and go back to check
1429 		 * if this entry needs to be added to the list.  Since we do
1430 		 * some operations without any locking other threads may
1431 		 * have been looking for the same endpnt_type_t and gone
1432 		 * through this code path.  We check for this case and allow
1433 		 * one thread to link its endpnt_type_t to the list and the
1434 		 * other threads will simply free theirs.
1435 		 */
1436 		rw_exit(&endpnt_type_lock);
1437 		n_etype = endpnt_type_create(config);
1438 
1439 		/*
1440 		 * We need to reaquire the lock with RW_WRITER here so that
1441 		 * we can safely link the new endpoint type onto the list.
1442 		 */
1443 		rw_enter(&endpnt_type_lock, RW_WRITER);
1444 		goto top;
1445 	}
1446 
1447 	rw_exit(&endpnt_type_lock);
1448 	/*
1449 	 * If n_etype is not NULL, then another thread was able to
1450 	 * insert an endpnt_type_t of this type  onto the list before
1451 	 * we did.  Go ahead and free ours.
1452 	 */
1453 	if (n_etype != NULL)
1454 		endpnt_type_free(n_etype);
1455 
1456 	mutex_enter(&np->e_ilock);
1457 	/*
1458 	 * The algorithm to hand out endpoints is to first
1459 	 * give out those that are idle if such endpoints
1460 	 * exist.  Otherwise, create a new one if we haven't
1461 	 * reached the max threshold.  Finally, we give out
1462 	 * endpoints in a pseudo LRU fashion (round-robin).
1463 	 *
1464 	 * Note:  The idle list is merely a hint of those endpoints
1465 	 * that should be idle.  There exists a window after the
1466 	 * endpoint is released and before it is linked back onto the
1467 	 * idle list where a thread could get a reference to it and
1468 	 * use it.  This is okay, since the reference counts will
1469 	 * still be consistent.
1470 	 */
1471 	if ((endp = (endpnt_t *)list_head(&np->e_ilist)) != NULL) {
1472 		timeout_id_t t_id = 0;
1473 
1474 		mutex_enter(&endp->e_lock);
1475 		endp->e_ref++;
1476 		endp->e_itime = 0;
1477 		endp->e_flags &= ~ENDPNT_ONIDLE;
1478 		mutex_exit(&endp->e_lock);
1479 
1480 		/*
1481 		 * Pop the endpoint off the idle list and hand it off
1482 		 */
1483 		list_remove(&np->e_ilist, endp);
1484 
1485 		if (np->e_itimer != 0) {
1486 			t_id = np->e_itimer;
1487 			np->e_itimer = 0;
1488 		}
1489 		mutex_exit(&np->e_ilock);
1490 		/*
1491 		 * Reset the idle timer if it has been set
1492 		 */
1493 		if (t_id != (timeout_id_t)0)
1494 			(void) untimeout(t_id);
1495 
1496 		if (check_endpnt(endp, &new) == 0)
1497 			return (new);
1498 	} else if (np->e_cnt >= clnt_clts_max_endpoints) {
1499 		/*
1500 		 * There are no idle endpoints currently, so
1501 		 * create a new one if we have not reached the maximum or
1502 		 * hand one out in round-robin.
1503 		 */
1504 		mutex_exit(&np->e_ilock);
1505 		mutex_enter(&np->e_plock);
1506 		endp = np->e_pcurr;
1507 		mutex_enter(&endp->e_lock);
1508 		endp->e_ref++;
1509 		mutex_exit(&endp->e_lock);
1510 
1511 		ASSERT(endp != NULL);
1512 		/*
1513 		 * Advance the pointer to the next eligible endpoint, if
1514 		 * necessary.
1515 		 */
1516 		if (np->e_cnt > 1) {
1517 			next = (endpnt_t *)list_next(&np->e_pool, np->e_pcurr);
1518 			if (next == NULL)
1519 				next = (endpnt_t *)list_head(&np->e_pool);
1520 			np->e_pcurr = next;
1521 		}
1522 
1523 		mutex_exit(&np->e_plock);
1524 
1525 		/*
1526 		 * We need to check to see if this endpoint is bound or
1527 		 * not.  If it is in progress then just wait until
1528 		 * the set up is complete
1529 		 */
1530 		if (check_endpnt(endp, &new) == 0)
1531 			return (new);
1532 	} else {
1533 		mutex_exit(&np->e_ilock);
1534 		mutex_enter(&np->e_plock);
1535 
1536 		/*
1537 		 * Allocate a new endpoint to use.  If we can't allocate any
1538 		 * more memory then use one that is already established if any
1539 		 * such endpoints exist.
1540 		 */
1541 		new = kmem_cache_alloc(endpnt_cache, KM_NOSLEEP);
1542 		if (new == NULL) {
1543 			RPCLOG0(1, "endpnt_get: kmem_cache_alloc failed\n");
1544 			/*
1545 			 * Try to recover by using an existing endpoint.
1546 			 */
1547 			if (np->e_cnt <= 0) {
1548 				mutex_exit(&np->e_plock);
1549 				return (NULL);
1550 			}
1551 			endp = np->e_pcurr;
1552 			if ((next = list_next(&np->e_pool, np->e_pcurr)) !=
1553 			    NULL)
1554 				np->e_pcurr = next;
1555 			ASSERT(endp != NULL);
1556 			mutex_enter(&endp->e_lock);
1557 			endp->e_ref++;
1558 			mutex_exit(&endp->e_lock);
1559 			mutex_exit(&np->e_plock);
1560 
1561 			if (check_endpnt(endp, &new) == 0)
1562 				return (new);
1563 		} else {
1564 			/*
1565 			 * Partially init an endpoint structure and put
1566 			 * it on the list, so that other interested threads
1567 			 * know that one is being created
1568 			 */
1569 			bzero(new, sizeof (struct endpnt));
1570 
1571 			cv_init(&new->e_cv, NULL, CV_DEFAULT, NULL);
1572 			mutex_init(&new->e_lock, NULL, MUTEX_DEFAULT, NULL);
1573 			new->e_ref = 1;
1574 			new->e_type = np;
1575 
1576 			/*
1577 			 * Link the endpoint into the pool.
1578 			 */
1579 			list_insert_head(&np->e_pool, new);
1580 			np->e_cnt++;
1581 			if (np->e_pcurr == NULL)
1582 				np->e_pcurr = new;
1583 			mutex_exit(&np->e_plock);
1584 		}
1585 	}
1586 
1587 	/*
1588 	 * The transport should be opened with sufficient privs
1589 	 */
1590 	cr = zone_kcred();
1591 	error = t_kopen(NULL, config->knc_rdev, FREAD|FWRITE|FNDELAY, &tiptr,
1592 	    cr);
1593 	if (error) {
1594 		RPCLOG(1, "endpnt_get: t_kopen: %d\n", error);
1595 		goto bad;
1596 	}
1597 
1598 	new->e_tiptr = tiptr;
1599 	rpc_poptimod(tiptr->fp->f_vnode);
1600 
1601 	/*
1602 	 * Allow the kernel to push the module on behalf of the user.
1603 	 */
1604 	error = strioctl(tiptr->fp->f_vnode, I_PUSH, (intptr_t)"rpcmod", 0,
1605 	    K_TO_K, cr, &retval);
1606 	if (error) {
1607 		RPCLOG(1, "endpnt_get: kstr_push on rpcmod failed %d\n", error);
1608 		goto bad;
1609 	}
1610 
1611 	error = strioctl(tiptr->fp->f_vnode, RPC_CLIENT, 0, 0, K_TO_K,
1612 	    cr, &retval);
1613 	if (error) {
1614 		RPCLOG(1, "endpnt_get: strioctl failed %d\n", error);
1615 		goto bad;
1616 	}
1617 
1618 	/*
1619 	 * Connectionless data flow should bypass the stream head.
1620 	 */
1621 	new->e_wq = tiptr->fp->f_vnode->v_stream->sd_wrq->q_next;
1622 
1623 	error = strioctl(tiptr->fp->f_vnode, I_PUSH, (intptr_t)"timod", 0,
1624 	    K_TO_K, cr, &retval);
1625 	if (error) {
1626 		RPCLOG(1, "endpnt_get: kstr_push on timod failed %d\n", error);
1627 		goto bad;
1628 	}
1629 
1630 	/*
1631 	 * Attempt to bind the endpoint.  If we fail then propogate
1632 	 * error back to calling subsystem, so that it can be handled
1633 	 * appropriately.
1634 	 * If the caller has not specified reserved port usage then
1635 	 * take the system default.
1636 	 */
1637 	if (useresvport == -1)
1638 		useresvport = clnt_clts_do_bindresvport;
1639 
1640 	if (useresvport &&
1641 	    (strcmp(config->knc_protofmly, NC_INET) == 0 ||
1642 	    strcmp(config->knc_protofmly, NC_INET6) == 0)) {
1643 
1644 		while ((error =
1645 		    bindresvport(new->e_tiptr, NULL, NULL, FALSE)) != 0) {
1646 			RPCLOG(1,
1647 			    "endpnt_get: bindresvport error %d\n", error);
1648 			if (error != EPROTO) {
1649 				if (rtries-- <= 0)
1650 					goto bad;
1651 
1652 				delay(hz << i++);
1653 				continue;
1654 			}
1655 
1656 			(void) t_kclose(new->e_tiptr, 1);
1657 			/*
1658 			 * reopen with all privileges
1659 			 */
1660 			error = t_kopen(NULL, config->knc_rdev,
1661 			    FREAD|FWRITE|FNDELAY,
1662 			    &new->e_tiptr, cr);
1663 			if (error) {
1664 				RPCLOG(1, "endpnt_get: t_kopen: %d\n", error);
1665 					new->e_tiptr = NULL;
1666 					goto bad;
1667 			}
1668 		}
1669 	} else if ((error = t_kbind(new->e_tiptr, NULL, NULL)) != 0) {
1670 		RPCLOG(1, "endpnt_get: t_kbind failed: %d\n", error);
1671 		goto bad;
1672 	}
1673 
1674 	/*
1675 	 * Set the flags and notify and waiters that we have an established
1676 	 * endpoint.
1677 	 */
1678 	mutex_enter(&new->e_lock);
1679 	new->e_flags |= ENDPNT_ESTABLISHED;
1680 	new->e_flags |= ENDPNT_BOUND;
1681 	if (new->e_flags & ENDPNT_WAITING) {
1682 		cv_broadcast(&new->e_cv);
1683 		new->e_flags &= ~ENDPNT_WAITING;
1684 	}
1685 	mutex_exit(&new->e_lock);
1686 
1687 	return (new);
1688 
1689 bad:
1690 	ASSERT(new != NULL);
1691 	/*
1692 	 * mark this endpoint as stale and notify any threads waiting
1693 	 * on this endpoint that it will be going away.
1694 	 */
1695 	mutex_enter(&new->e_lock);
1696 	if (new->e_ref > 0) {
1697 		new->e_flags |= ENDPNT_ESTABLISHED;
1698 		new->e_flags |= ENDPNT_STALE;
1699 		if (new->e_flags & ENDPNT_WAITING) {
1700 			cv_broadcast(&new->e_cv);
1701 			new->e_flags &= ~ENDPNT_WAITING;
1702 		}
1703 	}
1704 	new->e_ref--;
1705 	new->e_tiptr = NULL;
1706 	mutex_exit(&new->e_lock);
1707 
1708 	/*
1709 	 * If there was a transport endopoint opened, then close it.
1710 	 */
1711 	if (tiptr != NULL)
1712 		(void) t_kclose(tiptr, 1);
1713 
1714 	return (NULL);
1715 }
1716 
1717 /*
1718  * Release a referece to the endpoint
1719  */
1720 static void
endpnt_rele(struct endpnt * sp)1721 endpnt_rele(struct endpnt *sp)
1722 {
1723 	mutex_enter(&sp->e_lock);
1724 	ASSERT(sp->e_ref > 0);
1725 	sp->e_ref--;
1726 	/*
1727 	 * If the ref count is zero, then start the idle timer and link
1728 	 * the endpoint onto the idle list.
1729 	 */
1730 	if (sp->e_ref == 0) {
1731 		sp->e_itime = gethrestime_sec();
1732 
1733 		/*
1734 		 * Check to see if the endpoint is already linked to the idle
1735 		 * list, so that we don't try to reinsert it.
1736 		 */
1737 		if (sp->e_flags & ENDPNT_ONIDLE) {
1738 			mutex_exit(&sp->e_lock);
1739 			mutex_enter(&sp->e_type->e_ilock);
1740 			endpnt_reap_settimer(sp->e_type);
1741 			mutex_exit(&sp->e_type->e_ilock);
1742 			return;
1743 		}
1744 
1745 		sp->e_flags |= ENDPNT_ONIDLE;
1746 		mutex_exit(&sp->e_lock);
1747 		mutex_enter(&sp->e_type->e_ilock);
1748 		list_insert_tail(&sp->e_type->e_ilist, sp);
1749 		endpnt_reap_settimer(sp->e_type);
1750 		mutex_exit(&sp->e_type->e_ilock);
1751 	} else
1752 		mutex_exit(&sp->e_lock);
1753 }
1754 
1755 static void
endpnt_reap_settimer(endpnt_type_t * etp)1756 endpnt_reap_settimer(endpnt_type_t *etp)
1757 {
1758 	if (etp->e_itimer == (timeout_id_t)0)
1759 		etp->e_itimer = timeout(endpnt_reap_dispatch, (void *)etp,
1760 		    clnt_clts_taskq_dispatch_interval);
1761 }
1762 
1763 static void
endpnt_reap_dispatch(void * a)1764 endpnt_reap_dispatch(void *a)
1765 {
1766 	endpnt_type_t *etp = a;
1767 
1768 	/*
1769 	 * The idle timer has fired, so dispatch the taskq to close the
1770 	 * endpoint.
1771 	 */
1772 	if (taskq_dispatch(endpnt_taskq, (task_func_t *)endpnt_reap, etp,
1773 	    TQ_NOSLEEP) == NULL)
1774 		return;
1775 	mutex_enter(&etp->e_ilock);
1776 	etp->e_async_count++;
1777 	mutex_exit(&etp->e_ilock);
1778 }
1779 
1780 /*
1781  * Traverse the idle list and close those endpoints that have reached their
1782  * timeout interval.
1783  */
1784 static void
endpnt_reap(endpnt_type_t * etp)1785 endpnt_reap(endpnt_type_t *etp)
1786 {
1787 	struct endpnt *e;
1788 	struct endpnt *next_node = NULL;
1789 
1790 	mutex_enter(&etp->e_ilock);
1791 	e = list_head(&etp->e_ilist);
1792 	while (e != NULL) {
1793 		next_node = list_next(&etp->e_ilist, e);
1794 
1795 		mutex_enter(&e->e_lock);
1796 		if (e->e_ref > 0) {
1797 			mutex_exit(&e->e_lock);
1798 			e = next_node;
1799 			continue;
1800 		}
1801 
1802 		ASSERT(e->e_ref == 0);
1803 		if (e->e_itime > 0 &&
1804 		    (e->e_itime + clnt_clts_endpoint_reap_interval) <
1805 		    gethrestime_sec()) {
1806 			e->e_flags &= ~ENDPNT_BOUND;
1807 			(void) t_kclose(e->e_tiptr, 1);
1808 			e->e_tiptr = NULL;
1809 			e->e_itime = 0;
1810 		}
1811 		mutex_exit(&e->e_lock);
1812 		e = next_node;
1813 	}
1814 	etp->e_itimer = 0;
1815 	if (--etp->e_async_count == 0)
1816 		cv_signal(&etp->e_async_cv);
1817 	mutex_exit(&etp->e_ilock);
1818 }
1819 
1820 static void
endpnt_reclaim(zoneid_t zoneid)1821 endpnt_reclaim(zoneid_t zoneid)
1822 {
1823 	struct endpnt_type *np;
1824 	struct endpnt *e;
1825 	struct endpnt *next_node = NULL;
1826 	list_t free_list;
1827 	int rcnt = 0;
1828 
1829 	list_create(&free_list, sizeof (endpnt_t), offsetof(endpnt_t, e_node));
1830 
1831 	RPCLOG0(1, "endpnt_reclaim: reclaim callback started\n");
1832 	rw_enter(&endpnt_type_lock, RW_READER);
1833 	for (np = endpnt_type_list; np != NULL; np = np->e_next) {
1834 		if (zoneid != ALL_ZONES && zoneid != np->e_zoneid)
1835 			continue;
1836 
1837 		mutex_enter(&np->e_plock);
1838 		RPCLOG(1, "endpnt_reclaim: protofmly %s, ",
1839 		    np->e_protofmly);
1840 		RPCLOG(1, "rdev %ld\n", np->e_rdev);
1841 		RPCLOG(1, "endpnt_reclaim: found %d endpoint(s)\n",
1842 		    np->e_cnt);
1843 
1844 		if (np->e_cnt == 0) {
1845 			mutex_exit(&np->e_plock);
1846 			continue;
1847 		}
1848 
1849 		/*
1850 		 * The nice thing about maintaining an idle list is that if
1851 		 * there are any endpoints to reclaim, they are going to be
1852 		 * on this list.  Just go through and reap the one's that
1853 		 * have ref counts of zero.
1854 		 */
1855 		mutex_enter(&np->e_ilock);
1856 		e = list_head(&np->e_ilist);
1857 		while (e != NULL) {
1858 			next_node = list_next(&np->e_ilist, e);
1859 			mutex_enter(&e->e_lock);
1860 			if (e->e_ref > 0) {
1861 				mutex_exit(&e->e_lock);
1862 				e = next_node;
1863 				continue;
1864 			}
1865 			ASSERT(e->e_ref == 0);
1866 			mutex_exit(&e->e_lock);
1867 
1868 			list_remove(&np->e_ilist, e);
1869 			list_remove(&np->e_pool, e);
1870 			list_insert_head(&free_list, e);
1871 
1872 			rcnt++;
1873 			np->e_cnt--;
1874 			e = next_node;
1875 		}
1876 		mutex_exit(&np->e_ilock);
1877 		/*
1878 		 * Reset the current pointer to be safe
1879 		 */
1880 		if ((e = (struct endpnt *)list_head(&np->e_pool)) != NULL)
1881 			np->e_pcurr = e;
1882 		else {
1883 			ASSERT(np->e_cnt == 0);
1884 			np->e_pcurr = NULL;
1885 		}
1886 
1887 		mutex_exit(&np->e_plock);
1888 	}
1889 	rw_exit(&endpnt_type_lock);
1890 
1891 	while ((e = list_head(&free_list)) != NULL) {
1892 		list_remove(&free_list, e);
1893 		if (e->e_tiptr != NULL)
1894 			(void) t_kclose(e->e_tiptr, 1);
1895 
1896 		cv_destroy(&e->e_cv);
1897 		mutex_destroy(&e->e_lock);
1898 		kmem_cache_free(endpnt_cache, e);
1899 	}
1900 	list_destroy(&free_list);
1901 	RPCLOG(1, "endpnt_reclaim: reclaimed %d endpoint(s)\n", rcnt);
1902 }
1903 
1904 /*
1905  * Endpoint reclaim zones destructor callback routine.
1906  *
1907  * After reclaiming any cached entries, we basically go through the endpnt_type
1908  * list, canceling outstanding timeouts and free'ing data structures.
1909  */
1910 /* ARGSUSED */
1911 static void
endpnt_destructor(zoneid_t zoneid,void * a)1912 endpnt_destructor(zoneid_t zoneid, void *a)
1913 {
1914 	struct endpnt_type **npp;
1915 	struct endpnt_type *np;
1916 	struct endpnt_type *free_list = NULL;
1917 	timeout_id_t t_id = 0;
1918 	extern void clcleanup_zone(zoneid_t);
1919 	extern void clcleanup4_zone(zoneid_t);
1920 
1921 	/* Make sure NFS client handles are released. */
1922 	clcleanup_zone(zoneid);
1923 	clcleanup4_zone(zoneid);
1924 
1925 	endpnt_reclaim(zoneid);
1926 	/*
1927 	 * We don't need to be holding on to any locks across the call to
1928 	 * endpnt_reclaim() and the code below; we know that no-one can
1929 	 * be holding open connections for this zone (all processes and kernel
1930 	 * threads are gone), so nothing could be adding anything to the list.
1931 	 */
1932 	rw_enter(&endpnt_type_lock, RW_WRITER);
1933 	npp = &endpnt_type_list;
1934 	while ((np = *npp) != NULL) {
1935 		if (np->e_zoneid != zoneid) {
1936 			npp = &np->e_next;
1937 			continue;
1938 		}
1939 		mutex_enter(&np->e_plock);
1940 		mutex_enter(&np->e_ilock);
1941 		if (np->e_itimer != 0) {
1942 			t_id = np->e_itimer;
1943 			np->e_itimer = 0;
1944 		}
1945 		ASSERT(np->e_cnt == 0);
1946 		ASSERT(list_head(&np->e_pool) == NULL);
1947 		ASSERT(list_head(&np->e_ilist) == NULL);
1948 
1949 		mutex_exit(&np->e_ilock);
1950 		mutex_exit(&np->e_plock);
1951 
1952 		/*
1953 		 * untimeout() any outstanding timers that have not yet fired.
1954 		 */
1955 		if (t_id != (timeout_id_t)0)
1956 			(void) untimeout(t_id);
1957 		*npp = np->e_next;
1958 		np->e_next = free_list;
1959 		free_list = np;
1960 	}
1961 	rw_exit(&endpnt_type_lock);
1962 
1963 	while (free_list != NULL) {
1964 		np = free_list;
1965 		free_list = free_list->e_next;
1966 		/*
1967 		 * Wait for threads in endpnt_taskq trying to reap endpnt_ts in
1968 		 * the endpnt_type_t.
1969 		 */
1970 		mutex_enter(&np->e_ilock);
1971 		while (np->e_async_count > 0)
1972 			cv_wait(&np->e_async_cv, &np->e_ilock);
1973 		cv_destroy(&np->e_async_cv);
1974 		mutex_destroy(&np->e_plock);
1975 		mutex_destroy(&np->e_ilock);
1976 		list_destroy(&np->e_pool);
1977 		list_destroy(&np->e_ilist);
1978 		kmem_free(np, sizeof (endpnt_type_t));
1979 	}
1980 }
1981 
1982 /*
1983  * Endpoint reclaim kmem callback routine.
1984  */
1985 /* ARGSUSED */
1986 static void
endpnt_repossess(void * a)1987 endpnt_repossess(void *a)
1988 {
1989 	/*
1990 	 * Reclaim idle endpnt's from all zones.
1991 	 */
1992 	if (endpnt_taskq != NULL)
1993 		(void) taskq_dispatch(endpnt_taskq,
1994 		    (task_func_t *)endpnt_reclaim, (void *)ALL_ZONES,
1995 		    TQ_NOSLEEP);
1996 }
1997 
1998 /*
1999  * RPC request dispatch routine.  Constructs a datagram message and wraps it
2000  * around the RPC request to pass downstream.
2001  */
2002 static int
clnt_clts_dispatch_send(queue_t * q,mblk_t * mp,struct netbuf * addr,calllist_t * cp,uint_t xid,cred_t * cr)2003 clnt_clts_dispatch_send(queue_t *q, mblk_t *mp, struct netbuf *addr,
2004     calllist_t *cp, uint_t xid, cred_t *cr)
2005 {
2006 	mblk_t *bp;
2007 	int msgsz;
2008 	struct T_unitdata_req *udreq;
2009 
2010 	/*
2011 	 * Set up the call record.
2012 	 */
2013 	cp->call_wq = q;
2014 	cp->call_xid = xid;
2015 	cp->call_status = RPC_TIMEDOUT;
2016 	cp->call_notified = FALSE;
2017 	RPCLOG(64,
2018 	    "clnt_clts_dispatch_send: putting xid 0x%x on "
2019 	    "dispatch list\n", xid);
2020 	cp->call_hash = call_hash(xid, clnt_clts_hash_size);
2021 	cp->call_bucket = &clts_call_ht[cp->call_hash];
2022 	call_table_enter(cp);
2023 
2024 	/*
2025 	 * Construct the datagram
2026 	 */
2027 	msgsz = (int)TUNITDATAREQSZ;
2028 	/*
2029 	 * Note: if the receiver uses SCM_UCRED/getpeerucred the pid will
2030 	 * appear as -1.
2031 	 */
2032 	while (!(bp = allocb_cred(msgsz + addr->len, cr, NOPID))) {
2033 		if (strwaitbuf(msgsz + addr->len, BPRI_LO))
2034 			return (ENOSR);
2035 	}
2036 
2037 	udreq = (struct T_unitdata_req *)bp->b_wptr;
2038 	udreq->PRIM_type = T_UNITDATA_REQ;
2039 	udreq->DEST_length = addr->len;
2040 
2041 	if (addr->len) {
2042 		bcopy(addr->buf, bp->b_wptr + msgsz, addr->len);
2043 		udreq->DEST_offset = (t_scalar_t)msgsz;
2044 		msgsz += addr->len;
2045 	} else
2046 		udreq->DEST_offset = 0;
2047 	udreq->OPT_length = 0;
2048 	udreq->OPT_offset = 0;
2049 
2050 	bp->b_datap->db_type = M_PROTO;
2051 	bp->b_wptr += msgsz;
2052 
2053 	/*
2054 	 * Link the datagram header with the actual data
2055 	 */
2056 	linkb(bp, mp);
2057 
2058 	/*
2059 	 * Send downstream.
2060 	 */
2061 	if (canput(cp->call_wq)) {
2062 		put(cp->call_wq, bp);
2063 		return (0);
2064 	}
2065 
2066 	return (EIO);
2067 }
2068 
2069 /*
2070  * RPC response delivery routine.  Deliver the response to the waiting
2071  * thread by matching the xid.
2072  */
2073 void
clnt_clts_dispatch_notify(mblk_t * mp,int resp_off,zoneid_t zoneid)2074 clnt_clts_dispatch_notify(mblk_t *mp, int resp_off, zoneid_t zoneid)
2075 {
2076 	calllist_t *e = NULL;
2077 	call_table_t *chtp;
2078 	uint32_t xid;
2079 	uint_t hash;
2080 	unsigned char *hdr_offset;
2081 	mblk_t *resp;
2082 
2083 	/*
2084 	 * If the RPC response is not contained in the same mblk as the
2085 	 * datagram header, then move to the next mblk.
2086 	 */
2087 	hdr_offset = mp->b_rptr;
2088 	resp = mp;
2089 	if ((mp->b_wptr - (mp->b_rptr + resp_off)) == 0)
2090 		resp = mp->b_cont;
2091 	else
2092 		resp->b_rptr += resp_off;
2093 
2094 	ASSERT(resp != NULL);
2095 
2096 	if ((IS_P2ALIGNED(resp->b_rptr, sizeof (uint32_t))) &&
2097 	    (resp->b_wptr - resp->b_rptr) >= sizeof (xid))
2098 		xid = *((uint32_t *)resp->b_rptr);
2099 	else {
2100 		int i = 0;
2101 		unsigned char *p = (unsigned char *)&xid;
2102 		unsigned char *rptr;
2103 		mblk_t *tmp = resp;
2104 
2105 		/*
2106 		 * Copy the xid, byte-by-byte into xid.
2107 		 */
2108 		while (tmp) {
2109 			rptr = tmp->b_rptr;
2110 			while (rptr < tmp->b_wptr) {
2111 				*p++ = *rptr++;
2112 				if (++i >= sizeof (xid))
2113 					goto done_xid_copy;
2114 			}
2115 			tmp = tmp->b_cont;
2116 		}
2117 
2118 		/*
2119 		 * If we got here, we ran out of mblk space before the
2120 		 * xid could be copied.
2121 		 */
2122 		ASSERT(tmp == NULL && i < sizeof (xid));
2123 
2124 		RPCLOG0(1,
2125 		    "clnt_dispatch_notify(clts): message less than "
2126 		    "size of xid\n");
2127 
2128 		freemsg(mp);
2129 		return;
2130 	}
2131 
2132 done_xid_copy:
2133 
2134 	/*
2135 	 * Reset the read pointer back to the beginning of the protocol
2136 	 * header if we moved it.
2137 	 */
2138 	if (mp->b_rptr != hdr_offset)
2139 		mp->b_rptr = hdr_offset;
2140 
2141 	hash = call_hash(xid, clnt_clts_hash_size);
2142 	chtp = &clts_call_ht[hash];
2143 	/* call_table_find returns with the hash bucket locked */
2144 	call_table_find(chtp, xid, e);
2145 
2146 	if (e != NULL) {
2147 		mutex_enter(&e->call_lock);
2148 
2149 		/*
2150 		 * verify that the reply is coming in on
2151 		 * the same zone that it was sent from.
2152 		 */
2153 		if (e->call_zoneid != zoneid) {
2154 			mutex_exit(&e->call_lock);
2155 			mutex_exit(&chtp->ct_lock);
2156 			RPCLOG0(8, "clnt_dispatch_notify (clts): incorrect "
2157 			    "zoneid\n");
2158 			freemsg(mp);
2159 			return;
2160 		}
2161 
2162 		/*
2163 		 * found thread waiting for this reply.
2164 		 */
2165 		if (e->call_reply) {
2166 			RPCLOG(8,
2167 			    "clnt_dispatch_notify (clts): discarding old "
2168 			    "reply for xid 0x%x\n",
2169 			    xid);
2170 			freemsg(e->call_reply);
2171 		}
2172 		e->call_notified = TRUE;
2173 		e->call_reply = mp;
2174 		e->call_status = RPC_SUCCESS;
2175 		cv_signal(&e->call_cv);
2176 		mutex_exit(&e->call_lock);
2177 		mutex_exit(&chtp->ct_lock);
2178 	} else {
2179 		zone_t *zone;
2180 		struct rpcstat *rpcstat;
2181 
2182 		mutex_exit(&chtp->ct_lock);
2183 		RPCLOG(8, "clnt_dispatch_notify (clts): no caller for reply "
2184 		    "0x%x\n", xid);
2185 		freemsg(mp);
2186 		/*
2187 		 * This is unfortunate, but we need to lookup the zone so we
2188 		 * can increment its "rcbadxids" counter.
2189 		 */
2190 		zone = zone_find_by_id(zoneid);
2191 		if (zone == NULL) {
2192 			/*
2193 			 * The zone went away...
2194 			 */
2195 			return;
2196 		}
2197 		rpcstat = zone_getspecific(rpcstat_zone_key, zone);
2198 		if (zone_status_get(zone) >= ZONE_IS_SHUTTING_DOWN) {
2199 			/*
2200 			 * Not interested
2201 			 */
2202 			zone_rele(zone);
2203 			return;
2204 		}
2205 		RCSTAT_INCR(rpcstat->rpc_clts_client, rcbadxids);
2206 		zone_rele(zone);
2207 	}
2208 }
2209 
2210 /*
2211  * Init routine.  Called when rpcmod is loaded.
2212  */
2213 void
clnt_clts_init(void)2214 clnt_clts_init(void)
2215 {
2216 	endpnt_cache = kmem_cache_create("clnt_clts_endpnt_cache",
2217 	    sizeof (struct endpnt), 0, NULL, NULL, endpnt_repossess, NULL,
2218 	    NULL, 0);
2219 
2220 	rw_init(&endpnt_type_lock, NULL, RW_DEFAULT, NULL);
2221 
2222 	/*
2223 	 * Perform simple bounds checking to make sure that the setting is
2224 	 * reasonable
2225 	 */
2226 	if (clnt_clts_max_endpoints <= 0) {
2227 		if (clnt_clts_do_bindresvport)
2228 			clnt_clts_max_endpoints = RESERVED_PORTSPACE;
2229 		else
2230 			clnt_clts_max_endpoints = NONRESERVED_PORTSPACE;
2231 	}
2232 
2233 	if (clnt_clts_do_bindresvport &&
2234 	    clnt_clts_max_endpoints > RESERVED_PORTSPACE)
2235 		clnt_clts_max_endpoints = RESERVED_PORTSPACE;
2236 	else if (clnt_clts_max_endpoints > NONRESERVED_PORTSPACE)
2237 		clnt_clts_max_endpoints = NONRESERVED_PORTSPACE;
2238 
2239 	if (clnt_clts_hash_size < DEFAULT_MIN_HASH_SIZE)
2240 		clnt_clts_hash_size = DEFAULT_MIN_HASH_SIZE;
2241 
2242 	/*
2243 	 * Defer creating the taskq until rpcmod gets pushed.  If we are
2244 	 * in diskless boot mode, rpcmod will get loaded early even before
2245 	 * thread_create() is available.
2246 	 */
2247 	endpnt_taskq = NULL;
2248 	taskq_created = FALSE;
2249 	mutex_init(&endpnt_taskq_lock, NULL, MUTEX_DEFAULT, NULL);
2250 
2251 	if (clnt_clts_endpoint_reap_interval < DEFAULT_ENDPOINT_REAP_INTERVAL)
2252 		clnt_clts_endpoint_reap_interval =
2253 		    DEFAULT_ENDPOINT_REAP_INTERVAL;
2254 
2255 	/*
2256 	 * Dispatch the taskq at an interval which is offset from the
2257 	 * interval that the endpoints should be reaped.
2258 	 */
2259 	clnt_clts_taskq_dispatch_interval =
2260 	    (clnt_clts_endpoint_reap_interval + DEFAULT_INTERVAL_SHIFT) * hz;
2261 
2262 	/*
2263 	 * Initialize the completion queue
2264 	 */
2265 	clts_call_ht = call_table_init(clnt_clts_hash_size);
2266 	/*
2267 	 * Initialize the zone destructor callback.
2268 	 */
2269 	zone_key_create(&endpnt_destructor_key, NULL, NULL, endpnt_destructor);
2270 }
2271 
2272 void
clnt_clts_fini(void)2273 clnt_clts_fini(void)
2274 {
2275 	(void) zone_key_delete(endpnt_destructor_key);
2276 }
2277