17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5da1b9cd5Sjwahlig  * Common Development and Distribution License (the "License").
6da1b9cd5Sjwahlig  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
22*ed57cab9Srg  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
277c478bd9Sstevel@tonic-gate 
287c478bd9Sstevel@tonic-gate #include <sys/systm.h>
297c478bd9Sstevel@tonic-gate #include <rpc/auth.h>
307c478bd9Sstevel@tonic-gate #include <rpc/clnt.h>
317c478bd9Sstevel@tonic-gate #include <nfs/nfs4_kprot.h>
327c478bd9Sstevel@tonic-gate #include <nfs/nfs4.h>
337c478bd9Sstevel@tonic-gate #include <nfs/lm.h>
347c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
357c478bd9Sstevel@tonic-gate #include <sys/disp.h>
367c478bd9Sstevel@tonic-gate 
377c478bd9Sstevel@tonic-gate #include <sys/pathname.h>
387c478bd9Sstevel@tonic-gate 
397c478bd9Sstevel@tonic-gate #include <sys/strsubr.h>
407c478bd9Sstevel@tonic-gate #include <sys/ddi.h>
417c478bd9Sstevel@tonic-gate 
427c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
43*ed57cab9Srg #include <sys/sdt.h>
447c478bd9Sstevel@tonic-gate #include <inet/common.h>
457c478bd9Sstevel@tonic-gate #include <inet/ip.h>
467c478bd9Sstevel@tonic-gate #include <inet/ip6.h>
477c478bd9Sstevel@tonic-gate 
487c478bd9Sstevel@tonic-gate #define	MAX_READ_DELEGATIONS 5
497c478bd9Sstevel@tonic-gate 
507c478bd9Sstevel@tonic-gate krwlock_t rfs4_deleg_policy_lock;
517c478bd9Sstevel@tonic-gate srv_deleg_policy_t rfs4_deleg_policy = SRV_NEVER_DELEGATE;
527c478bd9Sstevel@tonic-gate static int rfs4_deleg_wlp = 5;
537c478bd9Sstevel@tonic-gate kmutex_t rfs4_deleg_lock;
547c478bd9Sstevel@tonic-gate static int rfs4_deleg_disabled;
557c478bd9Sstevel@tonic-gate 
567c478bd9Sstevel@tonic-gate #ifdef DEBUG
577c478bd9Sstevel@tonic-gate 
587c478bd9Sstevel@tonic-gate static int rfs4_test_cbgetattr_fail = 0;
597c478bd9Sstevel@tonic-gate int rfs4_cb_null;
607c478bd9Sstevel@tonic-gate int rfs4_cb_debug;
617c478bd9Sstevel@tonic-gate int rfs4_deleg_debug;
627c478bd9Sstevel@tonic-gate 
637c478bd9Sstevel@tonic-gate #endif
647c478bd9Sstevel@tonic-gate 
657c478bd9Sstevel@tonic-gate static void rfs4_recall_file(rfs4_file_t *,
667c478bd9Sstevel@tonic-gate 			    void (*recall)(rfs4_deleg_state_t *, bool_t),
677c478bd9Sstevel@tonic-gate 			    bool_t, rfs4_client_t *);
687c478bd9Sstevel@tonic-gate static	void		rfs4_revoke_deleg(rfs4_deleg_state_t *);
697c478bd9Sstevel@tonic-gate static	void		rfs4_revoke_file(rfs4_file_t *);
707c478bd9Sstevel@tonic-gate static	void		rfs4_cb_chflush(rfs4_cbinfo_t *);
717c478bd9Sstevel@tonic-gate static	CLIENT		*rfs4_cb_getch(rfs4_cbinfo_t *);
727c478bd9Sstevel@tonic-gate static	void		rfs4_cb_freech(rfs4_cbinfo_t *, CLIENT *, bool_t);
737c478bd9Sstevel@tonic-gate static rfs4_deleg_state_t *rfs4_deleg_state(rfs4_state_t *,
747c478bd9Sstevel@tonic-gate 				open_delegation_type4, int *);
757c478bd9Sstevel@tonic-gate 
767c478bd9Sstevel@tonic-gate /*
777c478bd9Sstevel@tonic-gate  * Convert a universal address to an transport specific
787c478bd9Sstevel@tonic-gate  * address using inet_pton.
797c478bd9Sstevel@tonic-gate  */
807c478bd9Sstevel@tonic-gate static int
817c478bd9Sstevel@tonic-gate uaddr2sockaddr(int af, char *ua, void *ap, in_port_t *pp)
827c478bd9Sstevel@tonic-gate {
837c478bd9Sstevel@tonic-gate 	int dots = 0, i, j, len, k;
847c478bd9Sstevel@tonic-gate 	unsigned char c;
857c478bd9Sstevel@tonic-gate 	in_port_t port = 0;
867c478bd9Sstevel@tonic-gate 
877c478bd9Sstevel@tonic-gate 	len = strlen(ua);
887c478bd9Sstevel@tonic-gate 
897c478bd9Sstevel@tonic-gate 	for (i = len-1; i >= 0; i--) {
907c478bd9Sstevel@tonic-gate 
917c478bd9Sstevel@tonic-gate 		if (ua[i] == '.')
927c478bd9Sstevel@tonic-gate 			dots++;
937c478bd9Sstevel@tonic-gate 
947c478bd9Sstevel@tonic-gate 		if (dots == 2) {
957c478bd9Sstevel@tonic-gate 
967c478bd9Sstevel@tonic-gate 			ua[i] = '\0';
977c478bd9Sstevel@tonic-gate 			/*
987c478bd9Sstevel@tonic-gate 			 * We use k to remember were to stick '.' back, since
997c478bd9Sstevel@tonic-gate 			 * ua was kmem_allocateded from the pool len+1.
1007c478bd9Sstevel@tonic-gate 			 */
1017c478bd9Sstevel@tonic-gate 			k = i;
1027c478bd9Sstevel@tonic-gate 			if (inet_pton(af, ua, ap) == 1) {
1037c478bd9Sstevel@tonic-gate 
1047c478bd9Sstevel@tonic-gate 				c = 0;
1057c478bd9Sstevel@tonic-gate 
1067c478bd9Sstevel@tonic-gate 				for (j = i+1; j < len; j++) {
1077c478bd9Sstevel@tonic-gate 					if (ua[j] == '.') {
1087c478bd9Sstevel@tonic-gate 						port = c << 8;
1097c478bd9Sstevel@tonic-gate 						c = 0;
1107c478bd9Sstevel@tonic-gate 					} else if (ua[j] >= '0' &&
1117c478bd9Sstevel@tonic-gate 					    ua[j] <= '9') {
1127c478bd9Sstevel@tonic-gate 						c *= 10;
1137c478bd9Sstevel@tonic-gate 						c += ua[j] - '0';
1147c478bd9Sstevel@tonic-gate 					} else {
1157c478bd9Sstevel@tonic-gate 						ua[k] = '.';
1167c478bd9Sstevel@tonic-gate 						return (EINVAL);
1177c478bd9Sstevel@tonic-gate 					}
1187c478bd9Sstevel@tonic-gate 				}
1197c478bd9Sstevel@tonic-gate 				port += c;
1207c478bd9Sstevel@tonic-gate 
1217c478bd9Sstevel@tonic-gate 
1227c478bd9Sstevel@tonic-gate 				/* reset to network order */
1237c478bd9Sstevel@tonic-gate 				if (af == AF_INET) {
1247c478bd9Sstevel@tonic-gate 					*(uint32_t *)ap =
125*ed57cab9Srg 					    htonl(*(uint32_t *)ap);
1267c478bd9Sstevel@tonic-gate 					*pp = htons(port);
1277c478bd9Sstevel@tonic-gate 				} else {
1287c478bd9Sstevel@tonic-gate 					int ix;
1297c478bd9Sstevel@tonic-gate 					uint16_t *sap;
1307c478bd9Sstevel@tonic-gate 
1317c478bd9Sstevel@tonic-gate 					for (sap = ap, ix = 0; ix <
1327c478bd9Sstevel@tonic-gate 					    sizeof (struct in6_addr) /
1337c478bd9Sstevel@tonic-gate 					    sizeof (uint16_t); ix++)
1347c478bd9Sstevel@tonic-gate 						sap[ix] = htons(sap[ix]);
1357c478bd9Sstevel@tonic-gate 
1367c478bd9Sstevel@tonic-gate 					*pp = htons(port);
1377c478bd9Sstevel@tonic-gate 				}
1387c478bd9Sstevel@tonic-gate 
1397c478bd9Sstevel@tonic-gate 				ua[k] = '.';
1407c478bd9Sstevel@tonic-gate 				return (0);
1417c478bd9Sstevel@tonic-gate 			} else {
1427c478bd9Sstevel@tonic-gate 				ua[k] = '.';
1437c478bd9Sstevel@tonic-gate 				return (EINVAL);
1447c478bd9Sstevel@tonic-gate 			}
1457c478bd9Sstevel@tonic-gate 		}
1467c478bd9Sstevel@tonic-gate 	}
1477c478bd9Sstevel@tonic-gate 
1487c478bd9Sstevel@tonic-gate 	return (EINVAL);
1497c478bd9Sstevel@tonic-gate }
1507c478bd9Sstevel@tonic-gate 
1517c478bd9Sstevel@tonic-gate /*
1527c478bd9Sstevel@tonic-gate  * Update the delegation policy with the
1537c478bd9Sstevel@tonic-gate  * value of "new_policy"
1547c478bd9Sstevel@tonic-gate  */
1557c478bd9Sstevel@tonic-gate void
1567c478bd9Sstevel@tonic-gate rfs4_set_deleg_policy(srv_deleg_policy_t new_policy)
1577c478bd9Sstevel@tonic-gate {
1587c478bd9Sstevel@tonic-gate 	rw_enter(&rfs4_deleg_policy_lock, RW_WRITER);
1597c478bd9Sstevel@tonic-gate 	rfs4_deleg_policy = new_policy;
1607c478bd9Sstevel@tonic-gate 	rw_exit(&rfs4_deleg_policy_lock);
1617c478bd9Sstevel@tonic-gate }
1627c478bd9Sstevel@tonic-gate 
1637c478bd9Sstevel@tonic-gate void
1647c478bd9Sstevel@tonic-gate rfs4_hold_deleg_policy(void)
1657c478bd9Sstevel@tonic-gate {
1667c478bd9Sstevel@tonic-gate 	rw_enter(&rfs4_deleg_policy_lock, RW_READER);
1677c478bd9Sstevel@tonic-gate }
1687c478bd9Sstevel@tonic-gate 
1697c478bd9Sstevel@tonic-gate void
1707c478bd9Sstevel@tonic-gate rfs4_rele_deleg_policy(void)
1717c478bd9Sstevel@tonic-gate {
1727c478bd9Sstevel@tonic-gate 	rw_exit(&rfs4_deleg_policy_lock);
1737c478bd9Sstevel@tonic-gate }
1747c478bd9Sstevel@tonic-gate 
1757c478bd9Sstevel@tonic-gate 
1767c478bd9Sstevel@tonic-gate /*
1777c478bd9Sstevel@tonic-gate  * This free function is to be used when the client struct is being
1787c478bd9Sstevel@tonic-gate  * released and nothing at all is needed of the callback info any
1797c478bd9Sstevel@tonic-gate  * longer.
1807c478bd9Sstevel@tonic-gate  */
1817c478bd9Sstevel@tonic-gate void
1827c478bd9Sstevel@tonic-gate rfs4_cbinfo_free(rfs4_cbinfo_t *cbp)
1837c478bd9Sstevel@tonic-gate {
1847c478bd9Sstevel@tonic-gate 	char *addr = cbp->cb_callback.cb_location.r_addr;
1857c478bd9Sstevel@tonic-gate 	char *netid = cbp->cb_callback.cb_location.r_netid;
1867c478bd9Sstevel@tonic-gate 
1877c478bd9Sstevel@tonic-gate 	/* Free old address if any */
1887c478bd9Sstevel@tonic-gate 
1897c478bd9Sstevel@tonic-gate 	if (addr)
1907c478bd9Sstevel@tonic-gate 		kmem_free(addr, strlen(addr) + 1);
1917c478bd9Sstevel@tonic-gate 	if (netid)
1927c478bd9Sstevel@tonic-gate 		kmem_free(netid, strlen(netid) + 1);
1937c478bd9Sstevel@tonic-gate 
1947c478bd9Sstevel@tonic-gate 	addr = cbp->cb_newer.cb_callback.cb_location.r_addr;
1957c478bd9Sstevel@tonic-gate 	netid = cbp->cb_newer.cb_callback.cb_location.r_netid;
1967c478bd9Sstevel@tonic-gate 
1977c478bd9Sstevel@tonic-gate 	if (addr)
1987c478bd9Sstevel@tonic-gate 		kmem_free(addr, strlen(addr) + 1);
1997c478bd9Sstevel@tonic-gate 	if (netid)
2007c478bd9Sstevel@tonic-gate 		kmem_free(netid, strlen(netid) + 1);
2017c478bd9Sstevel@tonic-gate 
2027c478bd9Sstevel@tonic-gate 	if (cbp->cb_chc_free) {
2037c478bd9Sstevel@tonic-gate 		rfs4_cb_chflush(cbp);
2047c478bd9Sstevel@tonic-gate 	}
2057c478bd9Sstevel@tonic-gate }
2067c478bd9Sstevel@tonic-gate 
2077c478bd9Sstevel@tonic-gate /*
2087c478bd9Sstevel@tonic-gate  * The server uses this to check the callback path supplied by the
2097c478bd9Sstevel@tonic-gate  * client.  The callback connection is marked "in progress" while this
2107c478bd9Sstevel@tonic-gate  * work is going on and then eventually marked either OK or FAILED.
2117c478bd9Sstevel@tonic-gate  * This work can be done as part of a separate thread and at the end
2127c478bd9Sstevel@tonic-gate  * of this the thread will exit or it may be done such that the caller
2137c478bd9Sstevel@tonic-gate  * will continue with other work.
2147c478bd9Sstevel@tonic-gate  */
2157c478bd9Sstevel@tonic-gate static void
2167c478bd9Sstevel@tonic-gate rfs4_do_cb_null(rfs4_client_t *cp)
2177c478bd9Sstevel@tonic-gate {
2187c478bd9Sstevel@tonic-gate 	struct timeval tv;
2197c478bd9Sstevel@tonic-gate 	CLIENT *ch;
2207c478bd9Sstevel@tonic-gate 	rfs4_cbstate_t newstate;
2217c478bd9Sstevel@tonic-gate 	rfs4_cbinfo_t *cbp = &cp->cbinfo;
2227c478bd9Sstevel@tonic-gate 
2237c478bd9Sstevel@tonic-gate 	mutex_enter(cbp->cb_lock);
2247c478bd9Sstevel@tonic-gate 	/* If another thread is doing CB_NULL RPC then return */
2257c478bd9Sstevel@tonic-gate 	if (cbp->cb_nullcaller == TRUE) {
2267c478bd9Sstevel@tonic-gate 		mutex_exit(cbp->cb_lock);
2277c478bd9Sstevel@tonic-gate 		rfs4_client_rele(cp);
2287c478bd9Sstevel@tonic-gate 		return;
2297c478bd9Sstevel@tonic-gate 	}
2307c478bd9Sstevel@tonic-gate 
2317c478bd9Sstevel@tonic-gate 	/* Mark the cbinfo as having a thread in the NULL callback */
2327c478bd9Sstevel@tonic-gate 	cbp->cb_nullcaller = TRUE;
2337c478bd9Sstevel@tonic-gate 
2347c478bd9Sstevel@tonic-gate 	/*
2357c478bd9Sstevel@tonic-gate 	 * Are there other threads still using the cbinfo client
2367c478bd9Sstevel@tonic-gate 	 * handles?  If so, this thread must wait before going and
2377c478bd9Sstevel@tonic-gate 	 * mucking aroiund with the callback information
2387c478bd9Sstevel@tonic-gate 	 */
239a31a5cfdSsamf 	while (cbp->cb_refcnt != 0)
2407c478bd9Sstevel@tonic-gate 		cv_wait(cbp->cb_cv_nullcaller, cbp->cb_lock);
2417c478bd9Sstevel@tonic-gate 
2427c478bd9Sstevel@tonic-gate 	/*
2437c478bd9Sstevel@tonic-gate 	 * This thread itself may find that new callback info has
2447c478bd9Sstevel@tonic-gate 	 * arrived and is set up to handle this case and redrive the
2457c478bd9Sstevel@tonic-gate 	 * call to the client's callback server.
2467c478bd9Sstevel@tonic-gate 	 */
2477c478bd9Sstevel@tonic-gate retry:
2487c478bd9Sstevel@tonic-gate 	if (cbp->cb_newer.cb_new == TRUE &&
2497c478bd9Sstevel@tonic-gate 	    cbp->cb_newer.cb_confirmed == TRUE) {
2507c478bd9Sstevel@tonic-gate 		char *addr = cbp->cb_callback.cb_location.r_addr;
2517c478bd9Sstevel@tonic-gate 		char *netid = cbp->cb_callback.cb_location.r_netid;
2527c478bd9Sstevel@tonic-gate 
2537c478bd9Sstevel@tonic-gate 		/*
2547c478bd9Sstevel@tonic-gate 		 * Free the old stuff if it exists; may be the first
2557c478bd9Sstevel@tonic-gate 		 * time through this path
2567c478bd9Sstevel@tonic-gate 		 */
2577c478bd9Sstevel@tonic-gate 		if (addr)
2587c478bd9Sstevel@tonic-gate 			kmem_free(addr, strlen(addr) + 1);
2597c478bd9Sstevel@tonic-gate 		if (netid)
2607c478bd9Sstevel@tonic-gate 			kmem_free(netid, strlen(netid) + 1);
2617c478bd9Sstevel@tonic-gate 
2627c478bd9Sstevel@tonic-gate 		/* Move over the addr/netid */
2637c478bd9Sstevel@tonic-gate 		cbp->cb_callback.cb_location.r_addr =
264*ed57cab9Srg 		    cbp->cb_newer.cb_callback.cb_location.r_addr;
2657c478bd9Sstevel@tonic-gate 		cbp->cb_newer.cb_callback.cb_location.r_addr = NULL;
2667c478bd9Sstevel@tonic-gate 		cbp->cb_callback.cb_location.r_netid =
267*ed57cab9Srg 		    cbp->cb_newer.cb_callback.cb_location.r_netid;
2687c478bd9Sstevel@tonic-gate 		cbp->cb_newer.cb_callback.cb_location.r_netid = NULL;
2697c478bd9Sstevel@tonic-gate 
2707c478bd9Sstevel@tonic-gate 		/* Get the program number */
2717c478bd9Sstevel@tonic-gate 		cbp->cb_callback.cb_program =
272*ed57cab9Srg 		    cbp->cb_newer.cb_callback.cb_program;
2737c478bd9Sstevel@tonic-gate 		cbp->cb_newer.cb_callback.cb_program = 0;
2747c478bd9Sstevel@tonic-gate 
2757c478bd9Sstevel@tonic-gate 		/* Don't forget the protocol's "cb_ident" field */
2767c478bd9Sstevel@tonic-gate 		cbp->cb_ident = cbp->cb_newer.cb_ident;
2777c478bd9Sstevel@tonic-gate 		cbp->cb_newer.cb_ident = 0;
2787c478bd9Sstevel@tonic-gate 
2797c478bd9Sstevel@tonic-gate 		/* no longer new */
2807c478bd9Sstevel@tonic-gate 		cbp->cb_newer.cb_new = FALSE;
2817c478bd9Sstevel@tonic-gate 		cbp->cb_newer.cb_confirmed = FALSE;
2827c478bd9Sstevel@tonic-gate 
2837c478bd9Sstevel@tonic-gate 		/* get rid of the old client handles that may exist */
2847c478bd9Sstevel@tonic-gate 		rfs4_cb_chflush(cbp);
2857c478bd9Sstevel@tonic-gate 
2867c478bd9Sstevel@tonic-gate 		cbp->cb_state = CB_NONE;
2877c478bd9Sstevel@tonic-gate 		cbp->cb_timefailed = 0; /* reset the clock */
2887c478bd9Sstevel@tonic-gate 		cbp->cb_notified_of_cb_path_down = TRUE;
2897c478bd9Sstevel@tonic-gate 	}
2907c478bd9Sstevel@tonic-gate 
2917c478bd9Sstevel@tonic-gate 	if (cbp->cb_state != CB_NONE) {
2927c478bd9Sstevel@tonic-gate 		cv_broadcast(cbp->cb_cv);	/* let the others know */
2937c478bd9Sstevel@tonic-gate 		cbp->cb_nullcaller = FALSE;
2947c478bd9Sstevel@tonic-gate 		mutex_exit(cbp->cb_lock);
2957c478bd9Sstevel@tonic-gate 		rfs4_client_rele(cp);
2967c478bd9Sstevel@tonic-gate 		return;
2977c478bd9Sstevel@tonic-gate 	}
2987c478bd9Sstevel@tonic-gate 
2997c478bd9Sstevel@tonic-gate 	/* mark rfs4_client_t as CALLBACK NULL in progress */
3007c478bd9Sstevel@tonic-gate 	cbp->cb_state = CB_INPROG;
3017c478bd9Sstevel@tonic-gate 	mutex_exit(cbp->cb_lock);
3027c478bd9Sstevel@tonic-gate 
3037c478bd9Sstevel@tonic-gate 	/* get/generate a client handle */
3047c478bd9Sstevel@tonic-gate 	if ((ch = rfs4_cb_getch(cbp)) == NULL) {
3057c478bd9Sstevel@tonic-gate 		mutex_enter(cbp->cb_lock);
3067c478bd9Sstevel@tonic-gate 		cbp->cb_state = CB_BAD;
3077c478bd9Sstevel@tonic-gate 		cbp->cb_timefailed = gethrestime_sec(); /* observability */
3087c478bd9Sstevel@tonic-gate 		goto retry;
3097c478bd9Sstevel@tonic-gate 	}
3107c478bd9Sstevel@tonic-gate 
3117c478bd9Sstevel@tonic-gate 
3127c478bd9Sstevel@tonic-gate 	tv.tv_sec = 30;
3137c478bd9Sstevel@tonic-gate 	tv.tv_usec = 0;
3147c478bd9Sstevel@tonic-gate 	if (clnt_call(ch, CB_NULL, xdr_void, NULL, xdr_void, NULL, tv) != 0) {
3157c478bd9Sstevel@tonic-gate 		newstate = CB_BAD;
3167c478bd9Sstevel@tonic-gate 	} else {
3177c478bd9Sstevel@tonic-gate 		newstate = CB_OK;
3187c478bd9Sstevel@tonic-gate #ifdef	DEBUG
3197c478bd9Sstevel@tonic-gate 		rfs4_cb_null++;
3207c478bd9Sstevel@tonic-gate #endif
3217c478bd9Sstevel@tonic-gate 	}
3227c478bd9Sstevel@tonic-gate 
3237c478bd9Sstevel@tonic-gate 	/* Check to see if the client has specified new callback info */
3247c478bd9Sstevel@tonic-gate 	mutex_enter(cbp->cb_lock);
3257c478bd9Sstevel@tonic-gate 	rfs4_cb_freech(cbp, ch, TRUE);
3267c478bd9Sstevel@tonic-gate 	if (cbp->cb_newer.cb_new == TRUE &&
3277c478bd9Sstevel@tonic-gate 	    cbp->cb_newer.cb_confirmed == TRUE) {
3287c478bd9Sstevel@tonic-gate 		goto retry;	/* give the CB_NULL another chance */
3297c478bd9Sstevel@tonic-gate 	}
3307c478bd9Sstevel@tonic-gate 
3317c478bd9Sstevel@tonic-gate 	cbp->cb_state = newstate;
3327c478bd9Sstevel@tonic-gate 	if (cbp->cb_state == CB_BAD)
3337c478bd9Sstevel@tonic-gate 		cbp->cb_timefailed = gethrestime_sec(); /* observability */
3347c478bd9Sstevel@tonic-gate 
3357c478bd9Sstevel@tonic-gate 	cv_broadcast(cbp->cb_cv);	/* start up the other threads */
3367c478bd9Sstevel@tonic-gate 	cbp->cb_nullcaller = FALSE;
3377c478bd9Sstevel@tonic-gate 	mutex_exit(cbp->cb_lock);
3387c478bd9Sstevel@tonic-gate 
3397c478bd9Sstevel@tonic-gate 	rfs4_client_rele(cp);
3407c478bd9Sstevel@tonic-gate }
3417c478bd9Sstevel@tonic-gate 
3427c478bd9Sstevel@tonic-gate /*
3437c478bd9Sstevel@tonic-gate  * Given a client struct, inspect the callback info to see if the
3447c478bd9Sstevel@tonic-gate  * callback path is up and available.  If it is being initialized,
3457c478bd9Sstevel@tonic-gate  * then wait for the CB_NULL RPC call to occur.
3467c478bd9Sstevel@tonic-gate  */
3477c478bd9Sstevel@tonic-gate static rfs4_cbinfo_t *
3487c478bd9Sstevel@tonic-gate rfs4_cbinfo_hold(rfs4_client_t *cp)
3497c478bd9Sstevel@tonic-gate {
3507c478bd9Sstevel@tonic-gate 	rfs4_cbinfo_t *cbp = &cp->cbinfo;
3517c478bd9Sstevel@tonic-gate 
3527c478bd9Sstevel@tonic-gate retry:
3537c478bd9Sstevel@tonic-gate 	mutex_enter(cbp->cb_lock);
3547c478bd9Sstevel@tonic-gate 
3557c478bd9Sstevel@tonic-gate 	if (cbp->cb_newer.cb_new == TRUE && cbp->cb_nullcaller == FALSE) {
3567c478bd9Sstevel@tonic-gate 		/*
3577c478bd9Sstevel@tonic-gate 		 * Looks like a new callback path may be available and
3587c478bd9Sstevel@tonic-gate 		 * noone has set it up.
3597c478bd9Sstevel@tonic-gate 		 */
3607c478bd9Sstevel@tonic-gate 		mutex_exit(cbp->cb_lock);
3617c478bd9Sstevel@tonic-gate 		rfs4_dbe_hold(cp->dbe);
3627c478bd9Sstevel@tonic-gate 		rfs4_do_cb_null(cp); /* caller will release client hold */
3637c478bd9Sstevel@tonic-gate 		goto retry;
3647c478bd9Sstevel@tonic-gate 	}
3657c478bd9Sstevel@tonic-gate 
3667c478bd9Sstevel@tonic-gate 	/* Is there a thread working on doing the CB_NULL RPC? */
3677c478bd9Sstevel@tonic-gate 	if (cbp->cb_nullcaller == TRUE)
3687c478bd9Sstevel@tonic-gate 		cv_wait(cbp->cb_cv, cbp->cb_lock);  /* if so, wait on it */
3697c478bd9Sstevel@tonic-gate 
3707c478bd9Sstevel@tonic-gate 	/* If the callback path is not okay (up and running), just quit */
3717c478bd9Sstevel@tonic-gate 	if (cbp->cb_state != CB_OK) {
3727c478bd9Sstevel@tonic-gate 		mutex_exit(cbp->cb_lock);
3737c478bd9Sstevel@tonic-gate 		return (NULL);
3747c478bd9Sstevel@tonic-gate 	}
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate 	/* Let someone know we are using the current callback info */
3777c478bd9Sstevel@tonic-gate 	cbp->cb_refcnt++;
3787c478bd9Sstevel@tonic-gate 	mutex_exit(cbp->cb_lock);
3797c478bd9Sstevel@tonic-gate 	return (cbp);
3807c478bd9Sstevel@tonic-gate }
3817c478bd9Sstevel@tonic-gate 
3827c478bd9Sstevel@tonic-gate /*
3837c478bd9Sstevel@tonic-gate  * The caller is done with the callback info.  It may be that the
3847c478bd9Sstevel@tonic-gate  * caller's RPC failed and the NFSv4 client has actually provided new
3857c478bd9Sstevel@tonic-gate  * callback information.  If so, let the caller know so they can
3867c478bd9Sstevel@tonic-gate  * advantage of this and maybe retry the RPC that originally failed.
3877c478bd9Sstevel@tonic-gate  */
3887c478bd9Sstevel@tonic-gate static int
3897c478bd9Sstevel@tonic-gate rfs4_cbinfo_rele(rfs4_cbinfo_t *cbp, rfs4_cbstate_t newstate)
3907c478bd9Sstevel@tonic-gate {
3917c478bd9Sstevel@tonic-gate 	int cb_new = FALSE;
3927c478bd9Sstevel@tonic-gate 
3937c478bd9Sstevel@tonic-gate 	mutex_enter(cbp->cb_lock);
3947c478bd9Sstevel@tonic-gate 
3957c478bd9Sstevel@tonic-gate 	/* The caller gets a chance to mark the callback info as bad */
3967c478bd9Sstevel@tonic-gate 	if (newstate != CB_NOCHANGE)
3977c478bd9Sstevel@tonic-gate 		cbp->cb_state = newstate;
3987c478bd9Sstevel@tonic-gate 	if (newstate == CB_FAILED) {
3997c478bd9Sstevel@tonic-gate 		cbp->cb_timefailed = gethrestime_sec(); /* observability */
4007c478bd9Sstevel@tonic-gate 		cbp->cb_notified_of_cb_path_down = FALSE;
4017c478bd9Sstevel@tonic-gate 	}
4027c478bd9Sstevel@tonic-gate 
4037c478bd9Sstevel@tonic-gate 	cbp->cb_refcnt--;	/* no longer using the information */
4047c478bd9Sstevel@tonic-gate 
4057c478bd9Sstevel@tonic-gate 	/*
4067c478bd9Sstevel@tonic-gate 	 * A thread may be waiting on this one to finish and if so,
4077c478bd9Sstevel@tonic-gate 	 * let it know that it is okay to do the CB_NULL to the
4087c478bd9Sstevel@tonic-gate 	 * client's callback server.
4097c478bd9Sstevel@tonic-gate 	 */
4107c478bd9Sstevel@tonic-gate 	if (cbp->cb_refcnt == 0 && cbp->cb_nullcaller)
4117c478bd9Sstevel@tonic-gate 		cv_broadcast(cbp->cb_cv_nullcaller);
4127c478bd9Sstevel@tonic-gate 
4137c478bd9Sstevel@tonic-gate 	/*
4147c478bd9Sstevel@tonic-gate 	 * If this is the last thread to use the callback info and
4157c478bd9Sstevel@tonic-gate 	 * there is new callback information to try and no thread is
4167c478bd9Sstevel@tonic-gate 	 * there ready to do the CB_NULL, then return true to teh
4177c478bd9Sstevel@tonic-gate 	 * caller so they can do the CB_NULL
4187c478bd9Sstevel@tonic-gate 	 */
4197c478bd9Sstevel@tonic-gate 	if (cbp->cb_refcnt == 0 &&
420*ed57cab9Srg 	    cbp->cb_nullcaller == FALSE &&
421*ed57cab9Srg 	    cbp->cb_newer.cb_new == TRUE &&
422*ed57cab9Srg 	    cbp->cb_newer.cb_confirmed == TRUE)
4237c478bd9Sstevel@tonic-gate 		cb_new = TRUE;
4247c478bd9Sstevel@tonic-gate 
4257c478bd9Sstevel@tonic-gate 	mutex_exit(cbp->cb_lock);
4267c478bd9Sstevel@tonic-gate 
4277c478bd9Sstevel@tonic-gate 	return (cb_new);
4287c478bd9Sstevel@tonic-gate }
4297c478bd9Sstevel@tonic-gate 
4307c478bd9Sstevel@tonic-gate /*
4317c478bd9Sstevel@tonic-gate  * Given the information in the callback info struct, create a client
4327c478bd9Sstevel@tonic-gate  * handle that can be used by the server for its callback path.
4337c478bd9Sstevel@tonic-gate  */
4347c478bd9Sstevel@tonic-gate static CLIENT *
4357c478bd9Sstevel@tonic-gate rfs4_cbch_init(rfs4_cbinfo_t *cbp)
4367c478bd9Sstevel@tonic-gate {
4377c478bd9Sstevel@tonic-gate 	struct knetconfig knc;
4387c478bd9Sstevel@tonic-gate 	vnode_t *vp;
4397c478bd9Sstevel@tonic-gate 	struct sockaddr_in addr4;
4407c478bd9Sstevel@tonic-gate 	struct sockaddr_in6 addr6;
4417c478bd9Sstevel@tonic-gate 	void *addr, *taddr;
4427c478bd9Sstevel@tonic-gate 	in_port_t *pp;
4437c478bd9Sstevel@tonic-gate 	int af;
4447c478bd9Sstevel@tonic-gate 	char *devnam;
445*ed57cab9Srg 	int err;
4467c478bd9Sstevel@tonic-gate 	struct netbuf nb;
4477c478bd9Sstevel@tonic-gate 	int size;
4487c478bd9Sstevel@tonic-gate 	CLIENT *ch = NULL;
4497c478bd9Sstevel@tonic-gate 	int useresvport = 0;
4507c478bd9Sstevel@tonic-gate 
4517c478bd9Sstevel@tonic-gate 	mutex_enter(cbp->cb_lock);
4527c478bd9Sstevel@tonic-gate 
4537c478bd9Sstevel@tonic-gate 	if (cbp->cb_callback.cb_location.r_netid == NULL ||
4547c478bd9Sstevel@tonic-gate 	    cbp->cb_callback.cb_location.r_addr == NULL) {
4557c478bd9Sstevel@tonic-gate 		goto cb_init_out;
4567c478bd9Sstevel@tonic-gate 	}
4577c478bd9Sstevel@tonic-gate 
4587c478bd9Sstevel@tonic-gate 	if (strcmp(cbp->cb_callback.cb_location.r_netid, "tcp") == 0) {
4597c478bd9Sstevel@tonic-gate 		knc.knc_semantics = NC_TPI_COTS;
4607c478bd9Sstevel@tonic-gate 		knc.knc_protofmly = "inet";
4617c478bd9Sstevel@tonic-gate 		knc.knc_proto = "tcp";
4627c478bd9Sstevel@tonic-gate 		devnam = "/dev/tcp";
4637c478bd9Sstevel@tonic-gate 		af = AF_INET;
4647c478bd9Sstevel@tonic-gate 	} else if (strcmp(cbp->cb_callback.cb_location.r_netid, "udp")
465*ed57cab9Srg 	    == 0) {
4667c478bd9Sstevel@tonic-gate 		knc.knc_semantics = NC_TPI_CLTS;
4677c478bd9Sstevel@tonic-gate 		knc.knc_protofmly = "inet";
4687c478bd9Sstevel@tonic-gate 		knc.knc_proto = "udp";
4697c478bd9Sstevel@tonic-gate 		devnam = "/dev/udp";
4707c478bd9Sstevel@tonic-gate 		af = AF_INET;
4717c478bd9Sstevel@tonic-gate 	} else if (strcmp(cbp->cb_callback.cb_location.r_netid, "tcp6")
472*ed57cab9Srg 	    == 0) {
4737c478bd9Sstevel@tonic-gate 		knc.knc_semantics = NC_TPI_COTS;
4747c478bd9Sstevel@tonic-gate 		knc.knc_protofmly = "inet6";
4757c478bd9Sstevel@tonic-gate 		knc.knc_proto = "tcp";
4767c478bd9Sstevel@tonic-gate 		devnam = "/dev/tcp6";
4777c478bd9Sstevel@tonic-gate 		af = AF_INET6;
4787c478bd9Sstevel@tonic-gate 	} else if (strcmp(cbp->cb_callback.cb_location.r_netid, "udp6")
479*ed57cab9Srg 	    == 0) {
4807c478bd9Sstevel@tonic-gate 		knc.knc_semantics = NC_TPI_CLTS;
4817c478bd9Sstevel@tonic-gate 		knc.knc_protofmly = "inet6";
4827c478bd9Sstevel@tonic-gate 		knc.knc_proto = "udp";
4837c478bd9Sstevel@tonic-gate 		devnam = "/dev/udp6";
4847c478bd9Sstevel@tonic-gate 		af = AF_INET6;
4857c478bd9Sstevel@tonic-gate 	} else {
4867c478bd9Sstevel@tonic-gate 		goto cb_init_out;
4877c478bd9Sstevel@tonic-gate 	}
4887c478bd9Sstevel@tonic-gate 
4897c478bd9Sstevel@tonic-gate 	if ((err = lookupname(devnam, UIO_SYSSPACE, FOLLOW,
4907c478bd9Sstevel@tonic-gate 	    NULLVPP, &vp)) != 0) {
4917c478bd9Sstevel@tonic-gate 
4927c478bd9Sstevel@tonic-gate 		goto cb_init_out;
4937c478bd9Sstevel@tonic-gate 	}
4947c478bd9Sstevel@tonic-gate 
4957c478bd9Sstevel@tonic-gate 	if (vp->v_type != VCHR) {
4967c478bd9Sstevel@tonic-gate 		VN_RELE(vp);
4977c478bd9Sstevel@tonic-gate 		goto cb_init_out;
4987c478bd9Sstevel@tonic-gate 	}
4997c478bd9Sstevel@tonic-gate 
5007c478bd9Sstevel@tonic-gate 	knc.knc_rdev = vp->v_rdev;
5017c478bd9Sstevel@tonic-gate 
5027c478bd9Sstevel@tonic-gate 	VN_RELE(vp);
5037c478bd9Sstevel@tonic-gate 
5047c478bd9Sstevel@tonic-gate 	if (af == AF_INET) {
5057c478bd9Sstevel@tonic-gate 		size = sizeof (addr4);
5067c478bd9Sstevel@tonic-gate 		bzero(&addr4, size);
5077c478bd9Sstevel@tonic-gate 		addr4.sin_family = (sa_family_t)af;
5087c478bd9Sstevel@tonic-gate 		addr = &addr4.sin_addr;
5097c478bd9Sstevel@tonic-gate 		pp = &addr4.sin_port;
5107c478bd9Sstevel@tonic-gate 		taddr = &addr4;
5117c478bd9Sstevel@tonic-gate 	} else /* AF_INET6 */ {
5127c478bd9Sstevel@tonic-gate 		size = sizeof (addr6);
5137c478bd9Sstevel@tonic-gate 		bzero(&addr6, size);
5147c478bd9Sstevel@tonic-gate 		addr6.sin6_family = (sa_family_t)af;
5157c478bd9Sstevel@tonic-gate 		addr = &addr6.sin6_addr;
5167c478bd9Sstevel@tonic-gate 		pp = &addr6.sin6_port;
5177c478bd9Sstevel@tonic-gate 		taddr = &addr6;
5187c478bd9Sstevel@tonic-gate 	}
5197c478bd9Sstevel@tonic-gate 
5207c478bd9Sstevel@tonic-gate 	if (uaddr2sockaddr(af,
521*ed57cab9Srg 	    cbp->cb_callback.cb_location.r_addr, addr, pp)) {
5227c478bd9Sstevel@tonic-gate 
5237c478bd9Sstevel@tonic-gate 		goto cb_init_out;
5247c478bd9Sstevel@tonic-gate 	}
5257c478bd9Sstevel@tonic-gate 
5267c478bd9Sstevel@tonic-gate 
5277c478bd9Sstevel@tonic-gate 	nb.maxlen = nb.len = size;
5287c478bd9Sstevel@tonic-gate 	nb.buf = (char *)taddr;
5297c478bd9Sstevel@tonic-gate 
5307c478bd9Sstevel@tonic-gate 	if (err = clnt_tli_kcreate(&knc, &nb, cbp->cb_callback.cb_program,
5317c478bd9Sstevel@tonic-gate 	    NFS_CB, 0, 0, curthread->t_cred, &ch)) {
5327c478bd9Sstevel@tonic-gate 
5337c478bd9Sstevel@tonic-gate 		ch = NULL;
5347c478bd9Sstevel@tonic-gate 	}
5357c478bd9Sstevel@tonic-gate 
5367c478bd9Sstevel@tonic-gate 	/* turn off reserved port usage */
5377c478bd9Sstevel@tonic-gate 	(void) CLNT_CONTROL(ch, CLSET_BINDRESVPORT, (char *)&useresvport);
5387c478bd9Sstevel@tonic-gate 
5397c478bd9Sstevel@tonic-gate cb_init_out:
5407c478bd9Sstevel@tonic-gate 	mutex_exit(cbp->cb_lock);
5417c478bd9Sstevel@tonic-gate 	return (ch);
5427c478bd9Sstevel@tonic-gate }
5437c478bd9Sstevel@tonic-gate 
5447c478bd9Sstevel@tonic-gate /*
5457c478bd9Sstevel@tonic-gate  * Iterate over the client handle cache and
5467c478bd9Sstevel@tonic-gate  * destroy it.
5477c478bd9Sstevel@tonic-gate  */
5487c478bd9Sstevel@tonic-gate static void
5497c478bd9Sstevel@tonic-gate rfs4_cb_chflush(rfs4_cbinfo_t *cbp)
5507c478bd9Sstevel@tonic-gate {
5517c478bd9Sstevel@tonic-gate 	CLIENT *ch;
5527c478bd9Sstevel@tonic-gate 
5537c478bd9Sstevel@tonic-gate 	while (cbp->cb_chc_free) {
5547c478bd9Sstevel@tonic-gate 		cbp->cb_chc_free--;
5557c478bd9Sstevel@tonic-gate 		ch = cbp->cb_chc[cbp->cb_chc_free];
5567c478bd9Sstevel@tonic-gate 		cbp->cb_chc[cbp->cb_chc_free] = NULL;
5577c478bd9Sstevel@tonic-gate 		if (ch) {
5587c478bd9Sstevel@tonic-gate 			if (ch->cl_auth)
5597c478bd9Sstevel@tonic-gate 				auth_destroy(ch->cl_auth);
5607c478bd9Sstevel@tonic-gate 			clnt_destroy(ch);
5617c478bd9Sstevel@tonic-gate 		}
5627c478bd9Sstevel@tonic-gate 	}
5637c478bd9Sstevel@tonic-gate }
5647c478bd9Sstevel@tonic-gate 
5657c478bd9Sstevel@tonic-gate /*
5667c478bd9Sstevel@tonic-gate  * Return a client handle, either from a the small
5677c478bd9Sstevel@tonic-gate  * rfs4_client_t cache or one that we just created.
5687c478bd9Sstevel@tonic-gate  */
5697c478bd9Sstevel@tonic-gate static CLIENT *
5707c478bd9Sstevel@tonic-gate rfs4_cb_getch(rfs4_cbinfo_t *cbp)
5717c478bd9Sstevel@tonic-gate {
5727c478bd9Sstevel@tonic-gate 	CLIENT *cbch = NULL;
5737c478bd9Sstevel@tonic-gate 	uint32_t zilch = 0;
5747c478bd9Sstevel@tonic-gate 
5757c478bd9Sstevel@tonic-gate 	mutex_enter(cbp->cb_lock);
5767c478bd9Sstevel@tonic-gate 
5777c478bd9Sstevel@tonic-gate 	if (cbp->cb_chc_free) {
5787c478bd9Sstevel@tonic-gate 		cbp->cb_chc_free--;
5797c478bd9Sstevel@tonic-gate 		cbch = cbp->cb_chc[ cbp->cb_chc_free ];
5807c478bd9Sstevel@tonic-gate 		mutex_exit(cbp->cb_lock);
5817c478bd9Sstevel@tonic-gate 		(void) CLNT_CONTROL(cbch, CLSET_XID, (char *)&zilch);
5827c478bd9Sstevel@tonic-gate 		return (cbch);
5837c478bd9Sstevel@tonic-gate 	}
5847c478bd9Sstevel@tonic-gate 
5857c478bd9Sstevel@tonic-gate 	mutex_exit(cbp->cb_lock);
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate 	/* none free so make it now */
5887c478bd9Sstevel@tonic-gate 	cbch = rfs4_cbch_init(cbp);
5897c478bd9Sstevel@tonic-gate 
5907c478bd9Sstevel@tonic-gate 	return (cbch);
5917c478bd9Sstevel@tonic-gate }
5927c478bd9Sstevel@tonic-gate 
5937c478bd9Sstevel@tonic-gate /*
5947c478bd9Sstevel@tonic-gate  * Return the client handle to the small cache or
5957c478bd9Sstevel@tonic-gate  * destroy it.
5967c478bd9Sstevel@tonic-gate  */
5977c478bd9Sstevel@tonic-gate static void
5987c478bd9Sstevel@tonic-gate rfs4_cb_freech(rfs4_cbinfo_t *cbp, CLIENT *ch, bool_t lockheld)
5997c478bd9Sstevel@tonic-gate {
6007c478bd9Sstevel@tonic-gate 	if (lockheld == FALSE)
6017c478bd9Sstevel@tonic-gate 		mutex_enter(cbp->cb_lock);
6027c478bd9Sstevel@tonic-gate 
6037c478bd9Sstevel@tonic-gate 	if (cbp->cb_chc_free < RFS4_CBCH_MAX) {
6047c478bd9Sstevel@tonic-gate 		cbp->cb_chc[ cbp->cb_chc_free++ ] = ch;
6057c478bd9Sstevel@tonic-gate 		if (lockheld == FALSE)
6067c478bd9Sstevel@tonic-gate 			mutex_exit(cbp->cb_lock);
6077c478bd9Sstevel@tonic-gate 		return;
6087c478bd9Sstevel@tonic-gate 	}
6097c478bd9Sstevel@tonic-gate 	if (lockheld == FALSE)
6107c478bd9Sstevel@tonic-gate 		mutex_exit(cbp->cb_lock);
6117c478bd9Sstevel@tonic-gate 
6127c478bd9Sstevel@tonic-gate 	/*
6137c478bd9Sstevel@tonic-gate 	 * cache maxed out of free entries, obliterate
6147c478bd9Sstevel@tonic-gate 	 * this client handle, destroy it, throw it away.
6157c478bd9Sstevel@tonic-gate 	 */
6167c478bd9Sstevel@tonic-gate 	if (ch->cl_auth)
6177c478bd9Sstevel@tonic-gate 		auth_destroy(ch->cl_auth);
6187c478bd9Sstevel@tonic-gate 	clnt_destroy(ch);
6197c478bd9Sstevel@tonic-gate }
6207c478bd9Sstevel@tonic-gate 
6217c478bd9Sstevel@tonic-gate /*
6227c478bd9Sstevel@tonic-gate  * With the supplied callback information - initialize the client
6237c478bd9Sstevel@tonic-gate  * callback data.  If there is a callback in progress, save the
6247c478bd9Sstevel@tonic-gate  * callback info so that a thread can pick it up in the future.
6257c478bd9Sstevel@tonic-gate  */
6267c478bd9Sstevel@tonic-gate void
6277c478bd9Sstevel@tonic-gate rfs4_client_setcb(rfs4_client_t *cp, cb_client4 *cb, uint32_t cb_ident)
6287c478bd9Sstevel@tonic-gate {
6297c478bd9Sstevel@tonic-gate 	char *addr = NULL;
6307c478bd9Sstevel@tonic-gate 	char *netid = NULL;
6317c478bd9Sstevel@tonic-gate 	rfs4_cbinfo_t *cbp = &cp->cbinfo;
6327c478bd9Sstevel@tonic-gate 	size_t len;
6337c478bd9Sstevel@tonic-gate 
6347c478bd9Sstevel@tonic-gate 	/* Set the call back for the client */
635a31a5cfdSsamf 	if (cb->cb_location.r_addr && cb->cb_location.r_addr[0] != '\0' &&
636a31a5cfdSsamf 	    cb->cb_location.r_netid && cb->cb_location.r_netid[0] != '\0') {
6377c478bd9Sstevel@tonic-gate 		len = strlen(cb->cb_location.r_addr) + 1;
6387c478bd9Sstevel@tonic-gate 		addr = kmem_alloc(len, KM_SLEEP);
6397c478bd9Sstevel@tonic-gate 		bcopy(cb->cb_location.r_addr, addr, len);
6407c478bd9Sstevel@tonic-gate 		len = strlen(cb->cb_location.r_netid) + 1;
6417c478bd9Sstevel@tonic-gate 		netid = kmem_alloc(len, KM_SLEEP);
6427c478bd9Sstevel@tonic-gate 		bcopy(cb->cb_location.r_netid, netid, len);
6437c478bd9Sstevel@tonic-gate 	}
6447c478bd9Sstevel@tonic-gate 	/* ready to save the new information but first free old, if exists */
6457c478bd9Sstevel@tonic-gate 	mutex_enter(cbp->cb_lock);
6467c478bd9Sstevel@tonic-gate 
6477c478bd9Sstevel@tonic-gate 	cbp->cb_newer.cb_callback.cb_program = cb->cb_program;
648a31a5cfdSsamf 
649a31a5cfdSsamf 	if (cbp->cb_newer.cb_callback.cb_location.r_addr != NULL)
650a31a5cfdSsamf 		kmem_free(cbp->cb_newer.cb_callback.cb_location.r_addr,
651a31a5cfdSsamf 		    strlen(cbp->cb_newer.cb_callback.cb_location.r_addr) + 1);
6527c478bd9Sstevel@tonic-gate 	cbp->cb_newer.cb_callback.cb_location.r_addr = addr;
653a31a5cfdSsamf 
654a31a5cfdSsamf 	if (cbp->cb_newer.cb_callback.cb_location.r_netid != NULL)
655a31a5cfdSsamf 		kmem_free(cbp->cb_newer.cb_callback.cb_location.r_netid,
656a31a5cfdSsamf 		    strlen(cbp->cb_newer.cb_callback.cb_location.r_netid) + 1);
6577c478bd9Sstevel@tonic-gate 	cbp->cb_newer.cb_callback.cb_location.r_netid = netid;
6587c478bd9Sstevel@tonic-gate 
6597c478bd9Sstevel@tonic-gate 	cbp->cb_newer.cb_ident = cb_ident;
6607c478bd9Sstevel@tonic-gate 
6617c478bd9Sstevel@tonic-gate 	if (addr && *addr && netid && *netid) {
6627c478bd9Sstevel@tonic-gate 		cbp->cb_newer.cb_new = TRUE;
6637c478bd9Sstevel@tonic-gate 		cbp->cb_newer.cb_confirmed = FALSE;
6647c478bd9Sstevel@tonic-gate 	} else {
6657c478bd9Sstevel@tonic-gate 		cbp->cb_newer.cb_new = FALSE;
6667c478bd9Sstevel@tonic-gate 		cbp->cb_newer.cb_confirmed = FALSE;
6677c478bd9Sstevel@tonic-gate 	}
6687c478bd9Sstevel@tonic-gate 
6697c478bd9Sstevel@tonic-gate 	mutex_exit(cbp->cb_lock);
6707c478bd9Sstevel@tonic-gate }
6717c478bd9Sstevel@tonic-gate 
6727c478bd9Sstevel@tonic-gate /*
6737c478bd9Sstevel@tonic-gate  * The server uses this when processing SETCLIENTID_CONFIRM.  Callback
6747c478bd9Sstevel@tonic-gate  * information may have been provided on SETCLIENTID and this call
6757c478bd9Sstevel@tonic-gate  * marks that information as confirmed and then starts a thread to
6767c478bd9Sstevel@tonic-gate  * test the callback path.
6777c478bd9Sstevel@tonic-gate  */
6787c478bd9Sstevel@tonic-gate void
6797c478bd9Sstevel@tonic-gate rfs4_deleg_cb_check(rfs4_client_t *cp)
6807c478bd9Sstevel@tonic-gate {
6817c478bd9Sstevel@tonic-gate 	if (cp->cbinfo.cb_newer.cb_new == FALSE)
6827c478bd9Sstevel@tonic-gate 		return;
6837c478bd9Sstevel@tonic-gate 
6847c478bd9Sstevel@tonic-gate 	cp->cbinfo.cb_newer.cb_confirmed = TRUE;
6857c478bd9Sstevel@tonic-gate 
6867c478bd9Sstevel@tonic-gate 	rfs4_dbe_hold(cp->dbe); /* hold the client struct for thread */
6877c478bd9Sstevel@tonic-gate 
6887c478bd9Sstevel@tonic-gate 	(void) thread_create(NULL, 0, rfs4_do_cb_null, cp, 0, &p0, TS_RUN,
689*ed57cab9Srg 	    minclsyspri);
6907c478bd9Sstevel@tonic-gate }
6917c478bd9Sstevel@tonic-gate 
6927c478bd9Sstevel@tonic-gate static void
6937c478bd9Sstevel@tonic-gate rfs4args_cb_recall_free(nfs_cb_argop4 *argop)
6947c478bd9Sstevel@tonic-gate {
6957c478bd9Sstevel@tonic-gate 	CB_RECALL4args	*rec_argp;
6967c478bd9Sstevel@tonic-gate 
6977c478bd9Sstevel@tonic-gate 	rec_argp = &argop->nfs_cb_argop4_u.opcbrecall;
6987c478bd9Sstevel@tonic-gate 	if (rec_argp->fh.nfs_fh4_val)
6997c478bd9Sstevel@tonic-gate 		kmem_free(rec_argp->fh.nfs_fh4_val, rec_argp->fh.nfs_fh4_len);
7007c478bd9Sstevel@tonic-gate }
7017c478bd9Sstevel@tonic-gate 
7027c478bd9Sstevel@tonic-gate /* ARGSUSED */
7037c478bd9Sstevel@tonic-gate static void
7047c478bd9Sstevel@tonic-gate rfs4args_cb_getattr_free(nfs_cb_argop4 *argop)
7057c478bd9Sstevel@tonic-gate {
7067c478bd9Sstevel@tonic-gate 	CB_GETATTR4args *argp;
7077c478bd9Sstevel@tonic-gate 
7087c478bd9Sstevel@tonic-gate 	argp = &argop->nfs_cb_argop4_u.opcbgetattr;
7097c478bd9Sstevel@tonic-gate 	if (argp->fh.nfs_fh4_val)
7107c478bd9Sstevel@tonic-gate 		kmem_free(argp->fh.nfs_fh4_val, argp->fh.nfs_fh4_len);
7117c478bd9Sstevel@tonic-gate }
7127c478bd9Sstevel@tonic-gate 
7137c478bd9Sstevel@tonic-gate static void
7147c478bd9Sstevel@tonic-gate rfs4freeargres(CB_COMPOUND4args *args, CB_COMPOUND4res *resp)
7157c478bd9Sstevel@tonic-gate {
7167c478bd9Sstevel@tonic-gate 	int i, arglen;
7177c478bd9Sstevel@tonic-gate 	nfs_cb_argop4 *argop;
7187c478bd9Sstevel@tonic-gate 
7197c478bd9Sstevel@tonic-gate 	/*
7207c478bd9Sstevel@tonic-gate 	 * First free any special args alloc'd for specific ops.
7217c478bd9Sstevel@tonic-gate 	 */
7227c478bd9Sstevel@tonic-gate 	arglen = args->array_len;
7237c478bd9Sstevel@tonic-gate 	argop = args->array;
7247c478bd9Sstevel@tonic-gate 	for (i = 0; i < arglen; i++, argop++) {
7257c478bd9Sstevel@tonic-gate 
7267c478bd9Sstevel@tonic-gate 		switch (argop->argop) {
7277c478bd9Sstevel@tonic-gate 		case OP_CB_RECALL:
7287c478bd9Sstevel@tonic-gate 			rfs4args_cb_recall_free(argop);
7297c478bd9Sstevel@tonic-gate 			break;
7307c478bd9Sstevel@tonic-gate 
7317c478bd9Sstevel@tonic-gate 		case OP_CB_GETATTR:
7327c478bd9Sstevel@tonic-gate 			rfs4args_cb_getattr_free(argop);
7337c478bd9Sstevel@tonic-gate 			break;
7347c478bd9Sstevel@tonic-gate 
7357c478bd9Sstevel@tonic-gate 		default:
7367c478bd9Sstevel@tonic-gate 			return;
7377c478bd9Sstevel@tonic-gate 		}
7387c478bd9Sstevel@tonic-gate 	}
7397c478bd9Sstevel@tonic-gate 
7407c478bd9Sstevel@tonic-gate 	if (args->tag.utf8string_len > 0)
7417c478bd9Sstevel@tonic-gate 		UTF8STRING_FREE(args->tag)
7427c478bd9Sstevel@tonic-gate 
7437c478bd9Sstevel@tonic-gate 	kmem_free(args->array, arglen * sizeof (nfs_cb_argop4));
7447c478bd9Sstevel@tonic-gate 	if (resp)
7457c478bd9Sstevel@tonic-gate 		(void) xdr_free(xdr_CB_COMPOUND4res, (caddr_t)resp);
7467c478bd9Sstevel@tonic-gate }
7477c478bd9Sstevel@tonic-gate 
7487c478bd9Sstevel@tonic-gate /*
7497c478bd9Sstevel@tonic-gate  * General callback routine for the server to the client.
7507c478bd9Sstevel@tonic-gate  */
7517c478bd9Sstevel@tonic-gate static enum clnt_stat
7527c478bd9Sstevel@tonic-gate rfs4_do_callback(rfs4_client_t	*cp, CB_COMPOUND4args *args,
7537c478bd9Sstevel@tonic-gate 		CB_COMPOUND4res *res, struct timeval timeout)
7547c478bd9Sstevel@tonic-gate {
7557c478bd9Sstevel@tonic-gate 	rfs4_cbinfo_t *cbp;
7567c478bd9Sstevel@tonic-gate 	CLIENT *ch;
7577c478bd9Sstevel@tonic-gate 	/* start with this in case cb_getch() fails */
7587c478bd9Sstevel@tonic-gate 	enum clnt_stat	stat = RPC_FAILED;
7597c478bd9Sstevel@tonic-gate 
7607c478bd9Sstevel@tonic-gate 	res->tag.utf8string_val = NULL;
7617c478bd9Sstevel@tonic-gate 	res->array = NULL;
7627c478bd9Sstevel@tonic-gate 
7637c478bd9Sstevel@tonic-gate retry:
7647c478bd9Sstevel@tonic-gate 	cbp = rfs4_cbinfo_hold(cp);
7657c478bd9Sstevel@tonic-gate 	if (cbp == NULL)
7667c478bd9Sstevel@tonic-gate 		return (stat);
7677c478bd9Sstevel@tonic-gate 
7687c478bd9Sstevel@tonic-gate 	/* get a client handle */
7697c478bd9Sstevel@tonic-gate 	if ((ch = rfs4_cb_getch(cbp)) != NULL) {
7707c478bd9Sstevel@tonic-gate 		/*
7717c478bd9Sstevel@tonic-gate 		 * reset the cb_ident since it may have changed in
7727c478bd9Sstevel@tonic-gate 		 * rfs4_cbinfo_hold()
7737c478bd9Sstevel@tonic-gate 		 */
7747c478bd9Sstevel@tonic-gate 		args->callback_ident = cbp->cb_ident;
7757c478bd9Sstevel@tonic-gate 
776eac3aab7Srobinson 		stat = clnt_call(ch, CB_COMPOUND, xdr_CB_COMPOUND4args_srv,
777*ed57cab9Srg 		    (caddr_t)args, xdr_CB_COMPOUND4res,
778*ed57cab9Srg 		    (caddr_t)res, timeout);
7797c478bd9Sstevel@tonic-gate 
7807c478bd9Sstevel@tonic-gate 		/* free client handle */
7817c478bd9Sstevel@tonic-gate 		rfs4_cb_freech(cbp, ch, FALSE);
7827c478bd9Sstevel@tonic-gate 	}
7837c478bd9Sstevel@tonic-gate 
7847c478bd9Sstevel@tonic-gate 	/*
7857c478bd9Sstevel@tonic-gate 	 * If the rele says that there may be new callback info then
7867c478bd9Sstevel@tonic-gate 	 * retry this sequence and it may succeed as a result of the
7877c478bd9Sstevel@tonic-gate 	 * new callback path
7887c478bd9Sstevel@tonic-gate 	 */
7897c478bd9Sstevel@tonic-gate 	if (rfs4_cbinfo_rele(cbp,
790*ed57cab9Srg 	    (stat == RPC_SUCCESS ? CB_NOCHANGE : CB_FAILED)) == TRUE)
7917c478bd9Sstevel@tonic-gate 		goto retry;
7927c478bd9Sstevel@tonic-gate 
7937c478bd9Sstevel@tonic-gate 	return (stat);
7947c478bd9Sstevel@tonic-gate }
7957c478bd9Sstevel@tonic-gate 
7967c478bd9Sstevel@tonic-gate /*
7977c478bd9Sstevel@tonic-gate  * Used by the NFSv4 server to get attributes for a file while
7987c478bd9Sstevel@tonic-gate  * handling the case where a file has been write delegated.  For the
7997c478bd9Sstevel@tonic-gate  * time being, VOP_GETATTR() is called and CB_GETATTR processing is
8007c478bd9Sstevel@tonic-gate  * not undertaken.  This call site is maintained in case the server is
8017c478bd9Sstevel@tonic-gate  * updated in the future to handle write delegation space guarantees.
8027c478bd9Sstevel@tonic-gate  */
8037c478bd9Sstevel@tonic-gate nfsstat4
8047c478bd9Sstevel@tonic-gate rfs4_vop_getattr(vnode_t *vp, vattr_t *vap, int flag, cred_t *cr)
8057c478bd9Sstevel@tonic-gate {
8067c478bd9Sstevel@tonic-gate 	uint_t mask;
8077c478bd9Sstevel@tonic-gate 	int error;
8087c478bd9Sstevel@tonic-gate 
8097c478bd9Sstevel@tonic-gate 	mask = vap->va_mask;
8107c478bd9Sstevel@tonic-gate 	error = VOP_GETATTR(vp, vap, flag, cr);
8117c478bd9Sstevel@tonic-gate 	/*
8127c478bd9Sstevel@tonic-gate 	 * Some file systems clobber va_mask. it is probably wrong of
8137c478bd9Sstevel@tonic-gate 	 * them to do so, nonethless we practice defensive coding.
8147c478bd9Sstevel@tonic-gate 	 * See bug id 4276830.
8157c478bd9Sstevel@tonic-gate 	 */
8167c478bd9Sstevel@tonic-gate 	vap->va_mask = mask;
8177c478bd9Sstevel@tonic-gate 	return (puterrno4(error));
8187c478bd9Sstevel@tonic-gate }
8197c478bd9Sstevel@tonic-gate 
8207c478bd9Sstevel@tonic-gate /*
8217c478bd9Sstevel@tonic-gate  * This is used everywhere in the v2/v3 server to allow the
8227c478bd9Sstevel@tonic-gate  * integration of all NFS versions and the support of delegation.  For
8237c478bd9Sstevel@tonic-gate  * now, just call the VOP_GETATTR().  If the NFSv4 server is enhanced
8247c478bd9Sstevel@tonic-gate  * in the future to provide space guarantees for write delegations
8257c478bd9Sstevel@tonic-gate  * then this call site should be expanded to interact with the client.
8267c478bd9Sstevel@tonic-gate  */
8277c478bd9Sstevel@tonic-gate int
8287c478bd9Sstevel@tonic-gate rfs4_delegated_getattr(vnode_t *vp, vattr_t *vap, int flag, cred_t *cr)
8297c478bd9Sstevel@tonic-gate {
8307c478bd9Sstevel@tonic-gate 	return (VOP_GETATTR(vp, vap, flag, cr));
8317c478bd9Sstevel@tonic-gate }
8327c478bd9Sstevel@tonic-gate 
8337c478bd9Sstevel@tonic-gate /*
8347c478bd9Sstevel@tonic-gate  * Place the actual cb_recall otw call to client.
8357c478bd9Sstevel@tonic-gate  */
8367c478bd9Sstevel@tonic-gate static void
8377c478bd9Sstevel@tonic-gate rfs4_do_cb_recall(rfs4_deleg_state_t *dsp, bool_t trunc)
8387c478bd9Sstevel@tonic-gate {
8397c478bd9Sstevel@tonic-gate 	CB_COMPOUND4args	cb4_args;
8407c478bd9Sstevel@tonic-gate 	CB_COMPOUND4res		cb4_res;
8417c478bd9Sstevel@tonic-gate 	CB_RECALL4args		*rec_argp;
8427c478bd9Sstevel@tonic-gate 	nfs_cb_argop4		*argop;
8437c478bd9Sstevel@tonic-gate 	int			numops;
8447c478bd9Sstevel@tonic-gate 	int			argoplist_size;
8457c478bd9Sstevel@tonic-gate 	struct timeval		timeout;
8467c478bd9Sstevel@tonic-gate 	nfs_fh4			*fhp;
8477c478bd9Sstevel@tonic-gate 	enum clnt_stat		call_stat;
8487c478bd9Sstevel@tonic-gate 
8497c478bd9Sstevel@tonic-gate 	/*
8507c478bd9Sstevel@tonic-gate 	 * set up the compound args
8517c478bd9Sstevel@tonic-gate 	 */
8527c478bd9Sstevel@tonic-gate 	numops = 1;	/* CB_RECALL only */
8537c478bd9Sstevel@tonic-gate 
8547c478bd9Sstevel@tonic-gate 	argoplist_size = numops * sizeof (nfs_cb_argop4);
8557c478bd9Sstevel@tonic-gate 	argop = kmem_zalloc(argoplist_size, KM_SLEEP);
8567c478bd9Sstevel@tonic-gate 	argop->argop = OP_CB_RECALL;
8577c478bd9Sstevel@tonic-gate 	rec_argp = &argop->nfs_cb_argop4_u.opcbrecall;
8587c478bd9Sstevel@tonic-gate 
8597c478bd9Sstevel@tonic-gate 	(void) str_to_utf8("cb_recall", &cb4_args.tag);
8607c478bd9Sstevel@tonic-gate 	cb4_args.minorversion = CB4_MINORVERSION;
8617c478bd9Sstevel@tonic-gate 	/* cb4_args.callback_ident is set in rfs4_do_callback() */
8627c478bd9Sstevel@tonic-gate 	cb4_args.array_len = numops;
8637c478bd9Sstevel@tonic-gate 	cb4_args.array = argop;
8647c478bd9Sstevel@tonic-gate 
8657c478bd9Sstevel@tonic-gate 	/*
8667c478bd9Sstevel@tonic-gate 	 * fill in the args struct
8677c478bd9Sstevel@tonic-gate 	 */
8687c478bd9Sstevel@tonic-gate 	bcopy(&dsp->delegid.stateid, &rec_argp->stateid, sizeof (stateid4));
8697c478bd9Sstevel@tonic-gate 	rec_argp->truncate = trunc;
8707c478bd9Sstevel@tonic-gate 
8717c478bd9Sstevel@tonic-gate 	fhp = &dsp->finfo->filehandle;
8727c478bd9Sstevel@tonic-gate 	rec_argp->fh.nfs_fh4_val = kmem_alloc(sizeof (char) *
873*ed57cab9Srg 	    fhp->nfs_fh4_len, KM_SLEEP);
8747c478bd9Sstevel@tonic-gate 	nfs_fh4_copy(fhp, &rec_argp->fh);
8757c478bd9Sstevel@tonic-gate 
8767c478bd9Sstevel@tonic-gate 	/* Keep track of when we did this for observability */
8777c478bd9Sstevel@tonic-gate 	dsp->time_recalled = gethrestime_sec();
8787c478bd9Sstevel@tonic-gate 
8797c478bd9Sstevel@tonic-gate 	/*
8807c478bd9Sstevel@tonic-gate 	 * Set up the timeout for the callback and make the actual call.
8817c478bd9Sstevel@tonic-gate 	 * Timeout will be 80% of the lease period for this server.
8827c478bd9Sstevel@tonic-gate 	 */
8837c478bd9Sstevel@tonic-gate 	timeout.tv_sec = (rfs4_lease_time * 80) / 100;
8847c478bd9Sstevel@tonic-gate 	timeout.tv_usec = 0;
8857c478bd9Sstevel@tonic-gate 
886*ed57cab9Srg 	call_stat = rfs4_do_callback(dsp->client, &cb4_args, &cb4_res, timeout);
8877c478bd9Sstevel@tonic-gate 
8887c478bd9Sstevel@tonic-gate 	if (call_stat != RPC_SUCCESS || cb4_res.status != NFS4_OK) {
8897c478bd9Sstevel@tonic-gate 		rfs4_revoke_deleg(dsp);
8907c478bd9Sstevel@tonic-gate 	}
8917c478bd9Sstevel@tonic-gate 
8927c478bd9Sstevel@tonic-gate 	rfs4freeargres(&cb4_args, &cb4_res);
8937c478bd9Sstevel@tonic-gate }
8947c478bd9Sstevel@tonic-gate 
8957c478bd9Sstevel@tonic-gate struct recall_arg {
8967c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp;
8977c478bd9Sstevel@tonic-gate 	void (*recall)(rfs4_deleg_state_t *, bool_t trunc);
8987c478bd9Sstevel@tonic-gate 	bool_t trunc;
8997c478bd9Sstevel@tonic-gate };
9007c478bd9Sstevel@tonic-gate 
9017c478bd9Sstevel@tonic-gate static void
9027c478bd9Sstevel@tonic-gate do_recall(struct recall_arg *arg)
9037c478bd9Sstevel@tonic-gate {
9047c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp = arg->dsp;
9057c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp = dsp->finfo;
9067c478bd9Sstevel@tonic-gate 	callb_cpr_t cpr_info;
9077c478bd9Sstevel@tonic-gate 	kmutex_t cpr_lock;
9087c478bd9Sstevel@tonic-gate 
9097c478bd9Sstevel@tonic-gate 	mutex_init(&cpr_lock, NULL, MUTEX_DEFAULT, NULL);
9107c478bd9Sstevel@tonic-gate 	CALLB_CPR_INIT(&cpr_info, &cpr_lock, callb_generic_cpr, "nfsv4Recall");
9117c478bd9Sstevel@tonic-gate 
9127c478bd9Sstevel@tonic-gate 	/*
9137c478bd9Sstevel@tonic-gate 	 * It is possible that before this thread starts
9147c478bd9Sstevel@tonic-gate 	 * the client has send us a return_delegation, and
9157c478bd9Sstevel@tonic-gate 	 * if that is the case we do not need to send the
9167c478bd9Sstevel@tonic-gate 	 * recall callback.
9177c478bd9Sstevel@tonic-gate 	 */
9187c478bd9Sstevel@tonic-gate 	if (dsp->dtype != OPEN_DELEGATE_NONE) {
919*ed57cab9Srg 		DTRACE_PROBE3(nfss__i__recall,
920*ed57cab9Srg 		    struct recall_arg *, arg,
921*ed57cab9Srg 		    struct rfs4_deleg_state_t *, dsp,
922*ed57cab9Srg 		    struct rfs4_file_t *, fp);
9237c478bd9Sstevel@tonic-gate 
9247c478bd9Sstevel@tonic-gate 		if (arg->recall)
9257c478bd9Sstevel@tonic-gate 			(void) (*arg->recall)(dsp, arg->trunc);
9267c478bd9Sstevel@tonic-gate 	}
9277c478bd9Sstevel@tonic-gate 
9287c478bd9Sstevel@tonic-gate 	mutex_enter(fp->dinfo->recall_lock);
9297c478bd9Sstevel@tonic-gate 	/*
9307c478bd9Sstevel@tonic-gate 	 * Recall count may go negative if the parent thread that is
9317c478bd9Sstevel@tonic-gate 	 * creating the individual callback threads does not modify
9327c478bd9Sstevel@tonic-gate 	 * the recall_count field before the callback thread actually
9337c478bd9Sstevel@tonic-gate 	 * gets a response from the CB_RECALL
9347c478bd9Sstevel@tonic-gate 	 */
9357c478bd9Sstevel@tonic-gate 	fp->dinfo->recall_count--;
9367c478bd9Sstevel@tonic-gate 	if (fp->dinfo->recall_count == 0)
9377c478bd9Sstevel@tonic-gate 		cv_signal(fp->dinfo->recall_cv);
9387c478bd9Sstevel@tonic-gate 	mutex_exit(fp->dinfo->recall_lock);
9397c478bd9Sstevel@tonic-gate 
9407c478bd9Sstevel@tonic-gate 	mutex_enter(&cpr_lock);
9417c478bd9Sstevel@tonic-gate 	CALLB_CPR_EXIT(&cpr_info);
9427c478bd9Sstevel@tonic-gate 	mutex_destroy(&cpr_lock);
9437c478bd9Sstevel@tonic-gate 
9447c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_rele(dsp); /* release the hold for this thread */
9457c478bd9Sstevel@tonic-gate 
9467c478bd9Sstevel@tonic-gate 	kmem_free(arg, sizeof (struct recall_arg));
9477c478bd9Sstevel@tonic-gate }
9487c478bd9Sstevel@tonic-gate 
9497c478bd9Sstevel@tonic-gate struct master_recall_args {
9507c478bd9Sstevel@tonic-gate     rfs4_file_t *fp;
9517c478bd9Sstevel@tonic-gate     void (*recall)(rfs4_deleg_state_t *, bool_t);
9527c478bd9Sstevel@tonic-gate     bool_t trunc;
9537c478bd9Sstevel@tonic-gate };
9547c478bd9Sstevel@tonic-gate 
9557c478bd9Sstevel@tonic-gate static void
9567c478bd9Sstevel@tonic-gate do_recall_file(struct master_recall_args *map)
9577c478bd9Sstevel@tonic-gate {
9587c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp = map->fp;
9597c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp;
9607c478bd9Sstevel@tonic-gate 	struct recall_arg *arg;
9617c478bd9Sstevel@tonic-gate 	callb_cpr_t cpr_info;
9627c478bd9Sstevel@tonic-gate 	kmutex_t cpr_lock;
9637c478bd9Sstevel@tonic-gate 	int32_t recall_count;
9647c478bd9Sstevel@tonic-gate 
9657c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(fp->dbe);
966*ed57cab9Srg 
967*ed57cab9Srg 	/* Recall already in progress ? */
968*ed57cab9Srg 	mutex_enter(fp->dinfo->recall_lock);
9697c478bd9Sstevel@tonic-gate 	if (fp->dinfo->recall_count != 0) {
970*ed57cab9Srg 		mutex_exit(fp->dinfo->recall_lock);
9717c478bd9Sstevel@tonic-gate 		rfs4_dbe_rele_nolock(fp->dbe);
9727c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(fp->dbe);
9737c478bd9Sstevel@tonic-gate 		kmem_free(map, sizeof (struct master_recall_args));
9747c478bd9Sstevel@tonic-gate 		return;
9757c478bd9Sstevel@tonic-gate 	}
9767c478bd9Sstevel@tonic-gate 
977*ed57cab9Srg 	mutex_exit(fp->dinfo->recall_lock);
978*ed57cab9Srg 
9797c478bd9Sstevel@tonic-gate 	mutex_init(&cpr_lock, NULL, MUTEX_DEFAULT, NULL);
980*ed57cab9Srg 	CALLB_CPR_INIT(&cpr_info, &cpr_lock, callb_generic_cpr,	"v4RecallFile");
9817c478bd9Sstevel@tonic-gate 
9827c478bd9Sstevel@tonic-gate 	recall_count = 0;
9837c478bd9Sstevel@tonic-gate 	for (dsp = fp->delegationlist.next->dsp; dsp != NULL;
984*ed57cab9Srg 	    dsp = dsp->delegationlist.next->dsp) {
985*ed57cab9Srg 
986*ed57cab9Srg 		rfs4_dbe_lock(dsp->dbe);
987*ed57cab9Srg 		/*
988*ed57cab9Srg 		 * if this delegation state
989*ed57cab9Srg 		 * is being reaped skip it
990*ed57cab9Srg 		 */
991*ed57cab9Srg 		if (rfs4_dbe_is_invalid(dsp->dbe)) {
992*ed57cab9Srg 			rfs4_dbe_unlock(dsp->dbe);
993*ed57cab9Srg 			continue;
994*ed57cab9Srg 		}
995*ed57cab9Srg 
996*ed57cab9Srg 		/* hold for receiving thread */
997*ed57cab9Srg 		rfs4_dbe_hold(dsp->dbe);
998*ed57cab9Srg 		rfs4_dbe_unlock(dsp->dbe);
999*ed57cab9Srg 
10007c478bd9Sstevel@tonic-gate 		arg = kmem_alloc(sizeof (struct recall_arg), KM_SLEEP);
10017c478bd9Sstevel@tonic-gate 		arg->recall = map->recall;
10027c478bd9Sstevel@tonic-gate 		arg->trunc = map->trunc;
10037c478bd9Sstevel@tonic-gate 		arg->dsp = dsp;
10047c478bd9Sstevel@tonic-gate 
10057c478bd9Sstevel@tonic-gate 		recall_count++;
10067c478bd9Sstevel@tonic-gate 
10077c478bd9Sstevel@tonic-gate 		(void) thread_create(NULL, 0, do_recall, arg, 0, &p0, TS_RUN,
1008*ed57cab9Srg 		    minclsyspri);
10097c478bd9Sstevel@tonic-gate 	}
1010*ed57cab9Srg 
10117c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(fp->dbe);
10127c478bd9Sstevel@tonic-gate 
10137c478bd9Sstevel@tonic-gate 	mutex_enter(fp->dinfo->recall_lock);
10147c478bd9Sstevel@tonic-gate 	/*
10157c478bd9Sstevel@tonic-gate 	 * Recall count may go negative if the parent thread that is
10167c478bd9Sstevel@tonic-gate 	 * creating the individual callback threads does not modify
10177c478bd9Sstevel@tonic-gate 	 * the recall_count field before the callback thread actually
10187c478bd9Sstevel@tonic-gate 	 * gets a response from the CB_RECALL
10197c478bd9Sstevel@tonic-gate 	 */
10207c478bd9Sstevel@tonic-gate 	fp->dinfo->recall_count += recall_count;
10217c478bd9Sstevel@tonic-gate 	while (fp->dinfo->recall_count)
10227c478bd9Sstevel@tonic-gate 		cv_wait(fp->dinfo->recall_cv, fp->dinfo->recall_lock);
10237c478bd9Sstevel@tonic-gate 
10247c478bd9Sstevel@tonic-gate 	mutex_exit(fp->dinfo->recall_lock);
10257c478bd9Sstevel@tonic-gate 
1026*ed57cab9Srg 	DTRACE_PROBE1(nfss__i__recall_done, rfs4_file_t *, fp);
10277c478bd9Sstevel@tonic-gate 	rfs4_file_rele(fp);
10287c478bd9Sstevel@tonic-gate 	kmem_free(map, sizeof (struct master_recall_args));
10297c478bd9Sstevel@tonic-gate 	mutex_enter(&cpr_lock);
10307c478bd9Sstevel@tonic-gate 	CALLB_CPR_EXIT(&cpr_info);
10317c478bd9Sstevel@tonic-gate 	mutex_destroy(&cpr_lock);
10327c478bd9Sstevel@tonic-gate }
10337c478bd9Sstevel@tonic-gate 
10347c478bd9Sstevel@tonic-gate static void
10357c478bd9Sstevel@tonic-gate rfs4_recall_file(rfs4_file_t *fp,
10367c478bd9Sstevel@tonic-gate 	void (*recall)(rfs4_deleg_state_t *, bool_t trunc),
10377c478bd9Sstevel@tonic-gate 	bool_t trunc, rfs4_client_t *cp)
10387c478bd9Sstevel@tonic-gate {
10397c478bd9Sstevel@tonic-gate 	struct master_recall_args *args;
10407c478bd9Sstevel@tonic-gate 
10417c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(fp->dbe);
10427c478bd9Sstevel@tonic-gate 	if (fp->dinfo->dtype == OPEN_DELEGATE_NONE) {
10437c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(fp->dbe);
10447c478bd9Sstevel@tonic-gate 		return;
10457c478bd9Sstevel@tonic-gate 	}
10467c478bd9Sstevel@tonic-gate 	rfs4_dbe_hold(fp->dbe);	/* hold for new thread */
10477c478bd9Sstevel@tonic-gate 
10487c478bd9Sstevel@tonic-gate 	/*
10497c478bd9Sstevel@tonic-gate 	 * Mark the time we started the recall processing.
10507c478bd9Sstevel@tonic-gate 	 * If it has been previously recalled, do not reset the
10517c478bd9Sstevel@tonic-gate 	 * timer since this is used for the revocation decision.
10527c478bd9Sstevel@tonic-gate 	 */
10537c478bd9Sstevel@tonic-gate 	if (fp->dinfo->time_recalled == 0)
10547c478bd9Sstevel@tonic-gate 		fp->dinfo->time_recalled = gethrestime_sec();
10557c478bd9Sstevel@tonic-gate 	fp->dinfo->ever_recalled = TRUE; /* used for policy decision */
10567c478bd9Sstevel@tonic-gate 	/* Client causing recall not always available */
10577c478bd9Sstevel@tonic-gate 	if (cp)
10587c478bd9Sstevel@tonic-gate 		fp->dinfo->conflicted_client = cp->clientid;
10597c478bd9Sstevel@tonic-gate 
10607c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(fp->dbe);
10617c478bd9Sstevel@tonic-gate 
10627c478bd9Sstevel@tonic-gate 	args = kmem_alloc(sizeof (struct master_recall_args), KM_SLEEP);
10637c478bd9Sstevel@tonic-gate 	args->fp = fp;
10647c478bd9Sstevel@tonic-gate 	args->recall = recall;
10657c478bd9Sstevel@tonic-gate 	args->trunc = trunc;
10667c478bd9Sstevel@tonic-gate 
10677c478bd9Sstevel@tonic-gate 	(void) thread_create(NULL, 0, do_recall_file, args, 0, &p0, TS_RUN,
1068*ed57cab9Srg 	    minclsyspri);
10697c478bd9Sstevel@tonic-gate }
10707c478bd9Sstevel@tonic-gate 
10717c478bd9Sstevel@tonic-gate void
10727c478bd9Sstevel@tonic-gate rfs4_recall_deleg(rfs4_file_t *fp, bool_t trunc, rfs4_client_t *cp)
10737c478bd9Sstevel@tonic-gate {
10747c478bd9Sstevel@tonic-gate 	time_t elapsed1, elapsed2;
10757c478bd9Sstevel@tonic-gate 
10767c478bd9Sstevel@tonic-gate 	if (fp->dinfo->time_recalled != 0) {
10777c478bd9Sstevel@tonic-gate 		elapsed1 = gethrestime_sec() - fp->dinfo->time_recalled;
10787c478bd9Sstevel@tonic-gate 		elapsed2 = gethrestime_sec() - fp->dinfo->time_lastwrite;
10797c478bd9Sstevel@tonic-gate 		/* First check to see if a revocation should occur */
10807c478bd9Sstevel@tonic-gate 		if (elapsed1 > rfs4_lease_time &&
1081*ed57cab9Srg 		    elapsed2 > rfs4_lease_time) {
10827c478bd9Sstevel@tonic-gate 			rfs4_revoke_file(fp);
10837c478bd9Sstevel@tonic-gate 			return;
10847c478bd9Sstevel@tonic-gate 		}
10857c478bd9Sstevel@tonic-gate 		/*
10867c478bd9Sstevel@tonic-gate 		 * Next check to see if a recall should be done again
10877c478bd9Sstevel@tonic-gate 		 * so quickly.
10887c478bd9Sstevel@tonic-gate 		 */
10897c478bd9Sstevel@tonic-gate 		if (elapsed1 <= ((rfs4_lease_time * 20) / 100))
10907c478bd9Sstevel@tonic-gate 			return;
10917c478bd9Sstevel@tonic-gate 	}
10927c478bd9Sstevel@tonic-gate 	rfs4_recall_file(fp, rfs4_do_cb_recall, trunc, cp);
10937c478bd9Sstevel@tonic-gate }
10947c478bd9Sstevel@tonic-gate 
10957c478bd9Sstevel@tonic-gate /*
10967c478bd9Sstevel@tonic-gate  * rfs4_check_recall is called from rfs4_do_open to determine if the current
10977c478bd9Sstevel@tonic-gate  * open conflicts with the delegation.
10987c478bd9Sstevel@tonic-gate  * Return true if we need recall otherwise false.
10997c478bd9Sstevel@tonic-gate  * Assumes entry locks for sp and sp->finfo are held.
11007c478bd9Sstevel@tonic-gate  */
11017c478bd9Sstevel@tonic-gate bool_t
11027c478bd9Sstevel@tonic-gate rfs4_check_recall(rfs4_state_t *sp, uint32_t access)
11037c478bd9Sstevel@tonic-gate {
11047c478bd9Sstevel@tonic-gate 	open_delegation_type4 dtype = sp->finfo->dinfo->dtype;
11057c478bd9Sstevel@tonic-gate 
11067c478bd9Sstevel@tonic-gate 	switch (dtype) {
11077c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_NONE:
11087c478bd9Sstevel@tonic-gate 		/* Not currently delegated so there is nothing to do */
11097c478bd9Sstevel@tonic-gate 		return (FALSE);
11107c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_READ:
11117c478bd9Sstevel@tonic-gate 		/*
11127c478bd9Sstevel@tonic-gate 		 * If the access is only asking for READ then there is
11137c478bd9Sstevel@tonic-gate 		 * no conflict and nothing to do.  If it is asking
11147c478bd9Sstevel@tonic-gate 		 * for write, then there will be conflict and the read
11157c478bd9Sstevel@tonic-gate 		 * delegation should be recalled.
11167c478bd9Sstevel@tonic-gate 		 */
11177c478bd9Sstevel@tonic-gate 		if (access == OPEN4_SHARE_ACCESS_READ)
11187c478bd9Sstevel@tonic-gate 			return (FALSE);
11197c478bd9Sstevel@tonic-gate 		else
11207c478bd9Sstevel@tonic-gate 			return (TRUE);
11217c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_WRITE:
11227c478bd9Sstevel@tonic-gate 		/* Check to see if this client has the delegation */
11237c478bd9Sstevel@tonic-gate 		return (rfs4_is_deleg(sp));
11247c478bd9Sstevel@tonic-gate 	}
11257c478bd9Sstevel@tonic-gate 
11267c478bd9Sstevel@tonic-gate 	return (FALSE);
11277c478bd9Sstevel@tonic-gate }
11287c478bd9Sstevel@tonic-gate 
11297c478bd9Sstevel@tonic-gate /*
11307c478bd9Sstevel@tonic-gate  * Return the "best" allowable delegation available given the current
11317c478bd9Sstevel@tonic-gate  * delegation type and the desired access and deny modes on the file.
11327c478bd9Sstevel@tonic-gate  * At the point that this routine is called we know that the access and
11337c478bd9Sstevel@tonic-gate  * deny modes are consistent with the file modes.
11347c478bd9Sstevel@tonic-gate  */
11357c478bd9Sstevel@tonic-gate static open_delegation_type4
11367c478bd9Sstevel@tonic-gate rfs4_check_delegation(rfs4_state_t *sp, rfs4_file_t *fp)
11377c478bd9Sstevel@tonic-gate {
11387c478bd9Sstevel@tonic-gate 	open_delegation_type4 dtype = fp->dinfo->dtype;
11397c478bd9Sstevel@tonic-gate 	uint32_t access = sp->share_access;
11407c478bd9Sstevel@tonic-gate 	uint32_t deny = sp->share_deny;
11417c478bd9Sstevel@tonic-gate 	int readcnt = 0;
11427c478bd9Sstevel@tonic-gate 	int writecnt = 0;
11437c478bd9Sstevel@tonic-gate 
11447c478bd9Sstevel@tonic-gate 	switch (dtype) {
11457c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_NONE:
11467c478bd9Sstevel@tonic-gate 		/*
11477c478bd9Sstevel@tonic-gate 		 * Determine if more than just this OPEN have the file
11487c478bd9Sstevel@tonic-gate 		 * open and if so, no delegation may be provided to
11497c478bd9Sstevel@tonic-gate 		 * the client.
11507c478bd9Sstevel@tonic-gate 		 */
11517c478bd9Sstevel@tonic-gate 		if (access & OPEN4_SHARE_ACCESS_WRITE)
11527c478bd9Sstevel@tonic-gate 			writecnt++;
11537c478bd9Sstevel@tonic-gate 		if (access & OPEN4_SHARE_ACCESS_READ)
11547c478bd9Sstevel@tonic-gate 			readcnt++;
11557c478bd9Sstevel@tonic-gate 
11567c478bd9Sstevel@tonic-gate 		if (fp->access_read > readcnt || fp->access_write > writecnt)
11577c478bd9Sstevel@tonic-gate 			return (OPEN_DELEGATE_NONE);
11587c478bd9Sstevel@tonic-gate 
11597c478bd9Sstevel@tonic-gate 		/*
11607c478bd9Sstevel@tonic-gate 		 * If the client is going to write, or if the client
11617c478bd9Sstevel@tonic-gate 		 * has exclusive access, return a write delegation.
11627c478bd9Sstevel@tonic-gate 		 */
11637c478bd9Sstevel@tonic-gate 		if ((access & OPEN4_SHARE_ACCESS_WRITE) ||
11647c478bd9Sstevel@tonic-gate 		    (deny & (OPEN4_SHARE_DENY_READ | OPEN4_SHARE_DENY_WRITE)))
11657c478bd9Sstevel@tonic-gate 			return (OPEN_DELEGATE_WRITE);
11667c478bd9Sstevel@tonic-gate 		/*
11677c478bd9Sstevel@tonic-gate 		 * If we don't want to write or we've haven't denied read
11687c478bd9Sstevel@tonic-gate 		 * access to others, return a read delegation.
11697c478bd9Sstevel@tonic-gate 		 */
11707c478bd9Sstevel@tonic-gate 		if ((access & ~OPEN4_SHARE_ACCESS_WRITE) ||
1171*ed57cab9Srg 		    (deny & ~OPEN4_SHARE_DENY_READ))
11727c478bd9Sstevel@tonic-gate 			return (OPEN_DELEGATE_READ);
11737c478bd9Sstevel@tonic-gate 
11747c478bd9Sstevel@tonic-gate 		/* Shouldn't get here */
11757c478bd9Sstevel@tonic-gate 		return (OPEN_DELEGATE_NONE);
11767c478bd9Sstevel@tonic-gate 
11777c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_READ:
11787c478bd9Sstevel@tonic-gate 		/*
11797c478bd9Sstevel@tonic-gate 		 * If the file is delegated for read but we wan't to
11807c478bd9Sstevel@tonic-gate 		 * write or deny others to read then we can't delegate
11817c478bd9Sstevel@tonic-gate 		 * the file. We shouldn't get here since the delegation should
11827c478bd9Sstevel@tonic-gate 		 * have been recalled already.
11837c478bd9Sstevel@tonic-gate 		 */
11847c478bd9Sstevel@tonic-gate 		if ((access & OPEN4_SHARE_ACCESS_WRITE) ||
11857c478bd9Sstevel@tonic-gate 		    (deny & OPEN4_SHARE_DENY_READ))
1186*ed57cab9Srg 			return (OPEN_DELEGATE_NONE);
11877c478bd9Sstevel@tonic-gate 		return (OPEN_DELEGATE_READ);
11887c478bd9Sstevel@tonic-gate 
11897c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_WRITE:
11907c478bd9Sstevel@tonic-gate 		return (OPEN_DELEGATE_WRITE);
11917c478bd9Sstevel@tonic-gate 	}
11927c478bd9Sstevel@tonic-gate 
11937c478bd9Sstevel@tonic-gate 	/* Shouldn't get here */
11947c478bd9Sstevel@tonic-gate 	return (OPEN_DELEGATE_NONE);
11957c478bd9Sstevel@tonic-gate }
11967c478bd9Sstevel@tonic-gate 
11977c478bd9Sstevel@tonic-gate /*
11987c478bd9Sstevel@tonic-gate  * Given the desired delegation type and the "history" of the file
11997c478bd9Sstevel@tonic-gate  * determine the actual delegation type to return.
12007c478bd9Sstevel@tonic-gate  */
12017c478bd9Sstevel@tonic-gate static open_delegation_type4
12027c478bd9Sstevel@tonic-gate rfs4_delegation_policy(open_delegation_type4 dtype,
12037c478bd9Sstevel@tonic-gate 	rfs4_dinfo_t *dinfo, clientid4 cid)
12047c478bd9Sstevel@tonic-gate {
12057c478bd9Sstevel@tonic-gate 	time_t elapsed;
12067c478bd9Sstevel@tonic-gate 
12077c478bd9Sstevel@tonic-gate 	if (rfs4_deleg_policy != SRV_NORMAL_DELEGATE)
12087c478bd9Sstevel@tonic-gate 		return (OPEN_DELEGATE_NONE);
12097c478bd9Sstevel@tonic-gate 
12107c478bd9Sstevel@tonic-gate 	/*
12117c478bd9Sstevel@tonic-gate 	 * Has this file/delegation ever been recalled?  If not then
12127c478bd9Sstevel@tonic-gate 	 * no furhter checks for a delegation race need to be done.
12137c478bd9Sstevel@tonic-gate 	 * However if a recall has occurred, then check to see if a
12147c478bd9Sstevel@tonic-gate 	 * client has caused its own delegation recall to occur.  If
12157c478bd9Sstevel@tonic-gate 	 * not, then has a delegation for this file been returned
12167c478bd9Sstevel@tonic-gate 	 * recently?  If so, then do not assign a new delegation to
12177c478bd9Sstevel@tonic-gate 	 * avoid a "delegation race" between the original client and
12187c478bd9Sstevel@tonic-gate 	 * the new/conflicting client.
12197c478bd9Sstevel@tonic-gate 	 */
12207c478bd9Sstevel@tonic-gate 	if (dinfo->ever_recalled == TRUE) {
12217c478bd9Sstevel@tonic-gate 		if (dinfo->conflicted_client != cid) {
12227c478bd9Sstevel@tonic-gate 			elapsed = gethrestime_sec() - dinfo->time_returned;
12237c478bd9Sstevel@tonic-gate 			if (elapsed < rfs4_lease_time)
12247c478bd9Sstevel@tonic-gate 				return (OPEN_DELEGATE_NONE);
12257c478bd9Sstevel@tonic-gate 		}
12267c478bd9Sstevel@tonic-gate 	}
12277c478bd9Sstevel@tonic-gate 
12287c478bd9Sstevel@tonic-gate 	/* Limit the number of read grants */
12297c478bd9Sstevel@tonic-gate 	if (dtype == OPEN_DELEGATE_READ &&
1230*ed57cab9Srg 	    dinfo->rdgrants > MAX_READ_DELEGATIONS)
12317c478bd9Sstevel@tonic-gate 		return (OPEN_DELEGATE_NONE);
12327c478bd9Sstevel@tonic-gate 
12337c478bd9Sstevel@tonic-gate 	/*
12347c478bd9Sstevel@tonic-gate 	 * Should consider limiting total number of read/write
12357c478bd9Sstevel@tonic-gate 	 * delegations the server will permit.
12367c478bd9Sstevel@tonic-gate 	 */
12377c478bd9Sstevel@tonic-gate 
12387c478bd9Sstevel@tonic-gate 	return (dtype);
12397c478bd9Sstevel@tonic-gate }
12407c478bd9Sstevel@tonic-gate 
12417c478bd9Sstevel@tonic-gate /*
12427c478bd9Sstevel@tonic-gate  * Try and grant a delegation for an open give the state. The routine
12437c478bd9Sstevel@tonic-gate  * returns the delegation type granted. This could be OPEN_DELEGATE_NONE.
12447c478bd9Sstevel@tonic-gate  *
12457c478bd9Sstevel@tonic-gate  * The state and associate file entry must be locked
12467c478bd9Sstevel@tonic-gate  */
12477c478bd9Sstevel@tonic-gate rfs4_deleg_state_t *
12487c478bd9Sstevel@tonic-gate rfs4_grant_delegation(delegreq_t dreq, rfs4_state_t *sp, int *recall)
12497c478bd9Sstevel@tonic-gate {
12507c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp = sp->finfo;
12517c478bd9Sstevel@tonic-gate 	open_delegation_type4 dtype;
12527c478bd9Sstevel@tonic-gate 	int no_delegation;
12537c478bd9Sstevel@tonic-gate 
12547c478bd9Sstevel@tonic-gate 	ASSERT(rfs4_dbe_islocked(sp->dbe));
12557c478bd9Sstevel@tonic-gate 	ASSERT(rfs4_dbe_islocked(fp->dbe));
12567c478bd9Sstevel@tonic-gate 
12577c478bd9Sstevel@tonic-gate 	/* Is the server even providing delegations? */
12587c478bd9Sstevel@tonic-gate 	if (rfs4_deleg_policy == SRV_NEVER_DELEGATE || dreq == DELEG_NONE)
12597c478bd9Sstevel@tonic-gate 		return (NULL);
12607c478bd9Sstevel@tonic-gate 
12617c478bd9Sstevel@tonic-gate 	/* Check to see if delegations have been temporarily disabled */
12627c478bd9Sstevel@tonic-gate 	mutex_enter(&rfs4_deleg_lock);
12637c478bd9Sstevel@tonic-gate 	no_delegation = rfs4_deleg_disabled;
12647c478bd9Sstevel@tonic-gate 	mutex_exit(&rfs4_deleg_lock);
12657c478bd9Sstevel@tonic-gate 
12667c478bd9Sstevel@tonic-gate 	if (no_delegation)
12677c478bd9Sstevel@tonic-gate 		return (NULL);
12687c478bd9Sstevel@tonic-gate 
12697c478bd9Sstevel@tonic-gate 	/* Don't grant a delegation if a deletion is impending. */
12707c478bd9Sstevel@tonic-gate 	if (fp->dinfo->hold_grant > 0) {
12717c478bd9Sstevel@tonic-gate 		return (NULL);
12727c478bd9Sstevel@tonic-gate 	}
12737c478bd9Sstevel@tonic-gate 
12747c478bd9Sstevel@tonic-gate 	/*
12757c478bd9Sstevel@tonic-gate 	 * Don't grant a delegation if there are any lock manager
12767c478bd9Sstevel@tonic-gate 	 * (NFSv2/v3) locks for the file.  This is a bit of a hack (e.g.,
12777c478bd9Sstevel@tonic-gate 	 * if there are only read locks we should be able to grant a
12787c478bd9Sstevel@tonic-gate 	 * read-only delegation), but it's good enough for now.
12797c478bd9Sstevel@tonic-gate 	 *
12807c478bd9Sstevel@tonic-gate 	 * MT safety: the lock manager checks for conflicting delegations
12817c478bd9Sstevel@tonic-gate 	 * before processing a lock request.  That check will block until
12827c478bd9Sstevel@tonic-gate 	 * we are done here.  So if the lock manager acquires a lock after
12837c478bd9Sstevel@tonic-gate 	 * we decide to grant the delegation, the delegation will get
12847c478bd9Sstevel@tonic-gate 	 * immediately recalled (if there's a conflict), so we're safe.
12857c478bd9Sstevel@tonic-gate 	 */
12867c478bd9Sstevel@tonic-gate 	if (lm_vp_active(fp->vp)) {
12877c478bd9Sstevel@tonic-gate 		return (NULL);
12887c478bd9Sstevel@tonic-gate 	}
12897c478bd9Sstevel@tonic-gate 
12907c478bd9Sstevel@tonic-gate 	/*
12917c478bd9Sstevel@tonic-gate 	 * Based on the type of delegation request passed in, take the
12927c478bd9Sstevel@tonic-gate 	 * appropriate action (DELEG_NONE is handled above)
12937c478bd9Sstevel@tonic-gate 	 */
12947c478bd9Sstevel@tonic-gate 	switch (dreq) {
12957c478bd9Sstevel@tonic-gate 
12967c478bd9Sstevel@tonic-gate 	case DELEG_READ:
12977c478bd9Sstevel@tonic-gate 	case DELEG_WRITE:
12987c478bd9Sstevel@tonic-gate 		/*
12997c478bd9Sstevel@tonic-gate 		 * The server "must" grant the delegation in this case.
13007c478bd9Sstevel@tonic-gate 		 * Client is using open previous
13017c478bd9Sstevel@tonic-gate 		 */
13027c478bd9Sstevel@tonic-gate 		dtype = (open_delegation_type4)dreq;
13037c478bd9Sstevel@tonic-gate 		*recall = 1;
13047c478bd9Sstevel@tonic-gate 		break;
13057c478bd9Sstevel@tonic-gate 	case DELEG_ANY:
13067c478bd9Sstevel@tonic-gate 		/*
13077c478bd9Sstevel@tonic-gate 		 * If a valid callback path does not exist, no delegation may
13087c478bd9Sstevel@tonic-gate 		 * be granted.
13097c478bd9Sstevel@tonic-gate 		 */
13107c478bd9Sstevel@tonic-gate 		if (sp->owner->client->cbinfo.cb_state != CB_OK)
13117c478bd9Sstevel@tonic-gate 			return (NULL);
13127c478bd9Sstevel@tonic-gate 
13137c478bd9Sstevel@tonic-gate 		/*
13147c478bd9Sstevel@tonic-gate 		 * If the original operation which caused time_rm_delayed
13157c478bd9Sstevel@tonic-gate 		 * to be set hasn't been retried and completed for one
13167c478bd9Sstevel@tonic-gate 		 * full lease period, clear it and allow delegations to
13177c478bd9Sstevel@tonic-gate 		 * get granted again.
13187c478bd9Sstevel@tonic-gate 		 */
13197c478bd9Sstevel@tonic-gate 		if (fp->dinfo->time_rm_delayed > 0 &&
13207c478bd9Sstevel@tonic-gate 		    gethrestime_sec() >
13217c478bd9Sstevel@tonic-gate 		    fp->dinfo->time_rm_delayed + rfs4_lease_time)
13227c478bd9Sstevel@tonic-gate 			fp->dinfo->time_rm_delayed = 0;
13237c478bd9Sstevel@tonic-gate 
13247c478bd9Sstevel@tonic-gate 		/*
13257c478bd9Sstevel@tonic-gate 		 * If we are waiting for a delegation to be returned then
13267c478bd9Sstevel@tonic-gate 		 * don't delegate this file. We do this for correctness as
13277c478bd9Sstevel@tonic-gate 		 * well as if the file is being recalled we would likely
13287c478bd9Sstevel@tonic-gate 		 * recall this file again.
13297c478bd9Sstevel@tonic-gate 		 */
13307c478bd9Sstevel@tonic-gate 
13317c478bd9Sstevel@tonic-gate 		if (fp->dinfo->time_recalled != 0 ||
13327c478bd9Sstevel@tonic-gate 		    fp->dinfo->time_rm_delayed != 0)
13337c478bd9Sstevel@tonic-gate 			return (NULL);
13347c478bd9Sstevel@tonic-gate 
13357c478bd9Sstevel@tonic-gate 		/* Get the "best" delegation candidate */
13367c478bd9Sstevel@tonic-gate 		dtype = rfs4_check_delegation(sp, fp);
13377c478bd9Sstevel@tonic-gate 
13387c478bd9Sstevel@tonic-gate 		if (dtype == OPEN_DELEGATE_NONE)
13397c478bd9Sstevel@tonic-gate 			return (NULL);
13407c478bd9Sstevel@tonic-gate 
13417c478bd9Sstevel@tonic-gate 		/*
13427c478bd9Sstevel@tonic-gate 		 * Based on policy and the history of the file get the
13437c478bd9Sstevel@tonic-gate 		 * actual delegation.
13447c478bd9Sstevel@tonic-gate 		 */
13457c478bd9Sstevel@tonic-gate 		dtype = rfs4_delegation_policy(dtype, fp->dinfo,
1346*ed57cab9Srg 		    sp->owner->client->clientid);
13477c478bd9Sstevel@tonic-gate 
13487c478bd9Sstevel@tonic-gate 		if (dtype == OPEN_DELEGATE_NONE)
13497c478bd9Sstevel@tonic-gate 			return (NULL);
13507c478bd9Sstevel@tonic-gate 		break;
13517c478bd9Sstevel@tonic-gate 	default:
13527c478bd9Sstevel@tonic-gate 		return (NULL);
13537c478bd9Sstevel@tonic-gate 	}
13547c478bd9Sstevel@tonic-gate 
13557c478bd9Sstevel@tonic-gate 	/* set the delegation for the state */
13567c478bd9Sstevel@tonic-gate 	return (rfs4_deleg_state(sp, dtype, recall));
13577c478bd9Sstevel@tonic-gate }
13587c478bd9Sstevel@tonic-gate 
13597c478bd9Sstevel@tonic-gate void
13607c478bd9Sstevel@tonic-gate rfs4_set_deleg_response(rfs4_deleg_state_t *dsp, open_delegation4 *dp,
13617c478bd9Sstevel@tonic-gate 			nfsace4 *ace,  int recall)
13627c478bd9Sstevel@tonic-gate {
13637c478bd9Sstevel@tonic-gate 	open_write_delegation4 *wp;
13647c478bd9Sstevel@tonic-gate 	open_read_delegation4 *rp;
13657c478bd9Sstevel@tonic-gate 	nfs_space_limit4 *spl;
13667c478bd9Sstevel@tonic-gate 	nfsace4 nace;
13677c478bd9Sstevel@tonic-gate 
13687c478bd9Sstevel@tonic-gate 	/*
13697c478bd9Sstevel@tonic-gate 	 * We need to allocate a new copy of the who string.
13707c478bd9Sstevel@tonic-gate 	 * this string will be freed by the rfs4_op_open dis_resfree
13717c478bd9Sstevel@tonic-gate 	 * routine. We need to do this allocation since replays will
13727c478bd9Sstevel@tonic-gate 	 * be allocated and rfs4_compound can't tell the difference from
13737c478bd9Sstevel@tonic-gate 	 * a replay and an inital open. N.B. if an ace is passed in, it
13747c478bd9Sstevel@tonic-gate 	 * the caller's responsibility to free it.
13757c478bd9Sstevel@tonic-gate 	 */
13767c478bd9Sstevel@tonic-gate 
13777c478bd9Sstevel@tonic-gate 	if (ace == NULL) {
13787c478bd9Sstevel@tonic-gate 		/*
13797c478bd9Sstevel@tonic-gate 		 * Default is to deny all access, the client will have
13807c478bd9Sstevel@tonic-gate 		 * to contact the server.  XXX Do we want to actually
13817c478bd9Sstevel@tonic-gate 		 * set a deny for every one, or do we simply want to
13827c478bd9Sstevel@tonic-gate 		 * construct an entity that will match no one?
13837c478bd9Sstevel@tonic-gate 		 */
13847c478bd9Sstevel@tonic-gate 		nace.type = ACE4_ACCESS_DENIED_ACE_TYPE;
13857c478bd9Sstevel@tonic-gate 		nace.flag = 0;
13867c478bd9Sstevel@tonic-gate 		nace.access_mask = ACE4_VALID_MASK_BITS;
13877c478bd9Sstevel@tonic-gate 		(void) str_to_utf8(ACE4_WHO_EVERYONE, &nace.who);
13887c478bd9Sstevel@tonic-gate 	} else {
13897c478bd9Sstevel@tonic-gate 		nace.type = ace->type;
13907c478bd9Sstevel@tonic-gate 		nace.flag = ace->flag;
13917c478bd9Sstevel@tonic-gate 		nace.access_mask = ace->access_mask;
13927c478bd9Sstevel@tonic-gate 		(void) utf8_copy(&ace->who, &nace.who);
13937c478bd9Sstevel@tonic-gate 	}
13947c478bd9Sstevel@tonic-gate 
13957c478bd9Sstevel@tonic-gate 	dp->delegation_type = dsp->dtype;
13967c478bd9Sstevel@tonic-gate 
13977c478bd9Sstevel@tonic-gate 	switch (dsp->dtype) {
13987c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_NONE:
13997c478bd9Sstevel@tonic-gate 		break;
14007c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_READ:
14017c478bd9Sstevel@tonic-gate 		rp = &dp->open_delegation4_u.read;
14027c478bd9Sstevel@tonic-gate 		rp->stateid = dsp->delegid.stateid;
14037c478bd9Sstevel@tonic-gate 		rp->recall = (bool_t)recall;
14047c478bd9Sstevel@tonic-gate 		rp->permissions = nace;
14057c478bd9Sstevel@tonic-gate 		break;
14067c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_WRITE:
14077c478bd9Sstevel@tonic-gate 		wp = &dp->open_delegation4_u.write;
14087c478bd9Sstevel@tonic-gate 		wp->stateid = dsp->delegid.stateid;
14097c478bd9Sstevel@tonic-gate 		wp->recall = (bool_t)recall;
14107c478bd9Sstevel@tonic-gate 		spl = &wp->space_limit;
14117c478bd9Sstevel@tonic-gate 		spl->limitby = NFS_LIMIT_SIZE;
14127c478bd9Sstevel@tonic-gate 		spl->nfs_space_limit4_u.filesize = 0;
14137c478bd9Sstevel@tonic-gate 		wp->permissions = nace;
14147c478bd9Sstevel@tonic-gate 		break;
14157c478bd9Sstevel@tonic-gate 	}
14167c478bd9Sstevel@tonic-gate }
14177c478bd9Sstevel@tonic-gate 
14187c478bd9Sstevel@tonic-gate /*
14197c478bd9Sstevel@tonic-gate  * Check if the file is delegated via the provided file struct.
14207c478bd9Sstevel@tonic-gate  * Return TRUE if it is delegated.  This is intended for use by
14217c478bd9Sstevel@tonic-gate  * the v4 server.  The v2/v3 server code should use rfs4_check_delegated().
14227c478bd9Sstevel@tonic-gate  *
14237c478bd9Sstevel@tonic-gate  * Note that if the file is found to have a delegation, it is
14247c478bd9Sstevel@tonic-gate  * recalled, unless the clientid of the caller matches the clientid of the
14257c478bd9Sstevel@tonic-gate  * delegation. If the caller has specified, there is a slight delay
14267c478bd9Sstevel@tonic-gate  * inserted in the hopes that the delegation will be returned quickly.
14277c478bd9Sstevel@tonic-gate  */
14287c478bd9Sstevel@tonic-gate bool_t
14297c478bd9Sstevel@tonic-gate rfs4_check_delegated_byfp(int mode, rfs4_file_t *fp,
14307c478bd9Sstevel@tonic-gate 	bool_t trunc, bool_t do_delay, bool_t is_rm, clientid4 *cp)
14317c478bd9Sstevel@tonic-gate {
14327c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp;
14337c478bd9Sstevel@tonic-gate 
14347c478bd9Sstevel@tonic-gate 	/* Is delegation enabled? */
14357c478bd9Sstevel@tonic-gate 	if (rfs4_deleg_policy == SRV_NEVER_DELEGATE)
14367c478bd9Sstevel@tonic-gate 		return (FALSE);
14377c478bd9Sstevel@tonic-gate 
14387c478bd9Sstevel@tonic-gate 	/* do we have a delegation on this file? */
14397c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(fp->dbe);
14407c478bd9Sstevel@tonic-gate 	if (fp->dinfo->dtype == OPEN_DELEGATE_NONE) {
14417c478bd9Sstevel@tonic-gate 		if (is_rm)
14427c478bd9Sstevel@tonic-gate 			fp->dinfo->hold_grant++;
14437c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(fp->dbe);
14447c478bd9Sstevel@tonic-gate 		return (FALSE);
14457c478bd9Sstevel@tonic-gate 	}
14467c478bd9Sstevel@tonic-gate 	/*
14477c478bd9Sstevel@tonic-gate 	 * do we have a write delegation on this file or are we
14487c478bd9Sstevel@tonic-gate 	 * requesting write access to a file with any type of existing
14497c478bd9Sstevel@tonic-gate 	 * delegation?
14507c478bd9Sstevel@tonic-gate 	 */
14517c478bd9Sstevel@tonic-gate 	if (mode == FWRITE || fp->dinfo->dtype == OPEN_DELEGATE_WRITE) {
14527c478bd9Sstevel@tonic-gate 		if (cp != NULL) {
14537c478bd9Sstevel@tonic-gate 			dsp = fp->delegationlist.next->dsp;
14547c478bd9Sstevel@tonic-gate 			if (dsp == NULL) {
14557c478bd9Sstevel@tonic-gate 				rfs4_dbe_unlock(fp->dbe);
14567c478bd9Sstevel@tonic-gate 				return (FALSE);
14577c478bd9Sstevel@tonic-gate 			}
14587c478bd9Sstevel@tonic-gate 			/*
14597c478bd9Sstevel@tonic-gate 			 * Does the requestor already own the delegation?
14607c478bd9Sstevel@tonic-gate 			 */
14617c478bd9Sstevel@tonic-gate 			if (dsp->client->clientid == *(cp)) {
14627c478bd9Sstevel@tonic-gate 				rfs4_dbe_unlock(fp->dbe);
14637c478bd9Sstevel@tonic-gate 				return (FALSE);
14647c478bd9Sstevel@tonic-gate 			}
14657c478bd9Sstevel@tonic-gate 		}
14667c478bd9Sstevel@tonic-gate 
14677c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(fp->dbe);
14687c478bd9Sstevel@tonic-gate 		rfs4_recall_deleg(fp, trunc, NULL);
14697c478bd9Sstevel@tonic-gate 
14707c478bd9Sstevel@tonic-gate 		if (!do_delay) {
14717c478bd9Sstevel@tonic-gate 			rfs4_dbe_lock(fp->dbe);
14727c478bd9Sstevel@tonic-gate 			fp->dinfo->time_rm_delayed = gethrestime_sec();
14737c478bd9Sstevel@tonic-gate 			rfs4_dbe_unlock(fp->dbe);
14747c478bd9Sstevel@tonic-gate 			return (TRUE);
14757c478bd9Sstevel@tonic-gate 		}
14767c478bd9Sstevel@tonic-gate 
14777c478bd9Sstevel@tonic-gate 		delay(NFS4_DELEGATION_CONFLICT_DELAY);
14787c478bd9Sstevel@tonic-gate 
14797c478bd9Sstevel@tonic-gate 		rfs4_dbe_lock(fp->dbe);
14807c478bd9Sstevel@tonic-gate 		if (fp->dinfo->dtype != OPEN_DELEGATE_NONE) {
14817c478bd9Sstevel@tonic-gate 			fp->dinfo->time_rm_delayed = gethrestime_sec();
14827c478bd9Sstevel@tonic-gate 			rfs4_dbe_unlock(fp->dbe);
14837c478bd9Sstevel@tonic-gate 			return (TRUE);
14847c478bd9Sstevel@tonic-gate 		}
14857c478bd9Sstevel@tonic-gate 	}
14867c478bd9Sstevel@tonic-gate 	if (is_rm)
14877c478bd9Sstevel@tonic-gate 		fp->dinfo->hold_grant++;
14887c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(fp->dbe);
14897c478bd9Sstevel@tonic-gate 	return (FALSE);
14907c478bd9Sstevel@tonic-gate }
14917c478bd9Sstevel@tonic-gate 
14927c478bd9Sstevel@tonic-gate /*
14937c478bd9Sstevel@tonic-gate  * Check if the file is delegated in the case of a v2 or v3 access.
14947c478bd9Sstevel@tonic-gate  * Return TRUE if it is delegated which in turn means that v2 should
14957c478bd9Sstevel@tonic-gate  * drop the request and in the case of v3 JUKEBOX should be returned.
14967c478bd9Sstevel@tonic-gate  */
14977c478bd9Sstevel@tonic-gate bool_t
14987c478bd9Sstevel@tonic-gate rfs4_check_delegated(int mode, vnode_t *vp, bool_t trunc)
14997c478bd9Sstevel@tonic-gate {
15007c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp;
15017c478bd9Sstevel@tonic-gate 	bool_t create = FALSE;
15027c478bd9Sstevel@tonic-gate 	bool_t rc = FALSE;
15037c478bd9Sstevel@tonic-gate 
15047c478bd9Sstevel@tonic-gate 	rfs4_hold_deleg_policy();
15057c478bd9Sstevel@tonic-gate 
15067c478bd9Sstevel@tonic-gate 	/* Is delegation enabled? */
15077c478bd9Sstevel@tonic-gate 	if (rfs4_deleg_policy != SRV_NEVER_DELEGATE) {
15087c478bd9Sstevel@tonic-gate 		fp = rfs4_findfile(vp, NULL, &create);
15097c478bd9Sstevel@tonic-gate 		if (fp != NULL) {
15107c478bd9Sstevel@tonic-gate 			if (rfs4_check_delegated_byfp(mode, fp, trunc,
1511*ed57cab9Srg 			    TRUE, FALSE, NULL)) {
15127c478bd9Sstevel@tonic-gate 				rc = TRUE;
15137c478bd9Sstevel@tonic-gate 			}
15147c478bd9Sstevel@tonic-gate 			rfs4_file_rele(fp);
15157c478bd9Sstevel@tonic-gate 		}
15167c478bd9Sstevel@tonic-gate 	}
15177c478bd9Sstevel@tonic-gate 	rfs4_rele_deleg_policy();
15187c478bd9Sstevel@tonic-gate 	return (rc);
15197c478bd9Sstevel@tonic-gate }
15207c478bd9Sstevel@tonic-gate 
15217c478bd9Sstevel@tonic-gate /*
15227c478bd9Sstevel@tonic-gate  * Release a hold on the hold_grant counter which
15237c478bd9Sstevel@tonic-gate  * prevents delegation from being granted while a remove
15247c478bd9Sstevel@tonic-gate  * or a rename is in progress.
15257c478bd9Sstevel@tonic-gate  */
15267c478bd9Sstevel@tonic-gate void
15277c478bd9Sstevel@tonic-gate rfs4_clear_dont_grant(rfs4_file_t *fp)
15287c478bd9Sstevel@tonic-gate {
15297c478bd9Sstevel@tonic-gate 	if (rfs4_deleg_policy == SRV_NEVER_DELEGATE)
15307c478bd9Sstevel@tonic-gate 		return;
15317c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(fp->dbe);
15327c478bd9Sstevel@tonic-gate 	ASSERT(fp->dinfo->hold_grant > 0);
15337c478bd9Sstevel@tonic-gate 	fp->dinfo->hold_grant--;
15347c478bd9Sstevel@tonic-gate 	fp->dinfo->time_rm_delayed = 0;
15357c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(fp->dbe);
15367c478bd9Sstevel@tonic-gate }
15377c478bd9Sstevel@tonic-gate 
15387c478bd9Sstevel@tonic-gate /*
15397c478bd9Sstevel@tonic-gate  * State support for delegation.
15407c478bd9Sstevel@tonic-gate  * Set the state delegation type for this state;
15417c478bd9Sstevel@tonic-gate  * This routine is called from open via rfs4_grant_delegation and the entry
15427c478bd9Sstevel@tonic-gate  * locks on sp and sp->finfo are assumed.
15437c478bd9Sstevel@tonic-gate  */
15447c478bd9Sstevel@tonic-gate static rfs4_deleg_state_t *
15457c478bd9Sstevel@tonic-gate rfs4_deleg_state(rfs4_state_t *sp, open_delegation_type4 dtype, int *recall)
15467c478bd9Sstevel@tonic-gate {
15477c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp = sp->finfo;
15487c478bd9Sstevel@tonic-gate 	bool_t create = TRUE;
15497c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp;
15507c478bd9Sstevel@tonic-gate 	vnode_t *vp;
15517c478bd9Sstevel@tonic-gate 	int open_prev = *recall;
15527c478bd9Sstevel@tonic-gate 
1553da1b9cd5Sjwahlig 	ASSERT(rfs4_dbe_islocked(sp->dbe));
15547c478bd9Sstevel@tonic-gate 	ASSERT(rfs4_dbe_islocked(fp->dbe));
15557c478bd9Sstevel@tonic-gate 
15567c478bd9Sstevel@tonic-gate 	/* Shouldn't happen */
15577c478bd9Sstevel@tonic-gate 	if (fp->dinfo->recall_count != 0 ||
1558*ed57cab9Srg 	    (fp->dinfo->dtype == OPEN_DELEGATE_READ &&
1559*ed57cab9Srg 	    dtype != OPEN_DELEGATE_READ)) {
15607c478bd9Sstevel@tonic-gate 		return (NULL);
15617c478bd9Sstevel@tonic-gate 	}
15627c478bd9Sstevel@tonic-gate 
15637c478bd9Sstevel@tonic-gate 	/* Unlock to avoid deadlock */
15647c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(fp->dbe);
1565da1b9cd5Sjwahlig 	rfs4_dbe_unlock(sp->dbe);
15667c478bd9Sstevel@tonic-gate 
15677c478bd9Sstevel@tonic-gate 	dsp = rfs4_finddeleg(sp, &create);
15687c478bd9Sstevel@tonic-gate 
1569da1b9cd5Sjwahlig 	rfs4_dbe_lock(sp->dbe);
15707c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(fp->dbe);
15717c478bd9Sstevel@tonic-gate 
15727c478bd9Sstevel@tonic-gate 	if (dsp == NULL)
15737c478bd9Sstevel@tonic-gate 		return (NULL);
15747c478bd9Sstevel@tonic-gate 
1575da1b9cd5Sjwahlig 	/*
1576da1b9cd5Sjwahlig 	 * It is possible that since we dropped the lock
1577da1b9cd5Sjwahlig 	 * in order to call finddeleg, the rfs4_file_t
1578da1b9cd5Sjwahlig 	 * was marked such that we should not grant a
1579da1b9cd5Sjwahlig 	 * delegation, if so bail out.
1580da1b9cd5Sjwahlig 	 */
1581da1b9cd5Sjwahlig 	if (fp->dinfo->hold_grant > 0) {
1582da1b9cd5Sjwahlig 		rfs4_deleg_state_rele(dsp);
1583da1b9cd5Sjwahlig 		return (NULL);
1584da1b9cd5Sjwahlig 	}
1585da1b9cd5Sjwahlig 
15867c478bd9Sstevel@tonic-gate 	if (create == FALSE) {
15877c478bd9Sstevel@tonic-gate 		if (sp->owner->client == dsp->client &&
15887c478bd9Sstevel@tonic-gate 		    dsp->dtype == dtype) {
15897c478bd9Sstevel@tonic-gate 			return (dsp);
15907c478bd9Sstevel@tonic-gate 		} else {
15917c478bd9Sstevel@tonic-gate 			rfs4_deleg_state_rele(dsp);
15927c478bd9Sstevel@tonic-gate 			return (NULL);
15937c478bd9Sstevel@tonic-gate 		}
15947c478bd9Sstevel@tonic-gate 	}
15957c478bd9Sstevel@tonic-gate 
15967c478bd9Sstevel@tonic-gate 	/*
15977c478bd9Sstevel@tonic-gate 	 * Check that this file has not been delegated to another
15987c478bd9Sstevel@tonic-gate 	 * client
15997c478bd9Sstevel@tonic-gate 	 */
16007c478bd9Sstevel@tonic-gate 	if (fp->dinfo->recall_count != 0 ||
1601*ed57cab9Srg 	    fp->dinfo->dtype == OPEN_DELEGATE_WRITE ||
1602*ed57cab9Srg 	    (fp->dinfo->dtype == OPEN_DELEGATE_READ &&
1603*ed57cab9Srg 	    dtype != OPEN_DELEGATE_READ)) {
16047c478bd9Sstevel@tonic-gate 		rfs4_deleg_state_rele(dsp);
16057c478bd9Sstevel@tonic-gate 		return (NULL);
16067c478bd9Sstevel@tonic-gate 	}
16077c478bd9Sstevel@tonic-gate 
16087c478bd9Sstevel@tonic-gate 	vp = fp->vp;
16097c478bd9Sstevel@tonic-gate 	/* vnevent_support returns 0 if file system supports vnevents */
16107c478bd9Sstevel@tonic-gate 	if (vnevent_support(vp)) {
16117c478bd9Sstevel@tonic-gate 		rfs4_deleg_state_rele(dsp);
16127c478bd9Sstevel@tonic-gate 		return (NULL);
16137c478bd9Sstevel@tonic-gate 	}
16147c478bd9Sstevel@tonic-gate 
16157c478bd9Sstevel@tonic-gate 	*recall = 0;
16167c478bd9Sstevel@tonic-gate 	if (dtype == OPEN_DELEGATE_READ) {
16177c478bd9Sstevel@tonic-gate 		if (vn_is_opened(vp, V_WRITE) || vn_is_mapped(vp, V_WRITE)) {
16187c478bd9Sstevel@tonic-gate 			if (open_prev) {
16197c478bd9Sstevel@tonic-gate 				*recall = 1;
16207c478bd9Sstevel@tonic-gate 			} else {
16217c478bd9Sstevel@tonic-gate 				rfs4_deleg_state_rele(dsp);
16227c478bd9Sstevel@tonic-gate 				return (NULL);
16237c478bd9Sstevel@tonic-gate 			}
16247c478bd9Sstevel@tonic-gate 		}
16257c478bd9Sstevel@tonic-gate 		(void) fem_install(vp, deleg_rdops, (void *)fp, OPUNIQ,
1626*ed57cab9Srg 		    rfs4_mon_hold, rfs4_mon_rele);
16277c478bd9Sstevel@tonic-gate 		if (vn_is_opened(vp, V_WRITE) || vn_is_mapped(vp, V_WRITE)) {
16287c478bd9Sstevel@tonic-gate 			if (open_prev) {
16297c478bd9Sstevel@tonic-gate 				*recall = 1;
16307c478bd9Sstevel@tonic-gate 			} else {
16317c478bd9Sstevel@tonic-gate 				(void) fem_uninstall(vp, deleg_rdops,
1632*ed57cab9Srg 				    (void *)fp);
16337c478bd9Sstevel@tonic-gate 				rfs4_deleg_state_rele(dsp);
16347c478bd9Sstevel@tonic-gate 				return (NULL);
16357c478bd9Sstevel@tonic-gate 			}
16367c478bd9Sstevel@tonic-gate 		}
16377c478bd9Sstevel@tonic-gate 	} else { /* WRITE */
16387c478bd9Sstevel@tonic-gate 		if (vn_is_opened(vp, V_RDORWR) || vn_is_mapped(vp, V_RDORWR)) {
16397c478bd9Sstevel@tonic-gate 			if (open_prev) {
16407c478bd9Sstevel@tonic-gate 				*recall = 1;
16417c478bd9Sstevel@tonic-gate 			} else {
16427c478bd9Sstevel@tonic-gate 				rfs4_deleg_state_rele(dsp);
16437c478bd9Sstevel@tonic-gate 				return (NULL);
16447c478bd9Sstevel@tonic-gate 			}
16457c478bd9Sstevel@tonic-gate 		}
16467c478bd9Sstevel@tonic-gate 		(void) fem_install(vp, deleg_wrops, (void *)fp, OPUNIQ,
1647*ed57cab9Srg 		    rfs4_mon_hold, rfs4_mon_rele);
16487c478bd9Sstevel@tonic-gate 		if (vn_is_opened(vp, V_RDORWR) || vn_is_mapped(vp, V_RDORWR)) {
16497c478bd9Sstevel@tonic-gate 			if (open_prev) {
16507c478bd9Sstevel@tonic-gate 				*recall = 1;
16517c478bd9Sstevel@tonic-gate 			} else {
16527c478bd9Sstevel@tonic-gate 				(void) fem_uninstall(vp, deleg_wrops,
1653*ed57cab9Srg 				    (void *)fp);
16547c478bd9Sstevel@tonic-gate 				rfs4_deleg_state_rele(dsp);
16557c478bd9Sstevel@tonic-gate 				return (NULL);
16567c478bd9Sstevel@tonic-gate 			}
16577c478bd9Sstevel@tonic-gate 		}
16587c478bd9Sstevel@tonic-gate 	}
16597c478bd9Sstevel@tonic-gate 	/* Place on delegation list for file */
16607c478bd9Sstevel@tonic-gate 	insque(&dsp->delegationlist, fp->delegationlist.prev);
16617c478bd9Sstevel@tonic-gate 
16627c478bd9Sstevel@tonic-gate 	dsp->dtype = fp->dinfo->dtype = dtype;
16637c478bd9Sstevel@tonic-gate 
16647c478bd9Sstevel@tonic-gate 	/* Update delegation stats for this file */
16657c478bd9Sstevel@tonic-gate 	fp->dinfo->time_lastgrant = gethrestime_sec();
16667c478bd9Sstevel@tonic-gate 
16677c478bd9Sstevel@tonic-gate 	/* reset since this is a new delegation */
16687c478bd9Sstevel@tonic-gate 	fp->dinfo->conflicted_client = 0;
16697c478bd9Sstevel@tonic-gate 	fp->dinfo->ever_recalled = FALSE;
16707c478bd9Sstevel@tonic-gate 
16717c478bd9Sstevel@tonic-gate 	if (dtype == OPEN_DELEGATE_READ)
16727c478bd9Sstevel@tonic-gate 		fp->dinfo->rdgrants++;
16737c478bd9Sstevel@tonic-gate 	else
16747c478bd9Sstevel@tonic-gate 		fp->dinfo->wrgrants++;
16757c478bd9Sstevel@tonic-gate 
16767c478bd9Sstevel@tonic-gate 	return (dsp);
16777c478bd9Sstevel@tonic-gate }
16787c478bd9Sstevel@tonic-gate 
16797c478bd9Sstevel@tonic-gate /*
16807c478bd9Sstevel@tonic-gate  * State routine for the server when a delegation is returned.
16817c478bd9Sstevel@tonic-gate  */
16827c478bd9Sstevel@tonic-gate void
16837c478bd9Sstevel@tonic-gate rfs4_return_deleg(rfs4_deleg_state_t *dsp, bool_t revoked)
16847c478bd9Sstevel@tonic-gate {
16857c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp = dsp->finfo;
16867c478bd9Sstevel@tonic-gate 	open_delegation_type4 dtypewas;
16877c478bd9Sstevel@tonic-gate 
16887c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(fp->dbe);
16897c478bd9Sstevel@tonic-gate 	/* Remove state from recall list */
16907c478bd9Sstevel@tonic-gate 
16917c478bd9Sstevel@tonic-gate 	remque(&dsp->delegationlist);
16927c478bd9Sstevel@tonic-gate 	dsp->delegationlist.next = dsp->delegationlist.prev =
1693*ed57cab9Srg 	    &dsp->delegationlist;
16947c478bd9Sstevel@tonic-gate 
16957c478bd9Sstevel@tonic-gate 	if (&fp->delegationlist == fp->delegationlist.next) {
16967c478bd9Sstevel@tonic-gate 		dtypewas = fp->dinfo->dtype;
16977c478bd9Sstevel@tonic-gate 		fp->dinfo->dtype = OPEN_DELEGATE_NONE;
16987c478bd9Sstevel@tonic-gate 		rfs4_dbe_cv_broadcast(fp->dbe);
16997c478bd9Sstevel@tonic-gate 
17007c478bd9Sstevel@tonic-gate 		/* if file system was unshared, the vp will be NULL */
17017c478bd9Sstevel@tonic-gate 		if (fp->vp != NULL) {
17027c478bd9Sstevel@tonic-gate 			if (dtypewas == OPEN_DELEGATE_READ)
17037c478bd9Sstevel@tonic-gate 				(void) fem_uninstall(fp->vp, deleg_rdops,
1704*ed57cab9Srg 				    (void *)fp);
17057c478bd9Sstevel@tonic-gate 			else
17067c478bd9Sstevel@tonic-gate 				(void) fem_uninstall(fp->vp, deleg_wrops,
1707*ed57cab9Srg 				    (void *)fp);
17087c478bd9Sstevel@tonic-gate 		}
17097c478bd9Sstevel@tonic-gate 	}
17107c478bd9Sstevel@tonic-gate 
17117c478bd9Sstevel@tonic-gate 	switch (dsp->dtype) {
17127c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_READ:
17137c478bd9Sstevel@tonic-gate 		fp->dinfo->rdgrants--;
17147c478bd9Sstevel@tonic-gate 		break;
17157c478bd9Sstevel@tonic-gate 	case OPEN_DELEGATE_WRITE:
17167c478bd9Sstevel@tonic-gate 		fp->dinfo->wrgrants--;
17177c478bd9Sstevel@tonic-gate 		break;
17187c478bd9Sstevel@tonic-gate 	default:
17197c478bd9Sstevel@tonic-gate 		break;
17207c478bd9Sstevel@tonic-gate 	}
17217c478bd9Sstevel@tonic-gate 
17227c478bd9Sstevel@tonic-gate 	/* used in the policy decision */
17237c478bd9Sstevel@tonic-gate 	fp->dinfo->time_returned = gethrestime_sec();
17247c478bd9Sstevel@tonic-gate 
17257c478bd9Sstevel@tonic-gate 	/*
17267c478bd9Sstevel@tonic-gate 	 * reset the time_recalled field so future delegations are not
17277c478bd9Sstevel@tonic-gate 	 * accidentally revoked
17287c478bd9Sstevel@tonic-gate 	 */
17297c478bd9Sstevel@tonic-gate 	if ((fp->dinfo->rdgrants + fp->dinfo->wrgrants) == 0)
17307c478bd9Sstevel@tonic-gate 		fp->dinfo->time_recalled = 0;
17317c478bd9Sstevel@tonic-gate 
17327c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(fp->dbe);
17337c478bd9Sstevel@tonic-gate 
17347c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(dsp->dbe);
17357c478bd9Sstevel@tonic-gate 
17367c478bd9Sstevel@tonic-gate 	dsp->dtype = OPEN_DELEGATE_NONE;
17377c478bd9Sstevel@tonic-gate 
17387c478bd9Sstevel@tonic-gate 	if (revoked == TRUE)
17397c478bd9Sstevel@tonic-gate 		dsp->time_revoked = gethrestime_sec();
17407c478bd9Sstevel@tonic-gate 
17417c478bd9Sstevel@tonic-gate 	rfs4_dbe_invalidate(dsp->dbe);
17427c478bd9Sstevel@tonic-gate 
17437c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(dsp->dbe);
17447c478bd9Sstevel@tonic-gate 
17457c478bd9Sstevel@tonic-gate 	if (revoked == TRUE) {
17467c478bd9Sstevel@tonic-gate 		rfs4_dbe_lock(dsp->client->dbe);
17477c478bd9Sstevel@tonic-gate 		dsp->client->deleg_revoked++;	/* observability */
17487c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(dsp->client->dbe);
17497c478bd9Sstevel@tonic-gate 	}
17507c478bd9Sstevel@tonic-gate }
17517c478bd9Sstevel@tonic-gate 
17527c478bd9Sstevel@tonic-gate static void
17537c478bd9Sstevel@tonic-gate rfs4_revoke_deleg(rfs4_deleg_state_t *dsp)
17547c478bd9Sstevel@tonic-gate {
17557c478bd9Sstevel@tonic-gate 	rfs4_return_deleg(dsp, TRUE);
17567c478bd9Sstevel@tonic-gate }
17577c478bd9Sstevel@tonic-gate 
17587c478bd9Sstevel@tonic-gate static void
17597c478bd9Sstevel@tonic-gate rfs4_revoke_file(rfs4_file_t *fp)
17607c478bd9Sstevel@tonic-gate {
17617c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp;
17627c478bd9Sstevel@tonic-gate 
17637c478bd9Sstevel@tonic-gate 	/*
17647c478bd9Sstevel@tonic-gate 	 * The lock for rfs4_file_t must be held when traversing the
17657c478bd9Sstevel@tonic-gate 	 * delegation list but that lock needs to be released to call
17667c478bd9Sstevel@tonic-gate 	 * rfs4_revoke_deleg()
17677c478bd9Sstevel@tonic-gate 	 * This for loop is set up to check the list for being empty,
17687c478bd9Sstevel@tonic-gate 	 * and locking the rfs4_file_t struct on init and end
17697c478bd9Sstevel@tonic-gate 	 */
17707c478bd9Sstevel@tonic-gate 	for (rfs4_dbe_lock(fp->dbe);
1771*ed57cab9Srg 	    &fp->delegationlist != fp->delegationlist.next;
1772*ed57cab9Srg 	    rfs4_dbe_lock(fp->dbe)) {
17737c478bd9Sstevel@tonic-gate 
17747c478bd9Sstevel@tonic-gate 		dsp = fp->delegationlist.next->dsp;
17757c478bd9Sstevel@tonic-gate 		rfs4_dbe_hold(dsp->dbe);
17767c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(fp->dbe);
17777c478bd9Sstevel@tonic-gate 		rfs4_revoke_deleg(dsp);
17787c478bd9Sstevel@tonic-gate 		rfs4_deleg_state_rele(dsp);
17797c478bd9Sstevel@tonic-gate 	}
17807c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(fp->dbe);
17817c478bd9Sstevel@tonic-gate }
17827c478bd9Sstevel@tonic-gate 
17837c478bd9Sstevel@tonic-gate /*
17847c478bd9Sstevel@tonic-gate  * A delegation is assumed to be present on the file associated with
17857c478bd9Sstevel@tonic-gate  * "state".  Check to see if the delegation matches is associated with
17867c478bd9Sstevel@tonic-gate  * the same client as referenced by "state".  If it is not, TRUE is
17877c478bd9Sstevel@tonic-gate  * returned.  If the delegation DOES match the client (or no
17887c478bd9Sstevel@tonic-gate  * delegation is present), return FALSE.
17897c478bd9Sstevel@tonic-gate  * Assume the state entry and file entry are locked.
17907c478bd9Sstevel@tonic-gate  */
17917c478bd9Sstevel@tonic-gate bool_t
17927c478bd9Sstevel@tonic-gate rfs4_is_deleg(rfs4_state_t *state)
17937c478bd9Sstevel@tonic-gate {
17947c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp;
17957c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp = state->finfo;
17967c478bd9Sstevel@tonic-gate 	rfs4_client_t *cp = state->owner->client;
17977c478bd9Sstevel@tonic-gate 
17987c478bd9Sstevel@tonic-gate 	ASSERT(rfs4_dbe_islocked(fp->dbe));
17997c478bd9Sstevel@tonic-gate 	for (dsp = fp->delegationlist.next->dsp; dsp != NULL;
1800*ed57cab9Srg 	    dsp = dsp->delegationlist.next->dsp) {
18017c478bd9Sstevel@tonic-gate 		if (cp != dsp->client) {
18027c478bd9Sstevel@tonic-gate 			return (TRUE);
18037c478bd9Sstevel@tonic-gate 		}
18047c478bd9Sstevel@tonic-gate 	}
18057c478bd9Sstevel@tonic-gate 	return (FALSE);
18067c478bd9Sstevel@tonic-gate }
18077c478bd9Sstevel@tonic-gate 
18087c478bd9Sstevel@tonic-gate void
18097c478bd9Sstevel@tonic-gate rfs4_disable_delegation(void)
18107c478bd9Sstevel@tonic-gate {
18117c478bd9Sstevel@tonic-gate 	mutex_enter(&rfs4_deleg_lock);
18127c478bd9Sstevel@tonic-gate 	rfs4_deleg_disabled++;
18137c478bd9Sstevel@tonic-gate 	mutex_exit(&rfs4_deleg_lock);
18147c478bd9Sstevel@tonic-gate }
18157c478bd9Sstevel@tonic-gate 
18167c478bd9Sstevel@tonic-gate void
18177c478bd9Sstevel@tonic-gate rfs4_enable_delegation(void)
18187c478bd9Sstevel@tonic-gate {
18197c478bd9Sstevel@tonic-gate 	mutex_enter(&rfs4_deleg_lock);
18207c478bd9Sstevel@tonic-gate 	ASSERT(rfs4_deleg_disabled > 0);
18217c478bd9Sstevel@tonic-gate 	rfs4_deleg_disabled--;
18227c478bd9Sstevel@tonic-gate 	mutex_exit(&rfs4_deleg_lock);
18237c478bd9Sstevel@tonic-gate }
18247c478bd9Sstevel@tonic-gate 
18257c478bd9Sstevel@tonic-gate void
18267c478bd9Sstevel@tonic-gate rfs4_mon_hold(void *arg)
18277c478bd9Sstevel@tonic-gate {
18287c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp = arg;
18297c478bd9Sstevel@tonic-gate 
18307c478bd9Sstevel@tonic-gate 	rfs4_dbe_hold(fp->dbe);
18317c478bd9Sstevel@tonic-gate }
18327c478bd9Sstevel@tonic-gate 
18337c478bd9Sstevel@tonic-gate void
18347c478bd9Sstevel@tonic-gate rfs4_mon_rele(void *arg)
18357c478bd9Sstevel@tonic-gate {
18367c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp = arg;
18377c478bd9Sstevel@tonic-gate 
18387c478bd9Sstevel@tonic-gate 	rfs4_dbe_rele_nolock(fp->dbe);
18397c478bd9Sstevel@tonic-gate }
1840