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 5*da1b9cd5Sjwahlig * Common Development and Distribution License (the "License"). 6*da1b9cd5Sjwahlig * 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 /* 22eac3aab7Srobinson * Copyright 2006 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> 437c478bd9Sstevel@tonic-gate 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 = 1257c478bd9Sstevel@tonic-gate 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 if (cp == NULL) { 2247c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 2257c478bd9Sstevel@tonic-gate "rfs4_do_cb_null: no rfs4_client specified\n")); 2267c478bd9Sstevel@tonic-gate return; 2277c478bd9Sstevel@tonic-gate } 2287c478bd9Sstevel@tonic-gate 2297c478bd9Sstevel@tonic-gate mutex_enter(cbp->cb_lock); 2307c478bd9Sstevel@tonic-gate /* If another thread is doing CB_NULL RPC then return */ 2317c478bd9Sstevel@tonic-gate if (cbp->cb_nullcaller == TRUE) { 2327c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 2337c478bd9Sstevel@tonic-gate rfs4_client_rele(cp); 2347c478bd9Sstevel@tonic-gate return; 2357c478bd9Sstevel@tonic-gate } 2367c478bd9Sstevel@tonic-gate 2377c478bd9Sstevel@tonic-gate /* Mark the cbinfo as having a thread in the NULL callback */ 2387c478bd9Sstevel@tonic-gate cbp->cb_nullcaller = TRUE; 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate /* 2417c478bd9Sstevel@tonic-gate * Are there other threads still using the cbinfo client 2427c478bd9Sstevel@tonic-gate * handles? If so, this thread must wait before going and 2437c478bd9Sstevel@tonic-gate * mucking aroiund with the callback information 2447c478bd9Sstevel@tonic-gate */ 245a31a5cfdSsamf while (cbp->cb_refcnt != 0) 2467c478bd9Sstevel@tonic-gate cv_wait(cbp->cb_cv_nullcaller, cbp->cb_lock); 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate /* 2497c478bd9Sstevel@tonic-gate * This thread itself may find that new callback info has 2507c478bd9Sstevel@tonic-gate * arrived and is set up to handle this case and redrive the 2517c478bd9Sstevel@tonic-gate * call to the client's callback server. 2527c478bd9Sstevel@tonic-gate */ 2537c478bd9Sstevel@tonic-gate retry: 2547c478bd9Sstevel@tonic-gate if (cbp->cb_newer.cb_new == TRUE && 2557c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_confirmed == TRUE) { 2567c478bd9Sstevel@tonic-gate char *addr = cbp->cb_callback.cb_location.r_addr; 2577c478bd9Sstevel@tonic-gate char *netid = cbp->cb_callback.cb_location.r_netid; 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate /* 2607c478bd9Sstevel@tonic-gate * Free the old stuff if it exists; may be the first 2617c478bd9Sstevel@tonic-gate * time through this path 2627c478bd9Sstevel@tonic-gate */ 2637c478bd9Sstevel@tonic-gate if (addr) 2647c478bd9Sstevel@tonic-gate kmem_free(addr, strlen(addr) + 1); 2657c478bd9Sstevel@tonic-gate if (netid) 2667c478bd9Sstevel@tonic-gate kmem_free(netid, strlen(netid) + 1); 2677c478bd9Sstevel@tonic-gate 2687c478bd9Sstevel@tonic-gate /* Move over the addr/netid */ 2697c478bd9Sstevel@tonic-gate cbp->cb_callback.cb_location.r_addr = 2707c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_callback.cb_location.r_addr; 2717c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_callback.cb_location.r_addr = NULL; 2727c478bd9Sstevel@tonic-gate cbp->cb_callback.cb_location.r_netid = 2737c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_callback.cb_location.r_netid; 2747c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_callback.cb_location.r_netid = NULL; 2757c478bd9Sstevel@tonic-gate 2767c478bd9Sstevel@tonic-gate /* Get the program number */ 2777c478bd9Sstevel@tonic-gate cbp->cb_callback.cb_program = 2787c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_callback.cb_program; 2797c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_callback.cb_program = 0; 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate /* Don't forget the protocol's "cb_ident" field */ 2827c478bd9Sstevel@tonic-gate cbp->cb_ident = cbp->cb_newer.cb_ident; 2837c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_ident = 0; 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate /* no longer new */ 2867c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_new = FALSE; 2877c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_confirmed = FALSE; 2887c478bd9Sstevel@tonic-gate 2897c478bd9Sstevel@tonic-gate /* get rid of the old client handles that may exist */ 2907c478bd9Sstevel@tonic-gate rfs4_cb_chflush(cbp); 2917c478bd9Sstevel@tonic-gate 2927c478bd9Sstevel@tonic-gate cbp->cb_state = CB_NONE; 2937c478bd9Sstevel@tonic-gate cbp->cb_timefailed = 0; /* reset the clock */ 2947c478bd9Sstevel@tonic-gate cbp->cb_notified_of_cb_path_down = TRUE; 2957c478bd9Sstevel@tonic-gate } 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate if (cbp->cb_state != CB_NONE) { 2987c478bd9Sstevel@tonic-gate cv_broadcast(cbp->cb_cv); /* let the others know */ 2997c478bd9Sstevel@tonic-gate cbp->cb_nullcaller = FALSE; 3007c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 3017c478bd9Sstevel@tonic-gate rfs4_client_rele(cp); 3027c478bd9Sstevel@tonic-gate return; 3037c478bd9Sstevel@tonic-gate } 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate /* mark rfs4_client_t as CALLBACK NULL in progress */ 3067c478bd9Sstevel@tonic-gate cbp->cb_state = CB_INPROG; 3077c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 3087c478bd9Sstevel@tonic-gate 3097c478bd9Sstevel@tonic-gate /* get/generate a client handle */ 3107c478bd9Sstevel@tonic-gate if ((ch = rfs4_cb_getch(cbp)) == NULL) { 3117c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 3127c478bd9Sstevel@tonic-gate "rfs4_do_cb_null: failed to get client handle\n")); 3137c478bd9Sstevel@tonic-gate mutex_enter(cbp->cb_lock); 3147c478bd9Sstevel@tonic-gate cbp->cb_state = CB_BAD; 3157c478bd9Sstevel@tonic-gate cbp->cb_timefailed = gethrestime_sec(); /* observability */ 3167c478bd9Sstevel@tonic-gate goto retry; 3177c478bd9Sstevel@tonic-gate } 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate 3207c478bd9Sstevel@tonic-gate tv.tv_sec = 30; 3217c478bd9Sstevel@tonic-gate tv.tv_usec = 0; 3227c478bd9Sstevel@tonic-gate if (clnt_call(ch, CB_NULL, xdr_void, NULL, xdr_void, NULL, tv) != 0) { 3237c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 3247c478bd9Sstevel@tonic-gate "rfs4_do_cb_null: clnt_call failed\n")); 3257c478bd9Sstevel@tonic-gate 3267c478bd9Sstevel@tonic-gate newstate = CB_BAD; 3277c478bd9Sstevel@tonic-gate } else { 3287c478bd9Sstevel@tonic-gate newstate = CB_OK; 3297c478bd9Sstevel@tonic-gate #ifdef DEBUG 3307c478bd9Sstevel@tonic-gate rfs4_cb_null++; 3317c478bd9Sstevel@tonic-gate #endif 3327c478bd9Sstevel@tonic-gate } 3337c478bd9Sstevel@tonic-gate 3347c478bd9Sstevel@tonic-gate /* Check to see if the client has specified new callback info */ 3357c478bd9Sstevel@tonic-gate mutex_enter(cbp->cb_lock); 3367c478bd9Sstevel@tonic-gate rfs4_cb_freech(cbp, ch, TRUE); 3377c478bd9Sstevel@tonic-gate if (cbp->cb_newer.cb_new == TRUE && 3387c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_confirmed == TRUE) { 3397c478bd9Sstevel@tonic-gate goto retry; /* give the CB_NULL another chance */ 3407c478bd9Sstevel@tonic-gate } 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate cbp->cb_state = newstate; 3437c478bd9Sstevel@tonic-gate if (cbp->cb_state == CB_BAD) 3447c478bd9Sstevel@tonic-gate cbp->cb_timefailed = gethrestime_sec(); /* observability */ 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate cv_broadcast(cbp->cb_cv); /* start up the other threads */ 3477c478bd9Sstevel@tonic-gate cbp->cb_nullcaller = FALSE; 3487c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 3497c478bd9Sstevel@tonic-gate 3507c478bd9Sstevel@tonic-gate rfs4_client_rele(cp); 3517c478bd9Sstevel@tonic-gate } 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate /* 3547c478bd9Sstevel@tonic-gate * Given a client struct, inspect the callback info to see if the 3557c478bd9Sstevel@tonic-gate * callback path is up and available. If it is being initialized, 3567c478bd9Sstevel@tonic-gate * then wait for the CB_NULL RPC call to occur. 3577c478bd9Sstevel@tonic-gate */ 3587c478bd9Sstevel@tonic-gate static rfs4_cbinfo_t * 3597c478bd9Sstevel@tonic-gate rfs4_cbinfo_hold(rfs4_client_t *cp) 3607c478bd9Sstevel@tonic-gate { 3617c478bd9Sstevel@tonic-gate rfs4_cbinfo_t *cbp = &cp->cbinfo; 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate retry: 3647c478bd9Sstevel@tonic-gate mutex_enter(cbp->cb_lock); 3657c478bd9Sstevel@tonic-gate 3667c478bd9Sstevel@tonic-gate if (cbp->cb_newer.cb_new == TRUE && cbp->cb_nullcaller == FALSE) { 3677c478bd9Sstevel@tonic-gate /* 3687c478bd9Sstevel@tonic-gate * Looks like a new callback path may be available and 3697c478bd9Sstevel@tonic-gate * noone has set it up. 3707c478bd9Sstevel@tonic-gate */ 3717c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 3727c478bd9Sstevel@tonic-gate rfs4_dbe_hold(cp->dbe); 3737c478bd9Sstevel@tonic-gate rfs4_do_cb_null(cp); /* caller will release client hold */ 3747c478bd9Sstevel@tonic-gate goto retry; 3757c478bd9Sstevel@tonic-gate } 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate /* Is there a thread working on doing the CB_NULL RPC? */ 3787c478bd9Sstevel@tonic-gate if (cbp->cb_nullcaller == TRUE) 3797c478bd9Sstevel@tonic-gate cv_wait(cbp->cb_cv, cbp->cb_lock); /* if so, wait on it */ 3807c478bd9Sstevel@tonic-gate 3817c478bd9Sstevel@tonic-gate /* If the callback path is not okay (up and running), just quit */ 3827c478bd9Sstevel@tonic-gate if (cbp->cb_state != CB_OK) { 3837c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 3847c478bd9Sstevel@tonic-gate return (NULL); 3857c478bd9Sstevel@tonic-gate } 3867c478bd9Sstevel@tonic-gate 3877c478bd9Sstevel@tonic-gate /* Let someone know we are using the current callback info */ 3887c478bd9Sstevel@tonic-gate cbp->cb_refcnt++; 3897c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 3907c478bd9Sstevel@tonic-gate return (cbp); 3917c478bd9Sstevel@tonic-gate } 3927c478bd9Sstevel@tonic-gate 3937c478bd9Sstevel@tonic-gate /* 3947c478bd9Sstevel@tonic-gate * The caller is done with the callback info. It may be that the 3957c478bd9Sstevel@tonic-gate * caller's RPC failed and the NFSv4 client has actually provided new 3967c478bd9Sstevel@tonic-gate * callback information. If so, let the caller know so they can 3977c478bd9Sstevel@tonic-gate * advantage of this and maybe retry the RPC that originally failed. 3987c478bd9Sstevel@tonic-gate */ 3997c478bd9Sstevel@tonic-gate static int 4007c478bd9Sstevel@tonic-gate rfs4_cbinfo_rele(rfs4_cbinfo_t *cbp, rfs4_cbstate_t newstate) 4017c478bd9Sstevel@tonic-gate { 4027c478bd9Sstevel@tonic-gate int cb_new = FALSE; 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate mutex_enter(cbp->cb_lock); 4057c478bd9Sstevel@tonic-gate 4067c478bd9Sstevel@tonic-gate /* The caller gets a chance to mark the callback info as bad */ 4077c478bd9Sstevel@tonic-gate if (newstate != CB_NOCHANGE) 4087c478bd9Sstevel@tonic-gate cbp->cb_state = newstate; 4097c478bd9Sstevel@tonic-gate if (newstate == CB_FAILED) { 4107c478bd9Sstevel@tonic-gate cbp->cb_timefailed = gethrestime_sec(); /* observability */ 4117c478bd9Sstevel@tonic-gate cbp->cb_notified_of_cb_path_down = FALSE; 4127c478bd9Sstevel@tonic-gate } 4137c478bd9Sstevel@tonic-gate 4147c478bd9Sstevel@tonic-gate cbp->cb_refcnt--; /* no longer using the information */ 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate /* 4177c478bd9Sstevel@tonic-gate * A thread may be waiting on this one to finish and if so, 4187c478bd9Sstevel@tonic-gate * let it know that it is okay to do the CB_NULL to the 4197c478bd9Sstevel@tonic-gate * client's callback server. 4207c478bd9Sstevel@tonic-gate */ 4217c478bd9Sstevel@tonic-gate if (cbp->cb_refcnt == 0 && cbp->cb_nullcaller) 4227c478bd9Sstevel@tonic-gate cv_broadcast(cbp->cb_cv_nullcaller); 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate /* 4257c478bd9Sstevel@tonic-gate * If this is the last thread to use the callback info and 4267c478bd9Sstevel@tonic-gate * there is new callback information to try and no thread is 4277c478bd9Sstevel@tonic-gate * there ready to do the CB_NULL, then return true to teh 4287c478bd9Sstevel@tonic-gate * caller so they can do the CB_NULL 4297c478bd9Sstevel@tonic-gate */ 4307c478bd9Sstevel@tonic-gate if (cbp->cb_refcnt == 0 && 4317c478bd9Sstevel@tonic-gate cbp->cb_nullcaller == FALSE && 4327c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_new == TRUE && 4337c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_confirmed == TRUE) 4347c478bd9Sstevel@tonic-gate cb_new = TRUE; 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate return (cb_new); 4397c478bd9Sstevel@tonic-gate } 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate /* 4427c478bd9Sstevel@tonic-gate * Given the information in the callback info struct, create a client 4437c478bd9Sstevel@tonic-gate * handle that can be used by the server for its callback path. 4447c478bd9Sstevel@tonic-gate */ 4457c478bd9Sstevel@tonic-gate static CLIENT * 4467c478bd9Sstevel@tonic-gate rfs4_cbch_init(rfs4_cbinfo_t *cbp) 4477c478bd9Sstevel@tonic-gate { 4487c478bd9Sstevel@tonic-gate struct knetconfig knc; 4497c478bd9Sstevel@tonic-gate vnode_t *vp; 4507c478bd9Sstevel@tonic-gate struct sockaddr_in addr4; 4517c478bd9Sstevel@tonic-gate struct sockaddr_in6 addr6; 4527c478bd9Sstevel@tonic-gate void *addr, *taddr; 4537c478bd9Sstevel@tonic-gate in_port_t *pp; 4547c478bd9Sstevel@tonic-gate int af; 4557c478bd9Sstevel@tonic-gate char *devnam; 4567c478bd9Sstevel@tonic-gate int err = 0; 4577c478bd9Sstevel@tonic-gate struct netbuf nb; 4587c478bd9Sstevel@tonic-gate int size; 4597c478bd9Sstevel@tonic-gate CLIENT *ch = NULL; 4607c478bd9Sstevel@tonic-gate int useresvport = 0; 4617c478bd9Sstevel@tonic-gate 4627c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 4637c478bd9Sstevel@tonic-gate "rfs4_cbch_init: entry cbp->%p\n", (void *)cbp)); 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate mutex_enter(cbp->cb_lock); 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate if (cbp->cb_callback.cb_location.r_netid == NULL || 4687c478bd9Sstevel@tonic-gate cbp->cb_callback.cb_location.r_addr == NULL) { 4697c478bd9Sstevel@tonic-gate goto cb_init_out; 4707c478bd9Sstevel@tonic-gate } 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate if (strcmp(cbp->cb_callback.cb_location.r_netid, "tcp") == 0) { 4737c478bd9Sstevel@tonic-gate knc.knc_semantics = NC_TPI_COTS; 4747c478bd9Sstevel@tonic-gate knc.knc_protofmly = "inet"; 4757c478bd9Sstevel@tonic-gate knc.knc_proto = "tcp"; 4767c478bd9Sstevel@tonic-gate devnam = "/dev/tcp"; 4777c478bd9Sstevel@tonic-gate af = AF_INET; 4787c478bd9Sstevel@tonic-gate } else if (strcmp(cbp->cb_callback.cb_location.r_netid, "udp") 4797c478bd9Sstevel@tonic-gate == 0) { 4807c478bd9Sstevel@tonic-gate knc.knc_semantics = NC_TPI_CLTS; 4817c478bd9Sstevel@tonic-gate knc.knc_protofmly = "inet"; 4827c478bd9Sstevel@tonic-gate knc.knc_proto = "udp"; 4837c478bd9Sstevel@tonic-gate devnam = "/dev/udp"; 4847c478bd9Sstevel@tonic-gate af = AF_INET; 4857c478bd9Sstevel@tonic-gate } else if (strcmp(cbp->cb_callback.cb_location.r_netid, "tcp6") 4867c478bd9Sstevel@tonic-gate == 0) { 4877c478bd9Sstevel@tonic-gate knc.knc_semantics = NC_TPI_COTS; 4887c478bd9Sstevel@tonic-gate knc.knc_protofmly = "inet6"; 4897c478bd9Sstevel@tonic-gate knc.knc_proto = "tcp"; 4907c478bd9Sstevel@tonic-gate devnam = "/dev/tcp6"; 4917c478bd9Sstevel@tonic-gate af = AF_INET6; 4927c478bd9Sstevel@tonic-gate } else if (strcmp(cbp->cb_callback.cb_location.r_netid, "udp6") 4937c478bd9Sstevel@tonic-gate == 0) { 4947c478bd9Sstevel@tonic-gate knc.knc_semantics = NC_TPI_CLTS; 4957c478bd9Sstevel@tonic-gate knc.knc_protofmly = "inet6"; 4967c478bd9Sstevel@tonic-gate knc.knc_proto = "udp"; 4977c478bd9Sstevel@tonic-gate devnam = "/dev/udp6"; 4987c478bd9Sstevel@tonic-gate af = AF_INET6; 4997c478bd9Sstevel@tonic-gate } else { 5007c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 5017c478bd9Sstevel@tonic-gate "rfs4_cbch_init: unknown transport %s\n", 5027c478bd9Sstevel@tonic-gate cbp->cb_callback.cb_location.r_netid)); 5037c478bd9Sstevel@tonic-gate 5047c478bd9Sstevel@tonic-gate goto cb_init_out; 5057c478bd9Sstevel@tonic-gate } 5067c478bd9Sstevel@tonic-gate 5077c478bd9Sstevel@tonic-gate if ((err = lookupname(devnam, UIO_SYSSPACE, FOLLOW, 5087c478bd9Sstevel@tonic-gate NULLVPP, &vp)) != 0) { 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 5117c478bd9Sstevel@tonic-gate "rfs4_cbch_init: lookupname failed %d\n", err)); 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate goto cb_init_out; 5147c478bd9Sstevel@tonic-gate } 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate if (vp->v_type != VCHR) { 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 5197c478bd9Sstevel@tonic-gate "rfs4_cbch_init: %s is not VCHR", devnam)); 5207c478bd9Sstevel@tonic-gate VN_RELE(vp); 5217c478bd9Sstevel@tonic-gate goto cb_init_out; 5227c478bd9Sstevel@tonic-gate } 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate knc.knc_rdev = vp->v_rdev; 5257c478bd9Sstevel@tonic-gate 5267c478bd9Sstevel@tonic-gate VN_RELE(vp); 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate if (af == AF_INET) { 5297c478bd9Sstevel@tonic-gate size = sizeof (addr4); 5307c478bd9Sstevel@tonic-gate bzero(&addr4, size); 5317c478bd9Sstevel@tonic-gate addr4.sin_family = (sa_family_t)af; 5327c478bd9Sstevel@tonic-gate addr = &addr4.sin_addr; 5337c478bd9Sstevel@tonic-gate pp = &addr4.sin_port; 5347c478bd9Sstevel@tonic-gate taddr = &addr4; 5357c478bd9Sstevel@tonic-gate } else /* AF_INET6 */ { 5367c478bd9Sstevel@tonic-gate size = sizeof (addr6); 5377c478bd9Sstevel@tonic-gate bzero(&addr6, size); 5387c478bd9Sstevel@tonic-gate addr6.sin6_family = (sa_family_t)af; 5397c478bd9Sstevel@tonic-gate addr = &addr6.sin6_addr; 5407c478bd9Sstevel@tonic-gate pp = &addr6.sin6_port; 5417c478bd9Sstevel@tonic-gate taddr = &addr6; 5427c478bd9Sstevel@tonic-gate } 5437c478bd9Sstevel@tonic-gate 5447c478bd9Sstevel@tonic-gate if (uaddr2sockaddr(af, 5457c478bd9Sstevel@tonic-gate cbp->cb_callback.cb_location.r_addr, addr, pp)) { 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 5487c478bd9Sstevel@tonic-gate "rfs4_cbch_init: malformed universal addr: %s\n", 5497c478bd9Sstevel@tonic-gate cbp->cb_callback.cb_location.r_addr)); 5507c478bd9Sstevel@tonic-gate 5517c478bd9Sstevel@tonic-gate goto cb_init_out; 5527c478bd9Sstevel@tonic-gate } 5537c478bd9Sstevel@tonic-gate 5547c478bd9Sstevel@tonic-gate 5557c478bd9Sstevel@tonic-gate nb.maxlen = nb.len = size; 5567c478bd9Sstevel@tonic-gate nb.buf = (char *)taddr; 5577c478bd9Sstevel@tonic-gate 5587c478bd9Sstevel@tonic-gate if (err = clnt_tli_kcreate(&knc, &nb, cbp->cb_callback.cb_program, 5597c478bd9Sstevel@tonic-gate NFS_CB, 0, 0, curthread->t_cred, &ch)) { 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 5627c478bd9Sstevel@tonic-gate "rfs4_cbch_init: clnt_tli_kcreate failed %d\n", err)); 5637c478bd9Sstevel@tonic-gate ch = NULL; 5647c478bd9Sstevel@tonic-gate } 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate /* turn off reserved port usage */ 5677c478bd9Sstevel@tonic-gate (void) CLNT_CONTROL(ch, CLSET_BINDRESVPORT, (char *)&useresvport); 5687c478bd9Sstevel@tonic-gate 5697c478bd9Sstevel@tonic-gate cb_init_out: 5707c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 5717c478bd9Sstevel@tonic-gate return (ch); 5727c478bd9Sstevel@tonic-gate } 5737c478bd9Sstevel@tonic-gate 5747c478bd9Sstevel@tonic-gate /* 5757c478bd9Sstevel@tonic-gate * Iterate over the client handle cache and 5767c478bd9Sstevel@tonic-gate * destroy it. 5777c478bd9Sstevel@tonic-gate */ 5787c478bd9Sstevel@tonic-gate static void 5797c478bd9Sstevel@tonic-gate rfs4_cb_chflush(rfs4_cbinfo_t *cbp) 5807c478bd9Sstevel@tonic-gate { 5817c478bd9Sstevel@tonic-gate CLIENT *ch; 5827c478bd9Sstevel@tonic-gate 5837c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 5847c478bd9Sstevel@tonic-gate "rfs4_cb_flush: enter cbp->%p, cb_chc_free=%d\n", 5857c478bd9Sstevel@tonic-gate (void *)cbp, cbp->cb_chc_free)); 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate while (cbp->cb_chc_free) { 5887c478bd9Sstevel@tonic-gate cbp->cb_chc_free--; 5897c478bd9Sstevel@tonic-gate ch = cbp->cb_chc[cbp->cb_chc_free]; 5907c478bd9Sstevel@tonic-gate cbp->cb_chc[cbp->cb_chc_free] = NULL; 5917c478bd9Sstevel@tonic-gate if (ch) { 5927c478bd9Sstevel@tonic-gate if (ch->cl_auth) 5937c478bd9Sstevel@tonic-gate auth_destroy(ch->cl_auth); 5947c478bd9Sstevel@tonic-gate clnt_destroy(ch); 5957c478bd9Sstevel@tonic-gate } 5967c478bd9Sstevel@tonic-gate } 5977c478bd9Sstevel@tonic-gate } 5987c478bd9Sstevel@tonic-gate 5997c478bd9Sstevel@tonic-gate /* 6007c478bd9Sstevel@tonic-gate * Return a client handle, either from a the small 6017c478bd9Sstevel@tonic-gate * rfs4_client_t cache or one that we just created. 6027c478bd9Sstevel@tonic-gate */ 6037c478bd9Sstevel@tonic-gate static CLIENT * 6047c478bd9Sstevel@tonic-gate rfs4_cb_getch(rfs4_cbinfo_t *cbp) 6057c478bd9Sstevel@tonic-gate { 6067c478bd9Sstevel@tonic-gate CLIENT *cbch = NULL; 6077c478bd9Sstevel@tonic-gate uint32_t zilch = 0; 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 6107c478bd9Sstevel@tonic-gate "rfs4_cb_getch: enter cbp->%p, cb_chc_free=%d\n", 6117c478bd9Sstevel@tonic-gate (void *)cbp, cbp->cb_chc_free)); 6127c478bd9Sstevel@tonic-gate 6137c478bd9Sstevel@tonic-gate mutex_enter(cbp->cb_lock); 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate if (cbp->cb_chc_free) { 6167c478bd9Sstevel@tonic-gate cbp->cb_chc_free--; 6177c478bd9Sstevel@tonic-gate cbch = cbp->cb_chc[ cbp->cb_chc_free ]; 6187c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 6197c478bd9Sstevel@tonic-gate "rfs4_cb_getch: cb_chc_free=%d ch->%p\n", 6207c478bd9Sstevel@tonic-gate cbp->cb_chc_free, (void *)cbch)); 6217c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 6227c478bd9Sstevel@tonic-gate (void) CLNT_CONTROL(cbch, CLSET_XID, (char *)&zilch); 6237c478bd9Sstevel@tonic-gate return (cbch); 6247c478bd9Sstevel@tonic-gate } 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 6297c478bd9Sstevel@tonic-gate "rfs4_cb_getch: calling rfs4_cbch_init\n")); 6307c478bd9Sstevel@tonic-gate 6317c478bd9Sstevel@tonic-gate /* none free so make it now */ 6327c478bd9Sstevel@tonic-gate cbch = rfs4_cbch_init(cbp); 6337c478bd9Sstevel@tonic-gate 6347c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 6357c478bd9Sstevel@tonic-gate "rfs4_cb_getch: returning cbch->%p\n", (void *)cbch)); 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate return (cbch); 6387c478bd9Sstevel@tonic-gate } 6397c478bd9Sstevel@tonic-gate 6407c478bd9Sstevel@tonic-gate /* 6417c478bd9Sstevel@tonic-gate * Return the client handle to the small cache or 6427c478bd9Sstevel@tonic-gate * destroy it. 6437c478bd9Sstevel@tonic-gate */ 6447c478bd9Sstevel@tonic-gate static void 6457c478bd9Sstevel@tonic-gate rfs4_cb_freech(rfs4_cbinfo_t *cbp, CLIENT *ch, bool_t lockheld) 6467c478bd9Sstevel@tonic-gate { 6477c478bd9Sstevel@tonic-gate if (lockheld == FALSE) 6487c478bd9Sstevel@tonic-gate mutex_enter(cbp->cb_lock); 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate if (cbp->cb_chc_free < RFS4_CBCH_MAX) { 6517c478bd9Sstevel@tonic-gate cbp->cb_chc[ cbp->cb_chc_free++ ] = ch; 6527c478bd9Sstevel@tonic-gate if (lockheld == FALSE) 6537c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 6547c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 6557c478bd9Sstevel@tonic-gate "rfs4_cb_freech: caching cbp->%p, ch->%p, cb_chc_free=%d\n", 6567c478bd9Sstevel@tonic-gate (void *)cbp, (void *)ch, cbp->cb_chc_free)); 6577c478bd9Sstevel@tonic-gate return; 6587c478bd9Sstevel@tonic-gate } 6597c478bd9Sstevel@tonic-gate if (lockheld == FALSE) 6607c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 6617c478bd9Sstevel@tonic-gate 6627c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 6637c478bd9Sstevel@tonic-gate "rfs4_cb_freech: destroying cbp->%p, ch->%p, cb_chc_free=%d\n", 6647c478bd9Sstevel@tonic-gate (void *)cbp, (void *)ch, cbp->cb_chc_free)); 6657c478bd9Sstevel@tonic-gate 6667c478bd9Sstevel@tonic-gate /* 6677c478bd9Sstevel@tonic-gate * cache maxed out of free entries, obliterate 6687c478bd9Sstevel@tonic-gate * this client handle, destroy it, throw it away. 6697c478bd9Sstevel@tonic-gate */ 6707c478bd9Sstevel@tonic-gate if (ch->cl_auth) 6717c478bd9Sstevel@tonic-gate auth_destroy(ch->cl_auth); 6727c478bd9Sstevel@tonic-gate clnt_destroy(ch); 6737c478bd9Sstevel@tonic-gate } 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate /* 6767c478bd9Sstevel@tonic-gate * With the supplied callback information - initialize the client 6777c478bd9Sstevel@tonic-gate * callback data. If there is a callback in progress, save the 6787c478bd9Sstevel@tonic-gate * callback info so that a thread can pick it up in the future. 6797c478bd9Sstevel@tonic-gate */ 6807c478bd9Sstevel@tonic-gate void 6817c478bd9Sstevel@tonic-gate rfs4_client_setcb(rfs4_client_t *cp, cb_client4 *cb, uint32_t cb_ident) 6827c478bd9Sstevel@tonic-gate { 6837c478bd9Sstevel@tonic-gate char *addr = NULL; 6847c478bd9Sstevel@tonic-gate char *netid = NULL; 6857c478bd9Sstevel@tonic-gate rfs4_cbinfo_t *cbp = &cp->cbinfo; 6867c478bd9Sstevel@tonic-gate size_t len; 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate /* Set the call back for the client */ 689a31a5cfdSsamf if (cb->cb_location.r_addr && cb->cb_location.r_addr[0] != '\0' && 690a31a5cfdSsamf cb->cb_location.r_netid && cb->cb_location.r_netid[0] != '\0') { 6917c478bd9Sstevel@tonic-gate len = strlen(cb->cb_location.r_addr) + 1; 6927c478bd9Sstevel@tonic-gate addr = kmem_alloc(len, KM_SLEEP); 6937c478bd9Sstevel@tonic-gate bcopy(cb->cb_location.r_addr, addr, len); 6947c478bd9Sstevel@tonic-gate len = strlen(cb->cb_location.r_netid) + 1; 6957c478bd9Sstevel@tonic-gate netid = kmem_alloc(len, KM_SLEEP); 6967c478bd9Sstevel@tonic-gate bcopy(cb->cb_location.r_netid, netid, len); 6977c478bd9Sstevel@tonic-gate } 6987c478bd9Sstevel@tonic-gate /* ready to save the new information but first free old, if exists */ 6997c478bd9Sstevel@tonic-gate mutex_enter(cbp->cb_lock); 7007c478bd9Sstevel@tonic-gate 7017c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_callback.cb_program = cb->cb_program; 702a31a5cfdSsamf 703a31a5cfdSsamf if (cbp->cb_newer.cb_callback.cb_location.r_addr != NULL) 704a31a5cfdSsamf kmem_free(cbp->cb_newer.cb_callback.cb_location.r_addr, 705a31a5cfdSsamf strlen(cbp->cb_newer.cb_callback.cb_location.r_addr) + 1); 7067c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_callback.cb_location.r_addr = addr; 707a31a5cfdSsamf 708a31a5cfdSsamf if (cbp->cb_newer.cb_callback.cb_location.r_netid != NULL) 709a31a5cfdSsamf kmem_free(cbp->cb_newer.cb_callback.cb_location.r_netid, 710a31a5cfdSsamf strlen(cbp->cb_newer.cb_callback.cb_location.r_netid) + 1); 7117c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_callback.cb_location.r_netid = netid; 7127c478bd9Sstevel@tonic-gate 7137c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_ident = cb_ident; 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate if (addr && *addr && netid && *netid) { 7167c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_new = TRUE; 7177c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_confirmed = FALSE; 7187c478bd9Sstevel@tonic-gate } else { 7197c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_new = FALSE; 7207c478bd9Sstevel@tonic-gate cbp->cb_newer.cb_confirmed = FALSE; 7217c478bd9Sstevel@tonic-gate } 7227c478bd9Sstevel@tonic-gate 7237c478bd9Sstevel@tonic-gate mutex_exit(cbp->cb_lock); 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate /* 7277c478bd9Sstevel@tonic-gate * The server uses this when processing SETCLIENTID_CONFIRM. Callback 7287c478bd9Sstevel@tonic-gate * information may have been provided on SETCLIENTID and this call 7297c478bd9Sstevel@tonic-gate * marks that information as confirmed and then starts a thread to 7307c478bd9Sstevel@tonic-gate * test the callback path. 7317c478bd9Sstevel@tonic-gate */ 7327c478bd9Sstevel@tonic-gate void 7337c478bd9Sstevel@tonic-gate rfs4_deleg_cb_check(rfs4_client_t *cp) 7347c478bd9Sstevel@tonic-gate { 7357c478bd9Sstevel@tonic-gate if (cp->cbinfo.cb_newer.cb_new == FALSE) 7367c478bd9Sstevel@tonic-gate return; 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate cp->cbinfo.cb_newer.cb_confirmed = TRUE; 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate rfs4_dbe_hold(cp->dbe); /* hold the client struct for thread */ 7417c478bd9Sstevel@tonic-gate 7427c478bd9Sstevel@tonic-gate (void) thread_create(NULL, 0, rfs4_do_cb_null, cp, 0, &p0, TS_RUN, 7437c478bd9Sstevel@tonic-gate minclsyspri); 7447c478bd9Sstevel@tonic-gate } 7457c478bd9Sstevel@tonic-gate 7467c478bd9Sstevel@tonic-gate static void 7477c478bd9Sstevel@tonic-gate rfs4args_cb_recall_free(nfs_cb_argop4 *argop) 7487c478bd9Sstevel@tonic-gate { 7497c478bd9Sstevel@tonic-gate CB_RECALL4args *rec_argp; 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate rec_argp = &argop->nfs_cb_argop4_u.opcbrecall; 7527c478bd9Sstevel@tonic-gate if (rec_argp->fh.nfs_fh4_val) 7537c478bd9Sstevel@tonic-gate kmem_free(rec_argp->fh.nfs_fh4_val, rec_argp->fh.nfs_fh4_len); 7547c478bd9Sstevel@tonic-gate } 7557c478bd9Sstevel@tonic-gate 7567c478bd9Sstevel@tonic-gate /* ARGSUSED */ 7577c478bd9Sstevel@tonic-gate static void 7587c478bd9Sstevel@tonic-gate rfs4args_cb_getattr_free(nfs_cb_argop4 *argop) 7597c478bd9Sstevel@tonic-gate { 7607c478bd9Sstevel@tonic-gate CB_GETATTR4args *argp; 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate argp = &argop->nfs_cb_argop4_u.opcbgetattr; 7637c478bd9Sstevel@tonic-gate if (argp->fh.nfs_fh4_val) 7647c478bd9Sstevel@tonic-gate kmem_free(argp->fh.nfs_fh4_val, argp->fh.nfs_fh4_len); 7657c478bd9Sstevel@tonic-gate } 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate static void 7687c478bd9Sstevel@tonic-gate rfs4freeargres(CB_COMPOUND4args *args, CB_COMPOUND4res *resp) 7697c478bd9Sstevel@tonic-gate { 7707c478bd9Sstevel@tonic-gate int i, arglen; 7717c478bd9Sstevel@tonic-gate nfs_cb_argop4 *argop; 7727c478bd9Sstevel@tonic-gate 7737c478bd9Sstevel@tonic-gate /* 7747c478bd9Sstevel@tonic-gate * First free any special args alloc'd for specific ops. 7757c478bd9Sstevel@tonic-gate */ 7767c478bd9Sstevel@tonic-gate arglen = args->array_len; 7777c478bd9Sstevel@tonic-gate argop = args->array; 7787c478bd9Sstevel@tonic-gate for (i = 0; i < arglen; i++, argop++) { 7797c478bd9Sstevel@tonic-gate 7807c478bd9Sstevel@tonic-gate switch (argop->argop) { 7817c478bd9Sstevel@tonic-gate case OP_CB_RECALL: 7827c478bd9Sstevel@tonic-gate rfs4args_cb_recall_free(argop); 7837c478bd9Sstevel@tonic-gate break; 7847c478bd9Sstevel@tonic-gate 7857c478bd9Sstevel@tonic-gate case OP_CB_GETATTR: 7867c478bd9Sstevel@tonic-gate rfs4args_cb_getattr_free(argop); 7877c478bd9Sstevel@tonic-gate break; 7887c478bd9Sstevel@tonic-gate 7897c478bd9Sstevel@tonic-gate default: 7907c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, (CE_NOTE, 7917c478bd9Sstevel@tonic-gate "rfs4freeargres: unknown op")); 7927c478bd9Sstevel@tonic-gate return; 7937c478bd9Sstevel@tonic-gate } 7947c478bd9Sstevel@tonic-gate } 7957c478bd9Sstevel@tonic-gate 7967c478bd9Sstevel@tonic-gate if (args->tag.utf8string_len > 0) 7977c478bd9Sstevel@tonic-gate UTF8STRING_FREE(args->tag) 7987c478bd9Sstevel@tonic-gate 7997c478bd9Sstevel@tonic-gate kmem_free(args->array, arglen * sizeof (nfs_cb_argop4)); 8007c478bd9Sstevel@tonic-gate if (resp) 8017c478bd9Sstevel@tonic-gate (void) xdr_free(xdr_CB_COMPOUND4res, (caddr_t)resp); 8027c478bd9Sstevel@tonic-gate } 8037c478bd9Sstevel@tonic-gate 8047c478bd9Sstevel@tonic-gate /* 8057c478bd9Sstevel@tonic-gate * General callback routine for the server to the client. 8067c478bd9Sstevel@tonic-gate */ 8077c478bd9Sstevel@tonic-gate static enum clnt_stat 8087c478bd9Sstevel@tonic-gate rfs4_do_callback(rfs4_client_t *cp, CB_COMPOUND4args *args, 8097c478bd9Sstevel@tonic-gate CB_COMPOUND4res *res, struct timeval timeout) 8107c478bd9Sstevel@tonic-gate { 8117c478bd9Sstevel@tonic-gate rfs4_cbinfo_t *cbp; 8127c478bd9Sstevel@tonic-gate CLIENT *ch; 8137c478bd9Sstevel@tonic-gate /* start with this in case cb_getch() fails */ 8147c478bd9Sstevel@tonic-gate enum clnt_stat stat = RPC_FAILED; 8157c478bd9Sstevel@tonic-gate 8167c478bd9Sstevel@tonic-gate res->tag.utf8string_val = NULL; 8177c478bd9Sstevel@tonic-gate res->array = NULL; 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 8207c478bd9Sstevel@tonic-gate "rfs4_do_callback: enter cp->%p\n", (void *)cp)); 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate retry: 8237c478bd9Sstevel@tonic-gate cbp = rfs4_cbinfo_hold(cp); 8247c478bd9Sstevel@tonic-gate if (cbp == NULL) 8257c478bd9Sstevel@tonic-gate return (stat); 8267c478bd9Sstevel@tonic-gate 8277c478bd9Sstevel@tonic-gate /* get a client handle */ 8287c478bd9Sstevel@tonic-gate if ((ch = rfs4_cb_getch(cbp)) != NULL) { 8297c478bd9Sstevel@tonic-gate /* 8307c478bd9Sstevel@tonic-gate * reset the cb_ident since it may have changed in 8317c478bd9Sstevel@tonic-gate * rfs4_cbinfo_hold() 8327c478bd9Sstevel@tonic-gate */ 8337c478bd9Sstevel@tonic-gate args->callback_ident = cbp->cb_ident; 8347c478bd9Sstevel@tonic-gate 835eac3aab7Srobinson stat = clnt_call(ch, CB_COMPOUND, xdr_CB_COMPOUND4args_srv, 8367c478bd9Sstevel@tonic-gate (caddr_t)args, xdr_CB_COMPOUND4res, 8377c478bd9Sstevel@tonic-gate (caddr_t)res, timeout); 8387c478bd9Sstevel@tonic-gate 8397c478bd9Sstevel@tonic-gate /* free client handle */ 8407c478bd9Sstevel@tonic-gate rfs4_cb_freech(cbp, ch, FALSE); 8417c478bd9Sstevel@tonic-gate } 8427c478bd9Sstevel@tonic-gate 8437c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_cb_debug, (CE_NOTE, 8447c478bd9Sstevel@tonic-gate "rfs4_do_callback: exit with RPC status %d, %s", 8457c478bd9Sstevel@tonic-gate stat, clnt_sperrno(stat))); 8467c478bd9Sstevel@tonic-gate 8477c478bd9Sstevel@tonic-gate /* 8487c478bd9Sstevel@tonic-gate * If the rele says that there may be new callback info then 8497c478bd9Sstevel@tonic-gate * retry this sequence and it may succeed as a result of the 8507c478bd9Sstevel@tonic-gate * new callback path 8517c478bd9Sstevel@tonic-gate */ 8527c478bd9Sstevel@tonic-gate if (rfs4_cbinfo_rele(cbp, 8537c478bd9Sstevel@tonic-gate (stat == RPC_SUCCESS ? CB_NOCHANGE : CB_FAILED)) == TRUE) 8547c478bd9Sstevel@tonic-gate goto retry; 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate return (stat); 8577c478bd9Sstevel@tonic-gate } 8587c478bd9Sstevel@tonic-gate 8597c478bd9Sstevel@tonic-gate /* 8607c478bd9Sstevel@tonic-gate * Used by the NFSv4 server to get attributes for a file while 8617c478bd9Sstevel@tonic-gate * handling the case where a file has been write delegated. For the 8627c478bd9Sstevel@tonic-gate * time being, VOP_GETATTR() is called and CB_GETATTR processing is 8637c478bd9Sstevel@tonic-gate * not undertaken. This call site is maintained in case the server is 8647c478bd9Sstevel@tonic-gate * updated in the future to handle write delegation space guarantees. 8657c478bd9Sstevel@tonic-gate */ 8667c478bd9Sstevel@tonic-gate nfsstat4 8677c478bd9Sstevel@tonic-gate rfs4_vop_getattr(vnode_t *vp, vattr_t *vap, int flag, cred_t *cr) 8687c478bd9Sstevel@tonic-gate { 8697c478bd9Sstevel@tonic-gate uint_t mask; 8707c478bd9Sstevel@tonic-gate int error; 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate mask = vap->va_mask; 8737c478bd9Sstevel@tonic-gate error = VOP_GETATTR(vp, vap, flag, cr); 8747c478bd9Sstevel@tonic-gate /* 8757c478bd9Sstevel@tonic-gate * Some file systems clobber va_mask. it is probably wrong of 8767c478bd9Sstevel@tonic-gate * them to do so, nonethless we practice defensive coding. 8777c478bd9Sstevel@tonic-gate * See bug id 4276830. 8787c478bd9Sstevel@tonic-gate */ 8797c478bd9Sstevel@tonic-gate vap->va_mask = mask; 8807c478bd9Sstevel@tonic-gate return (puterrno4(error)); 8817c478bd9Sstevel@tonic-gate } 8827c478bd9Sstevel@tonic-gate 8837c478bd9Sstevel@tonic-gate /* 8847c478bd9Sstevel@tonic-gate * This is used everywhere in the v2/v3 server to allow the 8857c478bd9Sstevel@tonic-gate * integration of all NFS versions and the support of delegation. For 8867c478bd9Sstevel@tonic-gate * now, just call the VOP_GETATTR(). If the NFSv4 server is enhanced 8877c478bd9Sstevel@tonic-gate * in the future to provide space guarantees for write delegations 8887c478bd9Sstevel@tonic-gate * then this call site should be expanded to interact with the client. 8897c478bd9Sstevel@tonic-gate */ 8907c478bd9Sstevel@tonic-gate int 8917c478bd9Sstevel@tonic-gate rfs4_delegated_getattr(vnode_t *vp, vattr_t *vap, int flag, cred_t *cr) 8927c478bd9Sstevel@tonic-gate { 8937c478bd9Sstevel@tonic-gate return (VOP_GETATTR(vp, vap, flag, cr)); 8947c478bd9Sstevel@tonic-gate } 8957c478bd9Sstevel@tonic-gate 8967c478bd9Sstevel@tonic-gate /* 8977c478bd9Sstevel@tonic-gate * Place the actual cb_recall otw call to client. 8987c478bd9Sstevel@tonic-gate */ 8997c478bd9Sstevel@tonic-gate static void 9007c478bd9Sstevel@tonic-gate rfs4_do_cb_recall(rfs4_deleg_state_t *dsp, bool_t trunc) 9017c478bd9Sstevel@tonic-gate { 9027c478bd9Sstevel@tonic-gate CB_COMPOUND4args cb4_args; 9037c478bd9Sstevel@tonic-gate CB_COMPOUND4res cb4_res; 9047c478bd9Sstevel@tonic-gate CB_RECALL4args *rec_argp; 9057c478bd9Sstevel@tonic-gate nfs_cb_argop4 *argop; 9067c478bd9Sstevel@tonic-gate int numops; 9077c478bd9Sstevel@tonic-gate int argoplist_size; 9087c478bd9Sstevel@tonic-gate struct timeval timeout; 9097c478bd9Sstevel@tonic-gate nfs_fh4 *fhp; 9107c478bd9Sstevel@tonic-gate enum clnt_stat call_stat; 9117c478bd9Sstevel@tonic-gate 9127c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, (CE_NOTE, "rfs4_do_cb_recall: enter")); 9137c478bd9Sstevel@tonic-gate /* 9147c478bd9Sstevel@tonic-gate * set up the compound args 9157c478bd9Sstevel@tonic-gate */ 9167c478bd9Sstevel@tonic-gate numops = 1; /* CB_RECALL only */ 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate argoplist_size = numops * sizeof (nfs_cb_argop4); 9197c478bd9Sstevel@tonic-gate argop = kmem_zalloc(argoplist_size, KM_SLEEP); 9207c478bd9Sstevel@tonic-gate argop->argop = OP_CB_RECALL; 9217c478bd9Sstevel@tonic-gate rec_argp = &argop->nfs_cb_argop4_u.opcbrecall; 9227c478bd9Sstevel@tonic-gate 9237c478bd9Sstevel@tonic-gate (void) str_to_utf8("cb_recall", &cb4_args.tag); 9247c478bd9Sstevel@tonic-gate cb4_args.minorversion = CB4_MINORVERSION; 9257c478bd9Sstevel@tonic-gate /* cb4_args.callback_ident is set in rfs4_do_callback() */ 9267c478bd9Sstevel@tonic-gate cb4_args.array_len = numops; 9277c478bd9Sstevel@tonic-gate cb4_args.array = argop; 9287c478bd9Sstevel@tonic-gate 9297c478bd9Sstevel@tonic-gate /* 9307c478bd9Sstevel@tonic-gate * fill in the args struct 9317c478bd9Sstevel@tonic-gate */ 9327c478bd9Sstevel@tonic-gate bcopy(&dsp->delegid.stateid, &rec_argp->stateid, sizeof (stateid4)); 9337c478bd9Sstevel@tonic-gate rec_argp->truncate = trunc; 9347c478bd9Sstevel@tonic-gate 9357c478bd9Sstevel@tonic-gate fhp = &dsp->finfo->filehandle; 9367c478bd9Sstevel@tonic-gate rec_argp->fh.nfs_fh4_val = kmem_alloc(sizeof (char) * 9377c478bd9Sstevel@tonic-gate fhp->nfs_fh4_len, KM_SLEEP); 9387c478bd9Sstevel@tonic-gate nfs_fh4_copy(fhp, &rec_argp->fh); 9397c478bd9Sstevel@tonic-gate 9407c478bd9Sstevel@tonic-gate /* Keep track of when we did this for observability */ 9417c478bd9Sstevel@tonic-gate dsp->time_recalled = gethrestime_sec(); 9427c478bd9Sstevel@tonic-gate 9437c478bd9Sstevel@tonic-gate /* 9447c478bd9Sstevel@tonic-gate * Set up the timeout for the callback and make the actual call. 9457c478bd9Sstevel@tonic-gate * Timeout will be 80% of the lease period for this server. 9467c478bd9Sstevel@tonic-gate */ 9477c478bd9Sstevel@tonic-gate timeout.tv_sec = (rfs4_lease_time * 80) / 100; 9487c478bd9Sstevel@tonic-gate timeout.tv_usec = 0; 9497c478bd9Sstevel@tonic-gate 9507c478bd9Sstevel@tonic-gate call_stat = rfs4_do_callback(dsp->client, &cb4_args, 9517c478bd9Sstevel@tonic-gate &cb4_res, timeout); 9527c478bd9Sstevel@tonic-gate 9537c478bd9Sstevel@tonic-gate if (call_stat != RPC_SUCCESS || cb4_res.status != NFS4_OK) { 9547c478bd9Sstevel@tonic-gate rfs4_revoke_deleg(dsp); 9557c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, (CE_NOTE, 9567c478bd9Sstevel@tonic-gate "rfs4_do_cb_recall: rpcstat=%d cbstat=%d ", 9577c478bd9Sstevel@tonic-gate call_stat, cb4_res.status)); 9587c478bd9Sstevel@tonic-gate } 9597c478bd9Sstevel@tonic-gate 9607c478bd9Sstevel@tonic-gate rfs4freeargres(&cb4_args, &cb4_res); 9617c478bd9Sstevel@tonic-gate } 9627c478bd9Sstevel@tonic-gate 9637c478bd9Sstevel@tonic-gate struct recall_arg { 9647c478bd9Sstevel@tonic-gate rfs4_deleg_state_t *dsp; 9657c478bd9Sstevel@tonic-gate void (*recall)(rfs4_deleg_state_t *, bool_t trunc); 9667c478bd9Sstevel@tonic-gate bool_t trunc; 9677c478bd9Sstevel@tonic-gate }; 9687c478bd9Sstevel@tonic-gate 9697c478bd9Sstevel@tonic-gate static void 9707c478bd9Sstevel@tonic-gate do_recall(struct recall_arg *arg) 9717c478bd9Sstevel@tonic-gate { 9727c478bd9Sstevel@tonic-gate rfs4_deleg_state_t *dsp = arg->dsp; 9737c478bd9Sstevel@tonic-gate rfs4_file_t *fp = dsp->finfo; 9747c478bd9Sstevel@tonic-gate callb_cpr_t cpr_info; 9757c478bd9Sstevel@tonic-gate kmutex_t cpr_lock; 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate mutex_init(&cpr_lock, NULL, MUTEX_DEFAULT, NULL); 9787c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cpr_info, &cpr_lock, callb_generic_cpr, "nfsv4Recall"); 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate /* 9817c478bd9Sstevel@tonic-gate * It is possible that before this thread starts 9827c478bd9Sstevel@tonic-gate * the client has send us a return_delegation, and 9837c478bd9Sstevel@tonic-gate * if that is the case we do not need to send the 9847c478bd9Sstevel@tonic-gate * recall callback. 9857c478bd9Sstevel@tonic-gate */ 9867c478bd9Sstevel@tonic-gate if (dsp->dtype != OPEN_DELEGATE_NONE) { 9877c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, 9887c478bd9Sstevel@tonic-gate (CE_NOTE, "recall = %p, state = %p, fp = %p trunc = %d", 9897c478bd9Sstevel@tonic-gate (void*)arg->recall, (void*)dsp, (void*)fp, arg->trunc)); 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate if (arg->recall) 9927c478bd9Sstevel@tonic-gate (void) (*arg->recall)(dsp, arg->trunc); 9937c478bd9Sstevel@tonic-gate } 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate mutex_enter(fp->dinfo->recall_lock); 9967c478bd9Sstevel@tonic-gate /* 9977c478bd9Sstevel@tonic-gate * Recall count may go negative if the parent thread that is 9987c478bd9Sstevel@tonic-gate * creating the individual callback threads does not modify 9997c478bd9Sstevel@tonic-gate * the recall_count field before the callback thread actually 10007c478bd9Sstevel@tonic-gate * gets a response from the CB_RECALL 10017c478bd9Sstevel@tonic-gate */ 10027c478bd9Sstevel@tonic-gate fp->dinfo->recall_count--; 10037c478bd9Sstevel@tonic-gate if (fp->dinfo->recall_count == 0) 10047c478bd9Sstevel@tonic-gate cv_signal(fp->dinfo->recall_cv); 10057c478bd9Sstevel@tonic-gate mutex_exit(fp->dinfo->recall_lock); 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lock); 10087c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cpr_info); 10097c478bd9Sstevel@tonic-gate mutex_destroy(&cpr_lock); 10107c478bd9Sstevel@tonic-gate 10117c478bd9Sstevel@tonic-gate rfs4_deleg_state_rele(dsp); /* release the hold for this thread */ 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate kmem_free(arg, sizeof (struct recall_arg)); 10147c478bd9Sstevel@tonic-gate } 10157c478bd9Sstevel@tonic-gate 10167c478bd9Sstevel@tonic-gate struct master_recall_args { 10177c478bd9Sstevel@tonic-gate rfs4_file_t *fp; 10187c478bd9Sstevel@tonic-gate void (*recall)(rfs4_deleg_state_t *, bool_t); 10197c478bd9Sstevel@tonic-gate bool_t trunc; 10207c478bd9Sstevel@tonic-gate }; 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate static void 10237c478bd9Sstevel@tonic-gate do_recall_file(struct master_recall_args *map) 10247c478bd9Sstevel@tonic-gate { 10257c478bd9Sstevel@tonic-gate rfs4_file_t *fp = map->fp; 10267c478bd9Sstevel@tonic-gate rfs4_deleg_state_t *dsp; 10277c478bd9Sstevel@tonic-gate struct recall_arg *arg; 10287c478bd9Sstevel@tonic-gate callb_cpr_t cpr_info; 10297c478bd9Sstevel@tonic-gate kmutex_t cpr_lock; 10307c478bd9Sstevel@tonic-gate int32_t recall_count; 10317c478bd9Sstevel@tonic-gate 10327c478bd9Sstevel@tonic-gate rfs4_dbe_lock(fp->dbe); 10337c478bd9Sstevel@tonic-gate /* Recall already in progress */ 10347c478bd9Sstevel@tonic-gate if (fp->dinfo->recall_count != 0) { 10357c478bd9Sstevel@tonic-gate rfs4_dbe_rele_nolock(fp->dbe); 10367c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 10377c478bd9Sstevel@tonic-gate kmem_free(map, sizeof (struct master_recall_args)); 10387c478bd9Sstevel@tonic-gate return; 10397c478bd9Sstevel@tonic-gate } 10407c478bd9Sstevel@tonic-gate 10417c478bd9Sstevel@tonic-gate mutex_init(&cpr_lock, NULL, MUTEX_DEFAULT, NULL); 10427c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cpr_info, &cpr_lock, callb_generic_cpr, 10437c478bd9Sstevel@tonic-gate "nfsv4RecallFile"); 10447c478bd9Sstevel@tonic-gate 10457c478bd9Sstevel@tonic-gate recall_count = 0; 10467c478bd9Sstevel@tonic-gate for (dsp = fp->delegationlist.next->dsp; dsp != NULL; 10477c478bd9Sstevel@tonic-gate dsp = dsp->delegationlist.next->dsp) { 10487c478bd9Sstevel@tonic-gate arg = kmem_alloc(sizeof (struct recall_arg), KM_SLEEP); 10497c478bd9Sstevel@tonic-gate arg->recall = map->recall; 10507c478bd9Sstevel@tonic-gate arg->trunc = map->trunc; 10517c478bd9Sstevel@tonic-gate 10527c478bd9Sstevel@tonic-gate rfs4_dbe_hold(dsp->dbe); /* hold for receiving thread */ 10537c478bd9Sstevel@tonic-gate 10547c478bd9Sstevel@tonic-gate arg->dsp = dsp; 10557c478bd9Sstevel@tonic-gate 10567c478bd9Sstevel@tonic-gate recall_count++; 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate (void) thread_create(NULL, 0, do_recall, arg, 0, &p0, TS_RUN, 10597c478bd9Sstevel@tonic-gate minclsyspri); 10607c478bd9Sstevel@tonic-gate } 10617c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate mutex_enter(fp->dinfo->recall_lock); 10647c478bd9Sstevel@tonic-gate /* 10657c478bd9Sstevel@tonic-gate * Recall count may go negative if the parent thread that is 10667c478bd9Sstevel@tonic-gate * creating the individual callback threads does not modify 10677c478bd9Sstevel@tonic-gate * the recall_count field before the callback thread actually 10687c478bd9Sstevel@tonic-gate * gets a response from the CB_RECALL 10697c478bd9Sstevel@tonic-gate */ 10707c478bd9Sstevel@tonic-gate fp->dinfo->recall_count += recall_count; 10717c478bd9Sstevel@tonic-gate while (fp->dinfo->recall_count) 10727c478bd9Sstevel@tonic-gate cv_wait(fp->dinfo->recall_cv, fp->dinfo->recall_lock); 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate mutex_exit(fp->dinfo->recall_lock); 10757c478bd9Sstevel@tonic-gate 10767c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, (CE_NOTE, "Recall complete for %p", 10777c478bd9Sstevel@tonic-gate (void*)fp)); 10787c478bd9Sstevel@tonic-gate rfs4_file_rele(fp); 10797c478bd9Sstevel@tonic-gate kmem_free(map, sizeof (struct master_recall_args)); 10807c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lock); 10817c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cpr_info); 10827c478bd9Sstevel@tonic-gate mutex_destroy(&cpr_lock); 10837c478bd9Sstevel@tonic-gate } 10847c478bd9Sstevel@tonic-gate 10857c478bd9Sstevel@tonic-gate static void 10867c478bd9Sstevel@tonic-gate rfs4_recall_file(rfs4_file_t *fp, 10877c478bd9Sstevel@tonic-gate void (*recall)(rfs4_deleg_state_t *, bool_t trunc), 10887c478bd9Sstevel@tonic-gate bool_t trunc, rfs4_client_t *cp) 10897c478bd9Sstevel@tonic-gate { 10907c478bd9Sstevel@tonic-gate struct master_recall_args *args; 10917c478bd9Sstevel@tonic-gate 10927c478bd9Sstevel@tonic-gate rfs4_dbe_lock(fp->dbe); 10937c478bd9Sstevel@tonic-gate if (fp->dinfo->dtype == OPEN_DELEGATE_NONE) { 10947c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 10957c478bd9Sstevel@tonic-gate return; 10967c478bd9Sstevel@tonic-gate } 10977c478bd9Sstevel@tonic-gate rfs4_dbe_hold(fp->dbe); /* hold for new thread */ 10987c478bd9Sstevel@tonic-gate 10997c478bd9Sstevel@tonic-gate /* 11007c478bd9Sstevel@tonic-gate * Mark the time we started the recall processing. 11017c478bd9Sstevel@tonic-gate * If it has been previously recalled, do not reset the 11027c478bd9Sstevel@tonic-gate * timer since this is used for the revocation decision. 11037c478bd9Sstevel@tonic-gate */ 11047c478bd9Sstevel@tonic-gate if (fp->dinfo->time_recalled == 0) 11057c478bd9Sstevel@tonic-gate fp->dinfo->time_recalled = gethrestime_sec(); 11067c478bd9Sstevel@tonic-gate fp->dinfo->ever_recalled = TRUE; /* used for policy decision */ 11077c478bd9Sstevel@tonic-gate /* Client causing recall not always available */ 11087c478bd9Sstevel@tonic-gate if (cp) 11097c478bd9Sstevel@tonic-gate fp->dinfo->conflicted_client = cp->clientid; 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 11127c478bd9Sstevel@tonic-gate 11137c478bd9Sstevel@tonic-gate args = kmem_alloc(sizeof (struct master_recall_args), KM_SLEEP); 11147c478bd9Sstevel@tonic-gate args->fp = fp; 11157c478bd9Sstevel@tonic-gate args->recall = recall; 11167c478bd9Sstevel@tonic-gate args->trunc = trunc; 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate (void) thread_create(NULL, 0, do_recall_file, args, 0, &p0, TS_RUN, 11197c478bd9Sstevel@tonic-gate minclsyspri); 11207c478bd9Sstevel@tonic-gate } 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate void 11237c478bd9Sstevel@tonic-gate rfs4_recall_deleg(rfs4_file_t *fp, bool_t trunc, rfs4_client_t *cp) 11247c478bd9Sstevel@tonic-gate { 11257c478bd9Sstevel@tonic-gate time_t elapsed1, elapsed2; 11267c478bd9Sstevel@tonic-gate 11277c478bd9Sstevel@tonic-gate if (fp->dinfo->time_recalled != 0) { 11287c478bd9Sstevel@tonic-gate elapsed1 = gethrestime_sec() - fp->dinfo->time_recalled; 11297c478bd9Sstevel@tonic-gate elapsed2 = gethrestime_sec() - fp->dinfo->time_lastwrite; 11307c478bd9Sstevel@tonic-gate /* First check to see if a revocation should occur */ 11317c478bd9Sstevel@tonic-gate if (elapsed1 > rfs4_lease_time && 11327c478bd9Sstevel@tonic-gate elapsed2 > rfs4_lease_time) { 11337c478bd9Sstevel@tonic-gate rfs4_revoke_file(fp); 11347c478bd9Sstevel@tonic-gate return; 11357c478bd9Sstevel@tonic-gate } 11367c478bd9Sstevel@tonic-gate /* 11377c478bd9Sstevel@tonic-gate * Next check to see if a recall should be done again 11387c478bd9Sstevel@tonic-gate * so quickly. 11397c478bd9Sstevel@tonic-gate */ 11407c478bd9Sstevel@tonic-gate if (elapsed1 <= ((rfs4_lease_time * 20) / 100)) 11417c478bd9Sstevel@tonic-gate return; 11427c478bd9Sstevel@tonic-gate } 11437c478bd9Sstevel@tonic-gate rfs4_recall_file(fp, rfs4_do_cb_recall, trunc, cp); 11447c478bd9Sstevel@tonic-gate } 11457c478bd9Sstevel@tonic-gate 11467c478bd9Sstevel@tonic-gate /* 11477c478bd9Sstevel@tonic-gate * rfs4_check_recall is called from rfs4_do_open to determine if the current 11487c478bd9Sstevel@tonic-gate * open conflicts with the delegation. 11497c478bd9Sstevel@tonic-gate * Return true if we need recall otherwise false. 11507c478bd9Sstevel@tonic-gate * Assumes entry locks for sp and sp->finfo are held. 11517c478bd9Sstevel@tonic-gate */ 11527c478bd9Sstevel@tonic-gate bool_t 11537c478bd9Sstevel@tonic-gate rfs4_check_recall(rfs4_state_t *sp, uint32_t access) 11547c478bd9Sstevel@tonic-gate { 11557c478bd9Sstevel@tonic-gate open_delegation_type4 dtype = sp->finfo->dinfo->dtype; 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate switch (dtype) { 11587c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_NONE: 11597c478bd9Sstevel@tonic-gate /* Not currently delegated so there is nothing to do */ 11607c478bd9Sstevel@tonic-gate return (FALSE); 11617c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_READ: 11627c478bd9Sstevel@tonic-gate /* 11637c478bd9Sstevel@tonic-gate * If the access is only asking for READ then there is 11647c478bd9Sstevel@tonic-gate * no conflict and nothing to do. If it is asking 11657c478bd9Sstevel@tonic-gate * for write, then there will be conflict and the read 11667c478bd9Sstevel@tonic-gate * delegation should be recalled. 11677c478bd9Sstevel@tonic-gate */ 11687c478bd9Sstevel@tonic-gate if (access == OPEN4_SHARE_ACCESS_READ) 11697c478bd9Sstevel@tonic-gate return (FALSE); 11707c478bd9Sstevel@tonic-gate else 11717c478bd9Sstevel@tonic-gate return (TRUE); 11727c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_WRITE: 11737c478bd9Sstevel@tonic-gate /* Check to see if this client has the delegation */ 11747c478bd9Sstevel@tonic-gate return (rfs4_is_deleg(sp)); 11757c478bd9Sstevel@tonic-gate } 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate return (FALSE); 11787c478bd9Sstevel@tonic-gate } 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate /* 11817c478bd9Sstevel@tonic-gate * Return the "best" allowable delegation available given the current 11827c478bd9Sstevel@tonic-gate * delegation type and the desired access and deny modes on the file. 11837c478bd9Sstevel@tonic-gate * At the point that this routine is called we know that the access and 11847c478bd9Sstevel@tonic-gate * deny modes are consistent with the file modes. 11857c478bd9Sstevel@tonic-gate */ 11867c478bd9Sstevel@tonic-gate static open_delegation_type4 11877c478bd9Sstevel@tonic-gate rfs4_check_delegation(rfs4_state_t *sp, rfs4_file_t *fp) 11887c478bd9Sstevel@tonic-gate { 11897c478bd9Sstevel@tonic-gate open_delegation_type4 dtype = fp->dinfo->dtype; 11907c478bd9Sstevel@tonic-gate uint32_t access = sp->share_access; 11917c478bd9Sstevel@tonic-gate uint32_t deny = sp->share_deny; 11927c478bd9Sstevel@tonic-gate int readcnt = 0; 11937c478bd9Sstevel@tonic-gate int writecnt = 0; 11947c478bd9Sstevel@tonic-gate 11957c478bd9Sstevel@tonic-gate switch (dtype) { 11967c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_NONE: 11977c478bd9Sstevel@tonic-gate /* 11987c478bd9Sstevel@tonic-gate * Determine if more than just this OPEN have the file 11997c478bd9Sstevel@tonic-gate * open and if so, no delegation may be provided to 12007c478bd9Sstevel@tonic-gate * the client. 12017c478bd9Sstevel@tonic-gate */ 12027c478bd9Sstevel@tonic-gate if (access & OPEN4_SHARE_ACCESS_WRITE) 12037c478bd9Sstevel@tonic-gate writecnt++; 12047c478bd9Sstevel@tonic-gate if (access & OPEN4_SHARE_ACCESS_READ) 12057c478bd9Sstevel@tonic-gate readcnt++; 12067c478bd9Sstevel@tonic-gate 12077c478bd9Sstevel@tonic-gate if (fp->access_read > readcnt || fp->access_write > writecnt) 12087c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_NONE); 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate /* 12117c478bd9Sstevel@tonic-gate * If the client is going to write, or if the client 12127c478bd9Sstevel@tonic-gate * has exclusive access, return a write delegation. 12137c478bd9Sstevel@tonic-gate */ 12147c478bd9Sstevel@tonic-gate if ((access & OPEN4_SHARE_ACCESS_WRITE) || 12157c478bd9Sstevel@tonic-gate (deny & (OPEN4_SHARE_DENY_READ | OPEN4_SHARE_DENY_WRITE))) 12167c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_WRITE); 12177c478bd9Sstevel@tonic-gate /* 12187c478bd9Sstevel@tonic-gate * If we don't want to write or we've haven't denied read 12197c478bd9Sstevel@tonic-gate * access to others, return a read delegation. 12207c478bd9Sstevel@tonic-gate */ 12217c478bd9Sstevel@tonic-gate if ((access & ~OPEN4_SHARE_ACCESS_WRITE) || 12227c478bd9Sstevel@tonic-gate (deny & ~OPEN4_SHARE_DENY_READ)) 12237c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_READ); 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate /* Shouldn't get here */ 12267c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_NONE); 12277c478bd9Sstevel@tonic-gate 12287c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_READ: 12297c478bd9Sstevel@tonic-gate /* 12307c478bd9Sstevel@tonic-gate * If the file is delegated for read but we wan't to 12317c478bd9Sstevel@tonic-gate * write or deny others to read then we can't delegate 12327c478bd9Sstevel@tonic-gate * the file. We shouldn't get here since the delegation should 12337c478bd9Sstevel@tonic-gate * have been recalled already. 12347c478bd9Sstevel@tonic-gate */ 12357c478bd9Sstevel@tonic-gate if ((access & OPEN4_SHARE_ACCESS_WRITE) || 12367c478bd9Sstevel@tonic-gate (deny & OPEN4_SHARE_DENY_READ)) 12377c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_NONE); 12387c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_READ); 12397c478bd9Sstevel@tonic-gate 12407c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_WRITE: 12417c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_WRITE); 12427c478bd9Sstevel@tonic-gate } 12437c478bd9Sstevel@tonic-gate 12447c478bd9Sstevel@tonic-gate /* Shouldn't get here */ 12457c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_NONE); 12467c478bd9Sstevel@tonic-gate } 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate /* 12497c478bd9Sstevel@tonic-gate * Given the desired delegation type and the "history" of the file 12507c478bd9Sstevel@tonic-gate * determine the actual delegation type to return. 12517c478bd9Sstevel@tonic-gate */ 12527c478bd9Sstevel@tonic-gate static open_delegation_type4 12537c478bd9Sstevel@tonic-gate rfs4_delegation_policy(open_delegation_type4 dtype, 12547c478bd9Sstevel@tonic-gate rfs4_dinfo_t *dinfo, clientid4 cid) 12557c478bd9Sstevel@tonic-gate { 12567c478bd9Sstevel@tonic-gate time_t elapsed; 12577c478bd9Sstevel@tonic-gate 12587c478bd9Sstevel@tonic-gate if (rfs4_deleg_policy != SRV_NORMAL_DELEGATE) 12597c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_NONE); 12607c478bd9Sstevel@tonic-gate 12617c478bd9Sstevel@tonic-gate /* 12627c478bd9Sstevel@tonic-gate * Has this file/delegation ever been recalled? If not then 12637c478bd9Sstevel@tonic-gate * no furhter checks for a delegation race need to be done. 12647c478bd9Sstevel@tonic-gate * However if a recall has occurred, then check to see if a 12657c478bd9Sstevel@tonic-gate * client has caused its own delegation recall to occur. If 12667c478bd9Sstevel@tonic-gate * not, then has a delegation for this file been returned 12677c478bd9Sstevel@tonic-gate * recently? If so, then do not assign a new delegation to 12687c478bd9Sstevel@tonic-gate * avoid a "delegation race" between the original client and 12697c478bd9Sstevel@tonic-gate * the new/conflicting client. 12707c478bd9Sstevel@tonic-gate */ 12717c478bd9Sstevel@tonic-gate if (dinfo->ever_recalled == TRUE) { 12727c478bd9Sstevel@tonic-gate if (dinfo->conflicted_client != cid) { 12737c478bd9Sstevel@tonic-gate elapsed = gethrestime_sec() - dinfo->time_returned; 12747c478bd9Sstevel@tonic-gate if (elapsed < rfs4_lease_time) 12757c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_NONE); 12767c478bd9Sstevel@tonic-gate } 12777c478bd9Sstevel@tonic-gate } 12787c478bd9Sstevel@tonic-gate 12797c478bd9Sstevel@tonic-gate /* Limit the number of read grants */ 12807c478bd9Sstevel@tonic-gate if (dtype == OPEN_DELEGATE_READ && 12817c478bd9Sstevel@tonic-gate dinfo->rdgrants > MAX_READ_DELEGATIONS) 12827c478bd9Sstevel@tonic-gate return (OPEN_DELEGATE_NONE); 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate /* 12857c478bd9Sstevel@tonic-gate * Should consider limiting total number of read/write 12867c478bd9Sstevel@tonic-gate * delegations the server will permit. 12877c478bd9Sstevel@tonic-gate */ 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate return (dtype); 12907c478bd9Sstevel@tonic-gate } 12917c478bd9Sstevel@tonic-gate 12927c478bd9Sstevel@tonic-gate /* 12937c478bd9Sstevel@tonic-gate * Try and grant a delegation for an open give the state. The routine 12947c478bd9Sstevel@tonic-gate * returns the delegation type granted. This could be OPEN_DELEGATE_NONE. 12957c478bd9Sstevel@tonic-gate * 12967c478bd9Sstevel@tonic-gate * The state and associate file entry must be locked 12977c478bd9Sstevel@tonic-gate */ 12987c478bd9Sstevel@tonic-gate rfs4_deleg_state_t * 12997c478bd9Sstevel@tonic-gate rfs4_grant_delegation(delegreq_t dreq, rfs4_state_t *sp, int *recall) 13007c478bd9Sstevel@tonic-gate { 13017c478bd9Sstevel@tonic-gate rfs4_file_t *fp = sp->finfo; 13027c478bd9Sstevel@tonic-gate open_delegation_type4 dtype; 13037c478bd9Sstevel@tonic-gate int no_delegation; 13047c478bd9Sstevel@tonic-gate 13057c478bd9Sstevel@tonic-gate ASSERT(rfs4_dbe_islocked(sp->dbe)); 13067c478bd9Sstevel@tonic-gate ASSERT(rfs4_dbe_islocked(fp->dbe)); 13077c478bd9Sstevel@tonic-gate 13087c478bd9Sstevel@tonic-gate /* Is the server even providing delegations? */ 13097c478bd9Sstevel@tonic-gate if (rfs4_deleg_policy == SRV_NEVER_DELEGATE || dreq == DELEG_NONE) 13107c478bd9Sstevel@tonic-gate return (NULL); 13117c478bd9Sstevel@tonic-gate 13127c478bd9Sstevel@tonic-gate /* Check to see if delegations have been temporarily disabled */ 13137c478bd9Sstevel@tonic-gate mutex_enter(&rfs4_deleg_lock); 13147c478bd9Sstevel@tonic-gate no_delegation = rfs4_deleg_disabled; 13157c478bd9Sstevel@tonic-gate mutex_exit(&rfs4_deleg_lock); 13167c478bd9Sstevel@tonic-gate 13177c478bd9Sstevel@tonic-gate if (no_delegation) 13187c478bd9Sstevel@tonic-gate return (NULL); 13197c478bd9Sstevel@tonic-gate 13207c478bd9Sstevel@tonic-gate /* Don't grant a delegation if a deletion is impending. */ 13217c478bd9Sstevel@tonic-gate if (fp->dinfo->hold_grant > 0) { 13227c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, 13237c478bd9Sstevel@tonic-gate (CE_NOTE, "rfs4_grant_delegation: hold_grant is set")); 13247c478bd9Sstevel@tonic-gate return (NULL); 13257c478bd9Sstevel@tonic-gate } 13267c478bd9Sstevel@tonic-gate 13277c478bd9Sstevel@tonic-gate /* 13287c478bd9Sstevel@tonic-gate * Don't grant a delegation if there are any lock manager 13297c478bd9Sstevel@tonic-gate * (NFSv2/v3) locks for the file. This is a bit of a hack (e.g., 13307c478bd9Sstevel@tonic-gate * if there are only read locks we should be able to grant a 13317c478bd9Sstevel@tonic-gate * read-only delegation), but it's good enough for now. 13327c478bd9Sstevel@tonic-gate * 13337c478bd9Sstevel@tonic-gate * MT safety: the lock manager checks for conflicting delegations 13347c478bd9Sstevel@tonic-gate * before processing a lock request. That check will block until 13357c478bd9Sstevel@tonic-gate * we are done here. So if the lock manager acquires a lock after 13367c478bd9Sstevel@tonic-gate * we decide to grant the delegation, the delegation will get 13377c478bd9Sstevel@tonic-gate * immediately recalled (if there's a conflict), so we're safe. 13387c478bd9Sstevel@tonic-gate */ 13397c478bd9Sstevel@tonic-gate if (lm_vp_active(fp->vp)) { 13407c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, 13417c478bd9Sstevel@tonic-gate (CE_NOTE, "rfs4_grant_delegation: NLM lock")); 13427c478bd9Sstevel@tonic-gate return (NULL); 13437c478bd9Sstevel@tonic-gate } 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate /* 13467c478bd9Sstevel@tonic-gate * Based on the type of delegation request passed in, take the 13477c478bd9Sstevel@tonic-gate * appropriate action (DELEG_NONE is handled above) 13487c478bd9Sstevel@tonic-gate */ 13497c478bd9Sstevel@tonic-gate switch (dreq) { 13507c478bd9Sstevel@tonic-gate 13517c478bd9Sstevel@tonic-gate case DELEG_READ: 13527c478bd9Sstevel@tonic-gate case DELEG_WRITE: 13537c478bd9Sstevel@tonic-gate /* 13547c478bd9Sstevel@tonic-gate * The server "must" grant the delegation in this case. 13557c478bd9Sstevel@tonic-gate * Client is using open previous 13567c478bd9Sstevel@tonic-gate */ 13577c478bd9Sstevel@tonic-gate dtype = (open_delegation_type4)dreq; 13587c478bd9Sstevel@tonic-gate *recall = 1; 13597c478bd9Sstevel@tonic-gate break; 13607c478bd9Sstevel@tonic-gate case DELEG_ANY: 13617c478bd9Sstevel@tonic-gate /* 13627c478bd9Sstevel@tonic-gate * If a valid callback path does not exist, no delegation may 13637c478bd9Sstevel@tonic-gate * be granted. 13647c478bd9Sstevel@tonic-gate */ 13657c478bd9Sstevel@tonic-gate if (sp->owner->client->cbinfo.cb_state != CB_OK) 13667c478bd9Sstevel@tonic-gate return (NULL); 13677c478bd9Sstevel@tonic-gate 13687c478bd9Sstevel@tonic-gate /* 13697c478bd9Sstevel@tonic-gate * If the original operation which caused time_rm_delayed 13707c478bd9Sstevel@tonic-gate * to be set hasn't been retried and completed for one 13717c478bd9Sstevel@tonic-gate * full lease period, clear it and allow delegations to 13727c478bd9Sstevel@tonic-gate * get granted again. 13737c478bd9Sstevel@tonic-gate */ 13747c478bd9Sstevel@tonic-gate if (fp->dinfo->time_rm_delayed > 0 && 13757c478bd9Sstevel@tonic-gate gethrestime_sec() > 13767c478bd9Sstevel@tonic-gate fp->dinfo->time_rm_delayed + rfs4_lease_time) 13777c478bd9Sstevel@tonic-gate fp->dinfo->time_rm_delayed = 0; 13787c478bd9Sstevel@tonic-gate 13797c478bd9Sstevel@tonic-gate /* 13807c478bd9Sstevel@tonic-gate * If we are waiting for a delegation to be returned then 13817c478bd9Sstevel@tonic-gate * don't delegate this file. We do this for correctness as 13827c478bd9Sstevel@tonic-gate * well as if the file is being recalled we would likely 13837c478bd9Sstevel@tonic-gate * recall this file again. 13847c478bd9Sstevel@tonic-gate */ 13857c478bd9Sstevel@tonic-gate 13867c478bd9Sstevel@tonic-gate if (fp->dinfo->time_recalled != 0 || 13877c478bd9Sstevel@tonic-gate fp->dinfo->time_rm_delayed != 0) 13887c478bd9Sstevel@tonic-gate return (NULL); 13897c478bd9Sstevel@tonic-gate 13907c478bd9Sstevel@tonic-gate /* Get the "best" delegation candidate */ 13917c478bd9Sstevel@tonic-gate dtype = rfs4_check_delegation(sp, fp); 13927c478bd9Sstevel@tonic-gate 13937c478bd9Sstevel@tonic-gate if (dtype == OPEN_DELEGATE_NONE) 13947c478bd9Sstevel@tonic-gate return (NULL); 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate /* 13977c478bd9Sstevel@tonic-gate * Based on policy and the history of the file get the 13987c478bd9Sstevel@tonic-gate * actual delegation. 13997c478bd9Sstevel@tonic-gate */ 14007c478bd9Sstevel@tonic-gate dtype = rfs4_delegation_policy(dtype, fp->dinfo, 14017c478bd9Sstevel@tonic-gate sp->owner->client->clientid); 14027c478bd9Sstevel@tonic-gate 14037c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, 14047c478bd9Sstevel@tonic-gate (CE_NOTE, "Grant policy dtype = %d", dtype)); 14057c478bd9Sstevel@tonic-gate if (dtype == OPEN_DELEGATE_NONE) 14067c478bd9Sstevel@tonic-gate return (NULL); 14077c478bd9Sstevel@tonic-gate break; 14087c478bd9Sstevel@tonic-gate default: 14097c478bd9Sstevel@tonic-gate return (NULL); 14107c478bd9Sstevel@tonic-gate } 14117c478bd9Sstevel@tonic-gate 14127c478bd9Sstevel@tonic-gate /* set the delegation for the state */ 14137c478bd9Sstevel@tonic-gate return (rfs4_deleg_state(sp, dtype, recall)); 14147c478bd9Sstevel@tonic-gate } 14157c478bd9Sstevel@tonic-gate 14167c478bd9Sstevel@tonic-gate void 14177c478bd9Sstevel@tonic-gate rfs4_set_deleg_response(rfs4_deleg_state_t *dsp, open_delegation4 *dp, 14187c478bd9Sstevel@tonic-gate nfsace4 *ace, int recall) 14197c478bd9Sstevel@tonic-gate { 14207c478bd9Sstevel@tonic-gate open_write_delegation4 *wp; 14217c478bd9Sstevel@tonic-gate open_read_delegation4 *rp; 14227c478bd9Sstevel@tonic-gate nfs_space_limit4 *spl; 14237c478bd9Sstevel@tonic-gate nfsace4 nace; 14247c478bd9Sstevel@tonic-gate 14257c478bd9Sstevel@tonic-gate /* 14267c478bd9Sstevel@tonic-gate * We need to allocate a new copy of the who string. 14277c478bd9Sstevel@tonic-gate * this string will be freed by the rfs4_op_open dis_resfree 14287c478bd9Sstevel@tonic-gate * routine. We need to do this allocation since replays will 14297c478bd9Sstevel@tonic-gate * be allocated and rfs4_compound can't tell the difference from 14307c478bd9Sstevel@tonic-gate * a replay and an inital open. N.B. if an ace is passed in, it 14317c478bd9Sstevel@tonic-gate * the caller's responsibility to free it. 14327c478bd9Sstevel@tonic-gate */ 14337c478bd9Sstevel@tonic-gate 14347c478bd9Sstevel@tonic-gate if (ace == NULL) { 14357c478bd9Sstevel@tonic-gate /* 14367c478bd9Sstevel@tonic-gate * Default is to deny all access, the client will have 14377c478bd9Sstevel@tonic-gate * to contact the server. XXX Do we want to actually 14387c478bd9Sstevel@tonic-gate * set a deny for every one, or do we simply want to 14397c478bd9Sstevel@tonic-gate * construct an entity that will match no one? 14407c478bd9Sstevel@tonic-gate */ 14417c478bd9Sstevel@tonic-gate nace.type = ACE4_ACCESS_DENIED_ACE_TYPE; 14427c478bd9Sstevel@tonic-gate nace.flag = 0; 14437c478bd9Sstevel@tonic-gate nace.access_mask = ACE4_VALID_MASK_BITS; 14447c478bd9Sstevel@tonic-gate (void) str_to_utf8(ACE4_WHO_EVERYONE, &nace.who); 14457c478bd9Sstevel@tonic-gate } else { 14467c478bd9Sstevel@tonic-gate nace.type = ace->type; 14477c478bd9Sstevel@tonic-gate nace.flag = ace->flag; 14487c478bd9Sstevel@tonic-gate nace.access_mask = ace->access_mask; 14497c478bd9Sstevel@tonic-gate (void) utf8_copy(&ace->who, &nace.who); 14507c478bd9Sstevel@tonic-gate } 14517c478bd9Sstevel@tonic-gate 14527c478bd9Sstevel@tonic-gate dp->delegation_type = dsp->dtype; 14537c478bd9Sstevel@tonic-gate 14547c478bd9Sstevel@tonic-gate switch (dsp->dtype) { 14557c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_NONE: 14567c478bd9Sstevel@tonic-gate break; 14577c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_READ: 14587c478bd9Sstevel@tonic-gate rp = &dp->open_delegation4_u.read; 14597c478bd9Sstevel@tonic-gate rp->stateid = dsp->delegid.stateid; 14607c478bd9Sstevel@tonic-gate rp->recall = (bool_t)recall; 14617c478bd9Sstevel@tonic-gate rp->permissions = nace; 14627c478bd9Sstevel@tonic-gate break; 14637c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_WRITE: 14647c478bd9Sstevel@tonic-gate wp = &dp->open_delegation4_u.write; 14657c478bd9Sstevel@tonic-gate wp->stateid = dsp->delegid.stateid; 14667c478bd9Sstevel@tonic-gate wp->recall = (bool_t)recall; 14677c478bd9Sstevel@tonic-gate spl = &wp->space_limit; 14687c478bd9Sstevel@tonic-gate spl->limitby = NFS_LIMIT_SIZE; 14697c478bd9Sstevel@tonic-gate spl->nfs_space_limit4_u.filesize = 0; 14707c478bd9Sstevel@tonic-gate wp->permissions = nace; 14717c478bd9Sstevel@tonic-gate break; 14727c478bd9Sstevel@tonic-gate } 14737c478bd9Sstevel@tonic-gate } 14747c478bd9Sstevel@tonic-gate 14757c478bd9Sstevel@tonic-gate /* 14767c478bd9Sstevel@tonic-gate * Check if the file is delegated via the provided file struct. 14777c478bd9Sstevel@tonic-gate * Return TRUE if it is delegated. This is intended for use by 14787c478bd9Sstevel@tonic-gate * the v4 server. The v2/v3 server code should use rfs4_check_delegated(). 14797c478bd9Sstevel@tonic-gate * 14807c478bd9Sstevel@tonic-gate * Note that if the file is found to have a delegation, it is 14817c478bd9Sstevel@tonic-gate * recalled, unless the clientid of the caller matches the clientid of the 14827c478bd9Sstevel@tonic-gate * delegation. If the caller has specified, there is a slight delay 14837c478bd9Sstevel@tonic-gate * inserted in the hopes that the delegation will be returned quickly. 14847c478bd9Sstevel@tonic-gate */ 14857c478bd9Sstevel@tonic-gate bool_t 14867c478bd9Sstevel@tonic-gate rfs4_check_delegated_byfp(int mode, rfs4_file_t *fp, 14877c478bd9Sstevel@tonic-gate bool_t trunc, bool_t do_delay, bool_t is_rm, clientid4 *cp) 14887c478bd9Sstevel@tonic-gate { 14897c478bd9Sstevel@tonic-gate rfs4_deleg_state_t *dsp; 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate /* Is delegation enabled? */ 14927c478bd9Sstevel@tonic-gate if (rfs4_deleg_policy == SRV_NEVER_DELEGATE) 14937c478bd9Sstevel@tonic-gate return (FALSE); 14947c478bd9Sstevel@tonic-gate 14957c478bd9Sstevel@tonic-gate /* do we have a delegation on this file? */ 14967c478bd9Sstevel@tonic-gate rfs4_dbe_lock(fp->dbe); 14977c478bd9Sstevel@tonic-gate if (fp->dinfo->dtype == OPEN_DELEGATE_NONE) { 14987c478bd9Sstevel@tonic-gate if (is_rm) 14997c478bd9Sstevel@tonic-gate fp->dinfo->hold_grant++; 15007c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 15017c478bd9Sstevel@tonic-gate return (FALSE); 15027c478bd9Sstevel@tonic-gate } 15037c478bd9Sstevel@tonic-gate /* 15047c478bd9Sstevel@tonic-gate * do we have a write delegation on this file or are we 15057c478bd9Sstevel@tonic-gate * requesting write access to a file with any type of existing 15067c478bd9Sstevel@tonic-gate * delegation? 15077c478bd9Sstevel@tonic-gate */ 15087c478bd9Sstevel@tonic-gate if (mode == FWRITE || fp->dinfo->dtype == OPEN_DELEGATE_WRITE) { 15097c478bd9Sstevel@tonic-gate if (cp != NULL) { 15107c478bd9Sstevel@tonic-gate dsp = fp->delegationlist.next->dsp; 15117c478bd9Sstevel@tonic-gate if (dsp == NULL) { 15127c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 15137c478bd9Sstevel@tonic-gate return (FALSE); 15147c478bd9Sstevel@tonic-gate } 15157c478bd9Sstevel@tonic-gate /* 15167c478bd9Sstevel@tonic-gate * Does the requestor already own the delegation? 15177c478bd9Sstevel@tonic-gate */ 15187c478bd9Sstevel@tonic-gate if (dsp->client->clientid == *(cp)) { 15197c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 15207c478bd9Sstevel@tonic-gate return (FALSE); 15217c478bd9Sstevel@tonic-gate } 15227c478bd9Sstevel@tonic-gate } 15237c478bd9Sstevel@tonic-gate 15247c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 15257c478bd9Sstevel@tonic-gate rfs4_recall_deleg(fp, trunc, NULL); 15267c478bd9Sstevel@tonic-gate 15277c478bd9Sstevel@tonic-gate if (!do_delay) { 15287c478bd9Sstevel@tonic-gate rfs4_dbe_lock(fp->dbe); 15297c478bd9Sstevel@tonic-gate fp->dinfo->time_rm_delayed = gethrestime_sec(); 15307c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 15317c478bd9Sstevel@tonic-gate return (TRUE); 15327c478bd9Sstevel@tonic-gate } 15337c478bd9Sstevel@tonic-gate 15347c478bd9Sstevel@tonic-gate delay(NFS4_DELEGATION_CONFLICT_DELAY); 15357c478bd9Sstevel@tonic-gate 15367c478bd9Sstevel@tonic-gate rfs4_dbe_lock(fp->dbe); 15377c478bd9Sstevel@tonic-gate if (fp->dinfo->dtype != OPEN_DELEGATE_NONE) { 15387c478bd9Sstevel@tonic-gate fp->dinfo->time_rm_delayed = gethrestime_sec(); 15397c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 15407c478bd9Sstevel@tonic-gate return (TRUE); 15417c478bd9Sstevel@tonic-gate } 15427c478bd9Sstevel@tonic-gate } 15437c478bd9Sstevel@tonic-gate if (is_rm) 15447c478bd9Sstevel@tonic-gate fp->dinfo->hold_grant++; 15457c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 15467c478bd9Sstevel@tonic-gate return (FALSE); 15477c478bd9Sstevel@tonic-gate } 15487c478bd9Sstevel@tonic-gate 15497c478bd9Sstevel@tonic-gate /* 15507c478bd9Sstevel@tonic-gate * Check if the file is delegated in the case of a v2 or v3 access. 15517c478bd9Sstevel@tonic-gate * Return TRUE if it is delegated which in turn means that v2 should 15527c478bd9Sstevel@tonic-gate * drop the request and in the case of v3 JUKEBOX should be returned. 15537c478bd9Sstevel@tonic-gate */ 15547c478bd9Sstevel@tonic-gate bool_t 15557c478bd9Sstevel@tonic-gate rfs4_check_delegated(int mode, vnode_t *vp, bool_t trunc) 15567c478bd9Sstevel@tonic-gate { 15577c478bd9Sstevel@tonic-gate rfs4_file_t *fp; 15587c478bd9Sstevel@tonic-gate bool_t create = FALSE; 15597c478bd9Sstevel@tonic-gate bool_t rc = FALSE; 15607c478bd9Sstevel@tonic-gate 15617c478bd9Sstevel@tonic-gate rfs4_hold_deleg_policy(); 15627c478bd9Sstevel@tonic-gate 15637c478bd9Sstevel@tonic-gate /* Is delegation enabled? */ 15647c478bd9Sstevel@tonic-gate if (rfs4_deleg_policy != SRV_NEVER_DELEGATE) { 15657c478bd9Sstevel@tonic-gate fp = rfs4_findfile(vp, NULL, &create); 15667c478bd9Sstevel@tonic-gate if (fp != NULL) { 15677c478bd9Sstevel@tonic-gate if (rfs4_check_delegated_byfp(mode, fp, trunc, 15687c478bd9Sstevel@tonic-gate TRUE, FALSE, NULL)) { 15697c478bd9Sstevel@tonic-gate rc = TRUE; 15707c478bd9Sstevel@tonic-gate } 15717c478bd9Sstevel@tonic-gate rfs4_file_rele(fp); 15727c478bd9Sstevel@tonic-gate } 15737c478bd9Sstevel@tonic-gate } 15747c478bd9Sstevel@tonic-gate rfs4_rele_deleg_policy(); 15757c478bd9Sstevel@tonic-gate return (rc); 15767c478bd9Sstevel@tonic-gate } 15777c478bd9Sstevel@tonic-gate 15787c478bd9Sstevel@tonic-gate /* 15797c478bd9Sstevel@tonic-gate * Release a hold on the hold_grant counter which 15807c478bd9Sstevel@tonic-gate * prevents delegation from being granted while a remove 15817c478bd9Sstevel@tonic-gate * or a rename is in progress. 15827c478bd9Sstevel@tonic-gate */ 15837c478bd9Sstevel@tonic-gate void 15847c478bd9Sstevel@tonic-gate rfs4_clear_dont_grant(rfs4_file_t *fp) 15857c478bd9Sstevel@tonic-gate { 15867c478bd9Sstevel@tonic-gate if (rfs4_deleg_policy == SRV_NEVER_DELEGATE) 15877c478bd9Sstevel@tonic-gate return; 15887c478bd9Sstevel@tonic-gate rfs4_dbe_lock(fp->dbe); 15897c478bd9Sstevel@tonic-gate ASSERT(fp->dinfo->hold_grant > 0); 15907c478bd9Sstevel@tonic-gate fp->dinfo->hold_grant--; 15917c478bd9Sstevel@tonic-gate fp->dinfo->time_rm_delayed = 0; 15927c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 15937c478bd9Sstevel@tonic-gate } 15947c478bd9Sstevel@tonic-gate 15957c478bd9Sstevel@tonic-gate /* 15967c478bd9Sstevel@tonic-gate * State support for delegation. 15977c478bd9Sstevel@tonic-gate * Set the state delegation type for this state; 15987c478bd9Sstevel@tonic-gate * This routine is called from open via rfs4_grant_delegation and the entry 15997c478bd9Sstevel@tonic-gate * locks on sp and sp->finfo are assumed. 16007c478bd9Sstevel@tonic-gate */ 16017c478bd9Sstevel@tonic-gate static rfs4_deleg_state_t * 16027c478bd9Sstevel@tonic-gate rfs4_deleg_state(rfs4_state_t *sp, open_delegation_type4 dtype, int *recall) 16037c478bd9Sstevel@tonic-gate { 16047c478bd9Sstevel@tonic-gate rfs4_file_t *fp = sp->finfo; 16057c478bd9Sstevel@tonic-gate bool_t create = TRUE; 16067c478bd9Sstevel@tonic-gate rfs4_deleg_state_t *dsp; 16077c478bd9Sstevel@tonic-gate vnode_t *vp; 16087c478bd9Sstevel@tonic-gate int open_prev = *recall; 16097c478bd9Sstevel@tonic-gate 1610*da1b9cd5Sjwahlig ASSERT(rfs4_dbe_islocked(sp->dbe)); 16117c478bd9Sstevel@tonic-gate ASSERT(rfs4_dbe_islocked(fp->dbe)); 16127c478bd9Sstevel@tonic-gate 16137c478bd9Sstevel@tonic-gate /* Shouldn't happen */ 16147c478bd9Sstevel@tonic-gate if (fp->dinfo->recall_count != 0 || 16157c478bd9Sstevel@tonic-gate (fp->dinfo->dtype == OPEN_DELEGATE_READ && 16167c478bd9Sstevel@tonic-gate dtype != OPEN_DELEGATE_READ)) { 16177c478bd9Sstevel@tonic-gate return (NULL); 16187c478bd9Sstevel@tonic-gate } 16197c478bd9Sstevel@tonic-gate 16207c478bd9Sstevel@tonic-gate /* Unlock to avoid deadlock */ 16217c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 1622*da1b9cd5Sjwahlig rfs4_dbe_unlock(sp->dbe); 16237c478bd9Sstevel@tonic-gate 16247c478bd9Sstevel@tonic-gate dsp = rfs4_finddeleg(sp, &create); 16257c478bd9Sstevel@tonic-gate 1626*da1b9cd5Sjwahlig rfs4_dbe_lock(sp->dbe); 16277c478bd9Sstevel@tonic-gate rfs4_dbe_lock(fp->dbe); 16287c478bd9Sstevel@tonic-gate 16297c478bd9Sstevel@tonic-gate if (dsp == NULL) 16307c478bd9Sstevel@tonic-gate return (NULL); 16317c478bd9Sstevel@tonic-gate 1632*da1b9cd5Sjwahlig /* 1633*da1b9cd5Sjwahlig * It is possible that since we dropped the lock 1634*da1b9cd5Sjwahlig * in order to call finddeleg, the rfs4_file_t 1635*da1b9cd5Sjwahlig * was marked such that we should not grant a 1636*da1b9cd5Sjwahlig * delegation, if so bail out. 1637*da1b9cd5Sjwahlig */ 1638*da1b9cd5Sjwahlig if (fp->dinfo->hold_grant > 0) { 1639*da1b9cd5Sjwahlig rfs4_deleg_state_rele(dsp); 1640*da1b9cd5Sjwahlig return (NULL); 1641*da1b9cd5Sjwahlig } 1642*da1b9cd5Sjwahlig 16437c478bd9Sstevel@tonic-gate if (create == FALSE) { 16447c478bd9Sstevel@tonic-gate if (sp->owner->client == dsp->client && 16457c478bd9Sstevel@tonic-gate dsp->dtype == dtype) { 16467c478bd9Sstevel@tonic-gate return (dsp); 16477c478bd9Sstevel@tonic-gate } else { 16487c478bd9Sstevel@tonic-gate rfs4_deleg_state_rele(dsp); 16497c478bd9Sstevel@tonic-gate return (NULL); 16507c478bd9Sstevel@tonic-gate } 16517c478bd9Sstevel@tonic-gate } 16527c478bd9Sstevel@tonic-gate 16537c478bd9Sstevel@tonic-gate /* 16547c478bd9Sstevel@tonic-gate * Check that this file has not been delegated to another 16557c478bd9Sstevel@tonic-gate * client 16567c478bd9Sstevel@tonic-gate */ 16577c478bd9Sstevel@tonic-gate if (fp->dinfo->recall_count != 0 || 16587c478bd9Sstevel@tonic-gate fp->dinfo->dtype == OPEN_DELEGATE_WRITE || 16597c478bd9Sstevel@tonic-gate (fp->dinfo->dtype == OPEN_DELEGATE_READ && 16607c478bd9Sstevel@tonic-gate dtype != OPEN_DELEGATE_READ)) { 16617c478bd9Sstevel@tonic-gate rfs4_deleg_state_rele(dsp); 16627c478bd9Sstevel@tonic-gate return (NULL); 16637c478bd9Sstevel@tonic-gate } 16647c478bd9Sstevel@tonic-gate 16657c478bd9Sstevel@tonic-gate vp = fp->vp; 16667c478bd9Sstevel@tonic-gate /* vnevent_support returns 0 if file system supports vnevents */ 16677c478bd9Sstevel@tonic-gate if (vnevent_support(vp)) { 16687c478bd9Sstevel@tonic-gate rfs4_deleg_state_rele(dsp); 16697c478bd9Sstevel@tonic-gate return (NULL); 16707c478bd9Sstevel@tonic-gate } 16717c478bd9Sstevel@tonic-gate 16727c478bd9Sstevel@tonic-gate *recall = 0; 16737c478bd9Sstevel@tonic-gate if (dtype == OPEN_DELEGATE_READ) { 16747c478bd9Sstevel@tonic-gate if (vn_is_opened(vp, V_WRITE) || vn_is_mapped(vp, V_WRITE)) { 16757c478bd9Sstevel@tonic-gate if (open_prev) { 16767c478bd9Sstevel@tonic-gate *recall = 1; 16777c478bd9Sstevel@tonic-gate } else { 16787c478bd9Sstevel@tonic-gate rfs4_deleg_state_rele(dsp); 16797c478bd9Sstevel@tonic-gate return (NULL); 16807c478bd9Sstevel@tonic-gate } 16817c478bd9Sstevel@tonic-gate } 16827c478bd9Sstevel@tonic-gate (void) fem_install(vp, deleg_rdops, (void *)fp, OPUNIQ, 16837c478bd9Sstevel@tonic-gate rfs4_mon_hold, rfs4_mon_rele); 16847c478bd9Sstevel@tonic-gate if (vn_is_opened(vp, V_WRITE) || vn_is_mapped(vp, V_WRITE)) { 16857c478bd9Sstevel@tonic-gate if (open_prev) { 16867c478bd9Sstevel@tonic-gate *recall = 1; 16877c478bd9Sstevel@tonic-gate } else { 16887c478bd9Sstevel@tonic-gate (void) fem_uninstall(vp, deleg_rdops, 16897c478bd9Sstevel@tonic-gate (void *)fp); 16907c478bd9Sstevel@tonic-gate rfs4_deleg_state_rele(dsp); 16917c478bd9Sstevel@tonic-gate return (NULL); 16927c478bd9Sstevel@tonic-gate } 16937c478bd9Sstevel@tonic-gate } 16947c478bd9Sstevel@tonic-gate } else { /* WRITE */ 16957c478bd9Sstevel@tonic-gate if (vn_is_opened(vp, V_RDORWR) || vn_is_mapped(vp, V_RDORWR)) { 16967c478bd9Sstevel@tonic-gate if (open_prev) { 16977c478bd9Sstevel@tonic-gate *recall = 1; 16987c478bd9Sstevel@tonic-gate } else { 16997c478bd9Sstevel@tonic-gate rfs4_deleg_state_rele(dsp); 17007c478bd9Sstevel@tonic-gate return (NULL); 17017c478bd9Sstevel@tonic-gate } 17027c478bd9Sstevel@tonic-gate } 17037c478bd9Sstevel@tonic-gate (void) fem_install(vp, deleg_wrops, (void *)fp, OPUNIQ, 17047c478bd9Sstevel@tonic-gate rfs4_mon_hold, rfs4_mon_rele); 17057c478bd9Sstevel@tonic-gate if (vn_is_opened(vp, V_RDORWR) || vn_is_mapped(vp, V_RDORWR)) { 17067c478bd9Sstevel@tonic-gate if (open_prev) { 17077c478bd9Sstevel@tonic-gate *recall = 1; 17087c478bd9Sstevel@tonic-gate } else { 17097c478bd9Sstevel@tonic-gate (void) fem_uninstall(vp, deleg_wrops, 17107c478bd9Sstevel@tonic-gate (void *)fp); 17117c478bd9Sstevel@tonic-gate rfs4_deleg_state_rele(dsp); 17127c478bd9Sstevel@tonic-gate return (NULL); 17137c478bd9Sstevel@tonic-gate } 17147c478bd9Sstevel@tonic-gate } 17157c478bd9Sstevel@tonic-gate } 17167c478bd9Sstevel@tonic-gate /* Place on delegation list for file */ 17177c478bd9Sstevel@tonic-gate insque(&dsp->delegationlist, fp->delegationlist.prev); 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate dsp->dtype = fp->dinfo->dtype = dtype; 17207c478bd9Sstevel@tonic-gate 17217c478bd9Sstevel@tonic-gate /* Update delegation stats for this file */ 17227c478bd9Sstevel@tonic-gate fp->dinfo->time_lastgrant = gethrestime_sec(); 17237c478bd9Sstevel@tonic-gate 17247c478bd9Sstevel@tonic-gate /* reset since this is a new delegation */ 17257c478bd9Sstevel@tonic-gate fp->dinfo->conflicted_client = 0; 17267c478bd9Sstevel@tonic-gate fp->dinfo->ever_recalled = FALSE; 17277c478bd9Sstevel@tonic-gate 17287c478bd9Sstevel@tonic-gate if (dtype == OPEN_DELEGATE_READ) 17297c478bd9Sstevel@tonic-gate fp->dinfo->rdgrants++; 17307c478bd9Sstevel@tonic-gate else 17317c478bd9Sstevel@tonic-gate fp->dinfo->wrgrants++; 17327c478bd9Sstevel@tonic-gate 17337c478bd9Sstevel@tonic-gate return (dsp); 17347c478bd9Sstevel@tonic-gate } 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate /* 17377c478bd9Sstevel@tonic-gate * State routine for the server when a delegation is returned. 17387c478bd9Sstevel@tonic-gate */ 17397c478bd9Sstevel@tonic-gate void 17407c478bd9Sstevel@tonic-gate rfs4_return_deleg(rfs4_deleg_state_t *dsp, bool_t revoked) 17417c478bd9Sstevel@tonic-gate { 17427c478bd9Sstevel@tonic-gate rfs4_file_t *fp = dsp->finfo; 17437c478bd9Sstevel@tonic-gate open_delegation_type4 dtypewas; 17447c478bd9Sstevel@tonic-gate 17457c478bd9Sstevel@tonic-gate rfs4_dbe_lock(fp->dbe); 17467c478bd9Sstevel@tonic-gate /* Remove state from recall list */ 17477c478bd9Sstevel@tonic-gate 17487c478bd9Sstevel@tonic-gate remque(&dsp->delegationlist); 17497c478bd9Sstevel@tonic-gate dsp->delegationlist.next = dsp->delegationlist.prev = 17507c478bd9Sstevel@tonic-gate &dsp->delegationlist; 17517c478bd9Sstevel@tonic-gate 17527c478bd9Sstevel@tonic-gate if (&fp->delegationlist == fp->delegationlist.next) { 17537c478bd9Sstevel@tonic-gate dtypewas = fp->dinfo->dtype; 17547c478bd9Sstevel@tonic-gate fp->dinfo->dtype = OPEN_DELEGATE_NONE; 17557c478bd9Sstevel@tonic-gate rfs4_dbe_cv_broadcast(fp->dbe); 17567c478bd9Sstevel@tonic-gate 17577c478bd9Sstevel@tonic-gate /* if file system was unshared, the vp will be NULL */ 17587c478bd9Sstevel@tonic-gate if (fp->vp != NULL) { 17597c478bd9Sstevel@tonic-gate if (dtypewas == OPEN_DELEGATE_READ) 17607c478bd9Sstevel@tonic-gate (void) fem_uninstall(fp->vp, deleg_rdops, 17617c478bd9Sstevel@tonic-gate (void *)fp); 17627c478bd9Sstevel@tonic-gate else 17637c478bd9Sstevel@tonic-gate (void) fem_uninstall(fp->vp, deleg_wrops, 17647c478bd9Sstevel@tonic-gate (void *)fp); 17657c478bd9Sstevel@tonic-gate } 17667c478bd9Sstevel@tonic-gate } 17677c478bd9Sstevel@tonic-gate 17687c478bd9Sstevel@tonic-gate switch (dsp->dtype) { 17697c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_READ: 17707c478bd9Sstevel@tonic-gate fp->dinfo->rdgrants--; 17717c478bd9Sstevel@tonic-gate break; 17727c478bd9Sstevel@tonic-gate case OPEN_DELEGATE_WRITE: 17737c478bd9Sstevel@tonic-gate fp->dinfo->wrgrants--; 17747c478bd9Sstevel@tonic-gate break; 17757c478bd9Sstevel@tonic-gate default: 17767c478bd9Sstevel@tonic-gate break; 17777c478bd9Sstevel@tonic-gate } 17787c478bd9Sstevel@tonic-gate 17797c478bd9Sstevel@tonic-gate /* used in the policy decision */ 17807c478bd9Sstevel@tonic-gate fp->dinfo->time_returned = gethrestime_sec(); 17817c478bd9Sstevel@tonic-gate 17827c478bd9Sstevel@tonic-gate /* 17837c478bd9Sstevel@tonic-gate * reset the time_recalled field so future delegations are not 17847c478bd9Sstevel@tonic-gate * accidentally revoked 17857c478bd9Sstevel@tonic-gate */ 17867c478bd9Sstevel@tonic-gate if ((fp->dinfo->rdgrants + fp->dinfo->wrgrants) == 0) 17877c478bd9Sstevel@tonic-gate fp->dinfo->time_recalled = 0; 17887c478bd9Sstevel@tonic-gate 17897c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 17907c478bd9Sstevel@tonic-gate 17917c478bd9Sstevel@tonic-gate rfs4_dbe_lock(dsp->dbe); 17927c478bd9Sstevel@tonic-gate 17937c478bd9Sstevel@tonic-gate dsp->dtype = OPEN_DELEGATE_NONE; 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate if (revoked == TRUE) 17967c478bd9Sstevel@tonic-gate dsp->time_revoked = gethrestime_sec(); 17977c478bd9Sstevel@tonic-gate 17987c478bd9Sstevel@tonic-gate rfs4_dbe_invalidate(dsp->dbe); 17997c478bd9Sstevel@tonic-gate 18007c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(dsp->dbe); 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate if (revoked == TRUE) { 18037c478bd9Sstevel@tonic-gate rfs4_dbe_lock(dsp->client->dbe); 18047c478bd9Sstevel@tonic-gate dsp->client->deleg_revoked++; /* observability */ 18057c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(dsp->client->dbe); 18067c478bd9Sstevel@tonic-gate } 18077c478bd9Sstevel@tonic-gate } 18087c478bd9Sstevel@tonic-gate 18097c478bd9Sstevel@tonic-gate static void 18107c478bd9Sstevel@tonic-gate rfs4_revoke_deleg(rfs4_deleg_state_t *dsp) 18117c478bd9Sstevel@tonic-gate { 18127c478bd9Sstevel@tonic-gate rfs4_return_deleg(dsp, TRUE); 18137c478bd9Sstevel@tonic-gate } 18147c478bd9Sstevel@tonic-gate 18157c478bd9Sstevel@tonic-gate static void 18167c478bd9Sstevel@tonic-gate rfs4_revoke_file(rfs4_file_t *fp) 18177c478bd9Sstevel@tonic-gate { 18187c478bd9Sstevel@tonic-gate rfs4_deleg_state_t *dsp; 18197c478bd9Sstevel@tonic-gate 18207c478bd9Sstevel@tonic-gate /* 18217c478bd9Sstevel@tonic-gate * The lock for rfs4_file_t must be held when traversing the 18227c478bd9Sstevel@tonic-gate * delegation list but that lock needs to be released to call 18237c478bd9Sstevel@tonic-gate * rfs4_revoke_deleg() 18247c478bd9Sstevel@tonic-gate * This for loop is set up to check the list for being empty, 18257c478bd9Sstevel@tonic-gate * and locking the rfs4_file_t struct on init and end 18267c478bd9Sstevel@tonic-gate */ 18277c478bd9Sstevel@tonic-gate for (rfs4_dbe_lock(fp->dbe); 18287c478bd9Sstevel@tonic-gate &fp->delegationlist != fp->delegationlist.next; 18297c478bd9Sstevel@tonic-gate rfs4_dbe_lock(fp->dbe)) { 18307c478bd9Sstevel@tonic-gate 18317c478bd9Sstevel@tonic-gate dsp = fp->delegationlist.next->dsp; 18327c478bd9Sstevel@tonic-gate rfs4_dbe_hold(dsp->dbe); 18337c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 18347c478bd9Sstevel@tonic-gate rfs4_revoke_deleg(dsp); 18357c478bd9Sstevel@tonic-gate rfs4_deleg_state_rele(dsp); 18367c478bd9Sstevel@tonic-gate } 18377c478bd9Sstevel@tonic-gate rfs4_dbe_unlock(fp->dbe); 18387c478bd9Sstevel@tonic-gate } 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate /* 18417c478bd9Sstevel@tonic-gate * A delegation is assumed to be present on the file associated with 18427c478bd9Sstevel@tonic-gate * "state". Check to see if the delegation matches is associated with 18437c478bd9Sstevel@tonic-gate * the same client as referenced by "state". If it is not, TRUE is 18447c478bd9Sstevel@tonic-gate * returned. If the delegation DOES match the client (or no 18457c478bd9Sstevel@tonic-gate * delegation is present), return FALSE. 18467c478bd9Sstevel@tonic-gate * Assume the state entry and file entry are locked. 18477c478bd9Sstevel@tonic-gate */ 18487c478bd9Sstevel@tonic-gate bool_t 18497c478bd9Sstevel@tonic-gate rfs4_is_deleg(rfs4_state_t *state) 18507c478bd9Sstevel@tonic-gate { 18517c478bd9Sstevel@tonic-gate rfs4_deleg_state_t *dsp; 18527c478bd9Sstevel@tonic-gate rfs4_file_t *fp = state->finfo; 18537c478bd9Sstevel@tonic-gate rfs4_client_t *cp = state->owner->client; 18547c478bd9Sstevel@tonic-gate 18557c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, 18567c478bd9Sstevel@tonic-gate (CE_NOTE, "rfs4_is_deleg enter: cp = %p", (void*)cp)); 18577c478bd9Sstevel@tonic-gate 18587c478bd9Sstevel@tonic-gate ASSERT(rfs4_dbe_islocked(fp->dbe)); 18597c478bd9Sstevel@tonic-gate for (dsp = fp->delegationlist.next->dsp; dsp != NULL; 18607c478bd9Sstevel@tonic-gate dsp = dsp->delegationlist.next->dsp) { 18617c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, 18627c478bd9Sstevel@tonic-gate (CE_NOTE, "rfs4_is_deleg: client = %p", 18637c478bd9Sstevel@tonic-gate (void*)dsp->client)); 18647c478bd9Sstevel@tonic-gate if (cp != dsp->client) { 18657c478bd9Sstevel@tonic-gate NFS4_DEBUG(rfs4_deleg_debug, 18667c478bd9Sstevel@tonic-gate (CE_NOTE, "rfs4_is_deleg is true")); 18677c478bd9Sstevel@tonic-gate return (TRUE); 18687c478bd9Sstevel@tonic-gate } 18697c478bd9Sstevel@tonic-gate } 18707c478bd9Sstevel@tonic-gate return (FALSE); 18717c478bd9Sstevel@tonic-gate } 18727c478bd9Sstevel@tonic-gate 18737c478bd9Sstevel@tonic-gate void 18747c478bd9Sstevel@tonic-gate rfs4_disable_delegation(void) 18757c478bd9Sstevel@tonic-gate { 18767c478bd9Sstevel@tonic-gate mutex_enter(&rfs4_deleg_lock); 18777c478bd9Sstevel@tonic-gate rfs4_deleg_disabled++; 18787c478bd9Sstevel@tonic-gate mutex_exit(&rfs4_deleg_lock); 18797c478bd9Sstevel@tonic-gate } 18807c478bd9Sstevel@tonic-gate 18817c478bd9Sstevel@tonic-gate void 18827c478bd9Sstevel@tonic-gate rfs4_enable_delegation(void) 18837c478bd9Sstevel@tonic-gate { 18847c478bd9Sstevel@tonic-gate mutex_enter(&rfs4_deleg_lock); 18857c478bd9Sstevel@tonic-gate ASSERT(rfs4_deleg_disabled > 0); 18867c478bd9Sstevel@tonic-gate rfs4_deleg_disabled--; 18877c478bd9Sstevel@tonic-gate mutex_exit(&rfs4_deleg_lock); 18887c478bd9Sstevel@tonic-gate } 18897c478bd9Sstevel@tonic-gate 18907c478bd9Sstevel@tonic-gate void 18917c478bd9Sstevel@tonic-gate rfs4_mon_hold(void *arg) 18927c478bd9Sstevel@tonic-gate { 18937c478bd9Sstevel@tonic-gate rfs4_file_t *fp = arg; 18947c478bd9Sstevel@tonic-gate 18957c478bd9Sstevel@tonic-gate rfs4_dbe_hold(fp->dbe); 18967c478bd9Sstevel@tonic-gate } 18977c478bd9Sstevel@tonic-gate 18987c478bd9Sstevel@tonic-gate void 18997c478bd9Sstevel@tonic-gate rfs4_mon_rele(void *arg) 19007c478bd9Sstevel@tonic-gate { 19017c478bd9Sstevel@tonic-gate rfs4_file_t *fp = arg; 19027c478bd9Sstevel@tonic-gate 19037c478bd9Sstevel@tonic-gate rfs4_dbe_rele_nolock(fp->dbe); 19047c478bd9Sstevel@tonic-gate } 1905