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 550a83466Sjwahlig * Common Development and Distribution License (the "License"). 650a83466Sjwahlig * 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 /* 22a19609f8Sjv * Copyright (c) 1986, 2010, Oracle and/or its affiliates. All rights reserved. 237c478bd9Sstevel@tonic-gate */ 247c478bd9Sstevel@tonic-gate 257c478bd9Sstevel@tonic-gate /* 267c478bd9Sstevel@tonic-gate * Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T. 277c478bd9Sstevel@tonic-gate * All Rights Reserved 287c478bd9Sstevel@tonic-gate */ 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate #include <sys/param.h> 317c478bd9Sstevel@tonic-gate #include <sys/types.h> 327c478bd9Sstevel@tonic-gate #include <sys/systm.h> 337c478bd9Sstevel@tonic-gate #include <sys/thread.h> 347c478bd9Sstevel@tonic-gate #include <sys/t_lock.h> 357c478bd9Sstevel@tonic-gate #include <sys/time.h> 367c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 377c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 387c478bd9Sstevel@tonic-gate #include <sys/errno.h> 397c478bd9Sstevel@tonic-gate #include <sys/buf.h> 407c478bd9Sstevel@tonic-gate #include <sys/stat.h> 417c478bd9Sstevel@tonic-gate #include <sys/cred.h> 427c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 437c478bd9Sstevel@tonic-gate #include <sys/debug.h> 447c478bd9Sstevel@tonic-gate #include <sys/dnlc.h> 457c478bd9Sstevel@tonic-gate #include <sys/vmsystm.h> 467c478bd9Sstevel@tonic-gate #include <sys/flock.h> 477c478bd9Sstevel@tonic-gate #include <sys/share.h> 487c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 497c478bd9Sstevel@tonic-gate #include <sys/tiuser.h> 507c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 517c478bd9Sstevel@tonic-gate #include <sys/callb.h> 527c478bd9Sstevel@tonic-gate #include <sys/acl.h> 537c478bd9Sstevel@tonic-gate #include <sys/kstat.h> 547c478bd9Sstevel@tonic-gate #include <sys/signal.h> 557c478bd9Sstevel@tonic-gate #include <sys/disp.h> 567c478bd9Sstevel@tonic-gate #include <sys/atomic.h> 577c478bd9Sstevel@tonic-gate #include <sys/list.h> 587c478bd9Sstevel@tonic-gate #include <sys/sdt.h> 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate #include <rpc/types.h> 617c478bd9Sstevel@tonic-gate #include <rpc/xdr.h> 627c478bd9Sstevel@tonic-gate #include <rpc/auth.h> 637c478bd9Sstevel@tonic-gate #include <rpc/clnt.h> 647c478bd9Sstevel@tonic-gate 657c478bd9Sstevel@tonic-gate #include <nfs/nfs.h> 667c478bd9Sstevel@tonic-gate #include <nfs/nfs_clnt.h> 677c478bd9Sstevel@tonic-gate #include <nfs/nfs_acl.h> 687c478bd9Sstevel@tonic-gate 697c478bd9Sstevel@tonic-gate #include <nfs/nfs4.h> 707c478bd9Sstevel@tonic-gate #include <nfs/rnode4.h> 717c478bd9Sstevel@tonic-gate #include <nfs/nfs4_clnt.h> 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate #include <vm/hat.h> 747c478bd9Sstevel@tonic-gate #include <vm/as.h> 757c478bd9Sstevel@tonic-gate #include <vm/page.h> 767c478bd9Sstevel@tonic-gate #include <vm/pvn.h> 777c478bd9Sstevel@tonic-gate #include <vm/seg.h> 787c478bd9Sstevel@tonic-gate #include <vm/seg_map.h> 797c478bd9Sstevel@tonic-gate #include <vm/seg_vn.h> 807c478bd9Sstevel@tonic-gate 817c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 827c478bd9Sstevel@tonic-gate 837c478bd9Sstevel@tonic-gate /* 847c478bd9Sstevel@tonic-gate * Arguments to page-flush thread. 857c478bd9Sstevel@tonic-gate */ 867c478bd9Sstevel@tonic-gate typedef struct { 877c478bd9Sstevel@tonic-gate vnode_t *vp; 887c478bd9Sstevel@tonic-gate cred_t *cr; 897c478bd9Sstevel@tonic-gate } pgflush_t; 907c478bd9Sstevel@tonic-gate 917c478bd9Sstevel@tonic-gate #ifdef DEBUG 927c478bd9Sstevel@tonic-gate int nfs4_client_lease_debug; 937c478bd9Sstevel@tonic-gate int nfs4_sharedfh_debug; 947c478bd9Sstevel@tonic-gate int nfs4_fname_debug; 957c478bd9Sstevel@tonic-gate 967c478bd9Sstevel@tonic-gate /* temporary: panic if v_type is inconsistent with r_attr va_type */ 977c478bd9Sstevel@tonic-gate int nfs4_vtype_debug; 987c478bd9Sstevel@tonic-gate 997c478bd9Sstevel@tonic-gate uint_t nfs4_tsd_key; 1007c478bd9Sstevel@tonic-gate #endif 1017c478bd9Sstevel@tonic-gate 1027c478bd9Sstevel@tonic-gate static time_t nfs4_client_resumed = 0; 1037c478bd9Sstevel@tonic-gate static callb_id_t cid = 0; 1047c478bd9Sstevel@tonic-gate 1057c478bd9Sstevel@tonic-gate static int nfs4renew(nfs4_server_t *); 1067c478bd9Sstevel@tonic-gate static void nfs4_attrcache_va(vnode_t *, nfs4_ga_res_t *, int); 1077c478bd9Sstevel@tonic-gate static void nfs4_pgflush_thread(pgflush_t *); 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate static boolean_t nfs4_client_cpr_callb(void *, int); 1107c478bd9Sstevel@tonic-gate 1117c478bd9Sstevel@tonic-gate struct mi4_globals { 1127c478bd9Sstevel@tonic-gate kmutex_t mig_lock; /* lock protecting mig_list */ 1137c478bd9Sstevel@tonic-gate list_t mig_list; /* list of NFS v4 mounts in zone */ 1147c478bd9Sstevel@tonic-gate boolean_t mig_destructor_called; 1157c478bd9Sstevel@tonic-gate }; 1167c478bd9Sstevel@tonic-gate 1177c478bd9Sstevel@tonic-gate static zone_key_t mi4_list_key; 1187c478bd9Sstevel@tonic-gate 1197c478bd9Sstevel@tonic-gate /* 1207c478bd9Sstevel@tonic-gate * Attributes caching: 1217c478bd9Sstevel@tonic-gate * 1227c478bd9Sstevel@tonic-gate * Attributes are cached in the rnode in struct vattr form. 1237c478bd9Sstevel@tonic-gate * There is a time associated with the cached attributes (r_time_attr_inval) 1247c478bd9Sstevel@tonic-gate * which tells whether the attributes are valid. The time is initialized 1257c478bd9Sstevel@tonic-gate * to the difference between current time and the modify time of the vnode 1267c478bd9Sstevel@tonic-gate * when new attributes are cached. This allows the attributes for 1277c478bd9Sstevel@tonic-gate * files that have changed recently to be timed out sooner than for files 1287c478bd9Sstevel@tonic-gate * that have not changed for a long time. There are minimum and maximum 1297c478bd9Sstevel@tonic-gate * timeout values that can be set per mount point. 1307c478bd9Sstevel@tonic-gate */ 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate /* 1337c478bd9Sstevel@tonic-gate * If a cache purge is in progress, wait for it to finish. 1347c478bd9Sstevel@tonic-gate * 1357c478bd9Sstevel@tonic-gate * The current thread must not be in the middle of an 1367c478bd9Sstevel@tonic-gate * nfs4_start_op/nfs4_end_op region. Otherwise, there could be a deadlock 1377c478bd9Sstevel@tonic-gate * between this thread, a recovery thread, and the page flush thread. 1387c478bd9Sstevel@tonic-gate */ 1397c478bd9Sstevel@tonic-gate int 1407c478bd9Sstevel@tonic-gate nfs4_waitfor_purge_complete(vnode_t *vp) 1417c478bd9Sstevel@tonic-gate { 1427c478bd9Sstevel@tonic-gate rnode4_t *rp; 1437c478bd9Sstevel@tonic-gate k_sigset_t smask; 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 1467c478bd9Sstevel@tonic-gate if ((rp->r_serial != NULL && rp->r_serial != curthread) || 1477c478bd9Sstevel@tonic-gate ((rp->r_flags & R4PGFLUSH) && rp->r_pgflush != curthread)) { 1487c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 1497c478bd9Sstevel@tonic-gate sigintr(&smask, VTOMI4(vp)->mi_flags & MI4_INT); 1507c478bd9Sstevel@tonic-gate while ((rp->r_serial != NULL && rp->r_serial != curthread) || 1517c478bd9Sstevel@tonic-gate ((rp->r_flags & R4PGFLUSH) && 1527c478bd9Sstevel@tonic-gate rp->r_pgflush != curthread)) { 1537c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&rp->r_cv, &rp->r_statelock)) { 1547c478bd9Sstevel@tonic-gate sigunintr(&smask); 1557c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 1567c478bd9Sstevel@tonic-gate return (EINTR); 1577c478bd9Sstevel@tonic-gate } 1587c478bd9Sstevel@tonic-gate } 1597c478bd9Sstevel@tonic-gate sigunintr(&smask); 1607c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 1617c478bd9Sstevel@tonic-gate } 1627c478bd9Sstevel@tonic-gate return (0); 1637c478bd9Sstevel@tonic-gate } 1647c478bd9Sstevel@tonic-gate 1657c478bd9Sstevel@tonic-gate /* 1667c478bd9Sstevel@tonic-gate * Validate caches by checking cached attributes. If they have timed out, 1677c478bd9Sstevel@tonic-gate * then get new attributes from the server. As a side effect, cache 1687c478bd9Sstevel@tonic-gate * invalidation is done if the attributes have changed. 1697c478bd9Sstevel@tonic-gate * 1707c478bd9Sstevel@tonic-gate * If the attributes have not timed out and if there is a cache 1717c478bd9Sstevel@tonic-gate * invalidation being done by some other thread, then wait until that 1727c478bd9Sstevel@tonic-gate * thread has completed the cache invalidation. 1737c478bd9Sstevel@tonic-gate */ 1747c478bd9Sstevel@tonic-gate int 1757c478bd9Sstevel@tonic-gate nfs4_validate_caches(vnode_t *vp, cred_t *cr) 1767c478bd9Sstevel@tonic-gate { 1777c478bd9Sstevel@tonic-gate int error; 1787c478bd9Sstevel@tonic-gate nfs4_ga_res_t gar; 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate if (ATTRCACHE4_VALID(vp)) { 1817c478bd9Sstevel@tonic-gate error = nfs4_waitfor_purge_complete(vp); 1827c478bd9Sstevel@tonic-gate if (error) 1837c478bd9Sstevel@tonic-gate return (error); 1847c478bd9Sstevel@tonic-gate return (0); 1857c478bd9Sstevel@tonic-gate } 1867c478bd9Sstevel@tonic-gate 1877c478bd9Sstevel@tonic-gate return (nfs4_getattr_otw(vp, &gar, cr, 0)); 1887c478bd9Sstevel@tonic-gate } 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate /* 1917c478bd9Sstevel@tonic-gate * Fill in attribute from the cache. 1927c478bd9Sstevel@tonic-gate * If valid, then return 0 to indicate that no error occurred, 1937c478bd9Sstevel@tonic-gate * otherwise return 1 to indicate that an error occurred. 1947c478bd9Sstevel@tonic-gate */ 1957c478bd9Sstevel@tonic-gate static int 1967c478bd9Sstevel@tonic-gate nfs4_getattr_cache(vnode_t *vp, struct vattr *vap) 1977c478bd9Sstevel@tonic-gate { 1987c478bd9Sstevel@tonic-gate rnode4_t *rp; 1997c478bd9Sstevel@tonic-gate 2007c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 2017c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 2027c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statev4_lock); 2037c478bd9Sstevel@tonic-gate if (ATTRCACHE4_VALID(vp)) { 2047c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statev4_lock); 2057c478bd9Sstevel@tonic-gate /* 2067c478bd9Sstevel@tonic-gate * Cached attributes are valid 2077c478bd9Sstevel@tonic-gate */ 2087c478bd9Sstevel@tonic-gate *vap = rp->r_attr; 2097c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 2107c478bd9Sstevel@tonic-gate return (0); 2117c478bd9Sstevel@tonic-gate } 2127c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statev4_lock); 2137c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 2147c478bd9Sstevel@tonic-gate return (1); 2157c478bd9Sstevel@tonic-gate } 2167c478bd9Sstevel@tonic-gate 2177c478bd9Sstevel@tonic-gate 2187c478bd9Sstevel@tonic-gate /* 2197c478bd9Sstevel@tonic-gate * If returned error is ESTALE flush all caches. The nfs4_purge_caches() 2207c478bd9Sstevel@tonic-gate * call is synchronous because all the pages were invalidated by the 2217c478bd9Sstevel@tonic-gate * nfs4_invalidate_pages() call. 2227c478bd9Sstevel@tonic-gate */ 2237c478bd9Sstevel@tonic-gate void 2247c478bd9Sstevel@tonic-gate nfs4_purge_stale_fh(int errno, vnode_t *vp, cred_t *cr) 2257c478bd9Sstevel@tonic-gate { 2267c478bd9Sstevel@tonic-gate struct rnode4 *rp = VTOR4(vp); 2277c478bd9Sstevel@tonic-gate 2287c478bd9Sstevel@tonic-gate /* Ensure that the ..._end_op() call has been done */ 2297c478bd9Sstevel@tonic-gate ASSERT(tsd_get(nfs4_tsd_key) == NULL); 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate if (errno != ESTALE) 2327c478bd9Sstevel@tonic-gate return; 2337c478bd9Sstevel@tonic-gate 2347c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 2357c478bd9Sstevel@tonic-gate rp->r_flags |= R4STALE; 2367c478bd9Sstevel@tonic-gate if (!rp->r_error) 2377c478bd9Sstevel@tonic-gate rp->r_error = errno; 2387c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 2397c478bd9Sstevel@tonic-gate if (nfs4_has_pages(vp)) 2407c478bd9Sstevel@tonic-gate nfs4_invalidate_pages(vp, (u_offset_t)0, cr); 2417c478bd9Sstevel@tonic-gate nfs4_purge_caches(vp, NFS4_PURGE_DNLC, cr, FALSE); 2427c478bd9Sstevel@tonic-gate } 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate /* 2457c478bd9Sstevel@tonic-gate * Purge all of the various NFS `data' caches. If "asyncpg" is TRUE, the 2467c478bd9Sstevel@tonic-gate * page purge is done asynchronously. 2477c478bd9Sstevel@tonic-gate */ 2487c478bd9Sstevel@tonic-gate void 2497c478bd9Sstevel@tonic-gate nfs4_purge_caches(vnode_t *vp, int purge_dnlc, cred_t *cr, int asyncpg) 2507c478bd9Sstevel@tonic-gate { 2517c478bd9Sstevel@tonic-gate rnode4_t *rp; 2527c478bd9Sstevel@tonic-gate char *contents; 2537c478bd9Sstevel@tonic-gate vnode_t *xattr; 2547c478bd9Sstevel@tonic-gate int size; 2557c478bd9Sstevel@tonic-gate int pgflush; /* are we the page flush thread? */ 2567c478bd9Sstevel@tonic-gate 2577c478bd9Sstevel@tonic-gate /* 2587c478bd9Sstevel@tonic-gate * Purge the DNLC for any entries which refer to this file. 2597c478bd9Sstevel@tonic-gate */ 2607c478bd9Sstevel@tonic-gate if (vp->v_count > 1 && 2617c478bd9Sstevel@tonic-gate (vp->v_type == VDIR || purge_dnlc == NFS4_PURGE_DNLC)) 2627c478bd9Sstevel@tonic-gate dnlc_purge_vp(vp); 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate /* 2657c478bd9Sstevel@tonic-gate * Clear any readdir state bits and purge the readlink response cache. 2667c478bd9Sstevel@tonic-gate */ 2677c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 2687c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 2697c478bd9Sstevel@tonic-gate rp->r_flags &= ~R4LOOKUP; 2707c478bd9Sstevel@tonic-gate contents = rp->r_symlink.contents; 2717c478bd9Sstevel@tonic-gate size = rp->r_symlink.size; 2727c478bd9Sstevel@tonic-gate rp->r_symlink.contents = NULL; 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate xattr = rp->r_xattr_dir; 2757c478bd9Sstevel@tonic-gate rp->r_xattr_dir = NULL; 2767c478bd9Sstevel@tonic-gate 2777c478bd9Sstevel@tonic-gate /* 2787c478bd9Sstevel@tonic-gate * Purge pathconf cache too. 2797c478bd9Sstevel@tonic-gate */ 2807c478bd9Sstevel@tonic-gate rp->r_pathconf.pc4_xattr_valid = 0; 2817c478bd9Sstevel@tonic-gate rp->r_pathconf.pc4_cache_valid = 0; 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate pgflush = (curthread == rp->r_pgflush); 2847c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate if (contents != NULL) { 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate kmem_free((void *)contents, size); 2897c478bd9Sstevel@tonic-gate } 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate if (xattr != NULL) 2927c478bd9Sstevel@tonic-gate VN_RELE(xattr); 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate /* 2957c478bd9Sstevel@tonic-gate * Flush the page cache. If the current thread is the page flush 2967c478bd9Sstevel@tonic-gate * thread, don't initiate a new page flush. There's no need for 2977c478bd9Sstevel@tonic-gate * it, and doing it correctly is hard. 2987c478bd9Sstevel@tonic-gate */ 2997c478bd9Sstevel@tonic-gate if (nfs4_has_pages(vp) && !pgflush) { 3007c478bd9Sstevel@tonic-gate if (!asyncpg) { 3017c478bd9Sstevel@tonic-gate (void) nfs4_waitfor_purge_complete(vp); 302d55e25c3SPavel Filipensky nfs4_flush_pages(vp, cr); 3037c478bd9Sstevel@tonic-gate } else { 3047c478bd9Sstevel@tonic-gate pgflush_t *args; 3057c478bd9Sstevel@tonic-gate 3067c478bd9Sstevel@tonic-gate /* 3077c478bd9Sstevel@tonic-gate * We don't hold r_statelock while creating the 3087c478bd9Sstevel@tonic-gate * thread, in case the call blocks. So we use a 3097c478bd9Sstevel@tonic-gate * flag to indicate that a page flush thread is 3107c478bd9Sstevel@tonic-gate * active. 3117c478bd9Sstevel@tonic-gate */ 3127c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 3137c478bd9Sstevel@tonic-gate if (rp->r_flags & R4PGFLUSH) { 3147c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 3157c478bd9Sstevel@tonic-gate } else { 3167c478bd9Sstevel@tonic-gate rp->r_flags |= R4PGFLUSH; 3177c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate args = kmem_alloc(sizeof (pgflush_t), 320b9238976Sth KM_SLEEP); 3217c478bd9Sstevel@tonic-gate args->vp = vp; 3227c478bd9Sstevel@tonic-gate VN_HOLD(args->vp); 3237c478bd9Sstevel@tonic-gate args->cr = cr; 3247c478bd9Sstevel@tonic-gate crhold(args->cr); 3257c478bd9Sstevel@tonic-gate (void) zthread_create(NULL, 0, 326b9238976Sth nfs4_pgflush_thread, args, 0, 327b9238976Sth minclsyspri); 3287c478bd9Sstevel@tonic-gate } 3297c478bd9Sstevel@tonic-gate } 3307c478bd9Sstevel@tonic-gate } 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate /* 3337c478bd9Sstevel@tonic-gate * Flush the readdir response cache. 3347c478bd9Sstevel@tonic-gate */ 3357c478bd9Sstevel@tonic-gate nfs4_purge_rddir_cache(vp); 3367c478bd9Sstevel@tonic-gate } 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate /* 3397c478bd9Sstevel@tonic-gate * Invalidate all pages for the given file, after writing back the dirty 3407c478bd9Sstevel@tonic-gate * ones. 3417c478bd9Sstevel@tonic-gate */ 3427c478bd9Sstevel@tonic-gate 343d55e25c3SPavel Filipensky void 344d55e25c3SPavel Filipensky nfs4_flush_pages(vnode_t *vp, cred_t *cr) 3457c478bd9Sstevel@tonic-gate { 3467c478bd9Sstevel@tonic-gate int error; 3477c478bd9Sstevel@tonic-gate rnode4_t *rp = VTOR4(vp); 3487c478bd9Sstevel@tonic-gate 349da6c28aaSamw error = VOP_PUTPAGE(vp, (u_offset_t)0, 0, B_INVAL, cr, NULL); 3507c478bd9Sstevel@tonic-gate if (error == ENOSPC || error == EDQUOT) { 3517c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 3527c478bd9Sstevel@tonic-gate if (!rp->r_error) 3537c478bd9Sstevel@tonic-gate rp->r_error = error; 3547c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 3557c478bd9Sstevel@tonic-gate } 3567c478bd9Sstevel@tonic-gate } 3577c478bd9Sstevel@tonic-gate 3587c478bd9Sstevel@tonic-gate /* 3597c478bd9Sstevel@tonic-gate * Page flush thread. 3607c478bd9Sstevel@tonic-gate */ 3617c478bd9Sstevel@tonic-gate 3627c478bd9Sstevel@tonic-gate static void 3637c478bd9Sstevel@tonic-gate nfs4_pgflush_thread(pgflush_t *args) 3647c478bd9Sstevel@tonic-gate { 3657c478bd9Sstevel@tonic-gate rnode4_t *rp = VTOR4(args->vp); 3667c478bd9Sstevel@tonic-gate 3677c478bd9Sstevel@tonic-gate /* remember which thread we are, so we don't deadlock ourselves */ 3687c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 3697c478bd9Sstevel@tonic-gate ASSERT(rp->r_pgflush == NULL); 3707c478bd9Sstevel@tonic-gate rp->r_pgflush = curthread; 3717c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 3727c478bd9Sstevel@tonic-gate 373d55e25c3SPavel Filipensky nfs4_flush_pages(args->vp, args->cr); 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 3767c478bd9Sstevel@tonic-gate rp->r_pgflush = NULL; 3777c478bd9Sstevel@tonic-gate rp->r_flags &= ~R4PGFLUSH; 3787c478bd9Sstevel@tonic-gate cv_broadcast(&rp->r_cv); 3797c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 3807c478bd9Sstevel@tonic-gate 3817c478bd9Sstevel@tonic-gate VN_RELE(args->vp); 3827c478bd9Sstevel@tonic-gate crfree(args->cr); 3837c478bd9Sstevel@tonic-gate kmem_free(args, sizeof (pgflush_t)); 3847c478bd9Sstevel@tonic-gate zthread_exit(); 3857c478bd9Sstevel@tonic-gate } 3867c478bd9Sstevel@tonic-gate 3877c478bd9Sstevel@tonic-gate /* 3887c478bd9Sstevel@tonic-gate * Purge the readdir cache of all entries which are not currently 3897c478bd9Sstevel@tonic-gate * being filled. 3907c478bd9Sstevel@tonic-gate */ 3917c478bd9Sstevel@tonic-gate void 3927c478bd9Sstevel@tonic-gate nfs4_purge_rddir_cache(vnode_t *vp) 3937c478bd9Sstevel@tonic-gate { 3947c478bd9Sstevel@tonic-gate rnode4_t *rp; 3957c478bd9Sstevel@tonic-gate 3967c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 3997c478bd9Sstevel@tonic-gate rp->r_direof = NULL; 4007c478bd9Sstevel@tonic-gate rp->r_flags &= ~R4LOOKUP; 4017c478bd9Sstevel@tonic-gate rp->r_flags |= R4READDIRWATTR; 4027c478bd9Sstevel@tonic-gate rddir4_cache_purge(rp); 4037c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 4047c478bd9Sstevel@tonic-gate } 4057c478bd9Sstevel@tonic-gate 4067c478bd9Sstevel@tonic-gate /* 4077c478bd9Sstevel@tonic-gate * Set attributes cache for given vnode using virtual attributes. There is 4087c478bd9Sstevel@tonic-gate * no cache validation, but if the attributes are deemed to be stale, they 4097c478bd9Sstevel@tonic-gate * are ignored. This corresponds to nfs3_attrcache(). 4107c478bd9Sstevel@tonic-gate * 4117c478bd9Sstevel@tonic-gate * Set the timeout value on the attribute cache and fill it 4127c478bd9Sstevel@tonic-gate * with the passed in attributes. 4137c478bd9Sstevel@tonic-gate */ 4147c478bd9Sstevel@tonic-gate void 4157c478bd9Sstevel@tonic-gate nfs4_attrcache_noinval(vnode_t *vp, nfs4_ga_res_t *garp, hrtime_t t) 4167c478bd9Sstevel@tonic-gate { 4177c478bd9Sstevel@tonic-gate rnode4_t *rp = VTOR4(vp); 4187c478bd9Sstevel@tonic-gate 4197c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 4207c478bd9Sstevel@tonic-gate if (rp->r_time_attr_saved <= t) 4217c478bd9Sstevel@tonic-gate nfs4_attrcache_va(vp, garp, FALSE); 4227c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 4237c478bd9Sstevel@tonic-gate } 4247c478bd9Sstevel@tonic-gate 4257c478bd9Sstevel@tonic-gate /* 4267c478bd9Sstevel@tonic-gate * Use the passed in virtual attributes to check to see whether the 4277c478bd9Sstevel@tonic-gate * data and metadata caches are valid, cache the new attributes, and 4287c478bd9Sstevel@tonic-gate * then do the cache invalidation if required. 4297c478bd9Sstevel@tonic-gate * 4307c478bd9Sstevel@tonic-gate * The cache validation and caching of the new attributes is done 4317c478bd9Sstevel@tonic-gate * atomically via the use of the mutex, r_statelock. If required, 4327c478bd9Sstevel@tonic-gate * the cache invalidation is done atomically w.r.t. the cache 4337c478bd9Sstevel@tonic-gate * validation and caching of the attributes via the pseudo lock, 4347c478bd9Sstevel@tonic-gate * r_serial. 4357c478bd9Sstevel@tonic-gate * 4367c478bd9Sstevel@tonic-gate * This routine is used to do cache validation and attributes caching 4377c478bd9Sstevel@tonic-gate * for operations with a single set of post operation attributes. 4387c478bd9Sstevel@tonic-gate */ 4397c478bd9Sstevel@tonic-gate 4407c478bd9Sstevel@tonic-gate void 4417c478bd9Sstevel@tonic-gate nfs4_attr_cache(vnode_t *vp, nfs4_ga_res_t *garp, 442b9238976Sth hrtime_t t, cred_t *cr, int async, 443b9238976Sth change_info4 *cinfo) 4447c478bd9Sstevel@tonic-gate { 4457c478bd9Sstevel@tonic-gate rnode4_t *rp; 4465e4df02aSvv int mtime_changed = 0; 4475e4df02aSvv int ctime_changed = 0; 4487c478bd9Sstevel@tonic-gate vsecattr_t *vsp; 4497c478bd9Sstevel@tonic-gate int was_serial, set_time_cache_inval, recov; 4507c478bd9Sstevel@tonic-gate vattr_t *vap = &garp->n4g_va; 4517c478bd9Sstevel@tonic-gate mntinfo4_t *mi = VTOMI4(vp); 4525e4df02aSvv len_t preattr_rsize; 4535e4df02aSvv boolean_t writemodify_set = B_FALSE; 4545e4df02aSvv boolean_t cachepurge_set = B_FALSE; 4557c478bd9Sstevel@tonic-gate 4567c478bd9Sstevel@tonic-gate ASSERT(mi->mi_vfsp->vfs_dev == garp->n4g_va.va_fsid); 4577c478bd9Sstevel@tonic-gate 4587c478bd9Sstevel@tonic-gate /* Is curthread the recovery thread? */ 4597c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 4607c478bd9Sstevel@tonic-gate recov = (VTOMI4(vp)->mi_recovthread == curthread); 4617c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 4647c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 4657c478bd9Sstevel@tonic-gate was_serial = (rp->r_serial == curthread); 4667c478bd9Sstevel@tonic-gate if (rp->r_serial && !was_serial) { 4677c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread); 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate /* 4707c478bd9Sstevel@tonic-gate * If we're the recovery thread, then purge current attrs 4717c478bd9Sstevel@tonic-gate * and bail out to avoid potential deadlock between another 4727c478bd9Sstevel@tonic-gate * thread caching attrs (r_serial thread), recov thread, 4737c478bd9Sstevel@tonic-gate * and an async writer thread. 4747c478bd9Sstevel@tonic-gate */ 4757c478bd9Sstevel@tonic-gate if (recov) { 4767c478bd9Sstevel@tonic-gate PURGE_ATTRCACHE4_LOCKED(rp); 4777c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 4787c478bd9Sstevel@tonic-gate return; 4797c478bd9Sstevel@tonic-gate } 4807c478bd9Sstevel@tonic-gate 4817c478bd9Sstevel@tonic-gate if (lwp != NULL) 4827c478bd9Sstevel@tonic-gate lwp->lwp_nostop++; 4837c478bd9Sstevel@tonic-gate while (rp->r_serial != NULL) { 4847c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&rp->r_cv, &rp->r_statelock)) { 4857c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 4867c478bd9Sstevel@tonic-gate if (lwp != NULL) 4877c478bd9Sstevel@tonic-gate lwp->lwp_nostop--; 4887c478bd9Sstevel@tonic-gate return; 4897c478bd9Sstevel@tonic-gate } 4907c478bd9Sstevel@tonic-gate } 4917c478bd9Sstevel@tonic-gate if (lwp != NULL) 4927c478bd9Sstevel@tonic-gate lwp->lwp_nostop--; 4937c478bd9Sstevel@tonic-gate } 4947c478bd9Sstevel@tonic-gate 4957c478bd9Sstevel@tonic-gate /* 4967c478bd9Sstevel@tonic-gate * If there is a page flush thread, the current thread needs to 4977c478bd9Sstevel@tonic-gate * bail out, to prevent a possible deadlock between the current 4987c478bd9Sstevel@tonic-gate * thread (which might be in a start_op/end_op region), the 4997c478bd9Sstevel@tonic-gate * recovery thread, and the page flush thread. Expire the 5007c478bd9Sstevel@tonic-gate * attribute cache, so that any attributes the current thread was 5017c478bd9Sstevel@tonic-gate * going to set are not lost. 5027c478bd9Sstevel@tonic-gate */ 5037c478bd9Sstevel@tonic-gate if ((rp->r_flags & R4PGFLUSH) && rp->r_pgflush != curthread) { 5047c478bd9Sstevel@tonic-gate PURGE_ATTRCACHE4_LOCKED(rp); 5057c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 5067c478bd9Sstevel@tonic-gate return; 5077c478bd9Sstevel@tonic-gate } 5087c478bd9Sstevel@tonic-gate 5097c478bd9Sstevel@tonic-gate if (rp->r_time_attr_saved > t) { 5107c478bd9Sstevel@tonic-gate /* 5117c478bd9Sstevel@tonic-gate * Attributes have been cached since these attributes were 51200fdf600Smaheshvs * probably made. If there is an inconsistency in what is 51300fdf600Smaheshvs * cached, mark them invalid. If not, don't act on them. 5147c478bd9Sstevel@tonic-gate */ 51500fdf600Smaheshvs if (!CACHE4_VALID(rp, vap->va_mtime, vap->va_size)) 51600fdf600Smaheshvs PURGE_ATTRCACHE4_LOCKED(rp); 5177c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 5187c478bd9Sstevel@tonic-gate return; 5197c478bd9Sstevel@tonic-gate } 5207c478bd9Sstevel@tonic-gate set_time_cache_inval = 0; 5217c478bd9Sstevel@tonic-gate if (cinfo) { 5227c478bd9Sstevel@tonic-gate /* 5237c478bd9Sstevel@tonic-gate * Only directory modifying callers pass non-NULL cinfo. 5247c478bd9Sstevel@tonic-gate */ 5257c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VDIR); 5267c478bd9Sstevel@tonic-gate /* 5277c478bd9Sstevel@tonic-gate * If the cache timeout either doesn't exist or hasn't expired, 5287c478bd9Sstevel@tonic-gate * and dir didn't changed on server before dirmod op 5297c478bd9Sstevel@tonic-gate * and dir didn't change after dirmod op but before getattr 5307c478bd9Sstevel@tonic-gate * then there's a chance that the client's cached data for 5317c478bd9Sstevel@tonic-gate * this object is current (not stale). No immediate cache 5327c478bd9Sstevel@tonic-gate * flush is required. 5337c478bd9Sstevel@tonic-gate * 5347c478bd9Sstevel@tonic-gate */ 5357c478bd9Sstevel@tonic-gate if ((! rp->r_time_cache_inval || t < rp->r_time_cache_inval) && 5367c478bd9Sstevel@tonic-gate cinfo->before == rp->r_change && 5377c478bd9Sstevel@tonic-gate (garp->n4g_change_valid && 5387c478bd9Sstevel@tonic-gate cinfo->after == garp->n4g_change)) { 5397c478bd9Sstevel@tonic-gate 5407c478bd9Sstevel@tonic-gate /* 5417c478bd9Sstevel@tonic-gate * If atomic isn't set, then the before/after info 5427c478bd9Sstevel@tonic-gate * cannot be blindly trusted. For this case, we tell 5437c478bd9Sstevel@tonic-gate * nfs4_attrcache_va to cache the attrs but also 5447c478bd9Sstevel@tonic-gate * establish an absolute maximum cache timeout. When 5457c478bd9Sstevel@tonic-gate * the timeout is reached, caches will be flushed. 5467c478bd9Sstevel@tonic-gate */ 5477c478bd9Sstevel@tonic-gate if (! cinfo->atomic) 5487c478bd9Sstevel@tonic-gate set_time_cache_inval = 1; 5497c478bd9Sstevel@tonic-gate } else { 5507c478bd9Sstevel@tonic-gate 5517c478bd9Sstevel@tonic-gate /* 5527c478bd9Sstevel@tonic-gate * We're not sure exactly what changed, but we know 5537c478bd9Sstevel@tonic-gate * what to do. flush all caches for dir. remove the 5547c478bd9Sstevel@tonic-gate * attr timeout. 5557c478bd9Sstevel@tonic-gate * 5567c478bd9Sstevel@tonic-gate * a) timeout expired. flush all caches. 5577c478bd9Sstevel@tonic-gate * b) r_change != cinfo.before. flush all caches. 5587c478bd9Sstevel@tonic-gate * c) r_change == cinfo.before, but cinfo.after != 5597c478bd9Sstevel@tonic-gate * post-op getattr(change). flush all caches. 5607c478bd9Sstevel@tonic-gate * d) post-op getattr(change) not provided by server. 5617c478bd9Sstevel@tonic-gate * flush all caches. 5627c478bd9Sstevel@tonic-gate */ 5637c478bd9Sstevel@tonic-gate mtime_changed = 1; 5647c478bd9Sstevel@tonic-gate ctime_changed = 1; 5657c478bd9Sstevel@tonic-gate rp->r_time_cache_inval = 0; 5667c478bd9Sstevel@tonic-gate } 5677c478bd9Sstevel@tonic-gate } else { 5685e4df02aSvv /* 5695e4df02aSvv * Write thread after writing data to file on remote server, 5705e4df02aSvv * will always set R4WRITEMODIFIED to indicate that file on 5715e4df02aSvv * remote server was modified with a WRITE operation and would 5725e4df02aSvv * have marked attribute cache as timed out. If R4WRITEMODIFIED 5735e4df02aSvv * is set, then do not check for mtime and ctime change. 5745e4df02aSvv */ 5757c478bd9Sstevel@tonic-gate if (!(rp->r_flags & R4WRITEMODIFIED)) { 5767c478bd9Sstevel@tonic-gate if (!CACHE4_VALID(rp, vap->va_mtime, vap->va_size)) 5777c478bd9Sstevel@tonic-gate mtime_changed = 1; 5785e4df02aSvv 5797c478bd9Sstevel@tonic-gate if (rp->r_attr.va_ctime.tv_sec != 5807c478bd9Sstevel@tonic-gate vap->va_ctime.tv_sec || 5817c478bd9Sstevel@tonic-gate rp->r_attr.va_ctime.tv_nsec != 5827c478bd9Sstevel@tonic-gate vap->va_ctime.tv_nsec) 5837c478bd9Sstevel@tonic-gate ctime_changed = 1; 584*4a695956SMarcel Telka 585*4a695956SMarcel Telka /* 586*4a695956SMarcel Telka * If the change attribute was not provided by server 587*4a695956SMarcel Telka * or it differs, then flush all caches. 588*4a695956SMarcel Telka */ 589*4a695956SMarcel Telka if (!garp->n4g_change_valid || 590*4a695956SMarcel Telka rp->r_change != garp->n4g_change) { 591*4a695956SMarcel Telka mtime_changed = 1; 592*4a695956SMarcel Telka ctime_changed = 1; 593*4a695956SMarcel Telka } 5947c478bd9Sstevel@tonic-gate } else { 5955e4df02aSvv writemodify_set = B_TRUE; 5967c478bd9Sstevel@tonic-gate } 5977c478bd9Sstevel@tonic-gate } 5987c478bd9Sstevel@tonic-gate 5995e4df02aSvv preattr_rsize = rp->r_size; 6005e4df02aSvv 6017c478bd9Sstevel@tonic-gate nfs4_attrcache_va(vp, garp, set_time_cache_inval); 6027c478bd9Sstevel@tonic-gate 6035e4df02aSvv /* 6045e4df02aSvv * If we have updated filesize in nfs4_attrcache_va, as soon as we 6055e4df02aSvv * drop statelock we will be in transition of purging all 6065e4df02aSvv * our caches and updating them. It is possible for another 6075e4df02aSvv * thread to pick this new file size and read in zeroed data. 6085e4df02aSvv * stall other threads till cache purge is complete. 6095e4df02aSvv */ 6105e4df02aSvv if ((!cinfo) && (rp->r_size != preattr_rsize)) { 6115e4df02aSvv /* 6125e4df02aSvv * If R4WRITEMODIFIED was set and we have updated the file 6135e4df02aSvv * size, Server's returned file size need not necessarily 6145e4df02aSvv * be because of this Client's WRITE. We need to purge 6155e4df02aSvv * all caches. 6165e4df02aSvv */ 6175e4df02aSvv if (writemodify_set) 6185e4df02aSvv mtime_changed = 1; 6195e4df02aSvv 6205e4df02aSvv if (mtime_changed && !(rp->r_flags & R4INCACHEPURGE)) { 6215e4df02aSvv rp->r_flags |= R4INCACHEPURGE; 6225e4df02aSvv cachepurge_set = B_TRUE; 6235e4df02aSvv } 6245e4df02aSvv } 6255e4df02aSvv 6267c478bd9Sstevel@tonic-gate if (!mtime_changed && !ctime_changed) { 6277c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 6287c478bd9Sstevel@tonic-gate return; 6297c478bd9Sstevel@tonic-gate } 6307c478bd9Sstevel@tonic-gate 6317c478bd9Sstevel@tonic-gate rp->r_serial = curthread; 6327c478bd9Sstevel@tonic-gate 6337c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 6347c478bd9Sstevel@tonic-gate 6357c478bd9Sstevel@tonic-gate /* 6367c478bd9Sstevel@tonic-gate * If we're the recov thread, then force async nfs4_purge_caches 6377c478bd9Sstevel@tonic-gate * to avoid potential deadlock. 6387c478bd9Sstevel@tonic-gate */ 6397c478bd9Sstevel@tonic-gate if (mtime_changed) 6407c478bd9Sstevel@tonic-gate nfs4_purge_caches(vp, NFS4_NOPURGE_DNLC, cr, recov ? 1 : async); 6417c478bd9Sstevel@tonic-gate 6425e4df02aSvv if ((rp->r_flags & R4INCACHEPURGE) && cachepurge_set) { 6435e4df02aSvv mutex_enter(&rp->r_statelock); 6445e4df02aSvv rp->r_flags &= ~R4INCACHEPURGE; 6455e4df02aSvv cv_broadcast(&rp->r_cv); 6465e4df02aSvv mutex_exit(&rp->r_statelock); 6475e4df02aSvv cachepurge_set = B_FALSE; 6485e4df02aSvv } 6495e4df02aSvv 6507c478bd9Sstevel@tonic-gate if (ctime_changed) { 6517c478bd9Sstevel@tonic-gate (void) nfs4_access_purge_rp(rp); 6527c478bd9Sstevel@tonic-gate if (rp->r_secattr != NULL) { 6537c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 6547c478bd9Sstevel@tonic-gate vsp = rp->r_secattr; 6557c478bd9Sstevel@tonic-gate rp->r_secattr = NULL; 6567c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 6577c478bd9Sstevel@tonic-gate if (vsp != NULL) 6587c478bd9Sstevel@tonic-gate nfs4_acl_free_cache(vsp); 6597c478bd9Sstevel@tonic-gate } 6607c478bd9Sstevel@tonic-gate } 6617c478bd9Sstevel@tonic-gate 6627c478bd9Sstevel@tonic-gate if (!was_serial) { 6637c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 6647c478bd9Sstevel@tonic-gate rp->r_serial = NULL; 6657c478bd9Sstevel@tonic-gate cv_broadcast(&rp->r_cv); 6667c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 6677c478bd9Sstevel@tonic-gate } 6687c478bd9Sstevel@tonic-gate } 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate /* 6717c478bd9Sstevel@tonic-gate * Set attributes cache for given vnode using virtual attributes. 6727c478bd9Sstevel@tonic-gate * 6737c478bd9Sstevel@tonic-gate * Set the timeout value on the attribute cache and fill it 6747c478bd9Sstevel@tonic-gate * with the passed in attributes. 6757c478bd9Sstevel@tonic-gate * 6767c478bd9Sstevel@tonic-gate * The caller must be holding r_statelock. 6777c478bd9Sstevel@tonic-gate */ 6787c478bd9Sstevel@tonic-gate static void 6797c478bd9Sstevel@tonic-gate nfs4_attrcache_va(vnode_t *vp, nfs4_ga_res_t *garp, int set_cache_timeout) 6807c478bd9Sstevel@tonic-gate { 6817c478bd9Sstevel@tonic-gate rnode4_t *rp; 6827c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 6837c478bd9Sstevel@tonic-gate hrtime_t delta; 6847c478bd9Sstevel@tonic-gate hrtime_t now; 6857c478bd9Sstevel@tonic-gate vattr_t *vap = &garp->n4g_va; 6867c478bd9Sstevel@tonic-gate 6877c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 6887c478bd9Sstevel@tonic-gate 6897c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&rp->r_statelock)); 6907c478bd9Sstevel@tonic-gate ASSERT(vap->va_mask == AT_ALL); 6917c478bd9Sstevel@tonic-gate 6927c478bd9Sstevel@tonic-gate /* Switch to master before checking v_flag */ 6937c478bd9Sstevel@tonic-gate if (IS_SHADOW(vp, rp)) 6947c478bd9Sstevel@tonic-gate vp = RTOV4(rp); 6957c478bd9Sstevel@tonic-gate 6967c478bd9Sstevel@tonic-gate now = gethrtime(); 6977c478bd9Sstevel@tonic-gate 6987c478bd9Sstevel@tonic-gate mi = VTOMI4(vp); 6997c478bd9Sstevel@tonic-gate 7007c478bd9Sstevel@tonic-gate /* 7017c478bd9Sstevel@tonic-gate * Only establish a new cache timeout (if requested). Never 7027c478bd9Sstevel@tonic-gate * extend a timeout. Never clear a timeout. Clearing a timeout 7037c478bd9Sstevel@tonic-gate * is done by nfs4_update_dircaches (ancestor in our call chain) 7047c478bd9Sstevel@tonic-gate */ 7057c478bd9Sstevel@tonic-gate if (set_cache_timeout && ! rp->r_time_cache_inval) 7067c478bd9Sstevel@tonic-gate rp->r_time_cache_inval = now + mi->mi_acdirmax; 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate /* 7097c478bd9Sstevel@tonic-gate * Delta is the number of nanoseconds that we will 7107c478bd9Sstevel@tonic-gate * cache the attributes of the file. It is based on 7117c478bd9Sstevel@tonic-gate * the number of nanoseconds since the last time that 7127c478bd9Sstevel@tonic-gate * we detected a change. The assumption is that files 7137c478bd9Sstevel@tonic-gate * that changed recently are likely to change again. 7147c478bd9Sstevel@tonic-gate * There is a minimum and a maximum for regular files 7157c478bd9Sstevel@tonic-gate * and for directories which is enforced though. 7167c478bd9Sstevel@tonic-gate * 7177c478bd9Sstevel@tonic-gate * Using the time since last change was detected 7187c478bd9Sstevel@tonic-gate * eliminates direct comparison or calculation 7197c478bd9Sstevel@tonic-gate * using mixed client and server times. NFS does 7207c478bd9Sstevel@tonic-gate * not make any assumptions regarding the client 7217c478bd9Sstevel@tonic-gate * and server clocks being synchronized. 7227c478bd9Sstevel@tonic-gate */ 7237c478bd9Sstevel@tonic-gate if (vap->va_mtime.tv_sec != rp->r_attr.va_mtime.tv_sec || 7247c478bd9Sstevel@tonic-gate vap->va_mtime.tv_nsec != rp->r_attr.va_mtime.tv_nsec || 7257c478bd9Sstevel@tonic-gate vap->va_size != rp->r_attr.va_size) { 7267c478bd9Sstevel@tonic-gate rp->r_time_attr_saved = now; 7277c478bd9Sstevel@tonic-gate } 7287c478bd9Sstevel@tonic-gate 7297c478bd9Sstevel@tonic-gate if ((mi->mi_flags & MI4_NOAC) || (vp->v_flag & VNOCACHE)) 7307c478bd9Sstevel@tonic-gate delta = 0; 7317c478bd9Sstevel@tonic-gate else { 7327c478bd9Sstevel@tonic-gate delta = now - rp->r_time_attr_saved; 7337c478bd9Sstevel@tonic-gate if (vp->v_type == VDIR) { 7347c478bd9Sstevel@tonic-gate if (delta < mi->mi_acdirmin) 7357c478bd9Sstevel@tonic-gate delta = mi->mi_acdirmin; 7367c478bd9Sstevel@tonic-gate else if (delta > mi->mi_acdirmax) 7377c478bd9Sstevel@tonic-gate delta = mi->mi_acdirmax; 7387c478bd9Sstevel@tonic-gate } else { 7397c478bd9Sstevel@tonic-gate if (delta < mi->mi_acregmin) 7407c478bd9Sstevel@tonic-gate delta = mi->mi_acregmin; 7417c478bd9Sstevel@tonic-gate else if (delta > mi->mi_acregmax) 7427c478bd9Sstevel@tonic-gate delta = mi->mi_acregmax; 7437c478bd9Sstevel@tonic-gate } 7447c478bd9Sstevel@tonic-gate } 7457c478bd9Sstevel@tonic-gate rp->r_time_attr_inval = now + delta; 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate rp->r_attr = *vap; 7487c478bd9Sstevel@tonic-gate if (garp->n4g_change_valid) 7497c478bd9Sstevel@tonic-gate rp->r_change = garp->n4g_change; 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate /* 7527c478bd9Sstevel@tonic-gate * The attributes that were returned may be valid and can 7537c478bd9Sstevel@tonic-gate * be used, but they may not be allowed to be cached. 7547c478bd9Sstevel@tonic-gate * Reset the timers to cause immediate invalidation and 7557c478bd9Sstevel@tonic-gate * clear r_change so no VERIFY operations will suceed 7567c478bd9Sstevel@tonic-gate */ 7577c478bd9Sstevel@tonic-gate if (garp->n4g_attrwhy == NFS4_GETATTR_NOCACHE_OK) { 7587c478bd9Sstevel@tonic-gate rp->r_time_attr_inval = now; 7597c478bd9Sstevel@tonic-gate rp->r_time_attr_saved = now; 7607c478bd9Sstevel@tonic-gate rp->r_change = 0; 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate /* 7647c478bd9Sstevel@tonic-gate * If mounted_on_fileid returned AND the object is a stub, 7657c478bd9Sstevel@tonic-gate * then set object's va_nodeid to the mounted over fid 7667c478bd9Sstevel@tonic-gate * returned by server. 7677c478bd9Sstevel@tonic-gate * 7687c478bd9Sstevel@tonic-gate * If mounted_on_fileid not provided/supported, then 7697c478bd9Sstevel@tonic-gate * just set it to 0 for now. Eventually it would be 7707c478bd9Sstevel@tonic-gate * better to set it to a hashed version of FH. This 7717c478bd9Sstevel@tonic-gate * would probably be good enough to provide a unique 7727c478bd9Sstevel@tonic-gate * fid/d_ino within a dir. 7737c478bd9Sstevel@tonic-gate * 7747c478bd9Sstevel@tonic-gate * We don't need to carry mounted_on_fileid in the 7757c478bd9Sstevel@tonic-gate * rnode as long as the client never requests fileid 7767c478bd9Sstevel@tonic-gate * without also requesting mounted_on_fileid. For 7777c478bd9Sstevel@tonic-gate * now, it stays. 7787c478bd9Sstevel@tonic-gate */ 7797c478bd9Sstevel@tonic-gate if (garp->n4g_mon_fid_valid) { 7807c478bd9Sstevel@tonic-gate rp->r_mntd_fid = garp->n4g_mon_fid; 7817c478bd9Sstevel@tonic-gate 782b9238976Sth if (RP_ISSTUB(rp)) 7837c478bd9Sstevel@tonic-gate rp->r_attr.va_nodeid = rp->r_mntd_fid; 7847c478bd9Sstevel@tonic-gate } 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate /* 7877c478bd9Sstevel@tonic-gate * Check to see if there are valid pathconf bits to 7887c478bd9Sstevel@tonic-gate * cache in the rnode. 7897c478bd9Sstevel@tonic-gate */ 7907c478bd9Sstevel@tonic-gate if (garp->n4g_ext_res) { 7917c478bd9Sstevel@tonic-gate if (garp->n4g_ext_res->n4g_pc4.pc4_cache_valid) { 7927c478bd9Sstevel@tonic-gate rp->r_pathconf = garp->n4g_ext_res->n4g_pc4; 7937c478bd9Sstevel@tonic-gate } else { 7947c478bd9Sstevel@tonic-gate if (garp->n4g_ext_res->n4g_pc4.pc4_xattr_valid) { 7957c478bd9Sstevel@tonic-gate rp->r_pathconf.pc4_xattr_valid = TRUE; 7967c478bd9Sstevel@tonic-gate rp->r_pathconf.pc4_xattr_exists = 7977c478bd9Sstevel@tonic-gate garp->n4g_ext_res->n4g_pc4.pc4_xattr_exists; 7987c478bd9Sstevel@tonic-gate } 7997c478bd9Sstevel@tonic-gate } 8007c478bd9Sstevel@tonic-gate } 8017c478bd9Sstevel@tonic-gate /* 8027c478bd9Sstevel@tonic-gate * Update the size of the file if there is no cached data or if 8037c478bd9Sstevel@tonic-gate * the cached data is clean and there is no data being written 8047c478bd9Sstevel@tonic-gate * out. 8057c478bd9Sstevel@tonic-gate */ 8067c478bd9Sstevel@tonic-gate if (rp->r_size != vap->va_size && 8077c478bd9Sstevel@tonic-gate (!vn_has_cached_data(vp) || 8087c478bd9Sstevel@tonic-gate (!(rp->r_flags & R4DIRTY) && rp->r_count == 0))) { 8097c478bd9Sstevel@tonic-gate rp->r_size = vap->va_size; 8107c478bd9Sstevel@tonic-gate } 8117c478bd9Sstevel@tonic-gate nfs_setswaplike(vp, vap); 8127c478bd9Sstevel@tonic-gate rp->r_flags &= ~R4WRITEMODIFIED; 8137c478bd9Sstevel@tonic-gate } 8147c478bd9Sstevel@tonic-gate 8157c478bd9Sstevel@tonic-gate /* 8167c478bd9Sstevel@tonic-gate * Get attributes over-the-wire and update attributes cache 8177c478bd9Sstevel@tonic-gate * if no error occurred in the over-the-wire operation. 8187c478bd9Sstevel@tonic-gate * Return 0 if successful, otherwise error. 8197c478bd9Sstevel@tonic-gate */ 8207c478bd9Sstevel@tonic-gate int 8217c478bd9Sstevel@tonic-gate nfs4_getattr_otw(vnode_t *vp, nfs4_ga_res_t *garp, cred_t *cr, int get_acl) 8227c478bd9Sstevel@tonic-gate { 8237c478bd9Sstevel@tonic-gate mntinfo4_t *mi = VTOMI4(vp); 8247c478bd9Sstevel@tonic-gate hrtime_t t; 8257c478bd9Sstevel@tonic-gate nfs4_recov_state_t recov_state; 8267c478bd9Sstevel@tonic-gate nfs4_error_t e = { 0, NFS4_OK, RPC_SUCCESS }; 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate recov_state.rs_flags = 0; 8297c478bd9Sstevel@tonic-gate recov_state.rs_num_retry_despite_err = 0; 8307c478bd9Sstevel@tonic-gate 8317c478bd9Sstevel@tonic-gate /* Save the original mount point security flavor */ 8327c478bd9Sstevel@tonic-gate (void) save_mnt_secinfo(mi->mi_curr_serv); 8337c478bd9Sstevel@tonic-gate 8347c478bd9Sstevel@tonic-gate recov_retry: 835b9238976Sth 8367c478bd9Sstevel@tonic-gate if ((e.error = nfs4_start_fop(mi, vp, NULL, OH_GETATTR, 837b9238976Sth &recov_state, NULL))) { 8387c478bd9Sstevel@tonic-gate (void) check_mnt_secinfo(mi->mi_curr_serv, vp); 8397c478bd9Sstevel@tonic-gate return (e.error); 8407c478bd9Sstevel@tonic-gate } 8417c478bd9Sstevel@tonic-gate 8427c478bd9Sstevel@tonic-gate t = gethrtime(); 8437c478bd9Sstevel@tonic-gate 8447c478bd9Sstevel@tonic-gate nfs4_getattr_otw_norecovery(vp, garp, &e, cr, get_acl); 8457c478bd9Sstevel@tonic-gate 8467c478bd9Sstevel@tonic-gate if (nfs4_needs_recovery(&e, FALSE, vp->v_vfsp)) { 8477c478bd9Sstevel@tonic-gate if (nfs4_start_recovery(&e, VTOMI4(vp), vp, NULL, NULL, 8482f172c55SRobert Thurlow NULL, OP_GETATTR, NULL, NULL, NULL) == FALSE) { 8497c478bd9Sstevel@tonic-gate nfs4_end_fop(VTOMI4(vp), vp, NULL, OH_GETATTR, 850b9238976Sth &recov_state, 1); 8517c478bd9Sstevel@tonic-gate goto recov_retry; 8527c478bd9Sstevel@tonic-gate } 8537c478bd9Sstevel@tonic-gate } 8547c478bd9Sstevel@tonic-gate 8557c478bd9Sstevel@tonic-gate nfs4_end_fop(VTOMI4(vp), vp, NULL, OH_GETATTR, &recov_state, 0); 8567c478bd9Sstevel@tonic-gate 8577c478bd9Sstevel@tonic-gate if (!e.error) { 8587c478bd9Sstevel@tonic-gate if (e.stat == NFS4_OK) { 8597c478bd9Sstevel@tonic-gate nfs4_attr_cache(vp, garp, t, cr, FALSE, NULL); 8607c478bd9Sstevel@tonic-gate } else { 8617c478bd9Sstevel@tonic-gate e.error = geterrno4(e.stat); 8627c478bd9Sstevel@tonic-gate 8637c478bd9Sstevel@tonic-gate nfs4_purge_stale_fh(e.error, vp, cr); 8647c478bd9Sstevel@tonic-gate } 8657c478bd9Sstevel@tonic-gate } 8667c478bd9Sstevel@tonic-gate 8677c478bd9Sstevel@tonic-gate /* 8687c478bd9Sstevel@tonic-gate * If getattr a node that is a stub for a crossed 8697c478bd9Sstevel@tonic-gate * mount point, keep the original secinfo flavor for 8707c478bd9Sstevel@tonic-gate * the current file system, not the crossed one. 8717c478bd9Sstevel@tonic-gate */ 8727c478bd9Sstevel@tonic-gate (void) check_mnt_secinfo(mi->mi_curr_serv, vp); 8737c478bd9Sstevel@tonic-gate 8747c478bd9Sstevel@tonic-gate return (e.error); 8757c478bd9Sstevel@tonic-gate } 8767c478bd9Sstevel@tonic-gate 8777c478bd9Sstevel@tonic-gate /* 8787c478bd9Sstevel@tonic-gate * Generate a compound to get attributes over-the-wire. 8797c478bd9Sstevel@tonic-gate */ 8807c478bd9Sstevel@tonic-gate void 8817c478bd9Sstevel@tonic-gate nfs4_getattr_otw_norecovery(vnode_t *vp, nfs4_ga_res_t *garp, 882b9238976Sth nfs4_error_t *ep, cred_t *cr, int get_acl) 8837c478bd9Sstevel@tonic-gate { 8847c478bd9Sstevel@tonic-gate COMPOUND4args_clnt args; 8857c478bd9Sstevel@tonic-gate COMPOUND4res_clnt res; 8867c478bd9Sstevel@tonic-gate int doqueue; 8877c478bd9Sstevel@tonic-gate rnode4_t *rp = VTOR4(vp); 8887c478bd9Sstevel@tonic-gate nfs_argop4 argop[2]; 8897c478bd9Sstevel@tonic-gate 8907c478bd9Sstevel@tonic-gate args.ctag = TAG_GETATTR; 8917c478bd9Sstevel@tonic-gate 8927c478bd9Sstevel@tonic-gate args.array_len = 2; 8937c478bd9Sstevel@tonic-gate args.array = argop; 8947c478bd9Sstevel@tonic-gate 8957c478bd9Sstevel@tonic-gate /* putfh */ 8967c478bd9Sstevel@tonic-gate argop[0].argop = OP_CPUTFH; 8977c478bd9Sstevel@tonic-gate argop[0].nfs_argop4_u.opcputfh.sfh = rp->r_fh; 8987c478bd9Sstevel@tonic-gate 8997c478bd9Sstevel@tonic-gate /* getattr */ 9007c478bd9Sstevel@tonic-gate /* 9017c478bd9Sstevel@tonic-gate * Unlike nfs version 2 and 3, where getattr returns all the 902da6c28aaSamw * attributes, nfs version 4 returns only the ones explicitly 9037c478bd9Sstevel@tonic-gate * asked for. This creates problems, as some system functions 9047c478bd9Sstevel@tonic-gate * (e.g. cache check) require certain attributes and if the 9057c478bd9Sstevel@tonic-gate * cached node lacks some attributes such as uid/gid, it can 9067c478bd9Sstevel@tonic-gate * affect system utilities (e.g. "ls") that rely on the information 9077c478bd9Sstevel@tonic-gate * to be there. This can lead to anything from system crashes to 9087c478bd9Sstevel@tonic-gate * corrupted information processed by user apps. 9097c478bd9Sstevel@tonic-gate * So to ensure that all bases are covered, request at least 9107c478bd9Sstevel@tonic-gate * the AT_ALL attribute mask. 9117c478bd9Sstevel@tonic-gate */ 9127c478bd9Sstevel@tonic-gate argop[1].argop = OP_GETATTR; 9137c478bd9Sstevel@tonic-gate argop[1].nfs_argop4_u.opgetattr.attr_request = NFS4_VATTR_MASK; 9147c478bd9Sstevel@tonic-gate if (get_acl) 9157c478bd9Sstevel@tonic-gate argop[1].nfs_argop4_u.opgetattr.attr_request |= FATTR4_ACL_MASK; 9167c478bd9Sstevel@tonic-gate argop[1].nfs_argop4_u.opgetattr.mi = VTOMI4(vp); 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate doqueue = 1; 9197c478bd9Sstevel@tonic-gate 9207c478bd9Sstevel@tonic-gate rfs4call(VTOMI4(vp), &args, &res, cr, &doqueue, 0, ep); 9217c478bd9Sstevel@tonic-gate 9227c478bd9Sstevel@tonic-gate if (ep->error) 9237c478bd9Sstevel@tonic-gate return; 9247c478bd9Sstevel@tonic-gate 9257c478bd9Sstevel@tonic-gate if (res.status != NFS4_OK) { 9267c478bd9Sstevel@tonic-gate (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 9277c478bd9Sstevel@tonic-gate return; 9287c478bd9Sstevel@tonic-gate } 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate *garp = res.array[1].nfs_resop4_u.opgetattr.ga_res; 9317c478bd9Sstevel@tonic-gate 9327c478bd9Sstevel@tonic-gate (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 9337c478bd9Sstevel@tonic-gate } 9347c478bd9Sstevel@tonic-gate 9357c478bd9Sstevel@tonic-gate /* 9367c478bd9Sstevel@tonic-gate * Return either cached or remote attributes. If get remote attr 9377c478bd9Sstevel@tonic-gate * use them to check and invalidate caches, then cache the new attributes. 9387c478bd9Sstevel@tonic-gate */ 9397c478bd9Sstevel@tonic-gate int 9407c478bd9Sstevel@tonic-gate nfs4getattr(vnode_t *vp, vattr_t *vap, cred_t *cr) 9417c478bd9Sstevel@tonic-gate { 9427c478bd9Sstevel@tonic-gate int error; 9437c478bd9Sstevel@tonic-gate rnode4_t *rp; 9447c478bd9Sstevel@tonic-gate nfs4_ga_res_t gar; 9457c478bd9Sstevel@tonic-gate 9467c478bd9Sstevel@tonic-gate ASSERT(nfs4_consistent_type(vp)); 9477c478bd9Sstevel@tonic-gate 9487c478bd9Sstevel@tonic-gate /* 9497c478bd9Sstevel@tonic-gate * If we've got cached attributes, we're done, otherwise go 9507c478bd9Sstevel@tonic-gate * to the server to get attributes, which will update the cache 951b9238976Sth * in the process. Either way, use the cached attributes for 952b9238976Sth * the caller's vattr_t. 953b9238976Sth * 954b9238976Sth * Note that we ignore the gar set by the OTW call: the attr caching 955b9238976Sth * code may make adjustments when storing to the rnode, and we want 956b9238976Sth * to see those changes here. 9577c478bd9Sstevel@tonic-gate */ 9587c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 959b9238976Sth error = 0; 9607c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 961b9238976Sth if (!ATTRCACHE4_VALID(vp)) { 9627c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 963b9238976Sth error = nfs4_getattr_otw(vp, &gar, cr, 0); 964b9238976Sth mutex_enter(&rp->r_statelock); 9657c478bd9Sstevel@tonic-gate } 9667c478bd9Sstevel@tonic-gate 9677c478bd9Sstevel@tonic-gate if (!error) 968b9238976Sth *vap = rp->r_attr; 9697c478bd9Sstevel@tonic-gate 9707c478bd9Sstevel@tonic-gate /* Return the client's view of file size */ 9717c478bd9Sstevel@tonic-gate vap->va_size = rp->r_size; 972b9238976Sth 9737c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 9747c478bd9Sstevel@tonic-gate 9757c478bd9Sstevel@tonic-gate ASSERT(nfs4_consistent_type(vp)); 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate return (error); 9787c478bd9Sstevel@tonic-gate } 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate int 9817c478bd9Sstevel@tonic-gate nfs4_attr_otw(vnode_t *vp, nfs4_tag_type_t tag_type, 982b9238976Sth nfs4_ga_res_t *garp, bitmap4 reqbitmap, cred_t *cr) 9837c478bd9Sstevel@tonic-gate { 9847c478bd9Sstevel@tonic-gate COMPOUND4args_clnt args; 9857c478bd9Sstevel@tonic-gate COMPOUND4res_clnt res; 9867c478bd9Sstevel@tonic-gate int doqueue; 9877c478bd9Sstevel@tonic-gate nfs_argop4 argop[2]; 9887c478bd9Sstevel@tonic-gate mntinfo4_t *mi = VTOMI4(vp); 9897c478bd9Sstevel@tonic-gate bool_t needrecov = FALSE; 9907c478bd9Sstevel@tonic-gate nfs4_recov_state_t recov_state; 9917c478bd9Sstevel@tonic-gate nfs4_error_t e = { 0, NFS4_OK, RPC_SUCCESS }; 9927c478bd9Sstevel@tonic-gate nfs4_ga_ext_res_t *gerp; 9937c478bd9Sstevel@tonic-gate 9947c478bd9Sstevel@tonic-gate recov_state.rs_flags = 0; 9957c478bd9Sstevel@tonic-gate recov_state.rs_num_retry_despite_err = 0; 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate recov_retry: 9987c478bd9Sstevel@tonic-gate args.ctag = tag_type; 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate args.array_len = 2; 10017c478bd9Sstevel@tonic-gate args.array = argop; 10027c478bd9Sstevel@tonic-gate 10037c478bd9Sstevel@tonic-gate e.error = nfs4_start_fop(mi, vp, NULL, OH_GETATTR, &recov_state, NULL); 10047c478bd9Sstevel@tonic-gate if (e.error) 10057c478bd9Sstevel@tonic-gate return (e.error); 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate /* putfh */ 10087c478bd9Sstevel@tonic-gate argop[0].argop = OP_CPUTFH; 10097c478bd9Sstevel@tonic-gate argop[0].nfs_argop4_u.opcputfh.sfh = VTOR4(vp)->r_fh; 10107c478bd9Sstevel@tonic-gate 10117c478bd9Sstevel@tonic-gate /* getattr */ 10127c478bd9Sstevel@tonic-gate argop[1].argop = OP_GETATTR; 10137c478bd9Sstevel@tonic-gate argop[1].nfs_argop4_u.opgetattr.attr_request = reqbitmap; 10147c478bd9Sstevel@tonic-gate argop[1].nfs_argop4_u.opgetattr.mi = mi; 10157c478bd9Sstevel@tonic-gate 10167c478bd9Sstevel@tonic-gate doqueue = 1; 10177c478bd9Sstevel@tonic-gate 10187c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_call_debug, (CE_NOTE, 10197c478bd9Sstevel@tonic-gate "nfs4_attr_otw: %s call, rp %s", needrecov ? "recov" : "first", 10207c478bd9Sstevel@tonic-gate rnode4info(VTOR4(vp)))); 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate rfs4call(mi, &args, &res, cr, &doqueue, 0, &e); 10237c478bd9Sstevel@tonic-gate 10247c478bd9Sstevel@tonic-gate needrecov = nfs4_needs_recovery(&e, FALSE, vp->v_vfsp); 10257c478bd9Sstevel@tonic-gate if (!needrecov && e.error) { 10267c478bd9Sstevel@tonic-gate nfs4_end_fop(VTOMI4(vp), vp, NULL, OH_GETATTR, &recov_state, 1027b9238976Sth needrecov); 10287c478bd9Sstevel@tonic-gate return (e.error); 10297c478bd9Sstevel@tonic-gate } 10307c478bd9Sstevel@tonic-gate 10317c478bd9Sstevel@tonic-gate if (needrecov) { 10327c478bd9Sstevel@tonic-gate bool_t abort; 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE, 10357c478bd9Sstevel@tonic-gate "nfs4_attr_otw: initiating recovery\n")); 10367c478bd9Sstevel@tonic-gate 10377c478bd9Sstevel@tonic-gate abort = nfs4_start_recovery(&e, VTOMI4(vp), vp, NULL, NULL, 10382f172c55SRobert Thurlow NULL, OP_GETATTR, NULL, NULL, NULL); 10397c478bd9Sstevel@tonic-gate nfs4_end_fop(VTOMI4(vp), vp, NULL, OH_GETATTR, &recov_state, 1040b9238976Sth needrecov); 10417c478bd9Sstevel@tonic-gate if (!e.error) { 10427c478bd9Sstevel@tonic-gate (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 10437c478bd9Sstevel@tonic-gate e.error = geterrno4(res.status); 10447c478bd9Sstevel@tonic-gate } 10457c478bd9Sstevel@tonic-gate if (abort == FALSE) 10467c478bd9Sstevel@tonic-gate goto recov_retry; 10477c478bd9Sstevel@tonic-gate return (e.error); 10487c478bd9Sstevel@tonic-gate } 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate if (res.status) { 10517c478bd9Sstevel@tonic-gate e.error = geterrno4(res.status); 10527c478bd9Sstevel@tonic-gate } else { 10537c478bd9Sstevel@tonic-gate gerp = garp->n4g_ext_res; 10547c478bd9Sstevel@tonic-gate bcopy(&res.array[1].nfs_resop4_u.opgetattr.ga_res, 1055b9238976Sth garp, sizeof (nfs4_ga_res_t)); 10567c478bd9Sstevel@tonic-gate garp->n4g_ext_res = gerp; 10577c478bd9Sstevel@tonic-gate if (garp->n4g_ext_res && 10587c478bd9Sstevel@tonic-gate res.array[1].nfs_resop4_u.opgetattr.ga_res.n4g_ext_res) 10597c478bd9Sstevel@tonic-gate bcopy(res.array[1].nfs_resop4_u.opgetattr. 1060b9238976Sth ga_res.n4g_ext_res, 1061b9238976Sth garp->n4g_ext_res, sizeof (nfs4_ga_ext_res_t)); 10627c478bd9Sstevel@tonic-gate } 10637c478bd9Sstevel@tonic-gate (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 10647c478bd9Sstevel@tonic-gate nfs4_end_fop(VTOMI4(vp), vp, NULL, OH_GETATTR, &recov_state, 1065b9238976Sth needrecov); 10667c478bd9Sstevel@tonic-gate return (e.error); 10677c478bd9Sstevel@tonic-gate } 10687c478bd9Sstevel@tonic-gate 10697c478bd9Sstevel@tonic-gate /* 10707c478bd9Sstevel@tonic-gate * Asynchronous I/O parameters. nfs_async_threads is the high-water mark 10717c478bd9Sstevel@tonic-gate * for the demand-based allocation of async threads per-mount. The 10727c478bd9Sstevel@tonic-gate * nfs_async_timeout is the amount of time a thread will live after it 10737c478bd9Sstevel@tonic-gate * becomes idle, unless new I/O requests are received before the thread 10747c478bd9Sstevel@tonic-gate * dies. See nfs4_async_putpage and nfs4_async_start. 10757c478bd9Sstevel@tonic-gate */ 10767c478bd9Sstevel@tonic-gate 10777c478bd9Sstevel@tonic-gate static void nfs4_async_start(struct vfs *); 10780776f5e6SVallish Vaidyeshwara static void nfs4_async_pgops_start(struct vfs *); 10790776f5e6SVallish Vaidyeshwara static void nfs4_async_common_start(struct vfs *, int); 10807c478bd9Sstevel@tonic-gate 10817c478bd9Sstevel@tonic-gate static void 10827c478bd9Sstevel@tonic-gate free_async_args4(struct nfs4_async_reqs *args) 10837c478bd9Sstevel@tonic-gate { 10847c478bd9Sstevel@tonic-gate rnode4_t *rp; 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate if (args->a_io != NFS4_INACTIVE) { 10877c478bd9Sstevel@tonic-gate rp = VTOR4(args->a_vp); 10887c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 10897c478bd9Sstevel@tonic-gate rp->r_count--; 10907c478bd9Sstevel@tonic-gate if (args->a_io == NFS4_PUTAPAGE || 10917c478bd9Sstevel@tonic-gate args->a_io == NFS4_PAGEIO) 10927c478bd9Sstevel@tonic-gate rp->r_awcount--; 10937c478bd9Sstevel@tonic-gate cv_broadcast(&rp->r_cv); 10947c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 10957c478bd9Sstevel@tonic-gate VN_RELE(args->a_vp); 10967c478bd9Sstevel@tonic-gate } 10977c478bd9Sstevel@tonic-gate crfree(args->a_cred); 10987c478bd9Sstevel@tonic-gate kmem_free(args, sizeof (*args)); 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate /* 11027c478bd9Sstevel@tonic-gate * Cross-zone thread creation and NFS access is disallowed, yet fsflush() and 11037c478bd9Sstevel@tonic-gate * pageout(), running in the global zone, have legitimate reasons to do 11047c478bd9Sstevel@tonic-gate * VOP_PUTPAGE(B_ASYNC) on other zones' NFS mounts. We avoid the problem by 11057c478bd9Sstevel@tonic-gate * use of a a per-mount "asynchronous requests manager thread" which is 11067c478bd9Sstevel@tonic-gate * signaled by the various asynchronous work routines when there is 11077c478bd9Sstevel@tonic-gate * asynchronous work to be done. It is responsible for creating new 11087c478bd9Sstevel@tonic-gate * worker threads if necessary, and notifying existing worker threads 11097c478bd9Sstevel@tonic-gate * that there is work to be done. 11107c478bd9Sstevel@tonic-gate * 11117c478bd9Sstevel@tonic-gate * In other words, it will "take the specifications from the customers and 11127c478bd9Sstevel@tonic-gate * give them to the engineers." 11137c478bd9Sstevel@tonic-gate * 11147c478bd9Sstevel@tonic-gate * Worker threads die off of their own accord if they are no longer 11157c478bd9Sstevel@tonic-gate * needed. 11167c478bd9Sstevel@tonic-gate * 11177c478bd9Sstevel@tonic-gate * This thread is killed when the zone is going away or the filesystem 11187c478bd9Sstevel@tonic-gate * is being unmounted. 11197c478bd9Sstevel@tonic-gate */ 11207c478bd9Sstevel@tonic-gate void 11217c478bd9Sstevel@tonic-gate nfs4_async_manager(vfs_t *vfsp) 11227c478bd9Sstevel@tonic-gate { 11237c478bd9Sstevel@tonic-gate callb_cpr_t cprinfo; 11247c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 11257c478bd9Sstevel@tonic-gate uint_t max_threads; 11267c478bd9Sstevel@tonic-gate 11277c478bd9Sstevel@tonic-gate mi = VFTOMI4(vfsp); 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cprinfo, &mi->mi_async_lock, callb_generic_cpr, 1130b9238976Sth "nfs4_async_manager"); 11317c478bd9Sstevel@tonic-gate 11327c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 11337c478bd9Sstevel@tonic-gate /* 11347c478bd9Sstevel@tonic-gate * We want to stash the max number of threads that this mount was 11357c478bd9Sstevel@tonic-gate * allowed so we can use it later when the variable is set to zero as 11367c478bd9Sstevel@tonic-gate * part of the zone/mount going away. 11377c478bd9Sstevel@tonic-gate * 11387c478bd9Sstevel@tonic-gate * We want to be able to create at least one thread to handle 1139388e50fcSMarcel Telka * asynchronous inactive calls. 11407c478bd9Sstevel@tonic-gate */ 11417c478bd9Sstevel@tonic-gate max_threads = MAX(mi->mi_max_threads, 1); 11427c478bd9Sstevel@tonic-gate /* 11437c478bd9Sstevel@tonic-gate * We don't want to wait for mi_max_threads to go to zero, since that 11447c478bd9Sstevel@tonic-gate * happens as part of a failed unmount, but this thread should only 11457c478bd9Sstevel@tonic-gate * exit when the mount is really going away. 11467c478bd9Sstevel@tonic-gate * 11477c478bd9Sstevel@tonic-gate * Once MI4_ASYNC_MGR_STOP is set, no more async operations will be 11487c478bd9Sstevel@tonic-gate * attempted: the various _async_*() functions know to do things 11497c478bd9Sstevel@tonic-gate * inline if mi_max_threads == 0. Henceforth we just drain out the 11507c478bd9Sstevel@tonic-gate * outstanding requests. 11517c478bd9Sstevel@tonic-gate * 11527c478bd9Sstevel@tonic-gate * Note that we still create zthreads even if we notice the zone is 11537c478bd9Sstevel@tonic-gate * shutting down (MI4_ASYNC_MGR_STOP is set); this may cause the zone 11547c478bd9Sstevel@tonic-gate * shutdown sequence to take slightly longer in some cases, but 11557c478bd9Sstevel@tonic-gate * doesn't violate the protocol, as all threads will exit as soon as 11567c478bd9Sstevel@tonic-gate * they're done processing the remaining requests. 11577c478bd9Sstevel@tonic-gate */ 1158388e50fcSMarcel Telka for (;;) { 11597c478bd9Sstevel@tonic-gate while (mi->mi_async_req_count > 0) { 11607c478bd9Sstevel@tonic-gate /* 11617c478bd9Sstevel@tonic-gate * Paranoia: If the mount started out having 11627c478bd9Sstevel@tonic-gate * (mi->mi_max_threads == 0), and the value was 11637c478bd9Sstevel@tonic-gate * later changed (via a debugger or somesuch), 11647c478bd9Sstevel@tonic-gate * we could be confused since we will think we 11657c478bd9Sstevel@tonic-gate * can't create any threads, and the calling 11667c478bd9Sstevel@tonic-gate * code (which looks at the current value of 11677c478bd9Sstevel@tonic-gate * mi->mi_max_threads, now non-zero) thinks we 11687c478bd9Sstevel@tonic-gate * can. 11697c478bd9Sstevel@tonic-gate * 11707c478bd9Sstevel@tonic-gate * So, because we're paranoid, we create threads 11717c478bd9Sstevel@tonic-gate * up to the maximum of the original and the 11727c478bd9Sstevel@tonic-gate * current value. This means that future 11737c478bd9Sstevel@tonic-gate * (debugger-induced) alterations of 11747c478bd9Sstevel@tonic-gate * mi->mi_max_threads are ignored for our 11757c478bd9Sstevel@tonic-gate * purposes, but who told them they could change 11767c478bd9Sstevel@tonic-gate * random values on a live kernel anyhow? 11777c478bd9Sstevel@tonic-gate */ 11780776f5e6SVallish Vaidyeshwara if (mi->mi_threads[NFS4_ASYNC_QUEUE] < 11797c478bd9Sstevel@tonic-gate MAX(mi->mi_max_threads, max_threads)) { 11800776f5e6SVallish Vaidyeshwara mi->mi_threads[NFS4_ASYNC_QUEUE]++; 11817c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 118250a83466Sjwahlig MI4_HOLD(mi); 11837c478bd9Sstevel@tonic-gate VFS_HOLD(vfsp); /* hold for new thread */ 11847c478bd9Sstevel@tonic-gate (void) zthread_create(NULL, 0, nfs4_async_start, 11857c478bd9Sstevel@tonic-gate vfsp, 0, minclsyspri); 11867c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 11870776f5e6SVallish Vaidyeshwara } else if (mi->mi_threads[NFS4_ASYNC_PGOPS_QUEUE] < 11880776f5e6SVallish Vaidyeshwara NUM_ASYNC_PGOPS_THREADS) { 11890776f5e6SVallish Vaidyeshwara mi->mi_threads[NFS4_ASYNC_PGOPS_QUEUE]++; 11900776f5e6SVallish Vaidyeshwara mutex_exit(&mi->mi_async_lock); 11910776f5e6SVallish Vaidyeshwara MI4_HOLD(mi); 11920776f5e6SVallish Vaidyeshwara VFS_HOLD(vfsp); /* hold for new thread */ 11930776f5e6SVallish Vaidyeshwara (void) zthread_create(NULL, 0, 11940776f5e6SVallish Vaidyeshwara nfs4_async_pgops_start, vfsp, 0, 11950776f5e6SVallish Vaidyeshwara minclsyspri); 11960776f5e6SVallish Vaidyeshwara mutex_enter(&mi->mi_async_lock); 11977c478bd9Sstevel@tonic-gate } 11980776f5e6SVallish Vaidyeshwara NFS4_WAKE_ASYNC_WORKER(mi->mi_async_work_cv); 11997c478bd9Sstevel@tonic-gate ASSERT(mi->mi_async_req_count != 0); 12007c478bd9Sstevel@tonic-gate mi->mi_async_req_count--; 12017c478bd9Sstevel@tonic-gate } 1202388e50fcSMarcel Telka 12037c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 1204388e50fcSMarcel Telka if (mi->mi_flags & MI4_ASYNC_MGR_STOP) { 1205388e50fcSMarcel Telka mutex_exit(&mi->mi_lock); 1206388e50fcSMarcel Telka break; 1207388e50fcSMarcel Telka } 1208388e50fcSMarcel Telka mutex_exit(&mi->mi_lock); 1209388e50fcSMarcel Telka 1210388e50fcSMarcel Telka CALLB_CPR_SAFE_BEGIN(&cprinfo); 1211388e50fcSMarcel Telka cv_wait(&mi->mi_async_reqs_cv, &mi->mi_async_lock); 1212388e50fcSMarcel Telka CALLB_CPR_SAFE_END(&cprinfo, &mi->mi_async_lock); 12137c478bd9Sstevel@tonic-gate } 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_zone_debug, (CE_NOTE, 12167c478bd9Sstevel@tonic-gate "nfs4_async_manager exiting for vfs %p\n", (void *)mi->mi_vfsp)); 12177c478bd9Sstevel@tonic-gate /* 12187c478bd9Sstevel@tonic-gate * Let everyone know we're done. 12197c478bd9Sstevel@tonic-gate */ 12207c478bd9Sstevel@tonic-gate mi->mi_manager_thread = NULL; 12217c478bd9Sstevel@tonic-gate /* 12227c478bd9Sstevel@tonic-gate * Wake up the inactive thread. 12237c478bd9Sstevel@tonic-gate */ 12247c478bd9Sstevel@tonic-gate cv_broadcast(&mi->mi_inact_req_cv); 12257c478bd9Sstevel@tonic-gate /* 12267c478bd9Sstevel@tonic-gate * Wake up anyone sitting in nfs4_async_manager_stop() 12277c478bd9Sstevel@tonic-gate */ 12287c478bd9Sstevel@tonic-gate cv_broadcast(&mi->mi_async_cv); 12297c478bd9Sstevel@tonic-gate /* 12307c478bd9Sstevel@tonic-gate * There is no explicit call to mutex_exit(&mi->mi_async_lock) 12317c478bd9Sstevel@tonic-gate * since CALLB_CPR_EXIT is actually responsible for releasing 12327c478bd9Sstevel@tonic-gate * 'mi_async_lock'. 12337c478bd9Sstevel@tonic-gate */ 12347c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cprinfo); 12357c478bd9Sstevel@tonic-gate VFS_RELE(vfsp); /* release thread's hold */ 123650a83466Sjwahlig MI4_RELE(mi); 12377c478bd9Sstevel@tonic-gate zthread_exit(); 12387c478bd9Sstevel@tonic-gate } 12397c478bd9Sstevel@tonic-gate 12407c478bd9Sstevel@tonic-gate /* 12417c478bd9Sstevel@tonic-gate * Signal (and wait for) the async manager thread to clean up and go away. 12427c478bd9Sstevel@tonic-gate */ 12437c478bd9Sstevel@tonic-gate void 12447c478bd9Sstevel@tonic-gate nfs4_async_manager_stop(vfs_t *vfsp) 12457c478bd9Sstevel@tonic-gate { 12467c478bd9Sstevel@tonic-gate mntinfo4_t *mi = VFTOMI4(vfsp); 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 12497c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 12507c478bd9Sstevel@tonic-gate mi->mi_flags |= MI4_ASYNC_MGR_STOP; 12517c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 12527c478bd9Sstevel@tonic-gate cv_broadcast(&mi->mi_async_reqs_cv); 12537c478bd9Sstevel@tonic-gate /* 12547c478bd9Sstevel@tonic-gate * Wait for the async manager thread to die. 12557c478bd9Sstevel@tonic-gate */ 12567c478bd9Sstevel@tonic-gate while (mi->mi_manager_thread != NULL) 12577c478bd9Sstevel@tonic-gate cv_wait(&mi->mi_async_cv, &mi->mi_async_lock); 12587c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 12597c478bd9Sstevel@tonic-gate } 12607c478bd9Sstevel@tonic-gate 12617c478bd9Sstevel@tonic-gate int 12627c478bd9Sstevel@tonic-gate nfs4_async_readahead(vnode_t *vp, u_offset_t blkoff, caddr_t addr, 1263b9238976Sth struct seg *seg, cred_t *cr, void (*readahead)(vnode_t *, 1264b9238976Sth u_offset_t, caddr_t, struct seg *, cred_t *)) 12657c478bd9Sstevel@tonic-gate { 12667c478bd9Sstevel@tonic-gate rnode4_t *rp; 12677c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 12687c478bd9Sstevel@tonic-gate struct nfs4_async_reqs *args; 12697c478bd9Sstevel@tonic-gate 12707c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 12717c478bd9Sstevel@tonic-gate ASSERT(rp->r_freef == NULL); 12727c478bd9Sstevel@tonic-gate 12737c478bd9Sstevel@tonic-gate mi = VTOMI4(vp); 12747c478bd9Sstevel@tonic-gate 12757c478bd9Sstevel@tonic-gate /* 12767c478bd9Sstevel@tonic-gate * If addr falls in a different segment, don't bother doing readahead. 12777c478bd9Sstevel@tonic-gate */ 12787c478bd9Sstevel@tonic-gate if (addr >= seg->s_base + seg->s_size) 12797c478bd9Sstevel@tonic-gate return (-1); 12807c478bd9Sstevel@tonic-gate 12817c478bd9Sstevel@tonic-gate /* 12827c478bd9Sstevel@tonic-gate * If we can't allocate a request structure, punt on the readahead. 12837c478bd9Sstevel@tonic-gate */ 12847c478bd9Sstevel@tonic-gate if ((args = kmem_alloc(sizeof (*args), KM_NOSLEEP)) == NULL) 12857c478bd9Sstevel@tonic-gate return (-1); 12867c478bd9Sstevel@tonic-gate 12877c478bd9Sstevel@tonic-gate /* 12887c478bd9Sstevel@tonic-gate * If a lock operation is pending, don't initiate any new 12897c478bd9Sstevel@tonic-gate * readaheads. Otherwise, bump r_count to indicate the new 12907c478bd9Sstevel@tonic-gate * asynchronous I/O. 12917c478bd9Sstevel@tonic-gate */ 12927c478bd9Sstevel@tonic-gate if (!nfs_rw_tryenter(&rp->r_lkserlock, RW_READER)) { 12937c478bd9Sstevel@tonic-gate kmem_free(args, sizeof (*args)); 12947c478bd9Sstevel@tonic-gate return (-1); 12957c478bd9Sstevel@tonic-gate } 12967c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 12977c478bd9Sstevel@tonic-gate rp->r_count++; 12987c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 12997c478bd9Sstevel@tonic-gate nfs_rw_exit(&rp->r_lkserlock); 13007c478bd9Sstevel@tonic-gate 13017c478bd9Sstevel@tonic-gate args->a_next = NULL; 13027c478bd9Sstevel@tonic-gate #ifdef DEBUG 13037c478bd9Sstevel@tonic-gate args->a_queuer = curthread; 13047c478bd9Sstevel@tonic-gate #endif 13057c478bd9Sstevel@tonic-gate VN_HOLD(vp); 13067c478bd9Sstevel@tonic-gate args->a_vp = vp; 13077c478bd9Sstevel@tonic-gate ASSERT(cr != NULL); 13087c478bd9Sstevel@tonic-gate crhold(cr); 13097c478bd9Sstevel@tonic-gate args->a_cred = cr; 13107c478bd9Sstevel@tonic-gate args->a_io = NFS4_READ_AHEAD; 13117c478bd9Sstevel@tonic-gate args->a_nfs4_readahead = readahead; 13127c478bd9Sstevel@tonic-gate args->a_nfs4_blkoff = blkoff; 13137c478bd9Sstevel@tonic-gate args->a_nfs4_seg = seg; 13147c478bd9Sstevel@tonic-gate args->a_nfs4_addr = addr; 13157c478bd9Sstevel@tonic-gate 13167c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 13177c478bd9Sstevel@tonic-gate 13187c478bd9Sstevel@tonic-gate /* 13197c478bd9Sstevel@tonic-gate * If asyncio has been disabled, don't bother readahead. 13207c478bd9Sstevel@tonic-gate */ 13217c478bd9Sstevel@tonic-gate if (mi->mi_max_threads == 0) { 13227c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 13237c478bd9Sstevel@tonic-gate goto noasync; 13247c478bd9Sstevel@tonic-gate } 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate /* 13277c478bd9Sstevel@tonic-gate * Link request structure into the async list and 13287c478bd9Sstevel@tonic-gate * wakeup async thread to do the i/o. 13297c478bd9Sstevel@tonic-gate */ 13307c478bd9Sstevel@tonic-gate if (mi->mi_async_reqs[NFS4_READ_AHEAD] == NULL) { 13317c478bd9Sstevel@tonic-gate mi->mi_async_reqs[NFS4_READ_AHEAD] = args; 13327c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_READ_AHEAD] = args; 13337c478bd9Sstevel@tonic-gate } else { 13347c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_READ_AHEAD]->a_next = args; 13357c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_READ_AHEAD] = args; 13367c478bd9Sstevel@tonic-gate } 13377c478bd9Sstevel@tonic-gate 13387c478bd9Sstevel@tonic-gate if (mi->mi_io_kstats) { 13397c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 13407c478bd9Sstevel@tonic-gate kstat_waitq_enter(KSTAT_IO_PTR(mi->mi_io_kstats)); 13417c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 13427c478bd9Sstevel@tonic-gate } 13437c478bd9Sstevel@tonic-gate 13447c478bd9Sstevel@tonic-gate mi->mi_async_req_count++; 13457c478bd9Sstevel@tonic-gate ASSERT(mi->mi_async_req_count != 0); 13467c478bd9Sstevel@tonic-gate cv_signal(&mi->mi_async_reqs_cv); 13477c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 13487c478bd9Sstevel@tonic-gate return (0); 13497c478bd9Sstevel@tonic-gate 13507c478bd9Sstevel@tonic-gate noasync: 13517c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 13527c478bd9Sstevel@tonic-gate rp->r_count--; 13537c478bd9Sstevel@tonic-gate cv_broadcast(&rp->r_cv); 13547c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 13557c478bd9Sstevel@tonic-gate VN_RELE(vp); 13567c478bd9Sstevel@tonic-gate crfree(cr); 13577c478bd9Sstevel@tonic-gate kmem_free(args, sizeof (*args)); 13587c478bd9Sstevel@tonic-gate return (-1); 13597c478bd9Sstevel@tonic-gate } 13607c478bd9Sstevel@tonic-gate 13610776f5e6SVallish Vaidyeshwara static void 13620776f5e6SVallish Vaidyeshwara nfs4_async_start(struct vfs *vfsp) 13630776f5e6SVallish Vaidyeshwara { 13640776f5e6SVallish Vaidyeshwara nfs4_async_common_start(vfsp, NFS4_ASYNC_QUEUE); 13650776f5e6SVallish Vaidyeshwara } 13660776f5e6SVallish Vaidyeshwara 13670776f5e6SVallish Vaidyeshwara static void 13680776f5e6SVallish Vaidyeshwara nfs4_async_pgops_start(struct vfs *vfsp) 13690776f5e6SVallish Vaidyeshwara { 13700776f5e6SVallish Vaidyeshwara nfs4_async_common_start(vfsp, NFS4_ASYNC_PGOPS_QUEUE); 13710776f5e6SVallish Vaidyeshwara } 13720776f5e6SVallish Vaidyeshwara 13737c478bd9Sstevel@tonic-gate /* 13747c478bd9Sstevel@tonic-gate * The async queues for each mounted file system are arranged as a 13757c478bd9Sstevel@tonic-gate * set of queues, one for each async i/o type. Requests are taken 13767c478bd9Sstevel@tonic-gate * from the queues in a round-robin fashion. A number of consecutive 13777c478bd9Sstevel@tonic-gate * requests are taken from each queue before moving on to the next 13787c478bd9Sstevel@tonic-gate * queue. This functionality may allow the NFS Version 2 server to do 13797c478bd9Sstevel@tonic-gate * write clustering, even if the client is mixing writes and reads 13807c478bd9Sstevel@tonic-gate * because it will take multiple write requests from the queue 13817c478bd9Sstevel@tonic-gate * before processing any of the other async i/o types. 13827c478bd9Sstevel@tonic-gate * 13830776f5e6SVallish Vaidyeshwara * XXX The nfs4_async_common_start thread is unsafe in the light of the present 13847c478bd9Sstevel@tonic-gate * model defined by cpr to suspend the system. Specifically over the 13857c478bd9Sstevel@tonic-gate * wire calls are cpr-unsafe. The thread should be reevaluated in 13867c478bd9Sstevel@tonic-gate * case of future updates to the cpr model. 13877c478bd9Sstevel@tonic-gate */ 13887c478bd9Sstevel@tonic-gate static void 13890776f5e6SVallish Vaidyeshwara nfs4_async_common_start(struct vfs *vfsp, int async_queue) 13907c478bd9Sstevel@tonic-gate { 13917c478bd9Sstevel@tonic-gate struct nfs4_async_reqs *args; 13927c478bd9Sstevel@tonic-gate mntinfo4_t *mi = VFTOMI4(vfsp); 13937c478bd9Sstevel@tonic-gate clock_t time_left = 1; 13947c478bd9Sstevel@tonic-gate callb_cpr_t cprinfo; 13957c478bd9Sstevel@tonic-gate int i; 13967c478bd9Sstevel@tonic-gate extern int nfs_async_timeout; 13970776f5e6SVallish Vaidyeshwara int async_types; 13980776f5e6SVallish Vaidyeshwara kcondvar_t *async_work_cv; 13990776f5e6SVallish Vaidyeshwara 14000776f5e6SVallish Vaidyeshwara if (async_queue == NFS4_ASYNC_QUEUE) { 14010776f5e6SVallish Vaidyeshwara async_types = NFS4_ASYNC_TYPES; 14020776f5e6SVallish Vaidyeshwara async_work_cv = &mi->mi_async_work_cv[NFS4_ASYNC_QUEUE]; 14030776f5e6SVallish Vaidyeshwara } else { 14040776f5e6SVallish Vaidyeshwara async_types = NFS4_ASYNC_PGOPS_TYPES; 14050776f5e6SVallish Vaidyeshwara async_work_cv = &mi->mi_async_work_cv[NFS4_ASYNC_PGOPS_QUEUE]; 14060776f5e6SVallish Vaidyeshwara } 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate /* 14097c478bd9Sstevel@tonic-gate * Dynamic initialization of nfs_async_timeout to allow nfs to be 14107c478bd9Sstevel@tonic-gate * built in an implementation independent manner. 14117c478bd9Sstevel@tonic-gate */ 14127c478bd9Sstevel@tonic-gate if (nfs_async_timeout == -1) 14137c478bd9Sstevel@tonic-gate nfs_async_timeout = NFS_ASYNC_TIMEOUT; 14147c478bd9Sstevel@tonic-gate 14157c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cprinfo, &mi->mi_async_lock, callb_generic_cpr, "nas"); 14167c478bd9Sstevel@tonic-gate 14177c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 14187c478bd9Sstevel@tonic-gate for (;;) { 14197c478bd9Sstevel@tonic-gate /* 14207c478bd9Sstevel@tonic-gate * Find the next queue containing an entry. We start 14217c478bd9Sstevel@tonic-gate * at the current queue pointer and then round robin 14227c478bd9Sstevel@tonic-gate * through all of them until we either find a non-empty 14237c478bd9Sstevel@tonic-gate * queue or have looked through all of them. 14247c478bd9Sstevel@tonic-gate */ 14250776f5e6SVallish Vaidyeshwara for (i = 0; i < async_types; i++) { 14260776f5e6SVallish Vaidyeshwara args = *mi->mi_async_curr[async_queue]; 14277c478bd9Sstevel@tonic-gate if (args != NULL) 14287c478bd9Sstevel@tonic-gate break; 14290776f5e6SVallish Vaidyeshwara mi->mi_async_curr[async_queue]++; 14300776f5e6SVallish Vaidyeshwara if (mi->mi_async_curr[async_queue] == 14310776f5e6SVallish Vaidyeshwara &mi->mi_async_reqs[async_types]) { 14320776f5e6SVallish Vaidyeshwara mi->mi_async_curr[async_queue] = 14330776f5e6SVallish Vaidyeshwara &mi->mi_async_reqs[0]; 14340776f5e6SVallish Vaidyeshwara } 14357c478bd9Sstevel@tonic-gate } 14367c478bd9Sstevel@tonic-gate /* 14377c478bd9Sstevel@tonic-gate * If we didn't find a entry, then block until woken up 14387c478bd9Sstevel@tonic-gate * again and then look through the queues again. 14397c478bd9Sstevel@tonic-gate */ 14407c478bd9Sstevel@tonic-gate if (args == NULL) { 14417c478bd9Sstevel@tonic-gate /* 14427c478bd9Sstevel@tonic-gate * Exiting is considered to be safe for CPR as well 14437c478bd9Sstevel@tonic-gate */ 14447c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 14457c478bd9Sstevel@tonic-gate 14467c478bd9Sstevel@tonic-gate /* 14477c478bd9Sstevel@tonic-gate * Wakeup thread waiting to unmount the file 14487c478bd9Sstevel@tonic-gate * system only if all async threads are inactive. 14497c478bd9Sstevel@tonic-gate * 14507c478bd9Sstevel@tonic-gate * If we've timed-out and there's nothing to do, 14517c478bd9Sstevel@tonic-gate * then get rid of this thread. 14527c478bd9Sstevel@tonic-gate */ 14537c478bd9Sstevel@tonic-gate if (mi->mi_max_threads == 0 || time_left <= 0) { 14540776f5e6SVallish Vaidyeshwara --mi->mi_threads[async_queue]; 14550776f5e6SVallish Vaidyeshwara 14560776f5e6SVallish Vaidyeshwara if (mi->mi_threads[NFS4_ASYNC_QUEUE] == 0 && 14570776f5e6SVallish Vaidyeshwara mi->mi_threads[NFS4_ASYNC_PGOPS_QUEUE] == 0) 14587c478bd9Sstevel@tonic-gate cv_signal(&mi->mi_async_cv); 14597c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cprinfo); 14607c478bd9Sstevel@tonic-gate VFS_RELE(vfsp); /* release thread's hold */ 146150a83466Sjwahlig MI4_RELE(mi); 14627c478bd9Sstevel@tonic-gate zthread_exit(); 14637c478bd9Sstevel@tonic-gate /* NOTREACHED */ 14647c478bd9Sstevel@tonic-gate } 14650776f5e6SVallish Vaidyeshwara time_left = cv_reltimedwait(async_work_cv, 1466d3d50737SRafael Vanoni &mi->mi_async_lock, nfs_async_timeout, 1467d3d50737SRafael Vanoni TR_CLOCK_TICK); 14687c478bd9Sstevel@tonic-gate 14697c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cprinfo, &mi->mi_async_lock); 14707c478bd9Sstevel@tonic-gate 14717c478bd9Sstevel@tonic-gate continue; 14727c478bd9Sstevel@tonic-gate } else { 14737c478bd9Sstevel@tonic-gate time_left = 1; 14747c478bd9Sstevel@tonic-gate } 14757c478bd9Sstevel@tonic-gate 14767c478bd9Sstevel@tonic-gate /* 14777c478bd9Sstevel@tonic-gate * Remove the request from the async queue and then 14787c478bd9Sstevel@tonic-gate * update the current async request queue pointer. If 14797c478bd9Sstevel@tonic-gate * the current queue is empty or we have removed enough 14807c478bd9Sstevel@tonic-gate * consecutive entries from it, then reset the counter 14817c478bd9Sstevel@tonic-gate * for this queue and then move the current pointer to 14827c478bd9Sstevel@tonic-gate * the next queue. 14837c478bd9Sstevel@tonic-gate */ 14840776f5e6SVallish Vaidyeshwara *mi->mi_async_curr[async_queue] = args->a_next; 14850776f5e6SVallish Vaidyeshwara if (*mi->mi_async_curr[async_queue] == NULL || 14867c478bd9Sstevel@tonic-gate --mi->mi_async_clusters[args->a_io] == 0) { 14877c478bd9Sstevel@tonic-gate mi->mi_async_clusters[args->a_io] = 1488b9238976Sth mi->mi_async_init_clusters; 14890776f5e6SVallish Vaidyeshwara mi->mi_async_curr[async_queue]++; 14900776f5e6SVallish Vaidyeshwara if (mi->mi_async_curr[async_queue] == 14910776f5e6SVallish Vaidyeshwara &mi->mi_async_reqs[async_types]) { 14920776f5e6SVallish Vaidyeshwara mi->mi_async_curr[async_queue] = 14930776f5e6SVallish Vaidyeshwara &mi->mi_async_reqs[0]; 14940776f5e6SVallish Vaidyeshwara } 14957c478bd9Sstevel@tonic-gate } 14967c478bd9Sstevel@tonic-gate 14977c478bd9Sstevel@tonic-gate if (args->a_io != NFS4_INACTIVE && mi->mi_io_kstats) { 14987c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 14997c478bd9Sstevel@tonic-gate kstat_waitq_exit(KSTAT_IO_PTR(mi->mi_io_kstats)); 15007c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 15017c478bd9Sstevel@tonic-gate } 15027c478bd9Sstevel@tonic-gate 15037c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 15047c478bd9Sstevel@tonic-gate 15057c478bd9Sstevel@tonic-gate /* 15067c478bd9Sstevel@tonic-gate * Obtain arguments from the async request structure. 15077c478bd9Sstevel@tonic-gate */ 15087c478bd9Sstevel@tonic-gate if (args->a_io == NFS4_READ_AHEAD && mi->mi_max_threads > 0) { 15097c478bd9Sstevel@tonic-gate (*args->a_nfs4_readahead)(args->a_vp, 1510b9238976Sth args->a_nfs4_blkoff, args->a_nfs4_addr, 1511b9238976Sth args->a_nfs4_seg, args->a_cred); 15127c478bd9Sstevel@tonic-gate } else if (args->a_io == NFS4_PUTAPAGE) { 15137c478bd9Sstevel@tonic-gate (void) (*args->a_nfs4_putapage)(args->a_vp, 1514b9238976Sth args->a_nfs4_pp, args->a_nfs4_off, 1515b9238976Sth args->a_nfs4_len, args->a_nfs4_flags, 1516b9238976Sth args->a_cred); 15177c478bd9Sstevel@tonic-gate } else if (args->a_io == NFS4_PAGEIO) { 15187c478bd9Sstevel@tonic-gate (void) (*args->a_nfs4_pageio)(args->a_vp, 1519b9238976Sth args->a_nfs4_pp, args->a_nfs4_off, 1520b9238976Sth args->a_nfs4_len, args->a_nfs4_flags, 1521b9238976Sth args->a_cred); 15227c478bd9Sstevel@tonic-gate } else if (args->a_io == NFS4_READDIR) { 15237c478bd9Sstevel@tonic-gate (void) ((*args->a_nfs4_readdir)(args->a_vp, 1524b9238976Sth args->a_nfs4_rdc, args->a_cred)); 15257c478bd9Sstevel@tonic-gate } else if (args->a_io == NFS4_COMMIT) { 15267c478bd9Sstevel@tonic-gate (*args->a_nfs4_commit)(args->a_vp, args->a_nfs4_plist, 1527b9238976Sth args->a_nfs4_offset, args->a_nfs4_count, 1528b9238976Sth args->a_cred); 15297c478bd9Sstevel@tonic-gate } else if (args->a_io == NFS4_INACTIVE) { 15307c478bd9Sstevel@tonic-gate nfs4_inactive_otw(args->a_vp, args->a_cred); 15317c478bd9Sstevel@tonic-gate } 15327c478bd9Sstevel@tonic-gate 15337c478bd9Sstevel@tonic-gate /* 15347c478bd9Sstevel@tonic-gate * Now, release the vnode and free the credentials 15357c478bd9Sstevel@tonic-gate * structure. 15367c478bd9Sstevel@tonic-gate */ 15377c478bd9Sstevel@tonic-gate free_async_args4(args); 15387c478bd9Sstevel@tonic-gate /* 15397c478bd9Sstevel@tonic-gate * Reacquire the mutex because it will be needed above. 15407c478bd9Sstevel@tonic-gate */ 15417c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 15427c478bd9Sstevel@tonic-gate } 15437c478bd9Sstevel@tonic-gate } 15447c478bd9Sstevel@tonic-gate 15457c478bd9Sstevel@tonic-gate /* 15467c478bd9Sstevel@tonic-gate * nfs4_inactive_thread - look for vnodes that need over-the-wire calls as 15477c478bd9Sstevel@tonic-gate * part of VOP_INACTIVE. 15487c478bd9Sstevel@tonic-gate */ 15497c478bd9Sstevel@tonic-gate 15507c478bd9Sstevel@tonic-gate void 15517c478bd9Sstevel@tonic-gate nfs4_inactive_thread(mntinfo4_t *mi) 15527c478bd9Sstevel@tonic-gate { 15537c478bd9Sstevel@tonic-gate struct nfs4_async_reqs *args; 15547c478bd9Sstevel@tonic-gate callb_cpr_t cprinfo; 15557c478bd9Sstevel@tonic-gate vfs_t *vfsp = mi->mi_vfsp; 15567c478bd9Sstevel@tonic-gate 15577c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cprinfo, &mi->mi_async_lock, callb_generic_cpr, 1558b9238976Sth "nfs4_inactive_thread"); 15597c478bd9Sstevel@tonic-gate 15607c478bd9Sstevel@tonic-gate for (;;) { 15617c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 15627c478bd9Sstevel@tonic-gate args = mi->mi_async_reqs[NFS4_INACTIVE]; 15637c478bd9Sstevel@tonic-gate if (args == NULL) { 15647c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 15657c478bd9Sstevel@tonic-gate /* 156650a83466Sjwahlig * We don't want to exit until the async manager is done 15677c478bd9Sstevel@tonic-gate * with its work; hence the check for mi_manager_thread 15687c478bd9Sstevel@tonic-gate * being NULL. 15697c478bd9Sstevel@tonic-gate * 15707c478bd9Sstevel@tonic-gate * The async manager thread will cv_broadcast() on 15717c478bd9Sstevel@tonic-gate * mi_inact_req_cv when it's done, at which point we'll 15727c478bd9Sstevel@tonic-gate * wake up and exit. 15737c478bd9Sstevel@tonic-gate */ 157450a83466Sjwahlig if (mi->mi_manager_thread == NULL) 15757c478bd9Sstevel@tonic-gate goto die; 15767c478bd9Sstevel@tonic-gate mi->mi_flags |= MI4_INACTIVE_IDLE; 15777c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 15787c478bd9Sstevel@tonic-gate cv_signal(&mi->mi_async_cv); 15797c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 15807c478bd9Sstevel@tonic-gate cv_wait(&mi->mi_inact_req_cv, &mi->mi_async_lock); 15817c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cprinfo, &mi->mi_async_lock); 15827c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 15837c478bd9Sstevel@tonic-gate } else { 15847c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 15857c478bd9Sstevel@tonic-gate mi->mi_flags &= ~MI4_INACTIVE_IDLE; 15867c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 15877c478bd9Sstevel@tonic-gate mi->mi_async_reqs[NFS4_INACTIVE] = args->a_next; 15887c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 15897c478bd9Sstevel@tonic-gate nfs4_inactive_otw(args->a_vp, args->a_cred); 15907c478bd9Sstevel@tonic-gate crfree(args->a_cred); 15917c478bd9Sstevel@tonic-gate kmem_free(args, sizeof (*args)); 15927c478bd9Sstevel@tonic-gate } 15937c478bd9Sstevel@tonic-gate } 15947c478bd9Sstevel@tonic-gate die: 15957c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 15967c478bd9Sstevel@tonic-gate mi->mi_inactive_thread = NULL; 15977c478bd9Sstevel@tonic-gate cv_signal(&mi->mi_async_cv); 159850a83466Sjwahlig 15997c478bd9Sstevel@tonic-gate /* 16007c478bd9Sstevel@tonic-gate * There is no explicit call to mutex_exit(&mi->mi_async_lock) since 16017c478bd9Sstevel@tonic-gate * CALLB_CPR_EXIT is actually responsible for releasing 'mi_async_lock'. 16027c478bd9Sstevel@tonic-gate */ 16037c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cprinfo); 160450a83466Sjwahlig 16057c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_zone_debug, (CE_NOTE, 16067c478bd9Sstevel@tonic-gate "nfs4_inactive_thread exiting for vfs %p\n", (void *)vfsp)); 160750a83466Sjwahlig 160850a83466Sjwahlig MI4_RELE(mi); 16097c478bd9Sstevel@tonic-gate zthread_exit(); 16107c478bd9Sstevel@tonic-gate /* NOTREACHED */ 16117c478bd9Sstevel@tonic-gate } 16127c478bd9Sstevel@tonic-gate 16137c478bd9Sstevel@tonic-gate /* 16147c478bd9Sstevel@tonic-gate * nfs_async_stop: 16157c478bd9Sstevel@tonic-gate * Wait for all outstanding putpage operations and the inactive thread to 16167c478bd9Sstevel@tonic-gate * complete; nfs4_async_stop_sig() without interruptibility. 16177c478bd9Sstevel@tonic-gate */ 16187c478bd9Sstevel@tonic-gate void 16197c478bd9Sstevel@tonic-gate nfs4_async_stop(struct vfs *vfsp) 16207c478bd9Sstevel@tonic-gate { 16217c478bd9Sstevel@tonic-gate mntinfo4_t *mi = VFTOMI4(vfsp); 16227c478bd9Sstevel@tonic-gate 16237c478bd9Sstevel@tonic-gate /* 16247c478bd9Sstevel@tonic-gate * Wait for all outstanding async operations to complete and for 16257c478bd9Sstevel@tonic-gate * worker threads to exit. 16267c478bd9Sstevel@tonic-gate */ 16277c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 16287c478bd9Sstevel@tonic-gate mi->mi_max_threads = 0; 16290776f5e6SVallish Vaidyeshwara NFS4_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv); 16300776f5e6SVallish Vaidyeshwara while (mi->mi_threads[NFS4_ASYNC_QUEUE] != 0 || 16310776f5e6SVallish Vaidyeshwara mi->mi_threads[NFS4_ASYNC_PGOPS_QUEUE] != 0) 16327c478bd9Sstevel@tonic-gate cv_wait(&mi->mi_async_cv, &mi->mi_async_lock); 16337c478bd9Sstevel@tonic-gate 16347c478bd9Sstevel@tonic-gate /* 16357c478bd9Sstevel@tonic-gate * Wait for the inactive thread to finish doing what it's doing. It 16367c478bd9Sstevel@tonic-gate * won't exit until the last reference to the vfs_t goes away. 16377c478bd9Sstevel@tonic-gate */ 16387c478bd9Sstevel@tonic-gate if (mi->mi_inactive_thread != NULL) { 16397c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 16407c478bd9Sstevel@tonic-gate while (!(mi->mi_flags & MI4_INACTIVE_IDLE) || 16417c478bd9Sstevel@tonic-gate (mi->mi_async_reqs[NFS4_INACTIVE] != NULL)) { 16427c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 16437c478bd9Sstevel@tonic-gate cv_wait(&mi->mi_async_cv, &mi->mi_async_lock); 16447c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 16457c478bd9Sstevel@tonic-gate } 16467c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 16477c478bd9Sstevel@tonic-gate } 16487c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 16497c478bd9Sstevel@tonic-gate } 16507c478bd9Sstevel@tonic-gate 16517c478bd9Sstevel@tonic-gate /* 16527c478bd9Sstevel@tonic-gate * nfs_async_stop_sig: 16537c478bd9Sstevel@tonic-gate * Wait for all outstanding putpage operations and the inactive thread to 16547c478bd9Sstevel@tonic-gate * complete. If a signal is delivered we will abort and return non-zero; 16557c478bd9Sstevel@tonic-gate * otherwise return 0. Since this routine is called from nfs4_unmount, we 1656da6c28aaSamw * need to make it interruptible. 16577c478bd9Sstevel@tonic-gate */ 16587c478bd9Sstevel@tonic-gate int 16597c478bd9Sstevel@tonic-gate nfs4_async_stop_sig(struct vfs *vfsp) 16607c478bd9Sstevel@tonic-gate { 16617c478bd9Sstevel@tonic-gate mntinfo4_t *mi = VFTOMI4(vfsp); 16627c478bd9Sstevel@tonic-gate ushort_t omax; 16637c478bd9Sstevel@tonic-gate bool_t intr = FALSE; 16647c478bd9Sstevel@tonic-gate 16657c478bd9Sstevel@tonic-gate /* 16667c478bd9Sstevel@tonic-gate * Wait for all outstanding putpage operations to complete and for 16677c478bd9Sstevel@tonic-gate * worker threads to exit. 16687c478bd9Sstevel@tonic-gate */ 16697c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 16707c478bd9Sstevel@tonic-gate omax = mi->mi_max_threads; 16717c478bd9Sstevel@tonic-gate mi->mi_max_threads = 0; 16720776f5e6SVallish Vaidyeshwara NFS4_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv); 16730776f5e6SVallish Vaidyeshwara while (mi->mi_threads[NFS4_ASYNC_QUEUE] != 0 || 16740776f5e6SVallish Vaidyeshwara mi->mi_threads[NFS4_ASYNC_PGOPS_QUEUE] != 0) { 16757c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&mi->mi_async_cv, &mi->mi_async_lock)) { 16767c478bd9Sstevel@tonic-gate intr = TRUE; 16777c478bd9Sstevel@tonic-gate goto interrupted; 16787c478bd9Sstevel@tonic-gate } 16797c478bd9Sstevel@tonic-gate } 16807c478bd9Sstevel@tonic-gate 16817c478bd9Sstevel@tonic-gate /* 16827c478bd9Sstevel@tonic-gate * Wait for the inactive thread to finish doing what it's doing. It 16837c478bd9Sstevel@tonic-gate * won't exit until the a last reference to the vfs_t goes away. 16847c478bd9Sstevel@tonic-gate */ 16857c478bd9Sstevel@tonic-gate if (mi->mi_inactive_thread != NULL) { 16867c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 16877c478bd9Sstevel@tonic-gate while (!(mi->mi_flags & MI4_INACTIVE_IDLE) || 16887c478bd9Sstevel@tonic-gate (mi->mi_async_reqs[NFS4_INACTIVE] != NULL)) { 16897c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 16907c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&mi->mi_async_cv, 16917c478bd9Sstevel@tonic-gate &mi->mi_async_lock)) { 16927c478bd9Sstevel@tonic-gate intr = TRUE; 16937c478bd9Sstevel@tonic-gate goto interrupted; 16947c478bd9Sstevel@tonic-gate } 16957c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 16967c478bd9Sstevel@tonic-gate } 16977c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 16987c478bd9Sstevel@tonic-gate } 16997c478bd9Sstevel@tonic-gate interrupted: 17007c478bd9Sstevel@tonic-gate if (intr) 17017c478bd9Sstevel@tonic-gate mi->mi_max_threads = omax; 17027c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 17037c478bd9Sstevel@tonic-gate 17047c478bd9Sstevel@tonic-gate return (intr); 17057c478bd9Sstevel@tonic-gate } 17067c478bd9Sstevel@tonic-gate 17077c478bd9Sstevel@tonic-gate int 17087c478bd9Sstevel@tonic-gate nfs4_async_putapage(vnode_t *vp, page_t *pp, u_offset_t off, size_t len, 1709b9238976Sth int flags, cred_t *cr, int (*putapage)(vnode_t *, page_t *, 1710b9238976Sth u_offset_t, size_t, int, cred_t *)) 17117c478bd9Sstevel@tonic-gate { 17127c478bd9Sstevel@tonic-gate rnode4_t *rp; 17137c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 17147c478bd9Sstevel@tonic-gate struct nfs4_async_reqs *args; 17157c478bd9Sstevel@tonic-gate 17167c478bd9Sstevel@tonic-gate ASSERT(flags & B_ASYNC); 17177c478bd9Sstevel@tonic-gate ASSERT(vp->v_vfsp != NULL); 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 17207c478bd9Sstevel@tonic-gate ASSERT(rp->r_count > 0); 17217c478bd9Sstevel@tonic-gate 17227c478bd9Sstevel@tonic-gate mi = VTOMI4(vp); 17237c478bd9Sstevel@tonic-gate 17247c478bd9Sstevel@tonic-gate /* 17257c478bd9Sstevel@tonic-gate * If we can't allocate a request structure, do the putpage 17267c478bd9Sstevel@tonic-gate * operation synchronously in this thread's context. 17277c478bd9Sstevel@tonic-gate */ 17287c478bd9Sstevel@tonic-gate if ((args = kmem_alloc(sizeof (*args), KM_NOSLEEP)) == NULL) 17297c478bd9Sstevel@tonic-gate goto noasync; 17307c478bd9Sstevel@tonic-gate 17317c478bd9Sstevel@tonic-gate args->a_next = NULL; 17327c478bd9Sstevel@tonic-gate #ifdef DEBUG 17337c478bd9Sstevel@tonic-gate args->a_queuer = curthread; 17347c478bd9Sstevel@tonic-gate #endif 17357c478bd9Sstevel@tonic-gate VN_HOLD(vp); 17367c478bd9Sstevel@tonic-gate args->a_vp = vp; 17377c478bd9Sstevel@tonic-gate ASSERT(cr != NULL); 17387c478bd9Sstevel@tonic-gate crhold(cr); 17397c478bd9Sstevel@tonic-gate args->a_cred = cr; 17407c478bd9Sstevel@tonic-gate args->a_io = NFS4_PUTAPAGE; 17417c478bd9Sstevel@tonic-gate args->a_nfs4_putapage = putapage; 17427c478bd9Sstevel@tonic-gate args->a_nfs4_pp = pp; 17437c478bd9Sstevel@tonic-gate args->a_nfs4_off = off; 17447c478bd9Sstevel@tonic-gate args->a_nfs4_len = (uint_t)len; 17457c478bd9Sstevel@tonic-gate args->a_nfs4_flags = flags; 17467c478bd9Sstevel@tonic-gate 17477c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 17487c478bd9Sstevel@tonic-gate 17497c478bd9Sstevel@tonic-gate /* 17507c478bd9Sstevel@tonic-gate * If asyncio has been disabled, then make a synchronous request. 17517c478bd9Sstevel@tonic-gate * This check is done a second time in case async io was diabled 17527c478bd9Sstevel@tonic-gate * while this thread was blocked waiting for memory pressure to 17537c478bd9Sstevel@tonic-gate * reduce or for the queue to drain. 17547c478bd9Sstevel@tonic-gate */ 17557c478bd9Sstevel@tonic-gate if (mi->mi_max_threads == 0) { 17567c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 17577c478bd9Sstevel@tonic-gate 17587c478bd9Sstevel@tonic-gate VN_RELE(vp); 17597c478bd9Sstevel@tonic-gate crfree(cr); 17607c478bd9Sstevel@tonic-gate kmem_free(args, sizeof (*args)); 17617c478bd9Sstevel@tonic-gate goto noasync; 17627c478bd9Sstevel@tonic-gate } 17637c478bd9Sstevel@tonic-gate 17647c478bd9Sstevel@tonic-gate /* 17657c478bd9Sstevel@tonic-gate * Link request structure into the async list and 17667c478bd9Sstevel@tonic-gate * wakeup async thread to do the i/o. 17677c478bd9Sstevel@tonic-gate */ 17687c478bd9Sstevel@tonic-gate if (mi->mi_async_reqs[NFS4_PUTAPAGE] == NULL) { 17697c478bd9Sstevel@tonic-gate mi->mi_async_reqs[NFS4_PUTAPAGE] = args; 17707c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_PUTAPAGE] = args; 17717c478bd9Sstevel@tonic-gate } else { 17727c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_PUTAPAGE]->a_next = args; 17737c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_PUTAPAGE] = args; 17747c478bd9Sstevel@tonic-gate } 17757c478bd9Sstevel@tonic-gate 17767c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 17777c478bd9Sstevel@tonic-gate rp->r_count++; 17787c478bd9Sstevel@tonic-gate rp->r_awcount++; 17797c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 17807c478bd9Sstevel@tonic-gate 17817c478bd9Sstevel@tonic-gate if (mi->mi_io_kstats) { 17827c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 17837c478bd9Sstevel@tonic-gate kstat_waitq_enter(KSTAT_IO_PTR(mi->mi_io_kstats)); 17847c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 17857c478bd9Sstevel@tonic-gate } 17867c478bd9Sstevel@tonic-gate 17877c478bd9Sstevel@tonic-gate mi->mi_async_req_count++; 17887c478bd9Sstevel@tonic-gate ASSERT(mi->mi_async_req_count != 0); 17897c478bd9Sstevel@tonic-gate cv_signal(&mi->mi_async_reqs_cv); 17907c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 17917c478bd9Sstevel@tonic-gate return (0); 17927c478bd9Sstevel@tonic-gate 17937c478bd9Sstevel@tonic-gate noasync: 17947c478bd9Sstevel@tonic-gate 1795aea676fdSArne Jansen if (curproc == proc_pageout || curproc == proc_fsflush) { 17967c478bd9Sstevel@tonic-gate /* 17977c478bd9Sstevel@tonic-gate * If we get here in the context of the pageout/fsflush, 17987c478bd9Sstevel@tonic-gate * or we have run out of memory or we're attempting to 17997c478bd9Sstevel@tonic-gate * unmount we refuse to do a sync write, because this may 18007c478bd9Sstevel@tonic-gate * hang pageout/fsflush and the machine. In this case, 18017c478bd9Sstevel@tonic-gate * we just re-mark the page as dirty and punt on the page. 18027c478bd9Sstevel@tonic-gate * 18037c478bd9Sstevel@tonic-gate * Make sure B_FORCE isn't set. We can re-mark the 18047c478bd9Sstevel@tonic-gate * pages as dirty and unlock the pages in one swoop by 18057c478bd9Sstevel@tonic-gate * passing in B_ERROR to pvn_write_done(). However, 18067c478bd9Sstevel@tonic-gate * we should make sure B_FORCE isn't set - we don't 18077c478bd9Sstevel@tonic-gate * want the page tossed before it gets written out. 18087c478bd9Sstevel@tonic-gate */ 18097c478bd9Sstevel@tonic-gate if (flags & B_FORCE) 18107c478bd9Sstevel@tonic-gate flags &= ~(B_INVAL | B_FORCE); 18117c478bd9Sstevel@tonic-gate pvn_write_done(pp, flags | B_ERROR); 18127c478bd9Sstevel@tonic-gate return (0); 18137c478bd9Sstevel@tonic-gate } 18147c478bd9Sstevel@tonic-gate 1815aea676fdSArne Jansen if (nfs_zone() != mi->mi_zone) { 1816aea676fdSArne Jansen /* 1817aea676fdSArne Jansen * So this was a cross-zone sync putpage. 1818aea676fdSArne Jansen * 1819aea676fdSArne Jansen * We pass in B_ERROR to pvn_write_done() to re-mark the pages 1820aea676fdSArne Jansen * as dirty and unlock them. 1821aea676fdSArne Jansen * 1822aea676fdSArne Jansen * We don't want to clear B_FORCE here as the caller presumably 1823aea676fdSArne Jansen * knows what they're doing if they set it. 1824aea676fdSArne Jansen */ 1825aea676fdSArne Jansen pvn_write_done(pp, flags | B_ERROR); 1826aea676fdSArne Jansen return (EPERM); 1827aea676fdSArne Jansen } 1828aea676fdSArne Jansen return ((*putapage)(vp, pp, off, len, flags, cr)); 18297c478bd9Sstevel@tonic-gate } 18307c478bd9Sstevel@tonic-gate 18317c478bd9Sstevel@tonic-gate int 18327c478bd9Sstevel@tonic-gate nfs4_async_pageio(vnode_t *vp, page_t *pp, u_offset_t io_off, size_t io_len, 1833b9238976Sth int flags, cred_t *cr, int (*pageio)(vnode_t *, page_t *, u_offset_t, 1834b9238976Sth size_t, int, cred_t *)) 18357c478bd9Sstevel@tonic-gate { 18367c478bd9Sstevel@tonic-gate rnode4_t *rp; 18377c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 18387c478bd9Sstevel@tonic-gate struct nfs4_async_reqs *args; 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate ASSERT(flags & B_ASYNC); 18417c478bd9Sstevel@tonic-gate ASSERT(vp->v_vfsp != NULL); 18427c478bd9Sstevel@tonic-gate 18437c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 18447c478bd9Sstevel@tonic-gate ASSERT(rp->r_count > 0); 18457c478bd9Sstevel@tonic-gate 18467c478bd9Sstevel@tonic-gate mi = VTOMI4(vp); 18477c478bd9Sstevel@tonic-gate 18487c478bd9Sstevel@tonic-gate /* 18497c478bd9Sstevel@tonic-gate * If we can't allocate a request structure, do the pageio 18507c478bd9Sstevel@tonic-gate * request synchronously in this thread's context. 18517c478bd9Sstevel@tonic-gate */ 18527c478bd9Sstevel@tonic-gate if ((args = kmem_alloc(sizeof (*args), KM_NOSLEEP)) == NULL) 18537c478bd9Sstevel@tonic-gate goto noasync; 18547c478bd9Sstevel@tonic-gate 18557c478bd9Sstevel@tonic-gate args->a_next = NULL; 18567c478bd9Sstevel@tonic-gate #ifdef DEBUG 18577c478bd9Sstevel@tonic-gate args->a_queuer = curthread; 18587c478bd9Sstevel@tonic-gate #endif 18597c478bd9Sstevel@tonic-gate VN_HOLD(vp); 18607c478bd9Sstevel@tonic-gate args->a_vp = vp; 18617c478bd9Sstevel@tonic-gate ASSERT(cr != NULL); 18627c478bd9Sstevel@tonic-gate crhold(cr); 18637c478bd9Sstevel@tonic-gate args->a_cred = cr; 18647c478bd9Sstevel@tonic-gate args->a_io = NFS4_PAGEIO; 18657c478bd9Sstevel@tonic-gate args->a_nfs4_pageio = pageio; 18667c478bd9Sstevel@tonic-gate args->a_nfs4_pp = pp; 18677c478bd9Sstevel@tonic-gate args->a_nfs4_off = io_off; 18687c478bd9Sstevel@tonic-gate args->a_nfs4_len = (uint_t)io_len; 18697c478bd9Sstevel@tonic-gate args->a_nfs4_flags = flags; 18707c478bd9Sstevel@tonic-gate 18717c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 18727c478bd9Sstevel@tonic-gate 18737c478bd9Sstevel@tonic-gate /* 18747c478bd9Sstevel@tonic-gate * If asyncio has been disabled, then make a synchronous request. 18757c478bd9Sstevel@tonic-gate * This check is done a second time in case async io was diabled 18767c478bd9Sstevel@tonic-gate * while this thread was blocked waiting for memory pressure to 18777c478bd9Sstevel@tonic-gate * reduce or for the queue to drain. 18787c478bd9Sstevel@tonic-gate */ 18797c478bd9Sstevel@tonic-gate if (mi->mi_max_threads == 0) { 18807c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 18817c478bd9Sstevel@tonic-gate 18827c478bd9Sstevel@tonic-gate VN_RELE(vp); 18837c478bd9Sstevel@tonic-gate crfree(cr); 18847c478bd9Sstevel@tonic-gate kmem_free(args, sizeof (*args)); 18857c478bd9Sstevel@tonic-gate goto noasync; 18867c478bd9Sstevel@tonic-gate } 18877c478bd9Sstevel@tonic-gate 18887c478bd9Sstevel@tonic-gate /* 18897c478bd9Sstevel@tonic-gate * Link request structure into the async list and 18907c478bd9Sstevel@tonic-gate * wakeup async thread to do the i/o. 18917c478bd9Sstevel@tonic-gate */ 18927c478bd9Sstevel@tonic-gate if (mi->mi_async_reqs[NFS4_PAGEIO] == NULL) { 18937c478bd9Sstevel@tonic-gate mi->mi_async_reqs[NFS4_PAGEIO] = args; 18947c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_PAGEIO] = args; 18957c478bd9Sstevel@tonic-gate } else { 18967c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_PAGEIO]->a_next = args; 18977c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_PAGEIO] = args; 18987c478bd9Sstevel@tonic-gate } 18997c478bd9Sstevel@tonic-gate 19007c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 19017c478bd9Sstevel@tonic-gate rp->r_count++; 19027c478bd9Sstevel@tonic-gate rp->r_awcount++; 19037c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 19047c478bd9Sstevel@tonic-gate 19057c478bd9Sstevel@tonic-gate if (mi->mi_io_kstats) { 19067c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 19077c478bd9Sstevel@tonic-gate kstat_waitq_enter(KSTAT_IO_PTR(mi->mi_io_kstats)); 19087c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 19097c478bd9Sstevel@tonic-gate } 19107c478bd9Sstevel@tonic-gate 19117c478bd9Sstevel@tonic-gate mi->mi_async_req_count++; 19127c478bd9Sstevel@tonic-gate ASSERT(mi->mi_async_req_count != 0); 19137c478bd9Sstevel@tonic-gate cv_signal(&mi->mi_async_reqs_cv); 19147c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 19157c478bd9Sstevel@tonic-gate return (0); 19167c478bd9Sstevel@tonic-gate 19177c478bd9Sstevel@tonic-gate noasync: 19187c478bd9Sstevel@tonic-gate /* 19197c478bd9Sstevel@tonic-gate * If we can't do it ASYNC, for reads we do nothing (but cleanup 19207c478bd9Sstevel@tonic-gate * the page list), for writes we do it synchronously, except for 19217c478bd9Sstevel@tonic-gate * proc_pageout/proc_fsflush as described below. 19227c478bd9Sstevel@tonic-gate */ 19237c478bd9Sstevel@tonic-gate if (flags & B_READ) { 19247c478bd9Sstevel@tonic-gate pvn_read_done(pp, flags | B_ERROR); 19257c478bd9Sstevel@tonic-gate return (0); 19267c478bd9Sstevel@tonic-gate } 19277c478bd9Sstevel@tonic-gate 19287c478bd9Sstevel@tonic-gate if (curproc == proc_pageout || curproc == proc_fsflush) { 19297c478bd9Sstevel@tonic-gate /* 19307c478bd9Sstevel@tonic-gate * If we get here in the context of the pageout/fsflush, 19317c478bd9Sstevel@tonic-gate * we refuse to do a sync write, because this may hang 19327c478bd9Sstevel@tonic-gate * pageout/fsflush (and the machine). In this case, we just 19337c478bd9Sstevel@tonic-gate * re-mark the page as dirty and punt on the page. 19347c478bd9Sstevel@tonic-gate * 19357c478bd9Sstevel@tonic-gate * Make sure B_FORCE isn't set. We can re-mark the 19367c478bd9Sstevel@tonic-gate * pages as dirty and unlock the pages in one swoop by 19377c478bd9Sstevel@tonic-gate * passing in B_ERROR to pvn_write_done(). However, 19387c478bd9Sstevel@tonic-gate * we should make sure B_FORCE isn't set - we don't 19397c478bd9Sstevel@tonic-gate * want the page tossed before it gets written out. 19407c478bd9Sstevel@tonic-gate */ 19417c478bd9Sstevel@tonic-gate if (flags & B_FORCE) 19427c478bd9Sstevel@tonic-gate flags &= ~(B_INVAL | B_FORCE); 19437c478bd9Sstevel@tonic-gate pvn_write_done(pp, flags | B_ERROR); 19447c478bd9Sstevel@tonic-gate return (0); 19457c478bd9Sstevel@tonic-gate } 19467c478bd9Sstevel@tonic-gate 1947108322fbScarlsonj if (nfs_zone() != mi->mi_zone) { 19487c478bd9Sstevel@tonic-gate /* 19497c478bd9Sstevel@tonic-gate * So this was a cross-zone sync pageio. We pass in B_ERROR 19507c478bd9Sstevel@tonic-gate * to pvn_write_done() to re-mark the pages as dirty and unlock 19517c478bd9Sstevel@tonic-gate * them. 19527c478bd9Sstevel@tonic-gate * 19537c478bd9Sstevel@tonic-gate * We don't want to clear B_FORCE here as the caller presumably 19547c478bd9Sstevel@tonic-gate * knows what they're doing if they set it. 19557c478bd9Sstevel@tonic-gate */ 19567c478bd9Sstevel@tonic-gate pvn_write_done(pp, flags | B_ERROR); 19577c478bd9Sstevel@tonic-gate return (EPERM); 19587c478bd9Sstevel@tonic-gate } 19597c478bd9Sstevel@tonic-gate return ((*pageio)(vp, pp, io_off, io_len, flags, cr)); 19607c478bd9Sstevel@tonic-gate } 19617c478bd9Sstevel@tonic-gate 19627c478bd9Sstevel@tonic-gate void 19637c478bd9Sstevel@tonic-gate nfs4_async_readdir(vnode_t *vp, rddir4_cache *rdc, cred_t *cr, 1964b9238976Sth int (*readdir)(vnode_t *, rddir4_cache *, cred_t *)) 19657c478bd9Sstevel@tonic-gate { 19667c478bd9Sstevel@tonic-gate rnode4_t *rp; 19677c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 19687c478bd9Sstevel@tonic-gate struct nfs4_async_reqs *args; 19697c478bd9Sstevel@tonic-gate 19707c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 19717c478bd9Sstevel@tonic-gate ASSERT(rp->r_freef == NULL); 19727c478bd9Sstevel@tonic-gate 19737c478bd9Sstevel@tonic-gate mi = VTOMI4(vp); 19747c478bd9Sstevel@tonic-gate 19757c478bd9Sstevel@tonic-gate /* 19767c478bd9Sstevel@tonic-gate * If we can't allocate a request structure, skip the readdir. 19777c478bd9Sstevel@tonic-gate */ 19787c478bd9Sstevel@tonic-gate if ((args = kmem_alloc(sizeof (*args), KM_NOSLEEP)) == NULL) 19797c478bd9Sstevel@tonic-gate goto noasync; 19807c478bd9Sstevel@tonic-gate 19817c478bd9Sstevel@tonic-gate args->a_next = NULL; 19827c478bd9Sstevel@tonic-gate #ifdef DEBUG 19837c478bd9Sstevel@tonic-gate args->a_queuer = curthread; 19847c478bd9Sstevel@tonic-gate #endif 19857c478bd9Sstevel@tonic-gate VN_HOLD(vp); 19867c478bd9Sstevel@tonic-gate args->a_vp = vp; 19877c478bd9Sstevel@tonic-gate ASSERT(cr != NULL); 19887c478bd9Sstevel@tonic-gate crhold(cr); 19897c478bd9Sstevel@tonic-gate args->a_cred = cr; 19907c478bd9Sstevel@tonic-gate args->a_io = NFS4_READDIR; 19917c478bd9Sstevel@tonic-gate args->a_nfs4_readdir = readdir; 19927c478bd9Sstevel@tonic-gate args->a_nfs4_rdc = rdc; 19937c478bd9Sstevel@tonic-gate 19947c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 19957c478bd9Sstevel@tonic-gate 19967c478bd9Sstevel@tonic-gate /* 19977c478bd9Sstevel@tonic-gate * If asyncio has been disabled, then skip this request 19987c478bd9Sstevel@tonic-gate */ 19997c478bd9Sstevel@tonic-gate if (mi->mi_max_threads == 0) { 20007c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 20017c478bd9Sstevel@tonic-gate 20027c478bd9Sstevel@tonic-gate VN_RELE(vp); 20037c478bd9Sstevel@tonic-gate crfree(cr); 20047c478bd9Sstevel@tonic-gate kmem_free(args, sizeof (*args)); 20057c478bd9Sstevel@tonic-gate goto noasync; 20067c478bd9Sstevel@tonic-gate } 20077c478bd9Sstevel@tonic-gate 20087c478bd9Sstevel@tonic-gate /* 20097c478bd9Sstevel@tonic-gate * Link request structure into the async list and 20107c478bd9Sstevel@tonic-gate * wakeup async thread to do the i/o. 20117c478bd9Sstevel@tonic-gate */ 20127c478bd9Sstevel@tonic-gate if (mi->mi_async_reqs[NFS4_READDIR] == NULL) { 20137c478bd9Sstevel@tonic-gate mi->mi_async_reqs[NFS4_READDIR] = args; 20147c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_READDIR] = args; 20157c478bd9Sstevel@tonic-gate } else { 20167c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_READDIR]->a_next = args; 20177c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_READDIR] = args; 20187c478bd9Sstevel@tonic-gate } 20197c478bd9Sstevel@tonic-gate 20207c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 20217c478bd9Sstevel@tonic-gate rp->r_count++; 20227c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 20237c478bd9Sstevel@tonic-gate 20247c478bd9Sstevel@tonic-gate if (mi->mi_io_kstats) { 20257c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 20267c478bd9Sstevel@tonic-gate kstat_waitq_enter(KSTAT_IO_PTR(mi->mi_io_kstats)); 20277c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 20287c478bd9Sstevel@tonic-gate } 20297c478bd9Sstevel@tonic-gate 20307c478bd9Sstevel@tonic-gate mi->mi_async_req_count++; 20317c478bd9Sstevel@tonic-gate ASSERT(mi->mi_async_req_count != 0); 20327c478bd9Sstevel@tonic-gate cv_signal(&mi->mi_async_reqs_cv); 20337c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 20347c478bd9Sstevel@tonic-gate return; 20357c478bd9Sstevel@tonic-gate 20367c478bd9Sstevel@tonic-gate noasync: 20377c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 20387c478bd9Sstevel@tonic-gate rdc->entries = NULL; 20397c478bd9Sstevel@tonic-gate /* 20407c478bd9Sstevel@tonic-gate * Indicate that no one is trying to fill this entry and 20417c478bd9Sstevel@tonic-gate * it still needs to be filled. 20427c478bd9Sstevel@tonic-gate */ 20437c478bd9Sstevel@tonic-gate rdc->flags &= ~RDDIR; 20447c478bd9Sstevel@tonic-gate rdc->flags |= RDDIRREQ; 20457c478bd9Sstevel@tonic-gate rddir4_cache_rele(rp, rdc); 20467c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 20477c478bd9Sstevel@tonic-gate } 20487c478bd9Sstevel@tonic-gate 20497c478bd9Sstevel@tonic-gate void 20507c478bd9Sstevel@tonic-gate nfs4_async_commit(vnode_t *vp, page_t *plist, offset3 offset, count3 count, 2051b9238976Sth cred_t *cr, void (*commit)(vnode_t *, page_t *, offset3, count3, 2052b9238976Sth cred_t *)) 20537c478bd9Sstevel@tonic-gate { 20547c478bd9Sstevel@tonic-gate rnode4_t *rp; 20557c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 20567c478bd9Sstevel@tonic-gate struct nfs4_async_reqs *args; 20577c478bd9Sstevel@tonic-gate page_t *pp; 20587c478bd9Sstevel@tonic-gate 20597c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 20607c478bd9Sstevel@tonic-gate mi = VTOMI4(vp); 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate /* 20637c478bd9Sstevel@tonic-gate * If we can't allocate a request structure, do the commit 20647c478bd9Sstevel@tonic-gate * operation synchronously in this thread's context. 20657c478bd9Sstevel@tonic-gate */ 20667c478bd9Sstevel@tonic-gate if ((args = kmem_alloc(sizeof (*args), KM_NOSLEEP)) == NULL) 20677c478bd9Sstevel@tonic-gate goto noasync; 20687c478bd9Sstevel@tonic-gate 20697c478bd9Sstevel@tonic-gate args->a_next = NULL; 20707c478bd9Sstevel@tonic-gate #ifdef DEBUG 20717c478bd9Sstevel@tonic-gate args->a_queuer = curthread; 20727c478bd9Sstevel@tonic-gate #endif 20737c478bd9Sstevel@tonic-gate VN_HOLD(vp); 20747c478bd9Sstevel@tonic-gate args->a_vp = vp; 20757c478bd9Sstevel@tonic-gate ASSERT(cr != NULL); 20767c478bd9Sstevel@tonic-gate crhold(cr); 20777c478bd9Sstevel@tonic-gate args->a_cred = cr; 20787c478bd9Sstevel@tonic-gate args->a_io = NFS4_COMMIT; 20797c478bd9Sstevel@tonic-gate args->a_nfs4_commit = commit; 20807c478bd9Sstevel@tonic-gate args->a_nfs4_plist = plist; 20817c478bd9Sstevel@tonic-gate args->a_nfs4_offset = offset; 20827c478bd9Sstevel@tonic-gate args->a_nfs4_count = count; 20837c478bd9Sstevel@tonic-gate 20847c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 20857c478bd9Sstevel@tonic-gate 20867c478bd9Sstevel@tonic-gate /* 20877c478bd9Sstevel@tonic-gate * If asyncio has been disabled, then make a synchronous request. 20887c478bd9Sstevel@tonic-gate * This check is done a second time in case async io was diabled 20897c478bd9Sstevel@tonic-gate * while this thread was blocked waiting for memory pressure to 20907c478bd9Sstevel@tonic-gate * reduce or for the queue to drain. 20917c478bd9Sstevel@tonic-gate */ 20927c478bd9Sstevel@tonic-gate if (mi->mi_max_threads == 0) { 20937c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 20947c478bd9Sstevel@tonic-gate 20957c478bd9Sstevel@tonic-gate VN_RELE(vp); 20967c478bd9Sstevel@tonic-gate crfree(cr); 20977c478bd9Sstevel@tonic-gate kmem_free(args, sizeof (*args)); 20987c478bd9Sstevel@tonic-gate goto noasync; 20997c478bd9Sstevel@tonic-gate } 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate /* 21027c478bd9Sstevel@tonic-gate * Link request structure into the async list and 21037c478bd9Sstevel@tonic-gate * wakeup async thread to do the i/o. 21047c478bd9Sstevel@tonic-gate */ 21057c478bd9Sstevel@tonic-gate if (mi->mi_async_reqs[NFS4_COMMIT] == NULL) { 21067c478bd9Sstevel@tonic-gate mi->mi_async_reqs[NFS4_COMMIT] = args; 21077c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_COMMIT] = args; 21087c478bd9Sstevel@tonic-gate } else { 21097c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_COMMIT]->a_next = args; 21107c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_COMMIT] = args; 21117c478bd9Sstevel@tonic-gate } 21127c478bd9Sstevel@tonic-gate 21137c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 21147c478bd9Sstevel@tonic-gate rp->r_count++; 21157c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 21167c478bd9Sstevel@tonic-gate 21177c478bd9Sstevel@tonic-gate if (mi->mi_io_kstats) { 21187c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 21197c478bd9Sstevel@tonic-gate kstat_waitq_enter(KSTAT_IO_PTR(mi->mi_io_kstats)); 21207c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 21217c478bd9Sstevel@tonic-gate } 21227c478bd9Sstevel@tonic-gate 21237c478bd9Sstevel@tonic-gate mi->mi_async_req_count++; 21247c478bd9Sstevel@tonic-gate ASSERT(mi->mi_async_req_count != 0); 21257c478bd9Sstevel@tonic-gate cv_signal(&mi->mi_async_reqs_cv); 21267c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 21277c478bd9Sstevel@tonic-gate return; 21287c478bd9Sstevel@tonic-gate 21297c478bd9Sstevel@tonic-gate noasync: 21307c478bd9Sstevel@tonic-gate if (curproc == proc_pageout || curproc == proc_fsflush || 2131108322fbScarlsonj nfs_zone() != mi->mi_zone) { 21327c478bd9Sstevel@tonic-gate while (plist != NULL) { 21337c478bd9Sstevel@tonic-gate pp = plist; 21347c478bd9Sstevel@tonic-gate page_sub(&plist, pp); 21357c478bd9Sstevel@tonic-gate pp->p_fsdata = C_COMMIT; 21367c478bd9Sstevel@tonic-gate page_unlock(pp); 21377c478bd9Sstevel@tonic-gate } 21387c478bd9Sstevel@tonic-gate return; 21397c478bd9Sstevel@tonic-gate } 21407c478bd9Sstevel@tonic-gate (*commit)(vp, plist, offset, count, cr); 21417c478bd9Sstevel@tonic-gate } 21427c478bd9Sstevel@tonic-gate 21437c478bd9Sstevel@tonic-gate /* 21447c478bd9Sstevel@tonic-gate * nfs4_async_inactive - hand off a VOP_INACTIVE call to a thread. The 21457c478bd9Sstevel@tonic-gate * reference to the vnode is handed over to the thread; the caller should 21467c478bd9Sstevel@tonic-gate * no longer refer to the vnode. 21477c478bd9Sstevel@tonic-gate * 21487c478bd9Sstevel@tonic-gate * Unlike most of the async routines, this handoff is needed for 21497c478bd9Sstevel@tonic-gate * correctness reasons, not just performance. So doing operations in the 21507c478bd9Sstevel@tonic-gate * context of the current thread is not an option. 21517c478bd9Sstevel@tonic-gate */ 21527c478bd9Sstevel@tonic-gate void 21537c478bd9Sstevel@tonic-gate nfs4_async_inactive(vnode_t *vp, cred_t *cr) 21547c478bd9Sstevel@tonic-gate { 21557c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 21567c478bd9Sstevel@tonic-gate struct nfs4_async_reqs *args; 21577c478bd9Sstevel@tonic-gate boolean_t signal_inactive_thread = B_FALSE; 21587c478bd9Sstevel@tonic-gate 21597c478bd9Sstevel@tonic-gate mi = VTOMI4(vp); 21607c478bd9Sstevel@tonic-gate 21617c478bd9Sstevel@tonic-gate args = kmem_alloc(sizeof (*args), KM_SLEEP); 21627c478bd9Sstevel@tonic-gate args->a_next = NULL; 21637c478bd9Sstevel@tonic-gate #ifdef DEBUG 21647c478bd9Sstevel@tonic-gate args->a_queuer = curthread; 21657c478bd9Sstevel@tonic-gate #endif 21667c478bd9Sstevel@tonic-gate args->a_vp = vp; 21677c478bd9Sstevel@tonic-gate ASSERT(cr != NULL); 21687c478bd9Sstevel@tonic-gate crhold(cr); 21697c478bd9Sstevel@tonic-gate args->a_cred = cr; 21707c478bd9Sstevel@tonic-gate args->a_io = NFS4_INACTIVE; 21717c478bd9Sstevel@tonic-gate 21727c478bd9Sstevel@tonic-gate /* 21737c478bd9Sstevel@tonic-gate * Note that we don't check mi->mi_max_threads here, since we 21747c478bd9Sstevel@tonic-gate * *need* to get rid of this vnode regardless of whether someone 21757c478bd9Sstevel@tonic-gate * set nfs4_max_threads to zero in /etc/system. 21767c478bd9Sstevel@tonic-gate * 21777c478bd9Sstevel@tonic-gate * The manager thread knows about this and is willing to create 2178da6c28aaSamw * at least one thread to accommodate us. 21797c478bd9Sstevel@tonic-gate */ 21807c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 21817c478bd9Sstevel@tonic-gate if (mi->mi_inactive_thread == NULL) { 21827c478bd9Sstevel@tonic-gate rnode4_t *rp; 21837c478bd9Sstevel@tonic-gate vnode_t *unldvp = NULL; 21847c478bd9Sstevel@tonic-gate char *unlname; 21857c478bd9Sstevel@tonic-gate cred_t *unlcred; 21867c478bd9Sstevel@tonic-gate 21877c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 21887c478bd9Sstevel@tonic-gate /* 21897c478bd9Sstevel@tonic-gate * We just need to free up the memory associated with the 21907c478bd9Sstevel@tonic-gate * vnode, which can be safely done from within the current 21917c478bd9Sstevel@tonic-gate * context. 21927c478bd9Sstevel@tonic-gate */ 21937c478bd9Sstevel@tonic-gate crfree(cr); /* drop our reference */ 21947c478bd9Sstevel@tonic-gate kmem_free(args, sizeof (*args)); 21957c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 21967c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 21977c478bd9Sstevel@tonic-gate if (rp->r_unldvp != NULL) { 21987c478bd9Sstevel@tonic-gate unldvp = rp->r_unldvp; 21997c478bd9Sstevel@tonic-gate rp->r_unldvp = NULL; 22007c478bd9Sstevel@tonic-gate unlname = rp->r_unlname; 22017c478bd9Sstevel@tonic-gate rp->r_unlname = NULL; 22027c478bd9Sstevel@tonic-gate unlcred = rp->r_unlcred; 22037c478bd9Sstevel@tonic-gate rp->r_unlcred = NULL; 22047c478bd9Sstevel@tonic-gate } 22057c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 22067c478bd9Sstevel@tonic-gate /* 22077c478bd9Sstevel@tonic-gate * No need to explicitly throw away any cached pages. The 22087c478bd9Sstevel@tonic-gate * eventual r4inactive() will attempt a synchronous 22097c478bd9Sstevel@tonic-gate * VOP_PUTPAGE() which will immediately fail since the request 22107c478bd9Sstevel@tonic-gate * is coming from the wrong zone, and then will proceed to call 22117c478bd9Sstevel@tonic-gate * nfs4_invalidate_pages() which will clean things up for us. 22127c478bd9Sstevel@tonic-gate * 22137c478bd9Sstevel@tonic-gate * Throw away the delegation here so rp4_addfree()'s attempt to 22147c478bd9Sstevel@tonic-gate * return any existing delegations becomes a no-op. 22157c478bd9Sstevel@tonic-gate */ 221650a83466Sjwahlig if (rp->r_deleg_type != OPEN_DELEGATE_NONE) { 221750a83466Sjwahlig (void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, 2218b9238976Sth FALSE); 22197c478bd9Sstevel@tonic-gate (void) nfs4delegreturn(rp, NFS4_DR_DISCARD); 222050a83466Sjwahlig nfs_rw_exit(&mi->mi_recovlock); 222150a83466Sjwahlig } 22227c478bd9Sstevel@tonic-gate nfs4_clear_open_streams(rp); 22237c478bd9Sstevel@tonic-gate 22247c478bd9Sstevel@tonic-gate rp4_addfree(rp, cr); 22257c478bd9Sstevel@tonic-gate if (unldvp != NULL) { 22267c478bd9Sstevel@tonic-gate kmem_free(unlname, MAXNAMELEN); 22277c478bd9Sstevel@tonic-gate VN_RELE(unldvp); 22287c478bd9Sstevel@tonic-gate crfree(unlcred); 22297c478bd9Sstevel@tonic-gate } 22307c478bd9Sstevel@tonic-gate return; 22317c478bd9Sstevel@tonic-gate } 22327c478bd9Sstevel@tonic-gate 22337c478bd9Sstevel@tonic-gate if (mi->mi_manager_thread == NULL) { 22347c478bd9Sstevel@tonic-gate /* 22357c478bd9Sstevel@tonic-gate * We want to talk to the inactive thread. 22367c478bd9Sstevel@tonic-gate */ 22377c478bd9Sstevel@tonic-gate signal_inactive_thread = B_TRUE; 22387c478bd9Sstevel@tonic-gate } 22397c478bd9Sstevel@tonic-gate 22407c478bd9Sstevel@tonic-gate /* 22417c478bd9Sstevel@tonic-gate * Enqueue the vnode and wake up either the special thread (empty 22427c478bd9Sstevel@tonic-gate * list) or an async thread. 22437c478bd9Sstevel@tonic-gate */ 22447c478bd9Sstevel@tonic-gate if (mi->mi_async_reqs[NFS4_INACTIVE] == NULL) { 22457c478bd9Sstevel@tonic-gate mi->mi_async_reqs[NFS4_INACTIVE] = args; 22467c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_INACTIVE] = args; 22477c478bd9Sstevel@tonic-gate signal_inactive_thread = B_TRUE; 22487c478bd9Sstevel@tonic-gate } else { 22497c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_INACTIVE]->a_next = args; 22507c478bd9Sstevel@tonic-gate mi->mi_async_tail[NFS4_INACTIVE] = args; 22517c478bd9Sstevel@tonic-gate } 22527c478bd9Sstevel@tonic-gate if (signal_inactive_thread) { 22537c478bd9Sstevel@tonic-gate cv_signal(&mi->mi_inact_req_cv); 22547c478bd9Sstevel@tonic-gate } else { 22557c478bd9Sstevel@tonic-gate mi->mi_async_req_count++; 22567c478bd9Sstevel@tonic-gate ASSERT(mi->mi_async_req_count != 0); 22577c478bd9Sstevel@tonic-gate cv_signal(&mi->mi_async_reqs_cv); 22587c478bd9Sstevel@tonic-gate } 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_async_lock); 22617c478bd9Sstevel@tonic-gate } 22627c478bd9Sstevel@tonic-gate 22637c478bd9Sstevel@tonic-gate int 22647c478bd9Sstevel@tonic-gate writerp4(rnode4_t *rp, caddr_t base, int tcount, struct uio *uio, int pgcreated) 22657c478bd9Sstevel@tonic-gate { 22667c478bd9Sstevel@tonic-gate int pagecreate; 22677c478bd9Sstevel@tonic-gate int n; 22687c478bd9Sstevel@tonic-gate int saved_n; 22697c478bd9Sstevel@tonic-gate caddr_t saved_base; 22707c478bd9Sstevel@tonic-gate u_offset_t offset; 22717c478bd9Sstevel@tonic-gate int error; 22727c478bd9Sstevel@tonic-gate int sm_error; 2273a5652762Spraks vnode_t *vp = RTOV(rp); 22747c478bd9Sstevel@tonic-gate 22757c478bd9Sstevel@tonic-gate ASSERT(tcount <= MAXBSIZE && tcount <= uio->uio_resid); 22767c478bd9Sstevel@tonic-gate ASSERT(nfs_rw_lock_held(&rp->r_rwlock, RW_WRITER)); 2277a5652762Spraks if (!vpm_enable) { 2278a5652762Spraks ASSERT(((uintptr_t)base & MAXBOFFSET) + tcount <= MAXBSIZE); 2279a5652762Spraks } 22807c478bd9Sstevel@tonic-gate 22817c478bd9Sstevel@tonic-gate /* 22827c478bd9Sstevel@tonic-gate * Move bytes in at most PAGESIZE chunks. We must avoid 22837c478bd9Sstevel@tonic-gate * spanning pages in uiomove() because page faults may cause 22847c478bd9Sstevel@tonic-gate * the cache to be invalidated out from under us. The r_size is not 22857c478bd9Sstevel@tonic-gate * updated until after the uiomove. If we push the last page of a 22867c478bd9Sstevel@tonic-gate * file before r_size is correct, we will lose the data written past 22877c478bd9Sstevel@tonic-gate * the current (and invalid) r_size. 22887c478bd9Sstevel@tonic-gate */ 22897c478bd9Sstevel@tonic-gate do { 22907c478bd9Sstevel@tonic-gate offset = uio->uio_loffset; 22917c478bd9Sstevel@tonic-gate pagecreate = 0; 22927c478bd9Sstevel@tonic-gate 22937c478bd9Sstevel@tonic-gate /* 22947c478bd9Sstevel@tonic-gate * n is the number of bytes required to satisfy the request 22957c478bd9Sstevel@tonic-gate * or the number of bytes to fill out the page. 22967c478bd9Sstevel@tonic-gate */ 2297a5652762Spraks n = (int)MIN((PAGESIZE - (offset & PAGEOFFSET)), tcount); 22987c478bd9Sstevel@tonic-gate 22997c478bd9Sstevel@tonic-gate /* 23007c478bd9Sstevel@tonic-gate * Check to see if we can skip reading in the page 23017c478bd9Sstevel@tonic-gate * and just allocate the memory. We can do this 23027c478bd9Sstevel@tonic-gate * if we are going to rewrite the entire mapping 23037c478bd9Sstevel@tonic-gate * or if we are going to write to or beyond the current 23047c478bd9Sstevel@tonic-gate * end of file from the beginning of the mapping. 23057c478bd9Sstevel@tonic-gate * 23067c478bd9Sstevel@tonic-gate * The read of r_size is now protected by r_statelock. 23077c478bd9Sstevel@tonic-gate */ 23087c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 23097c478bd9Sstevel@tonic-gate /* 23107c478bd9Sstevel@tonic-gate * When pgcreated is nonzero the caller has already done 23117c478bd9Sstevel@tonic-gate * a segmap_getmapflt with forcefault 0 and S_WRITE. With 23127c478bd9Sstevel@tonic-gate * segkpm this means we already have at least one page 23137c478bd9Sstevel@tonic-gate * created and mapped at base. 23147c478bd9Sstevel@tonic-gate */ 23157c478bd9Sstevel@tonic-gate pagecreate = pgcreated || 2316b9238976Sth ((offset & PAGEOFFSET) == 0 && 2317b9238976Sth (n == PAGESIZE || ((offset + n) >= rp->r_size))); 23187c478bd9Sstevel@tonic-gate 23197c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 23207c478bd9Sstevel@tonic-gate 2321a5652762Spraks if (!vpm_enable && pagecreate) { 23227c478bd9Sstevel@tonic-gate /* 23237c478bd9Sstevel@tonic-gate * The last argument tells segmap_pagecreate() to 23247c478bd9Sstevel@tonic-gate * always lock the page, as opposed to sometimes 23257c478bd9Sstevel@tonic-gate * returning with the page locked. This way we avoid a 23267c478bd9Sstevel@tonic-gate * fault on the ensuing uiomove(), but also 23277c478bd9Sstevel@tonic-gate * more importantly (to fix bug 1094402) we can 23287c478bd9Sstevel@tonic-gate * call segmap_fault() to unlock the page in all 23297c478bd9Sstevel@tonic-gate * cases. An alternative would be to modify 23307c478bd9Sstevel@tonic-gate * segmap_pagecreate() to tell us when it is 23317c478bd9Sstevel@tonic-gate * locking a page, but that's a fairly major 23327c478bd9Sstevel@tonic-gate * interface change. 23337c478bd9Sstevel@tonic-gate */ 23347c478bd9Sstevel@tonic-gate if (pgcreated == 0) 23357c478bd9Sstevel@tonic-gate (void) segmap_pagecreate(segkmap, base, 2336b9238976Sth (uint_t)n, 1); 23377c478bd9Sstevel@tonic-gate saved_base = base; 23387c478bd9Sstevel@tonic-gate saved_n = n; 23397c478bd9Sstevel@tonic-gate } 23407c478bd9Sstevel@tonic-gate 23417c478bd9Sstevel@tonic-gate /* 23427c478bd9Sstevel@tonic-gate * The number of bytes of data in the last page can not 23437c478bd9Sstevel@tonic-gate * be accurately be determined while page is being 23447c478bd9Sstevel@tonic-gate * uiomove'd to and the size of the file being updated. 23457c478bd9Sstevel@tonic-gate * Thus, inform threads which need to know accurately 23467c478bd9Sstevel@tonic-gate * how much data is in the last page of the file. They 23477c478bd9Sstevel@tonic-gate * will not do the i/o immediately, but will arrange for 23487c478bd9Sstevel@tonic-gate * the i/o to happen later when this modify operation 23497c478bd9Sstevel@tonic-gate * will have finished. 23507c478bd9Sstevel@tonic-gate */ 23517c478bd9Sstevel@tonic-gate ASSERT(!(rp->r_flags & R4MODINPROGRESS)); 23527c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 23537c478bd9Sstevel@tonic-gate rp->r_flags |= R4MODINPROGRESS; 23547c478bd9Sstevel@tonic-gate rp->r_modaddr = (offset & MAXBMASK); 23557c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 23567c478bd9Sstevel@tonic-gate 2357a5652762Spraks if (vpm_enable) { 2358a5652762Spraks /* 2359a5652762Spraks * Copy data. If new pages are created, part of 2360a5652762Spraks * the page that is not written will be initizliazed 2361a5652762Spraks * with zeros. 2362a5652762Spraks */ 2363a5652762Spraks error = vpm_data_copy(vp, offset, n, uio, 2364b9238976Sth !pagecreate, NULL, 0, S_WRITE); 2365a5652762Spraks } else { 2366a5652762Spraks error = uiomove(base, n, UIO_WRITE, uio); 2367a5652762Spraks } 23687c478bd9Sstevel@tonic-gate 23697c478bd9Sstevel@tonic-gate /* 23707c478bd9Sstevel@tonic-gate * r_size is the maximum number of 23717c478bd9Sstevel@tonic-gate * bytes known to be in the file. 23727c478bd9Sstevel@tonic-gate * Make sure it is at least as high as the 23737c478bd9Sstevel@tonic-gate * first unwritten byte pointed to by uio_loffset. 23747c478bd9Sstevel@tonic-gate */ 23757c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 23767c478bd9Sstevel@tonic-gate if (rp->r_size < uio->uio_loffset) 23777c478bd9Sstevel@tonic-gate rp->r_size = uio->uio_loffset; 23787c478bd9Sstevel@tonic-gate rp->r_flags &= ~R4MODINPROGRESS; 23797c478bd9Sstevel@tonic-gate rp->r_flags |= R4DIRTY; 23807c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 23817c478bd9Sstevel@tonic-gate 23827c478bd9Sstevel@tonic-gate /* n = # of bytes written */ 23837c478bd9Sstevel@tonic-gate n = (int)(uio->uio_loffset - offset); 2384a5652762Spraks 2385a5652762Spraks if (!vpm_enable) { 2386a5652762Spraks base += n; 2387a5652762Spraks } 2388a5652762Spraks 23897c478bd9Sstevel@tonic-gate tcount -= n; 23907c478bd9Sstevel@tonic-gate /* 23917c478bd9Sstevel@tonic-gate * If we created pages w/o initializing them completely, 23927c478bd9Sstevel@tonic-gate * we need to zero the part that wasn't set up. 23937c478bd9Sstevel@tonic-gate * This happens on a most EOF write cases and if 23947c478bd9Sstevel@tonic-gate * we had some sort of error during the uiomove. 23957c478bd9Sstevel@tonic-gate */ 2396a5652762Spraks if (!vpm_enable && pagecreate) { 23977c478bd9Sstevel@tonic-gate if ((uio->uio_loffset & PAGEOFFSET) || n == 0) 23987c478bd9Sstevel@tonic-gate (void) kzero(base, PAGESIZE - n); 23997c478bd9Sstevel@tonic-gate 24007c478bd9Sstevel@tonic-gate if (pgcreated) { 24017c478bd9Sstevel@tonic-gate /* 24027c478bd9Sstevel@tonic-gate * Caller is responsible for this page, 24037c478bd9Sstevel@tonic-gate * it was not created in this loop. 24047c478bd9Sstevel@tonic-gate */ 24057c478bd9Sstevel@tonic-gate pgcreated = 0; 24067c478bd9Sstevel@tonic-gate } else { 24077c478bd9Sstevel@tonic-gate /* 24087c478bd9Sstevel@tonic-gate * For bug 1094402: segmap_pagecreate locks 24097c478bd9Sstevel@tonic-gate * page. Unlock it. This also unlocks the 24107c478bd9Sstevel@tonic-gate * pages allocated by page_create_va() in 24117c478bd9Sstevel@tonic-gate * segmap_pagecreate(). 24127c478bd9Sstevel@tonic-gate */ 24137c478bd9Sstevel@tonic-gate sm_error = segmap_fault(kas.a_hat, segkmap, 2414b9238976Sth saved_base, saved_n, 2415b9238976Sth F_SOFTUNLOCK, S_WRITE); 24167c478bd9Sstevel@tonic-gate if (error == 0) 24177c478bd9Sstevel@tonic-gate error = sm_error; 24187c478bd9Sstevel@tonic-gate } 24197c478bd9Sstevel@tonic-gate } 24207c478bd9Sstevel@tonic-gate } while (tcount > 0 && error == 0); 24217c478bd9Sstevel@tonic-gate 24227c478bd9Sstevel@tonic-gate return (error); 24237c478bd9Sstevel@tonic-gate } 24247c478bd9Sstevel@tonic-gate 24257c478bd9Sstevel@tonic-gate int 24267c478bd9Sstevel@tonic-gate nfs4_putpages(vnode_t *vp, u_offset_t off, size_t len, int flags, cred_t *cr) 24277c478bd9Sstevel@tonic-gate { 24287c478bd9Sstevel@tonic-gate rnode4_t *rp; 24297c478bd9Sstevel@tonic-gate page_t *pp; 24307c478bd9Sstevel@tonic-gate u_offset_t eoff; 24317c478bd9Sstevel@tonic-gate u_offset_t io_off; 24327c478bd9Sstevel@tonic-gate size_t io_len; 24337c478bd9Sstevel@tonic-gate int error; 24347c478bd9Sstevel@tonic-gate int rdirty; 24357c478bd9Sstevel@tonic-gate int err; 24367c478bd9Sstevel@tonic-gate 24377c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 24387c478bd9Sstevel@tonic-gate ASSERT(rp->r_count > 0); 24397c478bd9Sstevel@tonic-gate 24407c478bd9Sstevel@tonic-gate if (!nfs4_has_pages(vp)) 24417c478bd9Sstevel@tonic-gate return (0); 24427c478bd9Sstevel@tonic-gate 24437c478bd9Sstevel@tonic-gate ASSERT(vp->v_type != VCHR); 24447c478bd9Sstevel@tonic-gate 24457c478bd9Sstevel@tonic-gate /* 24467c478bd9Sstevel@tonic-gate * If R4OUTOFSPACE is set, then all writes turn into B_INVAL 24477c478bd9Sstevel@tonic-gate * writes. B_FORCE is set to force the VM system to actually 24487c478bd9Sstevel@tonic-gate * invalidate the pages, even if the i/o failed. The pages 24497c478bd9Sstevel@tonic-gate * need to get invalidated because they can't be written out 24507c478bd9Sstevel@tonic-gate * because there isn't any space left on either the server's 24517c478bd9Sstevel@tonic-gate * file system or in the user's disk quota. The B_FREE bit 24527c478bd9Sstevel@tonic-gate * is cleared to avoid confusion as to whether this is a 24537c478bd9Sstevel@tonic-gate * request to place the page on the freelist or to destroy 24547c478bd9Sstevel@tonic-gate * it. 24557c478bd9Sstevel@tonic-gate */ 24567c478bd9Sstevel@tonic-gate if ((rp->r_flags & R4OUTOFSPACE) || 24577c478bd9Sstevel@tonic-gate (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED)) 24587c478bd9Sstevel@tonic-gate flags = (flags & ~B_FREE) | B_INVAL | B_FORCE; 24597c478bd9Sstevel@tonic-gate 24607c478bd9Sstevel@tonic-gate if (len == 0) { 24617c478bd9Sstevel@tonic-gate /* 24627c478bd9Sstevel@tonic-gate * If doing a full file synchronous operation, then clear 24637c478bd9Sstevel@tonic-gate * the R4DIRTY bit. If a page gets dirtied while the flush 24647c478bd9Sstevel@tonic-gate * is happening, then R4DIRTY will get set again. The 24657c478bd9Sstevel@tonic-gate * R4DIRTY bit must get cleared before the flush so that 24667c478bd9Sstevel@tonic-gate * we don't lose this information. 246784d68d8eSthurlow * 246884d68d8eSthurlow * If there are no full file async write operations 246984d68d8eSthurlow * pending and RDIRTY bit is set, clear it. 24707c478bd9Sstevel@tonic-gate */ 24717c478bd9Sstevel@tonic-gate if (off == (u_offset_t)0 && 24727c478bd9Sstevel@tonic-gate !(flags & B_ASYNC) && 24737c478bd9Sstevel@tonic-gate (rp->r_flags & R4DIRTY)) { 24747c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 24757c478bd9Sstevel@tonic-gate rdirty = (rp->r_flags & R4DIRTY); 24767c478bd9Sstevel@tonic-gate rp->r_flags &= ~R4DIRTY; 24777c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 247884d68d8eSthurlow } else if (flags & B_ASYNC && off == (u_offset_t)0) { 247984d68d8eSthurlow mutex_enter(&rp->r_statelock); 248084d68d8eSthurlow if (rp->r_flags & R4DIRTY && rp->r_awcount == 0) { 248184d68d8eSthurlow rdirty = (rp->r_flags & R4DIRTY); 248284d68d8eSthurlow rp->r_flags &= ~R4DIRTY; 248384d68d8eSthurlow } 248484d68d8eSthurlow mutex_exit(&rp->r_statelock); 24857c478bd9Sstevel@tonic-gate } else 24867c478bd9Sstevel@tonic-gate rdirty = 0; 24877c478bd9Sstevel@tonic-gate 24887c478bd9Sstevel@tonic-gate /* 24897c478bd9Sstevel@tonic-gate * Search the entire vp list for pages >= off, and flush 24907c478bd9Sstevel@tonic-gate * the dirty pages. 24917c478bd9Sstevel@tonic-gate */ 24927c478bd9Sstevel@tonic-gate error = pvn_vplist_dirty(vp, off, rp->r_putapage, 2493b9238976Sth flags, cr); 24947c478bd9Sstevel@tonic-gate 24957c478bd9Sstevel@tonic-gate /* 2496da6c28aaSamw * If an error occurred and the file was marked as dirty 24977c478bd9Sstevel@tonic-gate * before and we aren't forcibly invalidating pages, then 24987c478bd9Sstevel@tonic-gate * reset the R4DIRTY flag. 24997c478bd9Sstevel@tonic-gate */ 25007c478bd9Sstevel@tonic-gate if (error && rdirty && 25017c478bd9Sstevel@tonic-gate (flags & (B_INVAL | B_FORCE)) != (B_INVAL | B_FORCE)) { 25027c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 25037c478bd9Sstevel@tonic-gate rp->r_flags |= R4DIRTY; 25047c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 25057c478bd9Sstevel@tonic-gate } 25067c478bd9Sstevel@tonic-gate } else { 25077c478bd9Sstevel@tonic-gate /* 25087c478bd9Sstevel@tonic-gate * Do a range from [off...off + len) looking for pages 25097c478bd9Sstevel@tonic-gate * to deal with. 25107c478bd9Sstevel@tonic-gate */ 25117c478bd9Sstevel@tonic-gate error = 0; 25127c478bd9Sstevel@tonic-gate io_len = 0; 25137c478bd9Sstevel@tonic-gate eoff = off + len; 25147c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 25157c478bd9Sstevel@tonic-gate for (io_off = off; io_off < eoff && io_off < rp->r_size; 25167c478bd9Sstevel@tonic-gate io_off += io_len) { 25177c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 25187c478bd9Sstevel@tonic-gate /* 25197c478bd9Sstevel@tonic-gate * If we are not invalidating, synchronously 25207c478bd9Sstevel@tonic-gate * freeing or writing pages use the routine 25217c478bd9Sstevel@tonic-gate * page_lookup_nowait() to prevent reclaiming 25227c478bd9Sstevel@tonic-gate * them from the free list. 25237c478bd9Sstevel@tonic-gate */ 25247c478bd9Sstevel@tonic-gate if ((flags & B_INVAL) || !(flags & B_ASYNC)) { 25257c478bd9Sstevel@tonic-gate pp = page_lookup(vp, io_off, 25267c478bd9Sstevel@tonic-gate (flags & (B_INVAL | B_FREE)) ? 25277c478bd9Sstevel@tonic-gate SE_EXCL : SE_SHARED); 25287c478bd9Sstevel@tonic-gate } else { 25297c478bd9Sstevel@tonic-gate pp = page_lookup_nowait(vp, io_off, 25307c478bd9Sstevel@tonic-gate (flags & B_FREE) ? SE_EXCL : SE_SHARED); 25317c478bd9Sstevel@tonic-gate } 25327c478bd9Sstevel@tonic-gate 25337c478bd9Sstevel@tonic-gate if (pp == NULL || !pvn_getdirty(pp, flags)) 25347c478bd9Sstevel@tonic-gate io_len = PAGESIZE; 25357c478bd9Sstevel@tonic-gate else { 25367c478bd9Sstevel@tonic-gate err = (*rp->r_putapage)(vp, pp, &io_off, 25377c478bd9Sstevel@tonic-gate &io_len, flags, cr); 25387c478bd9Sstevel@tonic-gate if (!error) 25397c478bd9Sstevel@tonic-gate error = err; 25407c478bd9Sstevel@tonic-gate /* 25417c478bd9Sstevel@tonic-gate * "io_off" and "io_len" are returned as 25427c478bd9Sstevel@tonic-gate * the range of pages we actually wrote. 25437c478bd9Sstevel@tonic-gate * This allows us to skip ahead more quickly 25447c478bd9Sstevel@tonic-gate * since several pages may've been dealt 25457c478bd9Sstevel@tonic-gate * with by this iteration of the loop. 25467c478bd9Sstevel@tonic-gate */ 25477c478bd9Sstevel@tonic-gate } 25487c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 25497c478bd9Sstevel@tonic-gate } 25507c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 25517c478bd9Sstevel@tonic-gate } 25527c478bd9Sstevel@tonic-gate 25537c478bd9Sstevel@tonic-gate return (error); 25547c478bd9Sstevel@tonic-gate } 25557c478bd9Sstevel@tonic-gate 25567c478bd9Sstevel@tonic-gate void 25577c478bd9Sstevel@tonic-gate nfs4_invalidate_pages(vnode_t *vp, u_offset_t off, cred_t *cr) 25587c478bd9Sstevel@tonic-gate { 25597c478bd9Sstevel@tonic-gate rnode4_t *rp; 25607c478bd9Sstevel@tonic-gate 25617c478bd9Sstevel@tonic-gate rp = VTOR4(vp); 25627c478bd9Sstevel@tonic-gate if (IS_SHADOW(vp, rp)) 25637c478bd9Sstevel@tonic-gate vp = RTOV4(rp); 25647c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 25657c478bd9Sstevel@tonic-gate while (rp->r_flags & R4TRUNCATE) 25667c478bd9Sstevel@tonic-gate cv_wait(&rp->r_cv, &rp->r_statelock); 25677c478bd9Sstevel@tonic-gate rp->r_flags |= R4TRUNCATE; 25687c478bd9Sstevel@tonic-gate if (off == (u_offset_t)0) { 25697c478bd9Sstevel@tonic-gate rp->r_flags &= ~R4DIRTY; 25707c478bd9Sstevel@tonic-gate if (!(rp->r_flags & R4STALE)) 25717c478bd9Sstevel@tonic-gate rp->r_error = 0; 25727c478bd9Sstevel@tonic-gate } 25737c478bd9Sstevel@tonic-gate rp->r_truncaddr = off; 25747c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 25757c478bd9Sstevel@tonic-gate (void) pvn_vplist_dirty(vp, off, rp->r_putapage, 2576b9238976Sth B_INVAL | B_TRUNC, cr); 25777c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 25787c478bd9Sstevel@tonic-gate rp->r_flags &= ~R4TRUNCATE; 25797c478bd9Sstevel@tonic-gate cv_broadcast(&rp->r_cv); 25807c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 25817c478bd9Sstevel@tonic-gate } 25827c478bd9Sstevel@tonic-gate 25837c478bd9Sstevel@tonic-gate static int 25847c478bd9Sstevel@tonic-gate nfs4_mnt_kstat_update(kstat_t *ksp, int rw) 25857c478bd9Sstevel@tonic-gate { 25867c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 25877c478bd9Sstevel@tonic-gate struct mntinfo_kstat *mik; 25887c478bd9Sstevel@tonic-gate vfs_t *vfsp; 25897c478bd9Sstevel@tonic-gate 25907c478bd9Sstevel@tonic-gate /* this is a read-only kstat. Bail out on a write */ 25917c478bd9Sstevel@tonic-gate if (rw == KSTAT_WRITE) 25927c478bd9Sstevel@tonic-gate return (EACCES); 25937c478bd9Sstevel@tonic-gate 25947c478bd9Sstevel@tonic-gate 25957c478bd9Sstevel@tonic-gate /* 25967c478bd9Sstevel@tonic-gate * We don't want to wait here as kstat_chain_lock could be held by 25977c478bd9Sstevel@tonic-gate * dounmount(). dounmount() takes vfs_reflock before the chain lock 25987c478bd9Sstevel@tonic-gate * and thus could lead to a deadlock. 25997c478bd9Sstevel@tonic-gate */ 26007c478bd9Sstevel@tonic-gate vfsp = (struct vfs *)ksp->ks_private; 26017c478bd9Sstevel@tonic-gate 26027c478bd9Sstevel@tonic-gate mi = VFTOMI4(vfsp); 26037c478bd9Sstevel@tonic-gate mik = (struct mntinfo_kstat *)ksp->ks_data; 26047c478bd9Sstevel@tonic-gate 26057c478bd9Sstevel@tonic-gate (void) strcpy(mik->mik_proto, mi->mi_curr_serv->sv_knconf->knc_proto); 26067c478bd9Sstevel@tonic-gate 26077c478bd9Sstevel@tonic-gate mik->mik_vers = (uint32_t)mi->mi_vers; 26087c478bd9Sstevel@tonic-gate mik->mik_flags = mi->mi_flags; 26097c478bd9Sstevel@tonic-gate /* 26107c478bd9Sstevel@tonic-gate * The sv_secdata holds the flavor the client specifies. 26117c478bd9Sstevel@tonic-gate * If the client uses default and a security negotiation 26127c478bd9Sstevel@tonic-gate * occurs, sv_currsec will point to the current flavor 26137c478bd9Sstevel@tonic-gate * selected from the server flavor list. 26147c478bd9Sstevel@tonic-gate * sv_currsec is NULL if no security negotiation takes place. 26157c478bd9Sstevel@tonic-gate */ 26167c478bd9Sstevel@tonic-gate mik->mik_secmod = mi->mi_curr_serv->sv_currsec ? 2617b9238976Sth mi->mi_curr_serv->sv_currsec->secmod : 2618b9238976Sth mi->mi_curr_serv->sv_secdata->secmod; 26197c478bd9Sstevel@tonic-gate mik->mik_curread = (uint32_t)mi->mi_curread; 26207c478bd9Sstevel@tonic-gate mik->mik_curwrite = (uint32_t)mi->mi_curwrite; 26217c478bd9Sstevel@tonic-gate mik->mik_retrans = mi->mi_retrans; 26227c478bd9Sstevel@tonic-gate mik->mik_timeo = mi->mi_timeo; 26237c478bd9Sstevel@tonic-gate mik->mik_acregmin = HR2SEC(mi->mi_acregmin); 26247c478bd9Sstevel@tonic-gate mik->mik_acregmax = HR2SEC(mi->mi_acregmax); 26257c478bd9Sstevel@tonic-gate mik->mik_acdirmin = HR2SEC(mi->mi_acdirmin); 26267c478bd9Sstevel@tonic-gate mik->mik_acdirmax = HR2SEC(mi->mi_acdirmax); 26277c478bd9Sstevel@tonic-gate mik->mik_noresponse = (uint32_t)mi->mi_noresponse; 26287c478bd9Sstevel@tonic-gate mik->mik_failover = (uint32_t)mi->mi_failover; 26297c478bd9Sstevel@tonic-gate mik->mik_remap = (uint32_t)mi->mi_remap; 26307c478bd9Sstevel@tonic-gate 26317c478bd9Sstevel@tonic-gate (void) strcpy(mik->mik_curserver, mi->mi_curr_serv->sv_hostname); 26327c478bd9Sstevel@tonic-gate 26337c478bd9Sstevel@tonic-gate return (0); 26347c478bd9Sstevel@tonic-gate } 26357c478bd9Sstevel@tonic-gate 26367c478bd9Sstevel@tonic-gate void 26377c478bd9Sstevel@tonic-gate nfs4_mnt_kstat_init(struct vfs *vfsp) 26387c478bd9Sstevel@tonic-gate { 26397c478bd9Sstevel@tonic-gate mntinfo4_t *mi = VFTOMI4(vfsp); 26407c478bd9Sstevel@tonic-gate 26417c478bd9Sstevel@tonic-gate /* 26427c478bd9Sstevel@tonic-gate * PSARC 2001/697 Contract Private Interface 26437c478bd9Sstevel@tonic-gate * All nfs kstats are under SunMC contract 26447c478bd9Sstevel@tonic-gate * Please refer to the PSARC listed above and contact 26457c478bd9Sstevel@tonic-gate * SunMC before making any changes! 26467c478bd9Sstevel@tonic-gate * 26477c478bd9Sstevel@tonic-gate * Changes must be reviewed by Solaris File Sharing 26487c478bd9Sstevel@tonic-gate * Changes must be communicated to contract-2001-697@sun.com 26497c478bd9Sstevel@tonic-gate * 26507c478bd9Sstevel@tonic-gate */ 26517c478bd9Sstevel@tonic-gate 26527c478bd9Sstevel@tonic-gate mi->mi_io_kstats = kstat_create_zone("nfs", getminor(vfsp->vfs_dev), 26537c478bd9Sstevel@tonic-gate NULL, "nfs", KSTAT_TYPE_IO, 1, 0, mi->mi_zone->zone_id); 26547c478bd9Sstevel@tonic-gate if (mi->mi_io_kstats) { 26557c478bd9Sstevel@tonic-gate if (mi->mi_zone->zone_id != GLOBAL_ZONEID) 26567c478bd9Sstevel@tonic-gate kstat_zone_add(mi->mi_io_kstats, GLOBAL_ZONEID); 26577c478bd9Sstevel@tonic-gate mi->mi_io_kstats->ks_lock = &mi->mi_lock; 26587c478bd9Sstevel@tonic-gate kstat_install(mi->mi_io_kstats); 26597c478bd9Sstevel@tonic-gate } 26607c478bd9Sstevel@tonic-gate 26617c478bd9Sstevel@tonic-gate if ((mi->mi_ro_kstats = kstat_create_zone("nfs", 26627c478bd9Sstevel@tonic-gate getminor(vfsp->vfs_dev), "mntinfo", "misc", KSTAT_TYPE_RAW, 26637c478bd9Sstevel@tonic-gate sizeof (struct mntinfo_kstat), 0, mi->mi_zone->zone_id)) != NULL) { 26647c478bd9Sstevel@tonic-gate if (mi->mi_zone->zone_id != GLOBAL_ZONEID) 26657c478bd9Sstevel@tonic-gate kstat_zone_add(mi->mi_ro_kstats, GLOBAL_ZONEID); 26667c478bd9Sstevel@tonic-gate mi->mi_ro_kstats->ks_update = nfs4_mnt_kstat_update; 26677c478bd9Sstevel@tonic-gate mi->mi_ro_kstats->ks_private = (void *)vfsp; 26687c478bd9Sstevel@tonic-gate kstat_install(mi->mi_ro_kstats); 26697c478bd9Sstevel@tonic-gate } 26707c478bd9Sstevel@tonic-gate 26717c478bd9Sstevel@tonic-gate nfs4_mnt_recov_kstat_init(vfsp); 26727c478bd9Sstevel@tonic-gate } 26737c478bd9Sstevel@tonic-gate 26747c478bd9Sstevel@tonic-gate void 26757c478bd9Sstevel@tonic-gate nfs4_write_error(vnode_t *vp, int error, cred_t *cr) 26767c478bd9Sstevel@tonic-gate { 26777c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 2678d3d50737SRafael Vanoni clock_t now = ddi_get_lbolt(); 26797c478bd9Sstevel@tonic-gate 26807c478bd9Sstevel@tonic-gate mi = VTOMI4(vp); 26817c478bd9Sstevel@tonic-gate /* 26827c478bd9Sstevel@tonic-gate * In case of forced unmount, do not print any messages 26837c478bd9Sstevel@tonic-gate * since it can flood the console with error messages. 26847c478bd9Sstevel@tonic-gate */ 26857c478bd9Sstevel@tonic-gate if (mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED) 26867c478bd9Sstevel@tonic-gate return; 26877c478bd9Sstevel@tonic-gate 26887c478bd9Sstevel@tonic-gate /* 26897c478bd9Sstevel@tonic-gate * If the mount point is dead, not recoverable, do not 26907c478bd9Sstevel@tonic-gate * print error messages that can flood the console. 26917c478bd9Sstevel@tonic-gate */ 26927c478bd9Sstevel@tonic-gate if (mi->mi_flags & MI4_RECOV_FAIL) 26937c478bd9Sstevel@tonic-gate return; 26947c478bd9Sstevel@tonic-gate 26957c478bd9Sstevel@tonic-gate /* 26967c478bd9Sstevel@tonic-gate * No use in flooding the console with ENOSPC 26977c478bd9Sstevel@tonic-gate * messages from the same file system. 26987c478bd9Sstevel@tonic-gate */ 26997c478bd9Sstevel@tonic-gate if ((error != ENOSPC && error != EDQUOT) || 2700d3d50737SRafael Vanoni now - mi->mi_printftime > 0) { 27017c478bd9Sstevel@tonic-gate zoneid_t zoneid = mi->mi_zone->zone_id; 27027c478bd9Sstevel@tonic-gate 27037c478bd9Sstevel@tonic-gate #ifdef DEBUG 27047c478bd9Sstevel@tonic-gate nfs_perror(error, "NFS%ld write error on host %s: %m.\n", 27057c478bd9Sstevel@tonic-gate mi->mi_vers, VTOR4(vp)->r_server->sv_hostname, NULL); 27067c478bd9Sstevel@tonic-gate #else 27077c478bd9Sstevel@tonic-gate nfs_perror(error, "NFS write error on host %s: %m.\n", 27087c478bd9Sstevel@tonic-gate VTOR4(vp)->r_server->sv_hostname, NULL); 27097c478bd9Sstevel@tonic-gate #endif 27107c478bd9Sstevel@tonic-gate if (error == ENOSPC || error == EDQUOT) { 27117c478bd9Sstevel@tonic-gate zcmn_err(zoneid, CE_CONT, 27127c478bd9Sstevel@tonic-gate "^File: userid=%d, groupid=%d\n", 27137c478bd9Sstevel@tonic-gate crgetuid(cr), crgetgid(cr)); 27147c478bd9Sstevel@tonic-gate if (crgetuid(curthread->t_cred) != crgetuid(cr) || 27157c478bd9Sstevel@tonic-gate crgetgid(curthread->t_cred) != crgetgid(cr)) { 27167c478bd9Sstevel@tonic-gate zcmn_err(zoneid, CE_CONT, 27177c478bd9Sstevel@tonic-gate "^User: userid=%d, groupid=%d\n", 27187c478bd9Sstevel@tonic-gate crgetuid(curthread->t_cred), 27197c478bd9Sstevel@tonic-gate crgetgid(curthread->t_cred)); 27207c478bd9Sstevel@tonic-gate } 2721d3d50737SRafael Vanoni mi->mi_printftime = now + 27227c478bd9Sstevel@tonic-gate nfs_write_error_interval * hz; 27237c478bd9Sstevel@tonic-gate } 27247c478bd9Sstevel@tonic-gate sfh4_printfhandle(VTOR4(vp)->r_fh); 27257c478bd9Sstevel@tonic-gate #ifdef DEBUG 27267c478bd9Sstevel@tonic-gate if (error == EACCES) { 27277c478bd9Sstevel@tonic-gate zcmn_err(zoneid, CE_CONT, 27287c478bd9Sstevel@tonic-gate "nfs_bio: cred is%s kcred\n", 27297c478bd9Sstevel@tonic-gate cr == kcred ? "" : " not"); 27307c478bd9Sstevel@tonic-gate } 27317c478bd9Sstevel@tonic-gate #endif 27327c478bd9Sstevel@tonic-gate } 27337c478bd9Sstevel@tonic-gate } 27347c478bd9Sstevel@tonic-gate 27357c478bd9Sstevel@tonic-gate /* 27367c478bd9Sstevel@tonic-gate * Return non-zero if the given file can be safely memory mapped. Locks 27377c478bd9Sstevel@tonic-gate * are safe if whole-file (length and offset are both zero). 27387c478bd9Sstevel@tonic-gate */ 27397c478bd9Sstevel@tonic-gate 27407c478bd9Sstevel@tonic-gate #define SAFE_LOCK(flk) ((flk).l_start == 0 && (flk).l_len == 0) 27417c478bd9Sstevel@tonic-gate 27427c478bd9Sstevel@tonic-gate static int 27437c478bd9Sstevel@tonic-gate nfs4_safemap(const vnode_t *vp) 27447c478bd9Sstevel@tonic-gate { 27457c478bd9Sstevel@tonic-gate locklist_t *llp, *next_llp; 27467c478bd9Sstevel@tonic-gate int safe = 1; 27477c478bd9Sstevel@tonic-gate rnode4_t *rp = VTOR4(vp); 27487c478bd9Sstevel@tonic-gate 27497c478bd9Sstevel@tonic-gate ASSERT(nfs_rw_lock_held(&rp->r_lkserlock, RW_WRITER)); 27507c478bd9Sstevel@tonic-gate 27517c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_map_debug, (CE_NOTE, "nfs4_safemap: " 2752b9238976Sth "vp = %p", (void *)vp)); 27537c478bd9Sstevel@tonic-gate 27547c478bd9Sstevel@tonic-gate /* 27557c478bd9Sstevel@tonic-gate * Review all the locks for the vnode, both ones that have been 27567c478bd9Sstevel@tonic-gate * acquired and ones that are pending. We assume that 27577c478bd9Sstevel@tonic-gate * flk_active_locks_for_vp() has merged any locks that can be 27587c478bd9Sstevel@tonic-gate * merged (so that if a process has the entire file locked, it is 27597c478bd9Sstevel@tonic-gate * represented as a single lock). 27607c478bd9Sstevel@tonic-gate * 27617c478bd9Sstevel@tonic-gate * Note that we can't bail out of the loop if we find a non-safe 27627c478bd9Sstevel@tonic-gate * lock, because we have to free all the elements in the llp list. 27637c478bd9Sstevel@tonic-gate * We might be able to speed up this code slightly by not looking 27647c478bd9Sstevel@tonic-gate * at each lock's l_start and l_len fields once we've found a 27657c478bd9Sstevel@tonic-gate * non-safe lock. 27667c478bd9Sstevel@tonic-gate */ 27677c478bd9Sstevel@tonic-gate 27687c478bd9Sstevel@tonic-gate llp = flk_active_locks_for_vp(vp); 27697c478bd9Sstevel@tonic-gate while (llp) { 27707c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_map_debug, (CE_NOTE, 27717c478bd9Sstevel@tonic-gate "nfs4_safemap: active lock (%" PRId64 ", %" PRId64 ")", 27727c478bd9Sstevel@tonic-gate llp->ll_flock.l_start, llp->ll_flock.l_len)); 27737c478bd9Sstevel@tonic-gate if (!SAFE_LOCK(llp->ll_flock)) { 27747c478bd9Sstevel@tonic-gate safe = 0; 27757c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_map_debug, (CE_NOTE, 27767c478bd9Sstevel@tonic-gate "nfs4_safemap: unsafe active lock (%" PRId64 27777c478bd9Sstevel@tonic-gate ", %" PRId64 ")", llp->ll_flock.l_start, 27787c478bd9Sstevel@tonic-gate llp->ll_flock.l_len)); 27797c478bd9Sstevel@tonic-gate } 27807c478bd9Sstevel@tonic-gate next_llp = llp->ll_next; 27817c478bd9Sstevel@tonic-gate VN_RELE(llp->ll_vp); 27827c478bd9Sstevel@tonic-gate kmem_free(llp, sizeof (*llp)); 27837c478bd9Sstevel@tonic-gate llp = next_llp; 27847c478bd9Sstevel@tonic-gate } 27857c478bd9Sstevel@tonic-gate 27867c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_map_debug, (CE_NOTE, "nfs4_safemap: %s", 2787b9238976Sth safe ? "safe" : "unsafe")); 27887c478bd9Sstevel@tonic-gate return (safe); 27897c478bd9Sstevel@tonic-gate } 27907c478bd9Sstevel@tonic-gate 27917c478bd9Sstevel@tonic-gate /* 27927c478bd9Sstevel@tonic-gate * Return whether there is a lost LOCK or LOCKU queued up for the given 27937c478bd9Sstevel@tonic-gate * file that would make an mmap request unsafe. cf. nfs4_safemap(). 27947c478bd9Sstevel@tonic-gate */ 27957c478bd9Sstevel@tonic-gate 27967c478bd9Sstevel@tonic-gate bool_t 27977c478bd9Sstevel@tonic-gate nfs4_map_lost_lock_conflict(vnode_t *vp) 27987c478bd9Sstevel@tonic-gate { 27997c478bd9Sstevel@tonic-gate bool_t conflict = FALSE; 28007c478bd9Sstevel@tonic-gate nfs4_lost_rqst_t *lrp; 28017c478bd9Sstevel@tonic-gate mntinfo4_t *mi = VTOMI4(vp); 28027c478bd9Sstevel@tonic-gate 28037c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 28047c478bd9Sstevel@tonic-gate for (lrp = list_head(&mi->mi_lost_state); lrp != NULL; 28057c478bd9Sstevel@tonic-gate lrp = list_next(&mi->mi_lost_state, lrp)) { 28067c478bd9Sstevel@tonic-gate if (lrp->lr_op != OP_LOCK && lrp->lr_op != OP_LOCKU) 28077c478bd9Sstevel@tonic-gate continue; 28087c478bd9Sstevel@tonic-gate ASSERT(lrp->lr_vp != NULL); 2809da6c28aaSamw if (!VOP_CMP(lrp->lr_vp, vp, NULL)) 28107c478bd9Sstevel@tonic-gate continue; /* different file */ 28117c478bd9Sstevel@tonic-gate if (!SAFE_LOCK(*lrp->lr_flk)) { 28127c478bd9Sstevel@tonic-gate conflict = TRUE; 28137c478bd9Sstevel@tonic-gate break; 28147c478bd9Sstevel@tonic-gate } 28157c478bd9Sstevel@tonic-gate } 28167c478bd9Sstevel@tonic-gate 28177c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 28187c478bd9Sstevel@tonic-gate return (conflict); 28197c478bd9Sstevel@tonic-gate } 28207c478bd9Sstevel@tonic-gate 28217c478bd9Sstevel@tonic-gate /* 28227c478bd9Sstevel@tonic-gate * nfs_lockcompletion: 28237c478bd9Sstevel@tonic-gate * 28247c478bd9Sstevel@tonic-gate * If the vnode has a lock that makes it unsafe to cache the file, mark it 28257c478bd9Sstevel@tonic-gate * as non cachable (set VNOCACHE bit). 28267c478bd9Sstevel@tonic-gate */ 28277c478bd9Sstevel@tonic-gate 28287c478bd9Sstevel@tonic-gate void 28297c478bd9Sstevel@tonic-gate nfs4_lockcompletion(vnode_t *vp, int cmd) 28307c478bd9Sstevel@tonic-gate { 28317c478bd9Sstevel@tonic-gate rnode4_t *rp = VTOR4(vp); 28327c478bd9Sstevel@tonic-gate 28337c478bd9Sstevel@tonic-gate ASSERT(nfs_rw_lock_held(&rp->r_lkserlock, RW_WRITER)); 28347c478bd9Sstevel@tonic-gate ASSERT(!IS_SHADOW(vp, rp)); 28357c478bd9Sstevel@tonic-gate 28367c478bd9Sstevel@tonic-gate if (cmd == F_SETLK || cmd == F_SETLKW) { 28377c478bd9Sstevel@tonic-gate 28387c478bd9Sstevel@tonic-gate if (!nfs4_safemap(vp)) { 28397c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 28407c478bd9Sstevel@tonic-gate vp->v_flag |= VNOCACHE; 28417c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 28427c478bd9Sstevel@tonic-gate } else { 28437c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 28447c478bd9Sstevel@tonic-gate vp->v_flag &= ~VNOCACHE; 28457c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 28467c478bd9Sstevel@tonic-gate } 28477c478bd9Sstevel@tonic-gate } 28487c478bd9Sstevel@tonic-gate /* 28497c478bd9Sstevel@tonic-gate * The cached attributes of the file are stale after acquiring 28507c478bd9Sstevel@tonic-gate * the lock on the file. They were updated when the file was 28517c478bd9Sstevel@tonic-gate * opened, but not updated when the lock was acquired. Therefore the 28527c478bd9Sstevel@tonic-gate * cached attributes are invalidated after the lock is obtained. 28537c478bd9Sstevel@tonic-gate */ 28547c478bd9Sstevel@tonic-gate PURGE_ATTRCACHE4(vp); 28557c478bd9Sstevel@tonic-gate } 28567c478bd9Sstevel@tonic-gate 28577c478bd9Sstevel@tonic-gate /* ARGSUSED */ 28587c478bd9Sstevel@tonic-gate static void * 28597c478bd9Sstevel@tonic-gate nfs4_mi_init(zoneid_t zoneid) 28607c478bd9Sstevel@tonic-gate { 28617c478bd9Sstevel@tonic-gate struct mi4_globals *mig; 28627c478bd9Sstevel@tonic-gate 28637c478bd9Sstevel@tonic-gate mig = kmem_alloc(sizeof (*mig), KM_SLEEP); 28647c478bd9Sstevel@tonic-gate mutex_init(&mig->mig_lock, NULL, MUTEX_DEFAULT, NULL); 28657c478bd9Sstevel@tonic-gate list_create(&mig->mig_list, sizeof (mntinfo4_t), 28667c478bd9Sstevel@tonic-gate offsetof(mntinfo4_t, mi_zone_node)); 28677c478bd9Sstevel@tonic-gate mig->mig_destructor_called = B_FALSE; 28687c478bd9Sstevel@tonic-gate return (mig); 28697c478bd9Sstevel@tonic-gate } 28707c478bd9Sstevel@tonic-gate 28717c478bd9Sstevel@tonic-gate /* 28727c478bd9Sstevel@tonic-gate * Callback routine to tell all NFSv4 mounts in the zone to start tearing down 28737c478bd9Sstevel@tonic-gate * state and killing off threads. 28747c478bd9Sstevel@tonic-gate */ 28757c478bd9Sstevel@tonic-gate /* ARGSUSED */ 28767c478bd9Sstevel@tonic-gate static void 28777c478bd9Sstevel@tonic-gate nfs4_mi_shutdown(zoneid_t zoneid, void *data) 28787c478bd9Sstevel@tonic-gate { 28797c478bd9Sstevel@tonic-gate struct mi4_globals *mig = data; 28807c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 28817c478bd9Sstevel@tonic-gate nfs4_server_t *np; 28827c478bd9Sstevel@tonic-gate 28837c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_zone_debug, (CE_NOTE, 28847c478bd9Sstevel@tonic-gate "nfs4_mi_shutdown zone %d\n", zoneid)); 28857c478bd9Sstevel@tonic-gate ASSERT(mig != NULL); 288650a83466Sjwahlig for (;;) { 288750a83466Sjwahlig mutex_enter(&mig->mig_lock); 288850a83466Sjwahlig mi = list_head(&mig->mig_list); 288950a83466Sjwahlig if (mi == NULL) { 289050a83466Sjwahlig mutex_exit(&mig->mig_lock); 289150a83466Sjwahlig break; 289250a83466Sjwahlig } 28933fd6cc29Sthurlow 28947c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_zone_debug, (CE_NOTE, 28957c478bd9Sstevel@tonic-gate "nfs4_mi_shutdown stopping vfs %p\n", (void *)mi->mi_vfsp)); 28967c478bd9Sstevel@tonic-gate /* 28977c478bd9Sstevel@tonic-gate * purge the DNLC for this filesystem 28987c478bd9Sstevel@tonic-gate */ 28997c478bd9Sstevel@tonic-gate (void) dnlc_purge_vfsp(mi->mi_vfsp, 0); 29007c478bd9Sstevel@tonic-gate /* 29017c478bd9Sstevel@tonic-gate * Tell existing async worker threads to exit. 29027c478bd9Sstevel@tonic-gate */ 290350a83466Sjwahlig mutex_enter(&mi->mi_async_lock); 29047c478bd9Sstevel@tonic-gate mi->mi_max_threads = 0; 29050776f5e6SVallish Vaidyeshwara NFS4_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv); 29067c478bd9Sstevel@tonic-gate /* 290750a83466Sjwahlig * Set the appropriate flags, signal and wait for both the 290850a83466Sjwahlig * async manager and the inactive thread to exit when they're 290950a83466Sjwahlig * done with their current work. 29107c478bd9Sstevel@tonic-gate */ 29117c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 29127c478bd9Sstevel@tonic-gate mi->mi_flags |= (MI4_ASYNC_MGR_STOP|MI4_DEAD); 29137c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 291450a83466Sjwahlig mutex_exit(&mi->mi_async_lock); 291550a83466Sjwahlig if (mi->mi_manager_thread) { 291650a83466Sjwahlig nfs4_async_manager_stop(mi->mi_vfsp); 291750a83466Sjwahlig } 291850a83466Sjwahlig if (mi->mi_inactive_thread) { 291950a83466Sjwahlig mutex_enter(&mi->mi_async_lock); 292050a83466Sjwahlig cv_signal(&mi->mi_inact_req_cv); 292150a83466Sjwahlig /* 292250a83466Sjwahlig * Wait for the inactive thread to exit. 292350a83466Sjwahlig */ 292450a83466Sjwahlig while (mi->mi_inactive_thread != NULL) { 292550a83466Sjwahlig cv_wait(&mi->mi_async_cv, &mi->mi_async_lock); 292650a83466Sjwahlig } 292750a83466Sjwahlig mutex_exit(&mi->mi_async_lock); 292850a83466Sjwahlig } 29297c478bd9Sstevel@tonic-gate /* 293050a83466Sjwahlig * Wait for the recovery thread to complete, that is, it will 293150a83466Sjwahlig * signal when it is done using the "mi" structure and about 293250a83466Sjwahlig * to exit 29337c478bd9Sstevel@tonic-gate */ 293450a83466Sjwahlig mutex_enter(&mi->mi_lock); 293550a83466Sjwahlig while (mi->mi_in_recovery > 0) 293650a83466Sjwahlig cv_wait(&mi->mi_cv_in_recov, &mi->mi_lock); 293750a83466Sjwahlig mutex_exit(&mi->mi_lock); 29383fd6cc29Sthurlow /* 29393fd6cc29Sthurlow * We're done when every mi has been done or the list is empty. 294050a83466Sjwahlig * This one is done, remove it from the list. 29413fd6cc29Sthurlow */ 294250a83466Sjwahlig list_remove(&mig->mig_list, mi); 29433fd6cc29Sthurlow mutex_exit(&mig->mig_lock); 2944a19609f8Sjv zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4); 2945a19609f8Sjv 294650a83466Sjwahlig /* 294750a83466Sjwahlig * Release hold on vfs and mi done to prevent race with zone 294850a83466Sjwahlig * shutdown. This releases the hold in nfs4_mi_zonelist_add. 294950a83466Sjwahlig */ 29503fd6cc29Sthurlow VFS_RELE(mi->mi_vfsp); 295150a83466Sjwahlig MI4_RELE(mi); 29527c478bd9Sstevel@tonic-gate } 29537c478bd9Sstevel@tonic-gate /* 29547c478bd9Sstevel@tonic-gate * Tell each renew thread in the zone to exit 29557c478bd9Sstevel@tonic-gate */ 29567c478bd9Sstevel@tonic-gate mutex_enter(&nfs4_server_lst_lock); 29577c478bd9Sstevel@tonic-gate for (np = nfs4_server_lst.forw; np != &nfs4_server_lst; np = np->forw) { 29587c478bd9Sstevel@tonic-gate mutex_enter(&np->s_lock); 29597c478bd9Sstevel@tonic-gate if (np->zoneid == zoneid) { 29607c478bd9Sstevel@tonic-gate /* 29617c478bd9Sstevel@tonic-gate * We add another hold onto the nfs4_server_t 29627c478bd9Sstevel@tonic-gate * because this will make sure tha the nfs4_server_t 29637c478bd9Sstevel@tonic-gate * stays around until nfs4_callback_fini_zone destroys 29647c478bd9Sstevel@tonic-gate * the zone. This way, the renew thread can 29657c478bd9Sstevel@tonic-gate * unconditionally release its holds on the 29667c478bd9Sstevel@tonic-gate * nfs4_server_t. 29677c478bd9Sstevel@tonic-gate */ 29687c478bd9Sstevel@tonic-gate np->s_refcnt++; 29697c478bd9Sstevel@tonic-gate nfs4_mark_srv_dead(np); 29707c478bd9Sstevel@tonic-gate } 29717c478bd9Sstevel@tonic-gate mutex_exit(&np->s_lock); 29727c478bd9Sstevel@tonic-gate } 29737c478bd9Sstevel@tonic-gate mutex_exit(&nfs4_server_lst_lock); 29747c478bd9Sstevel@tonic-gate } 29757c478bd9Sstevel@tonic-gate 29767c478bd9Sstevel@tonic-gate static void 29777c478bd9Sstevel@tonic-gate nfs4_mi_free_globals(struct mi4_globals *mig) 29787c478bd9Sstevel@tonic-gate { 29797c478bd9Sstevel@tonic-gate list_destroy(&mig->mig_list); /* makes sure the list is empty */ 29807c478bd9Sstevel@tonic-gate mutex_destroy(&mig->mig_lock); 29817c478bd9Sstevel@tonic-gate kmem_free(mig, sizeof (*mig)); 29827c478bd9Sstevel@tonic-gate } 29837c478bd9Sstevel@tonic-gate 29847c478bd9Sstevel@tonic-gate /* ARGSUSED */ 29857c478bd9Sstevel@tonic-gate static void 29867c478bd9Sstevel@tonic-gate nfs4_mi_destroy(zoneid_t zoneid, void *data) 29877c478bd9Sstevel@tonic-gate { 29887c478bd9Sstevel@tonic-gate struct mi4_globals *mig = data; 29897c478bd9Sstevel@tonic-gate 29907c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_zone_debug, (CE_NOTE, 29917c478bd9Sstevel@tonic-gate "nfs4_mi_destroy zone %d\n", zoneid)); 29927c478bd9Sstevel@tonic-gate ASSERT(mig != NULL); 29937c478bd9Sstevel@tonic-gate mutex_enter(&mig->mig_lock); 29947c478bd9Sstevel@tonic-gate if (list_head(&mig->mig_list) != NULL) { 29957c478bd9Sstevel@tonic-gate /* Still waiting for VFS_FREEVFS() */ 29967c478bd9Sstevel@tonic-gate mig->mig_destructor_called = B_TRUE; 29977c478bd9Sstevel@tonic-gate mutex_exit(&mig->mig_lock); 29987c478bd9Sstevel@tonic-gate return; 29997c478bd9Sstevel@tonic-gate } 30007c478bd9Sstevel@tonic-gate nfs4_mi_free_globals(mig); 30017c478bd9Sstevel@tonic-gate } 30027c478bd9Sstevel@tonic-gate 30037c478bd9Sstevel@tonic-gate /* 30047c478bd9Sstevel@tonic-gate * Add an NFS mount to the per-zone list of NFS mounts. 30057c478bd9Sstevel@tonic-gate */ 30067c478bd9Sstevel@tonic-gate void 30077c478bd9Sstevel@tonic-gate nfs4_mi_zonelist_add(mntinfo4_t *mi) 30087c478bd9Sstevel@tonic-gate { 30097c478bd9Sstevel@tonic-gate struct mi4_globals *mig; 30107c478bd9Sstevel@tonic-gate 30117c478bd9Sstevel@tonic-gate mig = zone_getspecific(mi4_list_key, mi->mi_zone); 30127c478bd9Sstevel@tonic-gate mutex_enter(&mig->mig_lock); 30137c478bd9Sstevel@tonic-gate list_insert_head(&mig->mig_list, mi); 301450a83466Sjwahlig /* 301550a83466Sjwahlig * hold added to eliminate race with zone shutdown -this will be 301650a83466Sjwahlig * released in mi_shutdown 301750a83466Sjwahlig */ 301850a83466Sjwahlig MI4_HOLD(mi); 301950a83466Sjwahlig VFS_HOLD(mi->mi_vfsp); 30207c478bd9Sstevel@tonic-gate mutex_exit(&mig->mig_lock); 30217c478bd9Sstevel@tonic-gate } 30227c478bd9Sstevel@tonic-gate 30237c478bd9Sstevel@tonic-gate /* 30247c478bd9Sstevel@tonic-gate * Remove an NFS mount from the per-zone list of NFS mounts. 30257c478bd9Sstevel@tonic-gate */ 302650a83466Sjwahlig int 30277c478bd9Sstevel@tonic-gate nfs4_mi_zonelist_remove(mntinfo4_t *mi) 30287c478bd9Sstevel@tonic-gate { 30297c478bd9Sstevel@tonic-gate struct mi4_globals *mig; 303050a83466Sjwahlig int ret = 0; 30317c478bd9Sstevel@tonic-gate 30327c478bd9Sstevel@tonic-gate mig = zone_getspecific(mi4_list_key, mi->mi_zone); 30337c478bd9Sstevel@tonic-gate mutex_enter(&mig->mig_lock); 303450a83466Sjwahlig mutex_enter(&mi->mi_lock); 303550a83466Sjwahlig /* if this mi is marked dead, then the zone already released it */ 303650a83466Sjwahlig if (!(mi->mi_flags & MI4_DEAD)) { 303750a83466Sjwahlig list_remove(&mig->mig_list, mi); 30381dc00f28SJames Wahlig mutex_exit(&mi->mi_lock); 303950a83466Sjwahlig 304050a83466Sjwahlig /* release the holds put on in zonelist_add(). */ 304150a83466Sjwahlig VFS_RELE(mi->mi_vfsp); 304250a83466Sjwahlig MI4_RELE(mi); 304350a83466Sjwahlig ret = 1; 30441dc00f28SJames Wahlig } else { 30451dc00f28SJames Wahlig mutex_exit(&mi->mi_lock); 304650a83466Sjwahlig } 304750a83466Sjwahlig 30487c478bd9Sstevel@tonic-gate /* 30497c478bd9Sstevel@tonic-gate * We can be called asynchronously by VFS_FREEVFS() after the zone 30507c478bd9Sstevel@tonic-gate * shutdown/destroy callbacks have executed; if so, clean up the zone's 30517c478bd9Sstevel@tonic-gate * mi globals. 30527c478bd9Sstevel@tonic-gate */ 30537c478bd9Sstevel@tonic-gate if (list_head(&mig->mig_list) == NULL && 30547c478bd9Sstevel@tonic-gate mig->mig_destructor_called == B_TRUE) { 30557c478bd9Sstevel@tonic-gate nfs4_mi_free_globals(mig); 305650a83466Sjwahlig return (ret); 30577c478bd9Sstevel@tonic-gate } 30587c478bd9Sstevel@tonic-gate mutex_exit(&mig->mig_lock); 305950a83466Sjwahlig return (ret); 30607c478bd9Sstevel@tonic-gate } 30617c478bd9Sstevel@tonic-gate 30627c478bd9Sstevel@tonic-gate void 30637c478bd9Sstevel@tonic-gate nfs_free_mi4(mntinfo4_t *mi) 30647c478bd9Sstevel@tonic-gate { 30657c478bd9Sstevel@tonic-gate nfs4_open_owner_t *foop; 306650a83466Sjwahlig nfs4_oo_hash_bucket_t *bucketp; 30677c478bd9Sstevel@tonic-gate nfs4_debug_msg_t *msgp; 30687c478bd9Sstevel@tonic-gate int i; 306950a83466Sjwahlig servinfo4_t *svp; 30707c478bd9Sstevel@tonic-gate 3071f0558703SVallish Vaidyeshwara /* 3072f0558703SVallish Vaidyeshwara * Code introduced here should be carefully evaluated to make 3073f0558703SVallish Vaidyeshwara * sure none of the freed resources are accessed either directly 3074f0558703SVallish Vaidyeshwara * or indirectly after freeing them. For eg: Introducing calls to 3075f0558703SVallish Vaidyeshwara * NFS4_DEBUG that use mntinfo4_t structure member after freeing 3076f0558703SVallish Vaidyeshwara * the structure members or other routines calling back into NFS 3077f0558703SVallish Vaidyeshwara * accessing freed mntinfo4_t structure member. 3078f0558703SVallish Vaidyeshwara */ 30797c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 30807c478bd9Sstevel@tonic-gate ASSERT(mi->mi_recovthread == NULL); 30817c478bd9Sstevel@tonic-gate ASSERT(mi->mi_flags & MI4_ASYNC_MGR_STOP); 30827c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 30837c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_async_lock); 30840776f5e6SVallish Vaidyeshwara ASSERT(mi->mi_threads[NFS4_ASYNC_QUEUE] == 0 && 30850776f5e6SVallish Vaidyeshwara mi->mi_threads[NFS4_ASYNC_PGOPS_QUEUE] == 0); 30867c478bd9Sstevel@tonic-gate ASSERT(mi->mi_manager_thread == NULL); 308750a83466Sjwahlig mutex_exit(&mi->mi_async_lock); 308850a83466Sjwahlig if (mi->mi_io_kstats) { 308950a83466Sjwahlig kstat_delete(mi->mi_io_kstats); 309050a83466Sjwahlig mi->mi_io_kstats = NULL; 30917c478bd9Sstevel@tonic-gate } 309250a83466Sjwahlig if (mi->mi_ro_kstats) { 309350a83466Sjwahlig kstat_delete(mi->mi_ro_kstats); 309450a83466Sjwahlig mi->mi_ro_kstats = NULL; 309550a83466Sjwahlig } 309650a83466Sjwahlig if (mi->mi_recov_ksp) { 309750a83466Sjwahlig kstat_delete(mi->mi_recov_ksp); 309850a83466Sjwahlig mi->mi_recov_ksp = NULL; 30997c478bd9Sstevel@tonic-gate } 31007c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_msg_list_lock); 31017c478bd9Sstevel@tonic-gate while (msgp = list_head(&mi->mi_msg_list)) { 31027c478bd9Sstevel@tonic-gate list_remove(&mi->mi_msg_list, msgp); 31037c478bd9Sstevel@tonic-gate nfs4_free_msg(msgp); 31047c478bd9Sstevel@tonic-gate } 31057c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_msg_list_lock); 31067c478bd9Sstevel@tonic-gate list_destroy(&mi->mi_msg_list); 3107bbf2a467SNagakiran Rajashekar if (mi->mi_fname != NULL) 3108bbf2a467SNagakiran Rajashekar fn_rele(&mi->mi_fname); 31097c478bd9Sstevel@tonic-gate if (mi->mi_rootfh != NULL) 31107c478bd9Sstevel@tonic-gate sfh4_rele(&mi->mi_rootfh); 31117c478bd9Sstevel@tonic-gate if (mi->mi_srvparentfh != NULL) 31127c478bd9Sstevel@tonic-gate sfh4_rele(&mi->mi_srvparentfh); 3113f0558703SVallish Vaidyeshwara svp = mi->mi_servers; 3114f0558703SVallish Vaidyeshwara sv4_free(svp); 31157c478bd9Sstevel@tonic-gate mutex_destroy(&mi->mi_lock); 31167c478bd9Sstevel@tonic-gate mutex_destroy(&mi->mi_async_lock); 31177c478bd9Sstevel@tonic-gate mutex_destroy(&mi->mi_msg_list_lock); 31187c478bd9Sstevel@tonic-gate nfs_rw_destroy(&mi->mi_recovlock); 31197c478bd9Sstevel@tonic-gate nfs_rw_destroy(&mi->mi_rename_lock); 31207c478bd9Sstevel@tonic-gate nfs_rw_destroy(&mi->mi_fh_lock); 31217c478bd9Sstevel@tonic-gate cv_destroy(&mi->mi_failover_cv); 31227c478bd9Sstevel@tonic-gate cv_destroy(&mi->mi_async_reqs_cv); 31230776f5e6SVallish Vaidyeshwara cv_destroy(&mi->mi_async_work_cv[NFS4_ASYNC_QUEUE]); 31240776f5e6SVallish Vaidyeshwara cv_destroy(&mi->mi_async_work_cv[NFS4_ASYNC_PGOPS_QUEUE]); 31257c478bd9Sstevel@tonic-gate cv_destroy(&mi->mi_async_cv); 31267c478bd9Sstevel@tonic-gate cv_destroy(&mi->mi_inact_req_cv); 31277c478bd9Sstevel@tonic-gate /* 31287c478bd9Sstevel@tonic-gate * Destroy the oo hash lists and mutexes for the cred hash table. 31297c478bd9Sstevel@tonic-gate */ 31307c478bd9Sstevel@tonic-gate for (i = 0; i < NFS4_NUM_OO_BUCKETS; i++) { 31317c478bd9Sstevel@tonic-gate bucketp = &(mi->mi_oo_list[i]); 31327c478bd9Sstevel@tonic-gate /* Destroy any remaining open owners on the list */ 31337c478bd9Sstevel@tonic-gate foop = list_head(&bucketp->b_oo_hash_list); 31347c478bd9Sstevel@tonic-gate while (foop != NULL) { 31357c478bd9Sstevel@tonic-gate list_remove(&bucketp->b_oo_hash_list, foop); 31367c478bd9Sstevel@tonic-gate nfs4_destroy_open_owner(foop); 31377c478bd9Sstevel@tonic-gate foop = list_head(&bucketp->b_oo_hash_list); 31387c478bd9Sstevel@tonic-gate } 31397c478bd9Sstevel@tonic-gate list_destroy(&bucketp->b_oo_hash_list); 31407c478bd9Sstevel@tonic-gate mutex_destroy(&bucketp->b_lock); 31417c478bd9Sstevel@tonic-gate } 31427c478bd9Sstevel@tonic-gate /* 31437c478bd9Sstevel@tonic-gate * Empty and destroy the freed open owner list. 31447c478bd9Sstevel@tonic-gate */ 31457c478bd9Sstevel@tonic-gate foop = list_head(&mi->mi_foo_list); 31467c478bd9Sstevel@tonic-gate while (foop != NULL) { 31477c478bd9Sstevel@tonic-gate list_remove(&mi->mi_foo_list, foop); 31487c478bd9Sstevel@tonic-gate nfs4_destroy_open_owner(foop); 31497c478bd9Sstevel@tonic-gate foop = list_head(&mi->mi_foo_list); 31507c478bd9Sstevel@tonic-gate } 31517c478bd9Sstevel@tonic-gate list_destroy(&mi->mi_foo_list); 31527c478bd9Sstevel@tonic-gate list_destroy(&mi->mi_bseqid_list); 31537c478bd9Sstevel@tonic-gate list_destroy(&mi->mi_lost_state); 31547c478bd9Sstevel@tonic-gate avl_destroy(&mi->mi_filehandles); 31557c478bd9Sstevel@tonic-gate kmem_free(mi, sizeof (*mi)); 31567c478bd9Sstevel@tonic-gate } 315750a83466Sjwahlig void 315850a83466Sjwahlig mi_hold(mntinfo4_t *mi) 315950a83466Sjwahlig { 31601a5e258fSJosef 'Jeff' Sipek atomic_inc_32(&mi->mi_count); 316150a83466Sjwahlig ASSERT(mi->mi_count != 0); 316250a83466Sjwahlig } 316350a83466Sjwahlig 316450a83466Sjwahlig void 316550a83466Sjwahlig mi_rele(mntinfo4_t *mi) 316650a83466Sjwahlig { 316750a83466Sjwahlig ASSERT(mi->mi_count != 0); 31681a5e258fSJosef 'Jeff' Sipek if (atomic_dec_32_nv(&mi->mi_count) == 0) { 316950a83466Sjwahlig nfs_free_mi4(mi); 317050a83466Sjwahlig } 317150a83466Sjwahlig } 31727c478bd9Sstevel@tonic-gate 31737c478bd9Sstevel@tonic-gate vnode_t nfs4_xattr_notsupp_vnode; 31747c478bd9Sstevel@tonic-gate 31757c478bd9Sstevel@tonic-gate void 31767c478bd9Sstevel@tonic-gate nfs4_clnt_init(void) 31777c478bd9Sstevel@tonic-gate { 31787c478bd9Sstevel@tonic-gate nfs4_vnops_init(); 31797c478bd9Sstevel@tonic-gate (void) nfs4_rnode_init(); 31807c478bd9Sstevel@tonic-gate (void) nfs4_shadow_init(); 31817c478bd9Sstevel@tonic-gate (void) nfs4_acache_init(); 31827c478bd9Sstevel@tonic-gate (void) nfs4_subr_init(); 31837c478bd9Sstevel@tonic-gate nfs4_acl_init(); 31847c478bd9Sstevel@tonic-gate nfs_idmap_init(); 31857c478bd9Sstevel@tonic-gate nfs4_callback_init(); 31867c478bd9Sstevel@tonic-gate nfs4_secinfo_init(); 31877c478bd9Sstevel@tonic-gate #ifdef DEBUG 31887c478bd9Sstevel@tonic-gate tsd_create(&nfs4_tsd_key, NULL); 31897c478bd9Sstevel@tonic-gate #endif 31907c478bd9Sstevel@tonic-gate 31917c478bd9Sstevel@tonic-gate /* 31927c478bd9Sstevel@tonic-gate * Add a CPR callback so that we can update client 31937c478bd9Sstevel@tonic-gate * lease after a suspend and resume. 31947c478bd9Sstevel@tonic-gate */ 31957c478bd9Sstevel@tonic-gate cid = callb_add(nfs4_client_cpr_callb, 0, CB_CL_CPR_RPC, "nfs4"); 31967c478bd9Sstevel@tonic-gate 31977c478bd9Sstevel@tonic-gate zone_key_create(&mi4_list_key, nfs4_mi_init, nfs4_mi_shutdown, 31987c478bd9Sstevel@tonic-gate nfs4_mi_destroy); 31997c478bd9Sstevel@tonic-gate 32007c478bd9Sstevel@tonic-gate /* 32017c478bd9Sstevel@tonic-gate * Initialise the reference count of the notsupp xattr cache vnode to 1 32027c478bd9Sstevel@tonic-gate * so that it never goes away (VOP_INACTIVE isn't called on it). 32037c478bd9Sstevel@tonic-gate */ 32047c478bd9Sstevel@tonic-gate nfs4_xattr_notsupp_vnode.v_count = 1; 32057c478bd9Sstevel@tonic-gate } 32067c478bd9Sstevel@tonic-gate 32077c478bd9Sstevel@tonic-gate void 32087c478bd9Sstevel@tonic-gate nfs4_clnt_fini(void) 32097c478bd9Sstevel@tonic-gate { 32107c478bd9Sstevel@tonic-gate (void) zone_key_delete(mi4_list_key); 32117c478bd9Sstevel@tonic-gate nfs4_vnops_fini(); 32127c478bd9Sstevel@tonic-gate (void) nfs4_rnode_fini(); 32137c478bd9Sstevel@tonic-gate (void) nfs4_shadow_fini(); 32147c478bd9Sstevel@tonic-gate (void) nfs4_acache_fini(); 32157c478bd9Sstevel@tonic-gate (void) nfs4_subr_fini(); 32167c478bd9Sstevel@tonic-gate nfs_idmap_fini(); 32177c478bd9Sstevel@tonic-gate nfs4_callback_fini(); 32187c478bd9Sstevel@tonic-gate nfs4_secinfo_fini(); 32197c478bd9Sstevel@tonic-gate #ifdef DEBUG 32207c478bd9Sstevel@tonic-gate tsd_destroy(&nfs4_tsd_key); 32217c478bd9Sstevel@tonic-gate #endif 32227c478bd9Sstevel@tonic-gate if (cid) 32237c478bd9Sstevel@tonic-gate (void) callb_delete(cid); 32247c478bd9Sstevel@tonic-gate } 32257c478bd9Sstevel@tonic-gate 32267c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 32277c478bd9Sstevel@tonic-gate static boolean_t 32287c478bd9Sstevel@tonic-gate nfs4_client_cpr_callb(void *arg, int code) 32297c478bd9Sstevel@tonic-gate { 32307c478bd9Sstevel@tonic-gate /* 32317c478bd9Sstevel@tonic-gate * We get called for Suspend and Resume events. 32327c478bd9Sstevel@tonic-gate * For the suspend case we simply don't care! 32337c478bd9Sstevel@tonic-gate */ 32347c478bd9Sstevel@tonic-gate if (code == CB_CODE_CPR_CHKPT) { 32357c478bd9Sstevel@tonic-gate return (B_TRUE); 32367c478bd9Sstevel@tonic-gate } 32377c478bd9Sstevel@tonic-gate 32387c478bd9Sstevel@tonic-gate /* 32397c478bd9Sstevel@tonic-gate * When we get to here we are in the process of 32407c478bd9Sstevel@tonic-gate * resuming the system from a previous suspend. 32417c478bd9Sstevel@tonic-gate */ 32427c478bd9Sstevel@tonic-gate nfs4_client_resumed = gethrestime_sec(); 32437c478bd9Sstevel@tonic-gate return (B_TRUE); 32447c478bd9Sstevel@tonic-gate } 32457c478bd9Sstevel@tonic-gate 32467c478bd9Sstevel@tonic-gate void 32477c478bd9Sstevel@tonic-gate nfs4_renew_lease_thread(nfs4_server_t *sp) 32487c478bd9Sstevel@tonic-gate { 32497c478bd9Sstevel@tonic-gate int error = 0; 32507c478bd9Sstevel@tonic-gate time_t tmp_last_renewal_time, tmp_time, tmp_now_time, kip_secs; 32517c478bd9Sstevel@tonic-gate clock_t tick_delay = 0; 32527c478bd9Sstevel@tonic-gate clock_t time_left = 0; 32537c478bd9Sstevel@tonic-gate callb_cpr_t cpr_info; 32547c478bd9Sstevel@tonic-gate kmutex_t cpr_lock; 32557c478bd9Sstevel@tonic-gate 32567c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3257b9238976Sth "nfs4_renew_lease_thread: acting on sp 0x%p", (void*)sp)); 32587c478bd9Sstevel@tonic-gate mutex_init(&cpr_lock, NULL, MUTEX_DEFAULT, NULL); 32597c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cpr_info, &cpr_lock, callb_generic_cpr, "nfsv4Lease"); 32607c478bd9Sstevel@tonic-gate 32617c478bd9Sstevel@tonic-gate mutex_enter(&sp->s_lock); 32627c478bd9Sstevel@tonic-gate /* sp->s_lease_time is set via a GETATTR */ 32637c478bd9Sstevel@tonic-gate sp->last_renewal_time = gethrestime_sec(); 32647c478bd9Sstevel@tonic-gate sp->lease_valid = NFS4_LEASE_UNINITIALIZED; 32657c478bd9Sstevel@tonic-gate ASSERT(sp->s_refcnt >= 1); 32667c478bd9Sstevel@tonic-gate 32677c478bd9Sstevel@tonic-gate for (;;) { 32687c478bd9Sstevel@tonic-gate if (!sp->state_ref_count || 3269b9238976Sth sp->lease_valid != NFS4_LEASE_VALID) { 32707c478bd9Sstevel@tonic-gate 32717c478bd9Sstevel@tonic-gate kip_secs = MAX((sp->s_lease_time >> 1) - 3272b9238976Sth (3 * sp->propagation_delay.tv_sec), 1); 32737c478bd9Sstevel@tonic-gate 32747c478bd9Sstevel@tonic-gate tick_delay = SEC_TO_TICK(kip_secs); 32757c478bd9Sstevel@tonic-gate 32767c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3277b9238976Sth "nfs4_renew_lease_thread: no renew : thread " 3278b9238976Sth "wait %ld secs", kip_secs)); 32797c478bd9Sstevel@tonic-gate 32807c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3281b9238976Sth "nfs4_renew_lease_thread: no renew : " 3282b9238976Sth "state_ref_count %d, lease_valid %d", 3283b9238976Sth sp->state_ref_count, sp->lease_valid)); 32847c478bd9Sstevel@tonic-gate 32857c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lock); 32867c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cpr_info); 32877c478bd9Sstevel@tonic-gate mutex_exit(&cpr_lock); 3288d3d50737SRafael Vanoni time_left = cv_reltimedwait(&sp->cv_thread_exit, 3289d3d50737SRafael Vanoni &sp->s_lock, tick_delay, TR_CLOCK_TICK); 32907c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lock); 32917c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cpr_info, &cpr_lock); 32927c478bd9Sstevel@tonic-gate mutex_exit(&cpr_lock); 32937c478bd9Sstevel@tonic-gate 32947c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3295b9238976Sth "nfs4_renew_lease_thread: no renew: " 3296b9238976Sth "time left %ld", time_left)); 32977c478bd9Sstevel@tonic-gate 32987c478bd9Sstevel@tonic-gate if (sp->s_thread_exit == NFS4_THREAD_EXIT) 32997c478bd9Sstevel@tonic-gate goto die; 33007c478bd9Sstevel@tonic-gate continue; 33017c478bd9Sstevel@tonic-gate } 33027c478bd9Sstevel@tonic-gate 33037c478bd9Sstevel@tonic-gate tmp_last_renewal_time = sp->last_renewal_time; 33047c478bd9Sstevel@tonic-gate 33057c478bd9Sstevel@tonic-gate tmp_time = gethrestime_sec() - sp->last_renewal_time + 3306b9238976Sth (3 * sp->propagation_delay.tv_sec); 33077c478bd9Sstevel@tonic-gate 33087c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3309b9238976Sth "nfs4_renew_lease_thread: tmp_time %ld, " 3310b9238976Sth "sp->last_renewal_time %ld", tmp_time, 3311b9238976Sth sp->last_renewal_time)); 33127c478bd9Sstevel@tonic-gate 33137c478bd9Sstevel@tonic-gate kip_secs = MAX((sp->s_lease_time >> 1) - tmp_time, 1); 33147c478bd9Sstevel@tonic-gate 33157c478bd9Sstevel@tonic-gate tick_delay = SEC_TO_TICK(kip_secs); 33167c478bd9Sstevel@tonic-gate 33177c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3318b9238976Sth "nfs4_renew_lease_thread: valid lease: sleep for %ld " 3319b9238976Sth "secs", kip_secs)); 33207c478bd9Sstevel@tonic-gate 33217c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lock); 33227c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cpr_info); 33237c478bd9Sstevel@tonic-gate mutex_exit(&cpr_lock); 3324d3d50737SRafael Vanoni time_left = cv_reltimedwait(&sp->cv_thread_exit, &sp->s_lock, 3325d3d50737SRafael Vanoni tick_delay, TR_CLOCK_TICK); 33267c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lock); 33277c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cpr_info, &cpr_lock); 33287c478bd9Sstevel@tonic-gate mutex_exit(&cpr_lock); 33297c478bd9Sstevel@tonic-gate 33307c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3331b9238976Sth "nfs4_renew_lease_thread: valid lease: time left %ld :" 3332b9238976Sth "sp last_renewal_time %ld, nfs4_client_resumed %ld, " 3333b9238976Sth "tmp_last_renewal_time %ld", time_left, 3334b9238976Sth sp->last_renewal_time, nfs4_client_resumed, 3335b9238976Sth tmp_last_renewal_time)); 33367c478bd9Sstevel@tonic-gate 33377c478bd9Sstevel@tonic-gate if (sp->s_thread_exit == NFS4_THREAD_EXIT) 33387c478bd9Sstevel@tonic-gate goto die; 33397c478bd9Sstevel@tonic-gate 33407c478bd9Sstevel@tonic-gate if (tmp_last_renewal_time == sp->last_renewal_time || 3341b9238976Sth (nfs4_client_resumed != 0 && 3342b9238976Sth nfs4_client_resumed > sp->last_renewal_time)) { 33437c478bd9Sstevel@tonic-gate /* 33447c478bd9Sstevel@tonic-gate * Issue RENEW op since we haven't renewed the lease 33457c478bd9Sstevel@tonic-gate * since we slept. 33467c478bd9Sstevel@tonic-gate */ 33477c478bd9Sstevel@tonic-gate tmp_now_time = gethrestime_sec(); 33487c478bd9Sstevel@tonic-gate error = nfs4renew(sp); 33497c478bd9Sstevel@tonic-gate /* 33507c478bd9Sstevel@tonic-gate * Need to re-acquire sp's lock, nfs4renew() 33517c478bd9Sstevel@tonic-gate * relinqueshes it. 33527c478bd9Sstevel@tonic-gate */ 33537c478bd9Sstevel@tonic-gate mutex_enter(&sp->s_lock); 33547c478bd9Sstevel@tonic-gate 33557c478bd9Sstevel@tonic-gate /* 33567c478bd9Sstevel@tonic-gate * See if someone changed s_thread_exit while we gave 33577c478bd9Sstevel@tonic-gate * up s_lock. 33587c478bd9Sstevel@tonic-gate */ 33597c478bd9Sstevel@tonic-gate if (sp->s_thread_exit == NFS4_THREAD_EXIT) 33607c478bd9Sstevel@tonic-gate goto die; 33617c478bd9Sstevel@tonic-gate 33627c478bd9Sstevel@tonic-gate if (!error) { 33637c478bd9Sstevel@tonic-gate /* 33647c478bd9Sstevel@tonic-gate * check to see if we implicitly renewed while 33657c478bd9Sstevel@tonic-gate * we waited for a reply for our RENEW call. 33667c478bd9Sstevel@tonic-gate */ 33677c478bd9Sstevel@tonic-gate if (tmp_last_renewal_time == 3368b9238976Sth sp->last_renewal_time) { 33697c478bd9Sstevel@tonic-gate /* no implicit renew came */ 33707c478bd9Sstevel@tonic-gate sp->last_renewal_time = tmp_now_time; 33717c478bd9Sstevel@tonic-gate } else { 33727c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, 3373b9238976Sth (CE_NOTE, "renew_thread: did " 3374b9238976Sth "implicit renewal before reply " 3375b9238976Sth "from server for RENEW")); 33767c478bd9Sstevel@tonic-gate } 33777c478bd9Sstevel@tonic-gate } else { 33787c478bd9Sstevel@tonic-gate /* figure out error */ 33797c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3380b9238976Sth "renew_thread: nfs4renew returned error" 3381b9238976Sth " %d", error)); 33827c478bd9Sstevel@tonic-gate } 33837c478bd9Sstevel@tonic-gate 33847c478bd9Sstevel@tonic-gate } 33857c478bd9Sstevel@tonic-gate } 33867c478bd9Sstevel@tonic-gate 33877c478bd9Sstevel@tonic-gate die: 33887c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3389b9238976Sth "nfs4_renew_lease_thread: thread exiting")); 33907c478bd9Sstevel@tonic-gate 33917c478bd9Sstevel@tonic-gate while (sp->s_otw_call_count != 0) { 33927c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3393b9238976Sth "nfs4_renew_lease_thread: waiting for outstanding " 3394b9238976Sth "otw calls to finish for sp 0x%p, current " 3395b9238976Sth "s_otw_call_count %d", (void *)sp, 3396b9238976Sth sp->s_otw_call_count)); 33977c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lock); 33987c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cpr_info); 33997c478bd9Sstevel@tonic-gate mutex_exit(&cpr_lock); 34007c478bd9Sstevel@tonic-gate cv_wait(&sp->s_cv_otw_count, &sp->s_lock); 34017c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lock); 34027c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cpr_info, &cpr_lock); 34037c478bd9Sstevel@tonic-gate mutex_exit(&cpr_lock); 34047c478bd9Sstevel@tonic-gate } 34057c478bd9Sstevel@tonic-gate mutex_exit(&sp->s_lock); 34067c478bd9Sstevel@tonic-gate 34077c478bd9Sstevel@tonic-gate nfs4_server_rele(sp); /* free the thread's reference */ 34087c478bd9Sstevel@tonic-gate nfs4_server_rele(sp); /* free the list's reference */ 34097c478bd9Sstevel@tonic-gate sp = NULL; 34107c478bd9Sstevel@tonic-gate 34117c478bd9Sstevel@tonic-gate done: 34127c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lock); 34137c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cpr_info); /* drops cpr_lock */ 34147c478bd9Sstevel@tonic-gate mutex_destroy(&cpr_lock); 34157c478bd9Sstevel@tonic-gate 34167c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3417b9238976Sth "nfs4_renew_lease_thread: renew thread exit officially")); 34187c478bd9Sstevel@tonic-gate 34197c478bd9Sstevel@tonic-gate zthread_exit(); 34207c478bd9Sstevel@tonic-gate /* NOT REACHED */ 34217c478bd9Sstevel@tonic-gate } 34227c478bd9Sstevel@tonic-gate 34237c478bd9Sstevel@tonic-gate /* 34247c478bd9Sstevel@tonic-gate * Send out a RENEW op to the server. 34257c478bd9Sstevel@tonic-gate * Assumes sp is locked down. 34267c478bd9Sstevel@tonic-gate */ 34277c478bd9Sstevel@tonic-gate static int 34287c478bd9Sstevel@tonic-gate nfs4renew(nfs4_server_t *sp) 34297c478bd9Sstevel@tonic-gate { 34307c478bd9Sstevel@tonic-gate COMPOUND4args_clnt args; 34317c478bd9Sstevel@tonic-gate COMPOUND4res_clnt res; 34327c478bd9Sstevel@tonic-gate nfs_argop4 argop[1]; 34337c478bd9Sstevel@tonic-gate int doqueue = 1; 34347c478bd9Sstevel@tonic-gate int rpc_error; 34357c478bd9Sstevel@tonic-gate cred_t *cr; 34367c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 34377c478bd9Sstevel@tonic-gate timespec_t prop_time, after_time; 34387c478bd9Sstevel@tonic-gate int needrecov = FALSE; 34397c478bd9Sstevel@tonic-gate nfs4_recov_state_t recov_state; 34407c478bd9Sstevel@tonic-gate nfs4_error_t e = { 0, NFS4_OK, RPC_SUCCESS }; 34417c478bd9Sstevel@tonic-gate 34427c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "nfs4renew")); 34437c478bd9Sstevel@tonic-gate 34447c478bd9Sstevel@tonic-gate recov_state.rs_flags = 0; 34457c478bd9Sstevel@tonic-gate recov_state.rs_num_retry_despite_err = 0; 34467c478bd9Sstevel@tonic-gate 34477c478bd9Sstevel@tonic-gate recov_retry: 34487c478bd9Sstevel@tonic-gate mi = sp->mntinfo4_list; 34497c478bd9Sstevel@tonic-gate VFS_HOLD(mi->mi_vfsp); 34507c478bd9Sstevel@tonic-gate mutex_exit(&sp->s_lock); 34517c478bd9Sstevel@tonic-gate ASSERT(mi != NULL); 34527c478bd9Sstevel@tonic-gate 34537c478bd9Sstevel@tonic-gate e.error = nfs4_start_op(mi, NULL, NULL, &recov_state); 34547c478bd9Sstevel@tonic-gate if (e.error) { 34557c478bd9Sstevel@tonic-gate VFS_RELE(mi->mi_vfsp); 34567c478bd9Sstevel@tonic-gate return (e.error); 34577c478bd9Sstevel@tonic-gate } 34587c478bd9Sstevel@tonic-gate 34597c478bd9Sstevel@tonic-gate /* Check to see if we're dealing with a marked-dead sp */ 34607c478bd9Sstevel@tonic-gate mutex_enter(&sp->s_lock); 34617c478bd9Sstevel@tonic-gate if (sp->s_thread_exit == NFS4_THREAD_EXIT) { 34627c478bd9Sstevel@tonic-gate mutex_exit(&sp->s_lock); 34637c478bd9Sstevel@tonic-gate nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 34647c478bd9Sstevel@tonic-gate VFS_RELE(mi->mi_vfsp); 34657c478bd9Sstevel@tonic-gate return (0); 34667c478bd9Sstevel@tonic-gate } 34677c478bd9Sstevel@tonic-gate 34687c478bd9Sstevel@tonic-gate /* Make sure mi hasn't changed on us */ 34697c478bd9Sstevel@tonic-gate if (mi != sp->mntinfo4_list) { 34707c478bd9Sstevel@tonic-gate /* Must drop sp's lock to avoid a recursive mutex enter */ 34717c478bd9Sstevel@tonic-gate mutex_exit(&sp->s_lock); 34727c478bd9Sstevel@tonic-gate nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 34737c478bd9Sstevel@tonic-gate VFS_RELE(mi->mi_vfsp); 34747c478bd9Sstevel@tonic-gate mutex_enter(&sp->s_lock); 34757c478bd9Sstevel@tonic-gate goto recov_retry; 34767c478bd9Sstevel@tonic-gate } 34777c478bd9Sstevel@tonic-gate mutex_exit(&sp->s_lock); 34787c478bd9Sstevel@tonic-gate 34797c478bd9Sstevel@tonic-gate args.ctag = TAG_RENEW; 34807c478bd9Sstevel@tonic-gate 34817c478bd9Sstevel@tonic-gate args.array_len = 1; 34827c478bd9Sstevel@tonic-gate args.array = argop; 34837c478bd9Sstevel@tonic-gate 34847c478bd9Sstevel@tonic-gate argop[0].argop = OP_RENEW; 34857c478bd9Sstevel@tonic-gate 34867c478bd9Sstevel@tonic-gate mutex_enter(&sp->s_lock); 34877c478bd9Sstevel@tonic-gate argop[0].nfs_argop4_u.oprenew.clientid = sp->clientid; 34887c478bd9Sstevel@tonic-gate cr = sp->s_cred; 34897c478bd9Sstevel@tonic-gate crhold(cr); 34907c478bd9Sstevel@tonic-gate mutex_exit(&sp->s_lock); 34917c478bd9Sstevel@tonic-gate 34927c478bd9Sstevel@tonic-gate ASSERT(cr != NULL); 34937c478bd9Sstevel@tonic-gate 34947c478bd9Sstevel@tonic-gate /* used to figure out RTT for sp */ 34957c478bd9Sstevel@tonic-gate gethrestime(&prop_time); 34967c478bd9Sstevel@tonic-gate 34977c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_call_debug, (CE_NOTE, 34987c478bd9Sstevel@tonic-gate "nfs4renew: %s call, sp 0x%p", needrecov ? "recov" : "first", 34997c478bd9Sstevel@tonic-gate (void*)sp)); 35007c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "before: %ld s %ld ns ", 3501b9238976Sth prop_time.tv_sec, prop_time.tv_nsec)); 35027c478bd9Sstevel@tonic-gate 35037c478bd9Sstevel@tonic-gate DTRACE_PROBE2(nfs4__renew__start, nfs4_server_t *, sp, 3504b9238976Sth mntinfo4_t *, mi); 35057c478bd9Sstevel@tonic-gate 35067c478bd9Sstevel@tonic-gate rfs4call(mi, &args, &res, cr, &doqueue, 0, &e); 35077c478bd9Sstevel@tonic-gate crfree(cr); 35087c478bd9Sstevel@tonic-gate 35097c478bd9Sstevel@tonic-gate DTRACE_PROBE2(nfs4__renew__end, nfs4_server_t *, sp, 3510b9238976Sth mntinfo4_t *, mi); 35117c478bd9Sstevel@tonic-gate 35127c478bd9Sstevel@tonic-gate gethrestime(&after_time); 35137c478bd9Sstevel@tonic-gate 35147c478bd9Sstevel@tonic-gate mutex_enter(&sp->s_lock); 35157c478bd9Sstevel@tonic-gate sp->propagation_delay.tv_sec = 3516b9238976Sth MAX(1, after_time.tv_sec - prop_time.tv_sec); 35177c478bd9Sstevel@tonic-gate mutex_exit(&sp->s_lock); 35187c478bd9Sstevel@tonic-gate 35197c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "after : %ld s %ld ns ", 3520b9238976Sth after_time.tv_sec, after_time.tv_nsec)); 35217c478bd9Sstevel@tonic-gate 35227c478bd9Sstevel@tonic-gate if (e.error == 0 && res.status == NFS4ERR_CB_PATH_DOWN) { 3523d1ea0e82Swebaker (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 35247c478bd9Sstevel@tonic-gate nfs4_delegreturn_all(sp); 35257c478bd9Sstevel@tonic-gate nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 35267c478bd9Sstevel@tonic-gate VFS_RELE(mi->mi_vfsp); 35277c478bd9Sstevel@tonic-gate /* 35287c478bd9Sstevel@tonic-gate * If the server returns CB_PATH_DOWN, it has renewed 35297c478bd9Sstevel@tonic-gate * the lease and informed us that the callback path is 35307c478bd9Sstevel@tonic-gate * down. Since the lease is renewed, just return 0 and 35317c478bd9Sstevel@tonic-gate * let the renew thread proceed as normal. 35327c478bd9Sstevel@tonic-gate */ 35337c478bd9Sstevel@tonic-gate return (0); 35347c478bd9Sstevel@tonic-gate } 35357c478bd9Sstevel@tonic-gate 35367c478bd9Sstevel@tonic-gate needrecov = nfs4_needs_recovery(&e, FALSE, mi->mi_vfsp); 35377c478bd9Sstevel@tonic-gate if (!needrecov && e.error) { 35387c478bd9Sstevel@tonic-gate nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 35397c478bd9Sstevel@tonic-gate VFS_RELE(mi->mi_vfsp); 35407c478bd9Sstevel@tonic-gate return (e.error); 35417c478bd9Sstevel@tonic-gate } 35427c478bd9Sstevel@tonic-gate 35437c478bd9Sstevel@tonic-gate rpc_error = e.error; 35447c478bd9Sstevel@tonic-gate 35457c478bd9Sstevel@tonic-gate if (needrecov) { 35467c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE, 35477c478bd9Sstevel@tonic-gate "nfs4renew: initiating recovery\n")); 35487c478bd9Sstevel@tonic-gate 35497c478bd9Sstevel@tonic-gate if (nfs4_start_recovery(&e, mi, NULL, NULL, NULL, NULL, 35502f172c55SRobert Thurlow OP_RENEW, NULL, NULL, NULL) == FALSE) { 35517c478bd9Sstevel@tonic-gate nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 35527c478bd9Sstevel@tonic-gate VFS_RELE(mi->mi_vfsp); 35537c478bd9Sstevel@tonic-gate if (!e.error) 35547c478bd9Sstevel@tonic-gate (void) xdr_free(xdr_COMPOUND4res_clnt, 3555b9238976Sth (caddr_t)&res); 35567c478bd9Sstevel@tonic-gate mutex_enter(&sp->s_lock); 35577c478bd9Sstevel@tonic-gate goto recov_retry; 35587c478bd9Sstevel@tonic-gate } 35597c478bd9Sstevel@tonic-gate /* fall through for res.status case */ 35607c478bd9Sstevel@tonic-gate } 35617c478bd9Sstevel@tonic-gate 35627c478bd9Sstevel@tonic-gate if (res.status) { 35637c478bd9Sstevel@tonic-gate if (res.status == NFS4ERR_LEASE_MOVED) { 35647c478bd9Sstevel@tonic-gate /*EMPTY*/ 35657c478bd9Sstevel@tonic-gate /* 35667c478bd9Sstevel@tonic-gate * XXX need to try every mntinfo4 in sp->mntinfo4_list 35677c478bd9Sstevel@tonic-gate * to renew the lease on that server 35687c478bd9Sstevel@tonic-gate */ 35697c478bd9Sstevel@tonic-gate } 35707c478bd9Sstevel@tonic-gate e.error = geterrno4(res.status); 35717c478bd9Sstevel@tonic-gate } 35727c478bd9Sstevel@tonic-gate 35737c478bd9Sstevel@tonic-gate if (!rpc_error) 35747c478bd9Sstevel@tonic-gate (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 35757c478bd9Sstevel@tonic-gate 35767c478bd9Sstevel@tonic-gate nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 35777c478bd9Sstevel@tonic-gate 35787c478bd9Sstevel@tonic-gate VFS_RELE(mi->mi_vfsp); 35797c478bd9Sstevel@tonic-gate 35807c478bd9Sstevel@tonic-gate return (e.error); 35817c478bd9Sstevel@tonic-gate } 35827c478bd9Sstevel@tonic-gate 35837c478bd9Sstevel@tonic-gate void 35847c478bd9Sstevel@tonic-gate nfs4_inc_state_ref_count(mntinfo4_t *mi) 35857c478bd9Sstevel@tonic-gate { 35867c478bd9Sstevel@tonic-gate nfs4_server_t *sp; 35877c478bd9Sstevel@tonic-gate 35887c478bd9Sstevel@tonic-gate /* this locks down sp if it is found */ 35897c478bd9Sstevel@tonic-gate sp = find_nfs4_server(mi); 35907c478bd9Sstevel@tonic-gate 35917c478bd9Sstevel@tonic-gate if (sp != NULL) { 35927c478bd9Sstevel@tonic-gate nfs4_inc_state_ref_count_nolock(sp, mi); 35937c478bd9Sstevel@tonic-gate mutex_exit(&sp->s_lock); 35947c478bd9Sstevel@tonic-gate nfs4_server_rele(sp); 35957c478bd9Sstevel@tonic-gate } 35967c478bd9Sstevel@tonic-gate } 35977c478bd9Sstevel@tonic-gate 35987c478bd9Sstevel@tonic-gate /* 35997c478bd9Sstevel@tonic-gate * Bump the number of OPEN files (ie: those with state) so we know if this 36007c478bd9Sstevel@tonic-gate * nfs4_server has any state to maintain a lease for or not. 36017c478bd9Sstevel@tonic-gate * 36027c478bd9Sstevel@tonic-gate * Also, marks the nfs4_server's lease valid if it hasn't been done so already. 36037c478bd9Sstevel@tonic-gate */ 36047c478bd9Sstevel@tonic-gate void 36057c478bd9Sstevel@tonic-gate nfs4_inc_state_ref_count_nolock(nfs4_server_t *sp, mntinfo4_t *mi) 36067c478bd9Sstevel@tonic-gate { 36077c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&sp->s_lock)); 36087c478bd9Sstevel@tonic-gate 36097c478bd9Sstevel@tonic-gate sp->state_ref_count++; 36107c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3611b9238976Sth "nfs4_inc_state_ref_count: state_ref_count now %d", 3612b9238976Sth sp->state_ref_count)); 36137c478bd9Sstevel@tonic-gate 36147c478bd9Sstevel@tonic-gate if (sp->lease_valid == NFS4_LEASE_UNINITIALIZED) 36157c478bd9Sstevel@tonic-gate sp->lease_valid = NFS4_LEASE_VALID; 36167c478bd9Sstevel@tonic-gate 36177c478bd9Sstevel@tonic-gate /* 36187c478bd9Sstevel@tonic-gate * If this call caused the lease to be marked valid and/or 36197c478bd9Sstevel@tonic-gate * took the state_ref_count from 0 to 1, then start the time 36207c478bd9Sstevel@tonic-gate * on lease renewal. 36217c478bd9Sstevel@tonic-gate */ 36227c478bd9Sstevel@tonic-gate if (sp->lease_valid == NFS4_LEASE_VALID && sp->state_ref_count == 1) 36237c478bd9Sstevel@tonic-gate sp->last_renewal_time = gethrestime_sec(); 36247c478bd9Sstevel@tonic-gate 36257c478bd9Sstevel@tonic-gate /* update the number of open files for mi */ 36267c478bd9Sstevel@tonic-gate mi->mi_open_files++; 36277c478bd9Sstevel@tonic-gate } 36287c478bd9Sstevel@tonic-gate 36297c478bd9Sstevel@tonic-gate void 36307c478bd9Sstevel@tonic-gate nfs4_dec_state_ref_count(mntinfo4_t *mi) 36317c478bd9Sstevel@tonic-gate { 36327c478bd9Sstevel@tonic-gate nfs4_server_t *sp; 36337c478bd9Sstevel@tonic-gate 36347c478bd9Sstevel@tonic-gate /* this locks down sp if it is found */ 36357c478bd9Sstevel@tonic-gate sp = find_nfs4_server_all(mi, 1); 36367c478bd9Sstevel@tonic-gate 36377c478bd9Sstevel@tonic-gate if (sp != NULL) { 36387c478bd9Sstevel@tonic-gate nfs4_dec_state_ref_count_nolock(sp, mi); 36397c478bd9Sstevel@tonic-gate mutex_exit(&sp->s_lock); 36407c478bd9Sstevel@tonic-gate nfs4_server_rele(sp); 36417c478bd9Sstevel@tonic-gate } 36427c478bd9Sstevel@tonic-gate } 36437c478bd9Sstevel@tonic-gate 36447c478bd9Sstevel@tonic-gate /* 36457c478bd9Sstevel@tonic-gate * Decrement the number of OPEN files (ie: those with state) so we know if 36467c478bd9Sstevel@tonic-gate * this nfs4_server has any state to maintain a lease for or not. 36477c478bd9Sstevel@tonic-gate */ 36487c478bd9Sstevel@tonic-gate void 36497c478bd9Sstevel@tonic-gate nfs4_dec_state_ref_count_nolock(nfs4_server_t *sp, mntinfo4_t *mi) 36507c478bd9Sstevel@tonic-gate { 36517c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&sp->s_lock)); 36527c478bd9Sstevel@tonic-gate ASSERT(sp->state_ref_count != 0); 36537c478bd9Sstevel@tonic-gate sp->state_ref_count--; 36547c478bd9Sstevel@tonic-gate 36557c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3656b9238976Sth "nfs4_dec_state_ref_count: state ref count now %d", 3657b9238976Sth sp->state_ref_count)); 36587c478bd9Sstevel@tonic-gate 36597c478bd9Sstevel@tonic-gate mi->mi_open_files--; 36607c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3661b9238976Sth "nfs4_dec_state_ref_count: mi open files %d, v4 flags 0x%x", 3662b9238976Sth mi->mi_open_files, mi->mi_flags)); 36637c478bd9Sstevel@tonic-gate 36647c478bd9Sstevel@tonic-gate /* We don't have to hold the mi_lock to test mi_flags */ 36657c478bd9Sstevel@tonic-gate if (mi->mi_open_files == 0 && 36667c478bd9Sstevel@tonic-gate (mi->mi_flags & MI4_REMOVE_ON_LAST_CLOSE)) { 36677c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3668b9238976Sth "nfs4_dec_state_ref_count: remove mntinfo4 %p since " 3669b9238976Sth "we have closed the last open file", (void*)mi)); 36707c478bd9Sstevel@tonic-gate nfs4_remove_mi_from_server(mi, sp); 36717c478bd9Sstevel@tonic-gate } 36727c478bd9Sstevel@tonic-gate } 36737c478bd9Sstevel@tonic-gate 36747c478bd9Sstevel@tonic-gate bool_t 36757c478bd9Sstevel@tonic-gate inlease(nfs4_server_t *sp) 36767c478bd9Sstevel@tonic-gate { 36777c478bd9Sstevel@tonic-gate bool_t result; 36787c478bd9Sstevel@tonic-gate 36797c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&sp->s_lock)); 36807c478bd9Sstevel@tonic-gate 36817c478bd9Sstevel@tonic-gate if (sp->lease_valid == NFS4_LEASE_VALID && 36827c478bd9Sstevel@tonic-gate gethrestime_sec() < sp->last_renewal_time + sp->s_lease_time) 36837c478bd9Sstevel@tonic-gate result = TRUE; 36847c478bd9Sstevel@tonic-gate else 36857c478bd9Sstevel@tonic-gate result = FALSE; 36867c478bd9Sstevel@tonic-gate 36877c478bd9Sstevel@tonic-gate return (result); 36887c478bd9Sstevel@tonic-gate } 36897c478bd9Sstevel@tonic-gate 36907c478bd9Sstevel@tonic-gate 36917c478bd9Sstevel@tonic-gate /* 36927c478bd9Sstevel@tonic-gate * Return non-zero if the given nfs4_server_t is going through recovery. 36937c478bd9Sstevel@tonic-gate */ 36947c478bd9Sstevel@tonic-gate 36957c478bd9Sstevel@tonic-gate int 36967c478bd9Sstevel@tonic-gate nfs4_server_in_recovery(nfs4_server_t *sp) 36977c478bd9Sstevel@tonic-gate { 36987c478bd9Sstevel@tonic-gate return (nfs_rw_lock_held(&sp->s_recovlock, RW_WRITER)); 36997c478bd9Sstevel@tonic-gate } 37007c478bd9Sstevel@tonic-gate 37017c478bd9Sstevel@tonic-gate /* 37027c478bd9Sstevel@tonic-gate * Compare two shared filehandle objects. Returns -1, 0, or +1, if the 37037c478bd9Sstevel@tonic-gate * first is less than, equal to, or greater than the second. 37047c478bd9Sstevel@tonic-gate */ 37057c478bd9Sstevel@tonic-gate 37067c478bd9Sstevel@tonic-gate int 37077c478bd9Sstevel@tonic-gate sfh4cmp(const void *p1, const void *p2) 37087c478bd9Sstevel@tonic-gate { 37097c478bd9Sstevel@tonic-gate const nfs4_sharedfh_t *sfh1 = (const nfs4_sharedfh_t *)p1; 37107c478bd9Sstevel@tonic-gate const nfs4_sharedfh_t *sfh2 = (const nfs4_sharedfh_t *)p2; 37117c478bd9Sstevel@tonic-gate 37127c478bd9Sstevel@tonic-gate return (nfs4cmpfh(&sfh1->sfh_fh, &sfh2->sfh_fh)); 37137c478bd9Sstevel@tonic-gate } 37147c478bd9Sstevel@tonic-gate 37157c478bd9Sstevel@tonic-gate /* 37167c478bd9Sstevel@tonic-gate * Create a table for shared filehandle objects. 37177c478bd9Sstevel@tonic-gate */ 37187c478bd9Sstevel@tonic-gate 37197c478bd9Sstevel@tonic-gate void 37207c478bd9Sstevel@tonic-gate sfh4_createtab(avl_tree_t *tab) 37217c478bd9Sstevel@tonic-gate { 37227c478bd9Sstevel@tonic-gate avl_create(tab, sfh4cmp, sizeof (nfs4_sharedfh_t), 3723b9238976Sth offsetof(nfs4_sharedfh_t, sfh_tree)); 37247c478bd9Sstevel@tonic-gate } 37257c478bd9Sstevel@tonic-gate 37267c478bd9Sstevel@tonic-gate /* 37277c478bd9Sstevel@tonic-gate * Return a shared filehandle object for the given filehandle. The caller 37287c478bd9Sstevel@tonic-gate * is responsible for eventually calling sfh4_rele(). 37297c478bd9Sstevel@tonic-gate */ 37307c478bd9Sstevel@tonic-gate 37317c478bd9Sstevel@tonic-gate nfs4_sharedfh_t * 37327c478bd9Sstevel@tonic-gate sfh4_put(const nfs_fh4 *fh, mntinfo4_t *mi, nfs4_sharedfh_t *key) 37337c478bd9Sstevel@tonic-gate { 37347c478bd9Sstevel@tonic-gate nfs4_sharedfh_t *sfh, *nsfh; 37357c478bd9Sstevel@tonic-gate avl_index_t where; 37367c478bd9Sstevel@tonic-gate nfs4_sharedfh_t skey; 37377c478bd9Sstevel@tonic-gate 37387c478bd9Sstevel@tonic-gate if (!key) { 37397c478bd9Sstevel@tonic-gate skey.sfh_fh = *fh; 37407c478bd9Sstevel@tonic-gate key = &skey; 37417c478bd9Sstevel@tonic-gate } 37427c478bd9Sstevel@tonic-gate 37437c478bd9Sstevel@tonic-gate nsfh = kmem_alloc(sizeof (nfs4_sharedfh_t), KM_SLEEP); 37447c478bd9Sstevel@tonic-gate nsfh->sfh_fh.nfs_fh4_len = fh->nfs_fh4_len; 37457c478bd9Sstevel@tonic-gate /* 37467c478bd9Sstevel@tonic-gate * We allocate the largest possible filehandle size because it's 37477c478bd9Sstevel@tonic-gate * not that big, and it saves us from possibly having to resize the 37487c478bd9Sstevel@tonic-gate * buffer later. 37497c478bd9Sstevel@tonic-gate */ 37507c478bd9Sstevel@tonic-gate nsfh->sfh_fh.nfs_fh4_val = kmem_alloc(NFS4_FHSIZE, KM_SLEEP); 37517c478bd9Sstevel@tonic-gate bcopy(fh->nfs_fh4_val, nsfh->sfh_fh.nfs_fh4_val, fh->nfs_fh4_len); 37527c478bd9Sstevel@tonic-gate mutex_init(&nsfh->sfh_lock, NULL, MUTEX_DEFAULT, NULL); 37537c478bd9Sstevel@tonic-gate nsfh->sfh_refcnt = 1; 37547c478bd9Sstevel@tonic-gate nsfh->sfh_flags = SFH4_IN_TREE; 37557c478bd9Sstevel@tonic-gate nsfh->sfh_mi = mi; 37567c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_sharedfh_debug, (CE_NOTE, "sfh4_get: new object (%p)", 3757b9238976Sth (void *)nsfh)); 37587c478bd9Sstevel@tonic-gate 37597c478bd9Sstevel@tonic-gate (void) nfs_rw_enter_sig(&mi->mi_fh_lock, RW_WRITER, 0); 37607c478bd9Sstevel@tonic-gate sfh = avl_find(&mi->mi_filehandles, key, &where); 37617c478bd9Sstevel@tonic-gate if (sfh != NULL) { 37627c478bd9Sstevel@tonic-gate mutex_enter(&sfh->sfh_lock); 37637c478bd9Sstevel@tonic-gate sfh->sfh_refcnt++; 37647c478bd9Sstevel@tonic-gate mutex_exit(&sfh->sfh_lock); 37657c478bd9Sstevel@tonic-gate nfs_rw_exit(&mi->mi_fh_lock); 37667c478bd9Sstevel@tonic-gate /* free our speculative allocs */ 37677c478bd9Sstevel@tonic-gate kmem_free(nsfh->sfh_fh.nfs_fh4_val, NFS4_FHSIZE); 37687c478bd9Sstevel@tonic-gate kmem_free(nsfh, sizeof (nfs4_sharedfh_t)); 37697c478bd9Sstevel@tonic-gate return (sfh); 37707c478bd9Sstevel@tonic-gate } 37717c478bd9Sstevel@tonic-gate 37727c478bd9Sstevel@tonic-gate avl_insert(&mi->mi_filehandles, nsfh, where); 37737c478bd9Sstevel@tonic-gate nfs_rw_exit(&mi->mi_fh_lock); 37747c478bd9Sstevel@tonic-gate 37757c478bd9Sstevel@tonic-gate return (nsfh); 37767c478bd9Sstevel@tonic-gate } 37777c478bd9Sstevel@tonic-gate 37787c478bd9Sstevel@tonic-gate /* 37797c478bd9Sstevel@tonic-gate * Return a shared filehandle object for the given filehandle. The caller 37807c478bd9Sstevel@tonic-gate * is responsible for eventually calling sfh4_rele(). 37817c478bd9Sstevel@tonic-gate */ 37827c478bd9Sstevel@tonic-gate 37837c478bd9Sstevel@tonic-gate nfs4_sharedfh_t * 37847c478bd9Sstevel@tonic-gate sfh4_get(const nfs_fh4 *fh, mntinfo4_t *mi) 37857c478bd9Sstevel@tonic-gate { 37867c478bd9Sstevel@tonic-gate nfs4_sharedfh_t *sfh; 37877c478bd9Sstevel@tonic-gate nfs4_sharedfh_t key; 37887c478bd9Sstevel@tonic-gate 37897c478bd9Sstevel@tonic-gate ASSERT(fh->nfs_fh4_len <= NFS4_FHSIZE); 37907c478bd9Sstevel@tonic-gate 37917c478bd9Sstevel@tonic-gate #ifdef DEBUG 37927c478bd9Sstevel@tonic-gate if (nfs4_sharedfh_debug) { 37937c478bd9Sstevel@tonic-gate nfs4_fhandle_t fhandle; 37947c478bd9Sstevel@tonic-gate 37957c478bd9Sstevel@tonic-gate fhandle.fh_len = fh->nfs_fh4_len; 37967c478bd9Sstevel@tonic-gate bcopy(fh->nfs_fh4_val, fhandle.fh_buf, fhandle.fh_len); 37977c478bd9Sstevel@tonic-gate zcmn_err(mi->mi_zone->zone_id, CE_NOTE, "sfh4_get:"); 37987c478bd9Sstevel@tonic-gate nfs4_printfhandle(&fhandle); 37997c478bd9Sstevel@tonic-gate } 38007c478bd9Sstevel@tonic-gate #endif 38017c478bd9Sstevel@tonic-gate 38027c478bd9Sstevel@tonic-gate /* 38037c478bd9Sstevel@tonic-gate * If there's already an object for the given filehandle, bump the 38047c478bd9Sstevel@tonic-gate * reference count and return it. Otherwise, create a new object 38057c478bd9Sstevel@tonic-gate * and add it to the AVL tree. 38067c478bd9Sstevel@tonic-gate */ 38077c478bd9Sstevel@tonic-gate 38087c478bd9Sstevel@tonic-gate key.sfh_fh = *fh; 38097c478bd9Sstevel@tonic-gate 38107c478bd9Sstevel@tonic-gate (void) nfs_rw_enter_sig(&mi->mi_fh_lock, RW_READER, 0); 38117c478bd9Sstevel@tonic-gate sfh = avl_find(&mi->mi_filehandles, &key, NULL); 38127c478bd9Sstevel@tonic-gate if (sfh != NULL) { 38137c478bd9Sstevel@tonic-gate mutex_enter(&sfh->sfh_lock); 38147c478bd9Sstevel@tonic-gate sfh->sfh_refcnt++; 38157c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_sharedfh_debug, (CE_NOTE, 3816b9238976Sth "sfh4_get: found existing %p, new refcnt=%d", 3817b9238976Sth (void *)sfh, sfh->sfh_refcnt)); 38187c478bd9Sstevel@tonic-gate mutex_exit(&sfh->sfh_lock); 38197c478bd9Sstevel@tonic-gate nfs_rw_exit(&mi->mi_fh_lock); 38207c478bd9Sstevel@tonic-gate return (sfh); 38217c478bd9Sstevel@tonic-gate } 38227c478bd9Sstevel@tonic-gate nfs_rw_exit(&mi->mi_fh_lock); 38237c478bd9Sstevel@tonic-gate 38247c478bd9Sstevel@tonic-gate return (sfh4_put(fh, mi, &key)); 38257c478bd9Sstevel@tonic-gate } 38267c478bd9Sstevel@tonic-gate 38277c478bd9Sstevel@tonic-gate /* 38287c478bd9Sstevel@tonic-gate * Get a reference to the given shared filehandle object. 38297c478bd9Sstevel@tonic-gate */ 38307c478bd9Sstevel@tonic-gate 38317c478bd9Sstevel@tonic-gate void 38327c478bd9Sstevel@tonic-gate sfh4_hold(nfs4_sharedfh_t *sfh) 38337c478bd9Sstevel@tonic-gate { 38347c478bd9Sstevel@tonic-gate ASSERT(sfh->sfh_refcnt > 0); 38357c478bd9Sstevel@tonic-gate 38367c478bd9Sstevel@tonic-gate mutex_enter(&sfh->sfh_lock); 38377c478bd9Sstevel@tonic-gate sfh->sfh_refcnt++; 38387c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_sharedfh_debug, 3839b9238976Sth (CE_NOTE, "sfh4_hold %p, new refcnt=%d", 3840b9238976Sth (void *)sfh, sfh->sfh_refcnt)); 38417c478bd9Sstevel@tonic-gate mutex_exit(&sfh->sfh_lock); 38427c478bd9Sstevel@tonic-gate } 38437c478bd9Sstevel@tonic-gate 38447c478bd9Sstevel@tonic-gate /* 38457c478bd9Sstevel@tonic-gate * Release a reference to the given shared filehandle object and null out 38467c478bd9Sstevel@tonic-gate * the given pointer. 38477c478bd9Sstevel@tonic-gate */ 38487c478bd9Sstevel@tonic-gate 38497c478bd9Sstevel@tonic-gate void 38507c478bd9Sstevel@tonic-gate sfh4_rele(nfs4_sharedfh_t **sfhpp) 38517c478bd9Sstevel@tonic-gate { 38527c478bd9Sstevel@tonic-gate mntinfo4_t *mi; 38537c478bd9Sstevel@tonic-gate nfs4_sharedfh_t *sfh = *sfhpp; 38547c478bd9Sstevel@tonic-gate 38557c478bd9Sstevel@tonic-gate ASSERT(sfh->sfh_refcnt > 0); 38567c478bd9Sstevel@tonic-gate 38577c478bd9Sstevel@tonic-gate mutex_enter(&sfh->sfh_lock); 38587c478bd9Sstevel@tonic-gate if (sfh->sfh_refcnt > 1) { 38597c478bd9Sstevel@tonic-gate sfh->sfh_refcnt--; 38607c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_sharedfh_debug, (CE_NOTE, 38617c478bd9Sstevel@tonic-gate "sfh4_rele %p, new refcnt=%d", 38627c478bd9Sstevel@tonic-gate (void *)sfh, sfh->sfh_refcnt)); 38637c478bd9Sstevel@tonic-gate mutex_exit(&sfh->sfh_lock); 38647c478bd9Sstevel@tonic-gate goto finish; 38657c478bd9Sstevel@tonic-gate } 38667c478bd9Sstevel@tonic-gate mutex_exit(&sfh->sfh_lock); 38677c478bd9Sstevel@tonic-gate 38687c478bd9Sstevel@tonic-gate /* 38697c478bd9Sstevel@tonic-gate * Possibly the last reference, so get the lock for the table in 38707c478bd9Sstevel@tonic-gate * case it's time to remove the object from the table. 38717c478bd9Sstevel@tonic-gate */ 38727c478bd9Sstevel@tonic-gate mi = sfh->sfh_mi; 38737c478bd9Sstevel@tonic-gate (void) nfs_rw_enter_sig(&mi->mi_fh_lock, RW_WRITER, 0); 38747c478bd9Sstevel@tonic-gate mutex_enter(&sfh->sfh_lock); 38757c478bd9Sstevel@tonic-gate sfh->sfh_refcnt--; 38767c478bd9Sstevel@tonic-gate if (sfh->sfh_refcnt > 0) { 38777c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_sharedfh_debug, (CE_NOTE, 38787c478bd9Sstevel@tonic-gate "sfh4_rele %p, new refcnt=%d", 38797c478bd9Sstevel@tonic-gate (void *)sfh, sfh->sfh_refcnt)); 38807c478bd9Sstevel@tonic-gate mutex_exit(&sfh->sfh_lock); 38817c478bd9Sstevel@tonic-gate nfs_rw_exit(&mi->mi_fh_lock); 38827c478bd9Sstevel@tonic-gate goto finish; 38837c478bd9Sstevel@tonic-gate } 38847c478bd9Sstevel@tonic-gate 38857c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_sharedfh_debug, (CE_NOTE, 3886b9238976Sth "sfh4_rele %p, last ref", (void *)sfh)); 38877c478bd9Sstevel@tonic-gate if (sfh->sfh_flags & SFH4_IN_TREE) { 38887c478bd9Sstevel@tonic-gate avl_remove(&mi->mi_filehandles, sfh); 38897c478bd9Sstevel@tonic-gate sfh->sfh_flags &= ~SFH4_IN_TREE; 38907c478bd9Sstevel@tonic-gate } 38917c478bd9Sstevel@tonic-gate mutex_exit(&sfh->sfh_lock); 38927c478bd9Sstevel@tonic-gate nfs_rw_exit(&mi->mi_fh_lock); 38937c478bd9Sstevel@tonic-gate mutex_destroy(&sfh->sfh_lock); 38947c478bd9Sstevel@tonic-gate kmem_free(sfh->sfh_fh.nfs_fh4_val, NFS4_FHSIZE); 38957c478bd9Sstevel@tonic-gate kmem_free(sfh, sizeof (nfs4_sharedfh_t)); 38967c478bd9Sstevel@tonic-gate 38977c478bd9Sstevel@tonic-gate finish: 38987c478bd9Sstevel@tonic-gate *sfhpp = NULL; 38997c478bd9Sstevel@tonic-gate } 39007c478bd9Sstevel@tonic-gate 39017c478bd9Sstevel@tonic-gate /* 39027c478bd9Sstevel@tonic-gate * Update the filehandle for the given shared filehandle object. 39037c478bd9Sstevel@tonic-gate */ 39047c478bd9Sstevel@tonic-gate 39057c478bd9Sstevel@tonic-gate int nfs4_warn_dupfh = 0; /* if set, always warn about dup fhs below */ 39067c478bd9Sstevel@tonic-gate 39077c478bd9Sstevel@tonic-gate void 39087c478bd9Sstevel@tonic-gate sfh4_update(nfs4_sharedfh_t *sfh, const nfs_fh4 *newfh) 39097c478bd9Sstevel@tonic-gate { 39107c478bd9Sstevel@tonic-gate mntinfo4_t *mi = sfh->sfh_mi; 39117c478bd9Sstevel@tonic-gate nfs4_sharedfh_t *dupsfh; 39127c478bd9Sstevel@tonic-gate avl_index_t where; 39137c478bd9Sstevel@tonic-gate nfs4_sharedfh_t key; 39147c478bd9Sstevel@tonic-gate 39157c478bd9Sstevel@tonic-gate #ifdef DEBUG 39167c478bd9Sstevel@tonic-gate mutex_enter(&sfh->sfh_lock); 39177c478bd9Sstevel@tonic-gate ASSERT(sfh->sfh_refcnt > 0); 39187c478bd9Sstevel@tonic-gate mutex_exit(&sfh->sfh_lock); 39197c478bd9Sstevel@tonic-gate #endif 39207c478bd9Sstevel@tonic-gate ASSERT(newfh->nfs_fh4_len <= NFS4_FHSIZE); 39217c478bd9Sstevel@tonic-gate 39227c478bd9Sstevel@tonic-gate /* 39237c478bd9Sstevel@tonic-gate * The basic plan is to remove the shared filehandle object from 39247c478bd9Sstevel@tonic-gate * the table, update it to have the new filehandle, then reinsert 39257c478bd9Sstevel@tonic-gate * it. 39267c478bd9Sstevel@tonic-gate */ 39277c478bd9Sstevel@tonic-gate 39287c478bd9Sstevel@tonic-gate (void) nfs_rw_enter_sig(&mi->mi_fh_lock, RW_WRITER, 0); 39297c478bd9Sstevel@tonic-gate mutex_enter(&sfh->sfh_lock); 39307c478bd9Sstevel@tonic-gate if (sfh->sfh_flags & SFH4_IN_TREE) { 39317c478bd9Sstevel@tonic-gate avl_remove(&mi->mi_filehandles, sfh); 39327c478bd9Sstevel@tonic-gate sfh->sfh_flags &= ~SFH4_IN_TREE; 39337c478bd9Sstevel@tonic-gate } 39347c478bd9Sstevel@tonic-gate mutex_exit(&sfh->sfh_lock); 39357c478bd9Sstevel@tonic-gate sfh->sfh_fh.nfs_fh4_len = newfh->nfs_fh4_len; 39367c478bd9Sstevel@tonic-gate bcopy(newfh->nfs_fh4_val, sfh->sfh_fh.nfs_fh4_val, 39377c478bd9Sstevel@tonic-gate sfh->sfh_fh.nfs_fh4_len); 39387c478bd9Sstevel@tonic-gate 39397c478bd9Sstevel@tonic-gate /* 39407c478bd9Sstevel@tonic-gate * XXX If there is already a shared filehandle object with the new 39417c478bd9Sstevel@tonic-gate * filehandle, we're in trouble, because the rnode code assumes 39427c478bd9Sstevel@tonic-gate * that there is only one shared filehandle object for a given 39437c478bd9Sstevel@tonic-gate * filehandle. So issue a warning (for read-write mounts only) 39447c478bd9Sstevel@tonic-gate * and don't try to re-insert the given object into the table. 39457c478bd9Sstevel@tonic-gate * Hopefully the given object will quickly go away and everyone 39467c478bd9Sstevel@tonic-gate * will use the new object. 39477c478bd9Sstevel@tonic-gate */ 39487c478bd9Sstevel@tonic-gate key.sfh_fh = *newfh; 39497c478bd9Sstevel@tonic-gate dupsfh = avl_find(&mi->mi_filehandles, &key, &where); 39507c478bd9Sstevel@tonic-gate if (dupsfh != NULL) { 39517c478bd9Sstevel@tonic-gate if (!(mi->mi_vfsp->vfs_flag & VFS_RDONLY) || nfs4_warn_dupfh) { 39527c478bd9Sstevel@tonic-gate zcmn_err(mi->mi_zone->zone_id, CE_WARN, "sfh4_update: " 39537c478bd9Sstevel@tonic-gate "duplicate filehandle detected"); 39547c478bd9Sstevel@tonic-gate sfh4_printfhandle(dupsfh); 39557c478bd9Sstevel@tonic-gate } 39567c478bd9Sstevel@tonic-gate } else { 39577c478bd9Sstevel@tonic-gate avl_insert(&mi->mi_filehandles, sfh, where); 39587c478bd9Sstevel@tonic-gate mutex_enter(&sfh->sfh_lock); 39597c478bd9Sstevel@tonic-gate sfh->sfh_flags |= SFH4_IN_TREE; 39607c478bd9Sstevel@tonic-gate mutex_exit(&sfh->sfh_lock); 39617c478bd9Sstevel@tonic-gate } 39627c478bd9Sstevel@tonic-gate nfs_rw_exit(&mi->mi_fh_lock); 39637c478bd9Sstevel@tonic-gate } 39647c478bd9Sstevel@tonic-gate 39657c478bd9Sstevel@tonic-gate /* 39667c478bd9Sstevel@tonic-gate * Copy out the current filehandle for the given shared filehandle object. 39677c478bd9Sstevel@tonic-gate */ 39687c478bd9Sstevel@tonic-gate 39697c478bd9Sstevel@tonic-gate void 39707c478bd9Sstevel@tonic-gate sfh4_copyval(const nfs4_sharedfh_t *sfh, nfs4_fhandle_t *fhp) 39717c478bd9Sstevel@tonic-gate { 39727c478bd9Sstevel@tonic-gate mntinfo4_t *mi = sfh->sfh_mi; 39737c478bd9Sstevel@tonic-gate 39747c478bd9Sstevel@tonic-gate ASSERT(sfh->sfh_refcnt > 0); 39757c478bd9Sstevel@tonic-gate 39767c478bd9Sstevel@tonic-gate (void) nfs_rw_enter_sig(&mi->mi_fh_lock, RW_READER, 0); 39777c478bd9Sstevel@tonic-gate fhp->fh_len = sfh->sfh_fh.nfs_fh4_len; 39787c478bd9Sstevel@tonic-gate ASSERT(fhp->fh_len <= NFS4_FHSIZE); 39797c478bd9Sstevel@tonic-gate bcopy(sfh->sfh_fh.nfs_fh4_val, fhp->fh_buf, fhp->fh_len); 39807c478bd9Sstevel@tonic-gate nfs_rw_exit(&mi->mi_fh_lock); 39817c478bd9Sstevel@tonic-gate } 39827c478bd9Sstevel@tonic-gate 39837c478bd9Sstevel@tonic-gate /* 39847c478bd9Sstevel@tonic-gate * Print out the filehandle for the given shared filehandle object. 39857c478bd9Sstevel@tonic-gate */ 39867c478bd9Sstevel@tonic-gate 39877c478bd9Sstevel@tonic-gate void 39887c478bd9Sstevel@tonic-gate sfh4_printfhandle(const nfs4_sharedfh_t *sfh) 39897c478bd9Sstevel@tonic-gate { 39907c478bd9Sstevel@tonic-gate nfs4_fhandle_t fhandle; 39917c478bd9Sstevel@tonic-gate 39927c478bd9Sstevel@tonic-gate sfh4_copyval(sfh, &fhandle); 39937c478bd9Sstevel@tonic-gate nfs4_printfhandle(&fhandle); 39947c478bd9Sstevel@tonic-gate } 39957c478bd9Sstevel@tonic-gate 39967c478bd9Sstevel@tonic-gate /* 39977c478bd9Sstevel@tonic-gate * Compare 2 fnames. Returns -1 if the first is "less" than the second, 0 39987c478bd9Sstevel@tonic-gate * if they're the same, +1 if the first is "greater" than the second. The 39997c478bd9Sstevel@tonic-gate * caller (or whoever's calling the AVL package) is responsible for 40007c478bd9Sstevel@tonic-gate * handling locking issues. 40017c478bd9Sstevel@tonic-gate */ 40027c478bd9Sstevel@tonic-gate 40037c478bd9Sstevel@tonic-gate static int 40047c478bd9Sstevel@tonic-gate fncmp(const void *p1, const void *p2) 40057c478bd9Sstevel@tonic-gate { 40067c478bd9Sstevel@tonic-gate const nfs4_fname_t *f1 = p1; 40077c478bd9Sstevel@tonic-gate const nfs4_fname_t *f2 = p2; 40087c478bd9Sstevel@tonic-gate int res; 40097c478bd9Sstevel@tonic-gate 40107c478bd9Sstevel@tonic-gate res = strcmp(f1->fn_name, f2->fn_name); 40117c478bd9Sstevel@tonic-gate /* 40127c478bd9Sstevel@tonic-gate * The AVL package wants +/-1, not arbitrary positive or negative 40137c478bd9Sstevel@tonic-gate * integers. 40147c478bd9Sstevel@tonic-gate */ 40157c478bd9Sstevel@tonic-gate if (res > 0) 40167c478bd9Sstevel@tonic-gate res = 1; 40177c478bd9Sstevel@tonic-gate else if (res < 0) 40187c478bd9Sstevel@tonic-gate res = -1; 40197c478bd9Sstevel@tonic-gate return (res); 40207c478bd9Sstevel@tonic-gate } 40217c478bd9Sstevel@tonic-gate 40227c478bd9Sstevel@tonic-gate /* 40237c478bd9Sstevel@tonic-gate * Get or create an fname with the given name, as a child of the given 40247c478bd9Sstevel@tonic-gate * fname. The caller is responsible for eventually releasing the reference 40257c478bd9Sstevel@tonic-gate * (fn_rele()). parent may be NULL. 40267c478bd9Sstevel@tonic-gate */ 40277c478bd9Sstevel@tonic-gate 40287c478bd9Sstevel@tonic-gate nfs4_fname_t * 4029bbf2a467SNagakiran Rajashekar fn_get(nfs4_fname_t *parent, char *name, nfs4_sharedfh_t *sfh) 40307c478bd9Sstevel@tonic-gate { 40317c478bd9Sstevel@tonic-gate nfs4_fname_t key; 40327c478bd9Sstevel@tonic-gate nfs4_fname_t *fnp; 40337c478bd9Sstevel@tonic-gate avl_index_t where; 40347c478bd9Sstevel@tonic-gate 40357c478bd9Sstevel@tonic-gate key.fn_name = name; 40367c478bd9Sstevel@tonic-gate 40377c478bd9Sstevel@tonic-gate /* 40387c478bd9Sstevel@tonic-gate * If there's already an fname registered with the given name, bump 40397c478bd9Sstevel@tonic-gate * its reference count and return it. Otherwise, create a new one 40407c478bd9Sstevel@tonic-gate * and add it to the parent's AVL tree. 4041bbf2a467SNagakiran Rajashekar * 4042bbf2a467SNagakiran Rajashekar * fname entries we are looking for should match both name 4043bbf2a467SNagakiran Rajashekar * and sfh stored in the fname. 40447c478bd9Sstevel@tonic-gate */ 4045bbf2a467SNagakiran Rajashekar again: 40467c478bd9Sstevel@tonic-gate if (parent != NULL) { 40477c478bd9Sstevel@tonic-gate mutex_enter(&parent->fn_lock); 40487c478bd9Sstevel@tonic-gate fnp = avl_find(&parent->fn_children, &key, &where); 40497c478bd9Sstevel@tonic-gate if (fnp != NULL) { 4050bbf2a467SNagakiran Rajashekar /* 4051bbf2a467SNagakiran Rajashekar * This hold on fnp is released below later, 4052bbf2a467SNagakiran Rajashekar * in case this is not the fnp we want. 4053bbf2a467SNagakiran Rajashekar */ 40547c478bd9Sstevel@tonic-gate fn_hold(fnp); 4055bbf2a467SNagakiran Rajashekar 4056bbf2a467SNagakiran Rajashekar if (fnp->fn_sfh == sfh) { 4057bbf2a467SNagakiran Rajashekar /* 4058bbf2a467SNagakiran Rajashekar * We have found our entry. 4059bbf2a467SNagakiran Rajashekar * put an hold and return it. 4060bbf2a467SNagakiran Rajashekar */ 4061bbf2a467SNagakiran Rajashekar mutex_exit(&parent->fn_lock); 4062bbf2a467SNagakiran Rajashekar return (fnp); 4063bbf2a467SNagakiran Rajashekar } 4064bbf2a467SNagakiran Rajashekar 4065bbf2a467SNagakiran Rajashekar /* 4066bbf2a467SNagakiran Rajashekar * We have found an entry that has a mismatching 4067bbf2a467SNagakiran Rajashekar * fn_sfh. This could be a stale entry due to 4068bbf2a467SNagakiran Rajashekar * server side rename. We will remove this entry 4069bbf2a467SNagakiran Rajashekar * and make sure no such entries exist. 4070bbf2a467SNagakiran Rajashekar */ 40717c478bd9Sstevel@tonic-gate mutex_exit(&parent->fn_lock); 4072bbf2a467SNagakiran Rajashekar mutex_enter(&fnp->fn_lock); 4073bbf2a467SNagakiran Rajashekar if (fnp->fn_parent == parent) { 4074bbf2a467SNagakiran Rajashekar /* 4075bbf2a467SNagakiran Rajashekar * Remove ourselves from parent's 4076bbf2a467SNagakiran Rajashekar * fn_children tree. 4077bbf2a467SNagakiran Rajashekar */ 4078bbf2a467SNagakiran Rajashekar mutex_enter(&parent->fn_lock); 4079bbf2a467SNagakiran Rajashekar avl_remove(&parent->fn_children, fnp); 4080bbf2a467SNagakiran Rajashekar mutex_exit(&parent->fn_lock); 4081bbf2a467SNagakiran Rajashekar fn_rele(&fnp->fn_parent); 4082bbf2a467SNagakiran Rajashekar } 4083bbf2a467SNagakiran Rajashekar mutex_exit(&fnp->fn_lock); 4084bbf2a467SNagakiran Rajashekar fn_rele(&fnp); 4085bbf2a467SNagakiran Rajashekar goto again; 40867c478bd9Sstevel@tonic-gate } 40877c478bd9Sstevel@tonic-gate } 40887c478bd9Sstevel@tonic-gate 40897c478bd9Sstevel@tonic-gate fnp = kmem_alloc(sizeof (nfs4_fname_t), KM_SLEEP); 40907c478bd9Sstevel@tonic-gate mutex_init(&fnp->fn_lock, NULL, MUTEX_DEFAULT, NULL); 40917c478bd9Sstevel@tonic-gate fnp->fn_parent = parent; 40927c478bd9Sstevel@tonic-gate if (parent != NULL) 40937c478bd9Sstevel@tonic-gate fn_hold(parent); 40947c478bd9Sstevel@tonic-gate fnp->fn_len = strlen(name); 40957c478bd9Sstevel@tonic-gate ASSERT(fnp->fn_len < MAXNAMELEN); 40967c478bd9Sstevel@tonic-gate fnp->fn_name = kmem_alloc(fnp->fn_len + 1, KM_SLEEP); 40977c478bd9Sstevel@tonic-gate (void) strcpy(fnp->fn_name, name); 40987c478bd9Sstevel@tonic-gate fnp->fn_refcnt = 1; 4099bbf2a467SNagakiran Rajashekar 4100bbf2a467SNagakiran Rajashekar /* 4101bbf2a467SNagakiran Rajashekar * This hold on sfh is later released 4102bbf2a467SNagakiran Rajashekar * when we do the final fn_rele() on this fname. 4103bbf2a467SNagakiran Rajashekar */ 4104bbf2a467SNagakiran Rajashekar sfh4_hold(sfh); 4105bbf2a467SNagakiran Rajashekar fnp->fn_sfh = sfh; 4106bbf2a467SNagakiran Rajashekar 41077c478bd9Sstevel@tonic-gate avl_create(&fnp->fn_children, fncmp, sizeof (nfs4_fname_t), 41087c478bd9Sstevel@tonic-gate offsetof(nfs4_fname_t, fn_tree)); 41097c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_fname_debug, (CE_NOTE, 4110b9238976Sth "fn_get %p:%s, a new nfs4_fname_t!", 4111b9238976Sth (void *)fnp, fnp->fn_name)); 41127c478bd9Sstevel@tonic-gate if (parent != NULL) { 41137c478bd9Sstevel@tonic-gate avl_insert(&parent->fn_children, fnp, where); 41147c478bd9Sstevel@tonic-gate mutex_exit(&parent->fn_lock); 41157c478bd9Sstevel@tonic-gate } 41167c478bd9Sstevel@tonic-gate 41177c478bd9Sstevel@tonic-gate return (fnp); 41187c478bd9Sstevel@tonic-gate } 41197c478bd9Sstevel@tonic-gate 41207c478bd9Sstevel@tonic-gate void 41217c478bd9Sstevel@tonic-gate fn_hold(nfs4_fname_t *fnp) 41227c478bd9Sstevel@tonic-gate { 41231a5e258fSJosef 'Jeff' Sipek atomic_inc_32(&fnp->fn_refcnt); 41247c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_fname_debug, (CE_NOTE, 4125b9238976Sth "fn_hold %p:%s, new refcnt=%d", 4126b9238976Sth (void *)fnp, fnp->fn_name, fnp->fn_refcnt)); 41277c478bd9Sstevel@tonic-gate } 41287c478bd9Sstevel@tonic-gate 41297c478bd9Sstevel@tonic-gate /* 41307c478bd9Sstevel@tonic-gate * Decrement the reference count of the given fname, and destroy it if its 41317c478bd9Sstevel@tonic-gate * reference count goes to zero. Nulls out the given pointer. 41327c478bd9Sstevel@tonic-gate */ 41337c478bd9Sstevel@tonic-gate 41347c478bd9Sstevel@tonic-gate void 41357c478bd9Sstevel@tonic-gate fn_rele(nfs4_fname_t **fnpp) 41367c478bd9Sstevel@tonic-gate { 41377c478bd9Sstevel@tonic-gate nfs4_fname_t *parent; 41387c478bd9Sstevel@tonic-gate uint32_t newref; 41397c478bd9Sstevel@tonic-gate nfs4_fname_t *fnp; 41407c478bd9Sstevel@tonic-gate 41417c478bd9Sstevel@tonic-gate recur: 41427c478bd9Sstevel@tonic-gate fnp = *fnpp; 41437c478bd9Sstevel@tonic-gate *fnpp = NULL; 41447c478bd9Sstevel@tonic-gate 41457c478bd9Sstevel@tonic-gate mutex_enter(&fnp->fn_lock); 41467c478bd9Sstevel@tonic-gate parent = fnp->fn_parent; 41477c478bd9Sstevel@tonic-gate if (parent != NULL) 41487c478bd9Sstevel@tonic-gate mutex_enter(&parent->fn_lock); /* prevent new references */ 41491a5e258fSJosef 'Jeff' Sipek newref = atomic_dec_32_nv(&fnp->fn_refcnt); 41507c478bd9Sstevel@tonic-gate if (newref > 0) { 41517c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_fname_debug, (CE_NOTE, 4152b9238976Sth "fn_rele %p:%s, new refcnt=%d", 4153b9238976Sth (void *)fnp, fnp->fn_name, fnp->fn_refcnt)); 41547c478bd9Sstevel@tonic-gate if (parent != NULL) 41557c478bd9Sstevel@tonic-gate mutex_exit(&parent->fn_lock); 41567c478bd9Sstevel@tonic-gate mutex_exit(&fnp->fn_lock); 41577c478bd9Sstevel@tonic-gate return; 41587c478bd9Sstevel@tonic-gate } 41597c478bd9Sstevel@tonic-gate 41607c478bd9Sstevel@tonic-gate NFS4_DEBUG(nfs4_fname_debug, (CE_NOTE, 4161b9238976Sth "fn_rele %p:%s, last reference, deleting...", 4162b9238976Sth (void *)fnp, fnp->fn_name)); 41637c478bd9Sstevel@tonic-gate if (parent != NULL) { 41647c478bd9Sstevel@tonic-gate avl_remove(&parent->fn_children, fnp); 41657c478bd9Sstevel@tonic-gate mutex_exit(&parent->fn_lock); 41667c478bd9Sstevel@tonic-gate } 41677c478bd9Sstevel@tonic-gate kmem_free(fnp->fn_name, fnp->fn_len + 1); 4168bbf2a467SNagakiran Rajashekar sfh4_rele(&fnp->fn_sfh); 41697c478bd9Sstevel@tonic-gate mutex_destroy(&fnp->fn_lock); 41707c478bd9Sstevel@tonic-gate avl_destroy(&fnp->fn_children); 41717c478bd9Sstevel@tonic-gate kmem_free(fnp, sizeof (nfs4_fname_t)); 41727c478bd9Sstevel@tonic-gate /* 41737c478bd9Sstevel@tonic-gate * Recursivly fn_rele the parent. 41747c478bd9Sstevel@tonic-gate * Use goto instead of a recursive call to avoid stack overflow. 41757c478bd9Sstevel@tonic-gate */ 41767c478bd9Sstevel@tonic-gate if (parent != NULL) { 41777c478bd9Sstevel@tonic-gate fnpp = &parent; 41787c478bd9Sstevel@tonic-gate goto recur; 41797c478bd9Sstevel@tonic-gate } 41807c478bd9Sstevel@tonic-gate } 41817c478bd9Sstevel@tonic-gate 41827c478bd9Sstevel@tonic-gate /* 41837c478bd9Sstevel@tonic-gate * Returns the single component name of the given fname, in a MAXNAMELEN 41847c478bd9Sstevel@tonic-gate * string buffer, which the caller is responsible for freeing. Note that 41857c478bd9Sstevel@tonic-gate * the name may become invalid as a result of fn_move(). 41867c478bd9Sstevel@tonic-gate */ 41877c478bd9Sstevel@tonic-gate 41887c478bd9Sstevel@tonic-gate char * 41897c478bd9Sstevel@tonic-gate fn_name(nfs4_fname_t *fnp) 41907c478bd9Sstevel@tonic-gate { 41917c478bd9Sstevel@tonic-gate char *name; 41927c478bd9Sstevel@tonic-gate 41937c478bd9Sstevel@tonic-gate ASSERT(fnp->fn_len < MAXNAMELEN); 41947c478bd9Sstevel@tonic-gate name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 41957c478bd9Sstevel@tonic-gate mutex_enter(&fnp->fn_lock); 41967c478bd9Sstevel@tonic-gate (void) strcpy(name, fnp->fn_name); 41977c478bd9Sstevel@tonic-gate mutex_exit(&fnp->fn_lock); 41987c478bd9Sstevel@tonic-gate 41997c478bd9Sstevel@tonic-gate return (name); 42007c478bd9Sstevel@tonic-gate } 42017c478bd9Sstevel@tonic-gate 42027c478bd9Sstevel@tonic-gate 42037c478bd9Sstevel@tonic-gate /* 42047c478bd9Sstevel@tonic-gate * fn_path_realloc 42057c478bd9Sstevel@tonic-gate * 42067c478bd9Sstevel@tonic-gate * This function, used only by fn_path, constructs 42077c478bd9Sstevel@tonic-gate * a new string which looks like "prepend" + "/" + "current". 42087c478bd9Sstevel@tonic-gate * by allocating a new string and freeing the old one. 42097c478bd9Sstevel@tonic-gate */ 42107c478bd9Sstevel@tonic-gate static void 42117c478bd9Sstevel@tonic-gate fn_path_realloc(char **curses, char *prepend) 42127c478bd9Sstevel@tonic-gate { 42137c478bd9Sstevel@tonic-gate int len, curlen = 0; 42147c478bd9Sstevel@tonic-gate char *news; 42157c478bd9Sstevel@tonic-gate 42167c478bd9Sstevel@tonic-gate if (*curses == NULL) { 42177c478bd9Sstevel@tonic-gate /* 42187c478bd9Sstevel@tonic-gate * Prime the pump, allocate just the 42197c478bd9Sstevel@tonic-gate * space for prepend and return that. 42207c478bd9Sstevel@tonic-gate */ 42217c478bd9Sstevel@tonic-gate len = strlen(prepend) + 1; 42227c478bd9Sstevel@tonic-gate news = kmem_alloc(len, KM_SLEEP); 42237c478bd9Sstevel@tonic-gate (void) strncpy(news, prepend, len); 42247c478bd9Sstevel@tonic-gate } else { 42257c478bd9Sstevel@tonic-gate /* 42267c478bd9Sstevel@tonic-gate * Allocate the space for a new string 42277c478bd9Sstevel@tonic-gate * +1 +1 is for the "/" and the NULL 42287c478bd9Sstevel@tonic-gate * byte at the end of it all. 42297c478bd9Sstevel@tonic-gate */ 42307c478bd9Sstevel@tonic-gate curlen = strlen(*curses); 42317c478bd9Sstevel@tonic-gate len = curlen + strlen(prepend) + 1 + 1; 42327c478bd9Sstevel@tonic-gate news = kmem_alloc(len, KM_SLEEP); 42337c478bd9Sstevel@tonic-gate (void) strncpy(news, prepend, len); 42347c478bd9Sstevel@tonic-gate (void) strcat(news, "/"); 42357c478bd9Sstevel@tonic-gate (void) strcat(news, *curses); 42367c478bd9Sstevel@tonic-gate kmem_free(*curses, curlen + 1); 42377c478bd9Sstevel@tonic-gate } 42387c478bd9Sstevel@tonic-gate *curses = news; 42397c478bd9Sstevel@tonic-gate } 42407c478bd9Sstevel@tonic-gate 42417c478bd9Sstevel@tonic-gate /* 42427c478bd9Sstevel@tonic-gate * Returns the path name (starting from the fs root) for the given fname. 42437c478bd9Sstevel@tonic-gate * The caller is responsible for freeing. Note that the path may be or 42447c478bd9Sstevel@tonic-gate * become invalid as a result of fn_move(). 42457c478bd9Sstevel@tonic-gate */ 42467c478bd9Sstevel@tonic-gate 42477c478bd9Sstevel@tonic-gate char * 42487c478bd9Sstevel@tonic-gate fn_path(nfs4_fname_t *fnp) 42497c478bd9Sstevel@tonic-gate { 42507c478bd9Sstevel@tonic-gate char *path; 42517c478bd9Sstevel@tonic-gate nfs4_fname_t *nextfnp; 42527c478bd9Sstevel@tonic-gate 42537c478bd9Sstevel@tonic-gate if (fnp == NULL) 42547c478bd9Sstevel@tonic-gate return (NULL); 42557c478bd9Sstevel@tonic-gate 42567c478bd9Sstevel@tonic-gate path = NULL; 42577c478bd9Sstevel@tonic-gate 42587c478bd9Sstevel@tonic-gate /* walk up the tree constructing the pathname. */ 42597c478bd9Sstevel@tonic-gate 42607c478bd9Sstevel@tonic-gate fn_hold(fnp); /* adjust for later rele */ 42617c478bd9Sstevel@tonic-gate do { 42627c478bd9Sstevel@tonic-gate mutex_enter(&fnp->fn_lock); 42637c478bd9Sstevel@tonic-gate /* 42647c478bd9Sstevel@tonic-gate * Add fn_name in front of the current path 42657c478bd9Sstevel@tonic-gate */ 42667c478bd9Sstevel@tonic-gate fn_path_realloc(&path, fnp->fn_name); 42677c478bd9Sstevel@tonic-gate nextfnp = fnp->fn_parent; 42687c478bd9Sstevel@tonic-gate if (nextfnp != NULL) 42697c478bd9Sstevel@tonic-gate fn_hold(nextfnp); 42707c478bd9Sstevel@tonic-gate mutex_exit(&fnp->fn_lock); 42717c478bd9Sstevel@tonic-gate fn_rele(&fnp); 42727c478bd9Sstevel@tonic-gate fnp = nextfnp; 42737c478bd9Sstevel@tonic-gate } while (fnp != NULL); 42747c478bd9Sstevel@tonic-gate 42757c478bd9Sstevel@tonic-gate return (path); 42767c478bd9Sstevel@tonic-gate } 42777c478bd9Sstevel@tonic-gate 42787c478bd9Sstevel@tonic-gate /* 42797c478bd9Sstevel@tonic-gate * Return a reference to the parent of the given fname, which the caller is 42807c478bd9Sstevel@tonic-gate * responsible for eventually releasing. 42817c478bd9Sstevel@tonic-gate */ 42827c478bd9Sstevel@tonic-gate 42837c478bd9Sstevel@tonic-gate nfs4_fname_t * 42847c478bd9Sstevel@tonic-gate fn_parent(nfs4_fname_t *fnp) 42857c478bd9Sstevel@tonic-gate { 42867c478bd9Sstevel@tonic-gate nfs4_fname_t *parent; 42877c478bd9Sstevel@tonic-gate 42887c478bd9Sstevel@tonic-gate mutex_enter(&fnp->fn_lock); 42897c478bd9Sstevel@tonic-gate parent = fnp->fn_parent; 42907c478bd9Sstevel@tonic-gate if (parent != NULL) 42917c478bd9Sstevel@tonic-gate fn_hold(parent); 42927c478bd9Sstevel@tonic-gate mutex_exit(&fnp->fn_lock); 42937c478bd9Sstevel@tonic-gate 42947c478bd9Sstevel@tonic-gate return (parent); 42957c478bd9Sstevel@tonic-gate } 42967c478bd9Sstevel@tonic-gate 42977c478bd9Sstevel@tonic-gate /* 42987c478bd9Sstevel@tonic-gate * Update fnp so that its parent is newparent and its name is newname. 42997c478bd9Sstevel@tonic-gate */ 43007c478bd9Sstevel@tonic-gate 43017c478bd9Sstevel@tonic-gate void 43027c478bd9Sstevel@tonic-gate fn_move(nfs4_fname_t *fnp, nfs4_fname_t *newparent, char *newname) 43037c478bd9Sstevel@tonic-gate { 43047c478bd9Sstevel@tonic-gate nfs4_fname_t *parent, *tmpfnp; 43057c478bd9Sstevel@tonic-gate ssize_t newlen; 43067c478bd9Sstevel@tonic-gate nfs4_fname_t key; 43077c478bd9Sstevel@tonic-gate avl_index_t where; 43087c478bd9Sstevel@tonic-gate 43097c478bd9Sstevel@tonic-gate /* 43107c478bd9Sstevel@tonic-gate * This assert exists to catch the client trying to rename 43117c478bd9Sstevel@tonic-gate * a dir to be a child of itself. This happened at a recent 43127c478bd9Sstevel@tonic-gate * bakeoff against a 3rd party (broken) server which allowed 43137c478bd9Sstevel@tonic-gate * the rename to succeed. If it trips it means that: 43147c478bd9Sstevel@tonic-gate * a) the code in nfs4rename that detects this case is broken 43157c478bd9Sstevel@tonic-gate * b) the server is broken (since it allowed the bogus rename) 43167c478bd9Sstevel@tonic-gate * 43177c478bd9Sstevel@tonic-gate * For non-DEBUG kernels, prepare for a recursive mutex_enter 43187c478bd9Sstevel@tonic-gate * panic below from: mutex_enter(&newparent->fn_lock); 43197c478bd9Sstevel@tonic-gate */ 43207c478bd9Sstevel@tonic-gate ASSERT(fnp != newparent); 43217c478bd9Sstevel@tonic-gate 43227c478bd9Sstevel@tonic-gate /* 43237c478bd9Sstevel@tonic-gate * Remove fnp from its current parent, change its name, then add it 43244a36c613SPavel Filipensky * to newparent. It might happen that fnp was replaced by another 43254a36c613SPavel Filipensky * nfs4_fname_t with the same fn_name in parent->fn_children. 43264a36c613SPavel Filipensky * In such case, fnp->fn_parent is NULL and we skip the removal 43274a36c613SPavel Filipensky * of fnp from its current parent. 43287c478bd9Sstevel@tonic-gate */ 43297c478bd9Sstevel@tonic-gate mutex_enter(&fnp->fn_lock); 43307c478bd9Sstevel@tonic-gate parent = fnp->fn_parent; 43314a36c613SPavel Filipensky if (parent != NULL) { 43324a36c613SPavel Filipensky mutex_enter(&parent->fn_lock); 43334a36c613SPavel Filipensky avl_remove(&parent->fn_children, fnp); 43344a36c613SPavel Filipensky mutex_exit(&parent->fn_lock); 43354a36c613SPavel Filipensky fn_rele(&fnp->fn_parent); 43364a36c613SPavel Filipensky } 43377c478bd9Sstevel@tonic-gate 43387c478bd9Sstevel@tonic-gate newlen = strlen(newname); 43397c478bd9Sstevel@tonic-gate if (newlen != fnp->fn_len) { 43407c478bd9Sstevel@tonic-gate ASSERT(newlen < MAXNAMELEN); 43417c478bd9Sstevel@tonic-gate kmem_free(fnp->fn_name, fnp->fn_len + 1); 43427c478bd9Sstevel@tonic-gate fnp->fn_name = kmem_alloc(newlen + 1, KM_SLEEP); 43437c478bd9Sstevel@tonic-gate fnp->fn_len = newlen; 43447c478bd9Sstevel@tonic-gate } 43457c478bd9Sstevel@tonic-gate (void) strcpy(fnp->fn_name, newname); 43467c478bd9Sstevel@tonic-gate 43477c478bd9Sstevel@tonic-gate again: 43487c478bd9Sstevel@tonic-gate mutex_enter(&newparent->fn_lock); 43497c478bd9Sstevel@tonic-gate key.fn_name = fnp->fn_name; 43507c478bd9Sstevel@tonic-gate tmpfnp = avl_find(&newparent->fn_children, &key, &where); 43517c478bd9Sstevel@tonic-gate if (tmpfnp != NULL) { 43527c478bd9Sstevel@tonic-gate /* 43537c478bd9Sstevel@tonic-gate * This could be due to a file that was unlinked while 43547c478bd9Sstevel@tonic-gate * open, or perhaps the rnode is in the free list. Remove 43557c478bd9Sstevel@tonic-gate * it from newparent and let it go away on its own. The 43567c478bd9Sstevel@tonic-gate * contorted code is to deal with lock order issues and 43577c478bd9Sstevel@tonic-gate * race conditions. 43587c478bd9Sstevel@tonic-gate */ 43597c478bd9Sstevel@tonic-gate fn_hold(tmpfnp); 43607c478bd9Sstevel@tonic-gate mutex_exit(&newparent->fn_lock); 43617c478bd9Sstevel@tonic-gate mutex_enter(&tmpfnp->fn_lock); 43627c478bd9Sstevel@tonic-gate if (tmpfnp->fn_parent == newparent) { 43637c478bd9Sstevel@tonic-gate mutex_enter(&newparent->fn_lock); 43647c478bd9Sstevel@tonic-gate avl_remove(&newparent->fn_children, tmpfnp); 43657c478bd9Sstevel@tonic-gate mutex_exit(&newparent->fn_lock); 43667c478bd9Sstevel@tonic-gate fn_rele(&tmpfnp->fn_parent); 43677c478bd9Sstevel@tonic-gate } 43687c478bd9Sstevel@tonic-gate mutex_exit(&tmpfnp->fn_lock); 43697c478bd9Sstevel@tonic-gate fn_rele(&tmpfnp); 43707c478bd9Sstevel@tonic-gate goto again; 43717c478bd9Sstevel@tonic-gate } 43727c478bd9Sstevel@tonic-gate fnp->fn_parent = newparent; 43737c478bd9Sstevel@tonic-gate fn_hold(newparent); 43747c478bd9Sstevel@tonic-gate avl_insert(&newparent->fn_children, fnp, where); 43757c478bd9Sstevel@tonic-gate mutex_exit(&newparent->fn_lock); 43767c478bd9Sstevel@tonic-gate mutex_exit(&fnp->fn_lock); 43777c478bd9Sstevel@tonic-gate } 43787c478bd9Sstevel@tonic-gate 43797c478bd9Sstevel@tonic-gate #ifdef DEBUG 43807c478bd9Sstevel@tonic-gate /* 43817c478bd9Sstevel@tonic-gate * Return non-zero if the type information makes sense for the given vnode. 43827c478bd9Sstevel@tonic-gate * Otherwise panic. 43837c478bd9Sstevel@tonic-gate */ 43847c478bd9Sstevel@tonic-gate int 43857c478bd9Sstevel@tonic-gate nfs4_consistent_type(vnode_t *vp) 43867c478bd9Sstevel@tonic-gate { 43877c478bd9Sstevel@tonic-gate rnode4_t *rp = VTOR4(vp); 43887c478bd9Sstevel@tonic-gate 43897c478bd9Sstevel@tonic-gate if (nfs4_vtype_debug && vp->v_type != VNON && 43907c478bd9Sstevel@tonic-gate rp->r_attr.va_type != VNON && vp->v_type != rp->r_attr.va_type) { 43917c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, "vnode %p type mismatch; v_type=%d, " 4392b9238976Sth "rnode attr type=%d", (void *)vp, vp->v_type, 4393b9238976Sth rp->r_attr.va_type); 43947c478bd9Sstevel@tonic-gate } 43957c478bd9Sstevel@tonic-gate 43967c478bd9Sstevel@tonic-gate return (1); 43977c478bd9Sstevel@tonic-gate } 43987c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 4399