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 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 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 #pragma ident "%Z%%M% %I% %E% SMI" 317c478bd9Sstevel@tonic-gate 327c478bd9Sstevel@tonic-gate #include <sys/param.h> 337c478bd9Sstevel@tonic-gate #include <sys/types.h> 347c478bd9Sstevel@tonic-gate #include <sys/systm.h> 357c478bd9Sstevel@tonic-gate #include <sys/cred.h> 367c478bd9Sstevel@tonic-gate #include <sys/proc.h> 377c478bd9Sstevel@tonic-gate #include <sys/user.h> 387c478bd9Sstevel@tonic-gate #include <sys/time.h> 397c478bd9Sstevel@tonic-gate #include <sys/buf.h> 407c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 417c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 427c478bd9Sstevel@tonic-gate #include <sys/socket.h> 437c478bd9Sstevel@tonic-gate #include <sys/uio.h> 447c478bd9Sstevel@tonic-gate #include <sys/tiuser.h> 457c478bd9Sstevel@tonic-gate #include <sys/swap.h> 467c478bd9Sstevel@tonic-gate #include <sys/errno.h> 477c478bd9Sstevel@tonic-gate #include <sys/debug.h> 487c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 497c478bd9Sstevel@tonic-gate #include <sys/kstat.h> 507c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 517c478bd9Sstevel@tonic-gate #include <sys/vtrace.h> 527c478bd9Sstevel@tonic-gate #include <sys/session.h> 537c478bd9Sstevel@tonic-gate #include <sys/dnlc.h> 547c478bd9Sstevel@tonic-gate #include <sys/bitmap.h> 557c478bd9Sstevel@tonic-gate #include <sys/acl.h> 567c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 577c478bd9Sstevel@tonic-gate #include <sys/pathname.h> 587c478bd9Sstevel@tonic-gate #include <sys/flock.h> 597c478bd9Sstevel@tonic-gate #include <sys/dirent.h> 607c478bd9Sstevel@tonic-gate #include <sys/flock.h> 617c478bd9Sstevel@tonic-gate #include <sys/callb.h> 627c478bd9Sstevel@tonic-gate #include <sys/atomic.h> 637c478bd9Sstevel@tonic-gate #include <sys/list.h> 647c478bd9Sstevel@tonic-gate 657c478bd9Sstevel@tonic-gate #include <rpc/types.h> 667c478bd9Sstevel@tonic-gate #include <rpc/xdr.h> 677c478bd9Sstevel@tonic-gate #include <rpc/auth.h> 687c478bd9Sstevel@tonic-gate #include <rpc/clnt.h> 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate #include <nfs/nfs.h> 717c478bd9Sstevel@tonic-gate #include <nfs/nfs4.h> 727c478bd9Sstevel@tonic-gate #include <nfs/nfs_clnt.h> 737c478bd9Sstevel@tonic-gate #include <nfs/rnode.h> 747c478bd9Sstevel@tonic-gate #include <nfs/nfs_acl.h> 757c478bd9Sstevel@tonic-gate 767c478bd9Sstevel@tonic-gate /* 777c478bd9Sstevel@tonic-gate * The hash queues for the access to active and cached rnodes 787c478bd9Sstevel@tonic-gate * are organized as doubly linked lists. A reader/writer lock 797c478bd9Sstevel@tonic-gate * for each hash bucket is used to control access and to synchronize 807c478bd9Sstevel@tonic-gate * lookups, additions, and deletions from the hash queue. 817c478bd9Sstevel@tonic-gate * 827c478bd9Sstevel@tonic-gate * The rnode freelist is organized as a doubly linked list with 837c478bd9Sstevel@tonic-gate * a head pointer. Additions and deletions are synchronized via 847c478bd9Sstevel@tonic-gate * a single mutex. 857c478bd9Sstevel@tonic-gate * 867c478bd9Sstevel@tonic-gate * In order to add an rnode to the free list, it must be hashed into 877c478bd9Sstevel@tonic-gate * a hash queue and the exclusive lock to the hash queue be held. 887c478bd9Sstevel@tonic-gate * If an rnode is not hashed into a hash queue, then it is destroyed 897c478bd9Sstevel@tonic-gate * because it represents no valuable information that can be reused 907c478bd9Sstevel@tonic-gate * about the file. The exclusive lock to the hash queue must be 917c478bd9Sstevel@tonic-gate * held in order to prevent a lookup in the hash queue from finding 927c478bd9Sstevel@tonic-gate * the rnode and using it and assuming that the rnode is not on the 937c478bd9Sstevel@tonic-gate * freelist. The lookup in the hash queue will have the hash queue 947c478bd9Sstevel@tonic-gate * locked, either exclusive or shared. 957c478bd9Sstevel@tonic-gate * 967c478bd9Sstevel@tonic-gate * The vnode reference count for each rnode is not allowed to drop 977c478bd9Sstevel@tonic-gate * below 1. This prevents external entities, such as the VM 987c478bd9Sstevel@tonic-gate * subsystem, from acquiring references to vnodes already on the 997c478bd9Sstevel@tonic-gate * freelist and then trying to place them back on the freelist 1007c478bd9Sstevel@tonic-gate * when their reference is released. This means that the when an 1017c478bd9Sstevel@tonic-gate * rnode is looked up in the hash queues, then either the rnode 1027c478bd9Sstevel@tonic-gate * is removed from the freelist and that reference is tranfered to 1037c478bd9Sstevel@tonic-gate * the new reference or the vnode reference count must be incremented 1047c478bd9Sstevel@tonic-gate * accordingly. The mutex for the freelist must be held in order to 1057c478bd9Sstevel@tonic-gate * accurately test to see if the rnode is on the freelist or not. 1067c478bd9Sstevel@tonic-gate * The hash queue lock might be held shared and it is possible that 1077c478bd9Sstevel@tonic-gate * two different threads may race to remove the rnode from the 1087c478bd9Sstevel@tonic-gate * freelist. This race can be resolved by holding the mutex for the 1097c478bd9Sstevel@tonic-gate * freelist. Please note that the mutex for the freelist does not 1107c478bd9Sstevel@tonic-gate * need to held if the rnode is not on the freelist. It can not be 1117c478bd9Sstevel@tonic-gate * placed on the freelist due to the requirement that the thread 1127c478bd9Sstevel@tonic-gate * putting the rnode on the freelist must hold the exclusive lock 1137c478bd9Sstevel@tonic-gate * to the hash queue and the thread doing the lookup in the hash 1147c478bd9Sstevel@tonic-gate * queue is holding either a shared or exclusive lock to the hash 1157c478bd9Sstevel@tonic-gate * queue. 1167c478bd9Sstevel@tonic-gate * 1177c478bd9Sstevel@tonic-gate * The lock ordering is: 1187c478bd9Sstevel@tonic-gate * 1197c478bd9Sstevel@tonic-gate * hash bucket lock -> vnode lock 1207c478bd9Sstevel@tonic-gate * hash bucket lock -> freelist lock 1217c478bd9Sstevel@tonic-gate */ 1227c478bd9Sstevel@tonic-gate static rhashq_t *rtable; 1237c478bd9Sstevel@tonic-gate 1247c478bd9Sstevel@tonic-gate static kmutex_t rpfreelist_lock; 1257c478bd9Sstevel@tonic-gate static rnode_t *rpfreelist = NULL; 1267c478bd9Sstevel@tonic-gate static long rnew = 0; 1277c478bd9Sstevel@tonic-gate long nrnode = 0; 1287c478bd9Sstevel@tonic-gate 1297c478bd9Sstevel@tonic-gate static int rtablesize; 1307c478bd9Sstevel@tonic-gate static int rtablemask; 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate static int hashlen = 4; 1337c478bd9Sstevel@tonic-gate 1347c478bd9Sstevel@tonic-gate static struct kmem_cache *rnode_cache; 1357c478bd9Sstevel@tonic-gate 1367c478bd9Sstevel@tonic-gate /* 1377c478bd9Sstevel@tonic-gate * Mutex to protect the following variables: 1387c478bd9Sstevel@tonic-gate * nfs_major 1397c478bd9Sstevel@tonic-gate * nfs_minor 1407c478bd9Sstevel@tonic-gate */ 1417c478bd9Sstevel@tonic-gate kmutex_t nfs_minor_lock; 1427c478bd9Sstevel@tonic-gate int nfs_major; 1437c478bd9Sstevel@tonic-gate int nfs_minor; 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate /* Do we allow preepoch (negative) time values otw? */ 1467c478bd9Sstevel@tonic-gate bool_t nfs_allow_preepoch_time = FALSE; /* default: do not allow preepoch */ 1477c478bd9Sstevel@tonic-gate 1487c478bd9Sstevel@tonic-gate /* 1497c478bd9Sstevel@tonic-gate * Access cache 1507c478bd9Sstevel@tonic-gate */ 1517c478bd9Sstevel@tonic-gate static acache_hash_t *acache; 1527c478bd9Sstevel@tonic-gate static long nacache; /* used strictly to size the number of hash queues */ 1537c478bd9Sstevel@tonic-gate 1547c478bd9Sstevel@tonic-gate static int acachesize; 1557c478bd9Sstevel@tonic-gate static int acachemask; 1567c478bd9Sstevel@tonic-gate static struct kmem_cache *acache_cache; 1577c478bd9Sstevel@tonic-gate 1587c478bd9Sstevel@tonic-gate /* 1597c478bd9Sstevel@tonic-gate * Client side utilities 1607c478bd9Sstevel@tonic-gate */ 1617c478bd9Sstevel@tonic-gate 1627c478bd9Sstevel@tonic-gate /* 1637c478bd9Sstevel@tonic-gate * client side statistics 1647c478bd9Sstevel@tonic-gate */ 1657c478bd9Sstevel@tonic-gate static const struct clstat clstat_tmpl = { 1667c478bd9Sstevel@tonic-gate { "calls", KSTAT_DATA_UINT64 }, 1677c478bd9Sstevel@tonic-gate { "badcalls", KSTAT_DATA_UINT64 }, 1687c478bd9Sstevel@tonic-gate { "clgets", KSTAT_DATA_UINT64 }, 1697c478bd9Sstevel@tonic-gate { "cltoomany", KSTAT_DATA_UINT64 }, 1707c478bd9Sstevel@tonic-gate #ifdef DEBUG 1717c478bd9Sstevel@tonic-gate { "clalloc", KSTAT_DATA_UINT64 }, 1727c478bd9Sstevel@tonic-gate { "noresponse", KSTAT_DATA_UINT64 }, 1737c478bd9Sstevel@tonic-gate { "failover", KSTAT_DATA_UINT64 }, 1747c478bd9Sstevel@tonic-gate { "remap", KSTAT_DATA_UINT64 }, 1757c478bd9Sstevel@tonic-gate #endif 1767c478bd9Sstevel@tonic-gate }; 1777c478bd9Sstevel@tonic-gate 1787c478bd9Sstevel@tonic-gate /* 1797c478bd9Sstevel@tonic-gate * The following are statistics that describe behavior of the system as a whole 1807c478bd9Sstevel@tonic-gate * and doesn't correspond to any one particular zone. 1817c478bd9Sstevel@tonic-gate */ 1827c478bd9Sstevel@tonic-gate #ifdef DEBUG 1837c478bd9Sstevel@tonic-gate static struct clstat_debug { 1847c478bd9Sstevel@tonic-gate kstat_named_t nrnode; /* number of allocated rnodes */ 1857c478bd9Sstevel@tonic-gate kstat_named_t access; /* size of access cache */ 1867c478bd9Sstevel@tonic-gate kstat_named_t dirent; /* size of readdir cache */ 1877c478bd9Sstevel@tonic-gate kstat_named_t dirents; /* size of readdir buf cache */ 1887c478bd9Sstevel@tonic-gate kstat_named_t reclaim; /* number of reclaims */ 1897c478bd9Sstevel@tonic-gate kstat_named_t clreclaim; /* number of cl reclaims */ 1907c478bd9Sstevel@tonic-gate kstat_named_t f_reclaim; /* number of free reclaims */ 1917c478bd9Sstevel@tonic-gate kstat_named_t a_reclaim; /* number of active reclaims */ 1927c478bd9Sstevel@tonic-gate kstat_named_t r_reclaim; /* number of rnode reclaims */ 1937c478bd9Sstevel@tonic-gate kstat_named_t rpath; /* bytes used to store rpaths */ 1947c478bd9Sstevel@tonic-gate } clstat_debug = { 1957c478bd9Sstevel@tonic-gate { "nrnode", KSTAT_DATA_UINT64 }, 1967c478bd9Sstevel@tonic-gate { "access", KSTAT_DATA_UINT64 }, 1977c478bd9Sstevel@tonic-gate { "dirent", KSTAT_DATA_UINT64 }, 1987c478bd9Sstevel@tonic-gate { "dirents", KSTAT_DATA_UINT64 }, 1997c478bd9Sstevel@tonic-gate { "reclaim", KSTAT_DATA_UINT64 }, 2007c478bd9Sstevel@tonic-gate { "clreclaim", KSTAT_DATA_UINT64 }, 2017c478bd9Sstevel@tonic-gate { "f_reclaim", KSTAT_DATA_UINT64 }, 2027c478bd9Sstevel@tonic-gate { "a_reclaim", KSTAT_DATA_UINT64 }, 2037c478bd9Sstevel@tonic-gate { "r_reclaim", KSTAT_DATA_UINT64 }, 2047c478bd9Sstevel@tonic-gate { "r_path", KSTAT_DATA_UINT64 }, 2057c478bd9Sstevel@tonic-gate }; 2067c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate /* 2097c478bd9Sstevel@tonic-gate * We keep a global list of per-zone client data, so we can clean up all zones 2107c478bd9Sstevel@tonic-gate * if we get low on memory. 2117c478bd9Sstevel@tonic-gate */ 2127c478bd9Sstevel@tonic-gate static list_t nfs_clnt_list; 2137c478bd9Sstevel@tonic-gate static kmutex_t nfs_clnt_list_lock; 2147c478bd9Sstevel@tonic-gate static zone_key_t nfsclnt_zone_key; 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate static struct kmem_cache *chtab_cache; 2177c478bd9Sstevel@tonic-gate 2187c478bd9Sstevel@tonic-gate /* 2197c478bd9Sstevel@tonic-gate * Some servers do not properly update the attributes of the 2207c478bd9Sstevel@tonic-gate * directory when changes are made. To allow interoperability 2217c478bd9Sstevel@tonic-gate * with these broken servers, the nfs_disable_rddir_cache 2227c478bd9Sstevel@tonic-gate * parameter must be set in /etc/system 2237c478bd9Sstevel@tonic-gate */ 2247c478bd9Sstevel@tonic-gate int nfs_disable_rddir_cache = 0; 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate int clget(clinfo_t *, servinfo_t *, cred_t *, CLIENT **, 2277c478bd9Sstevel@tonic-gate struct chtab **); 2287c478bd9Sstevel@tonic-gate void clfree(CLIENT *, struct chtab *); 2297c478bd9Sstevel@tonic-gate static int acl_clget(mntinfo_t *, servinfo_t *, cred_t *, CLIENT **, 2307c478bd9Sstevel@tonic-gate struct chtab **, struct nfs_clnt *); 2317c478bd9Sstevel@tonic-gate static int nfs_clget(mntinfo_t *, servinfo_t *, cred_t *, CLIENT **, 2327c478bd9Sstevel@tonic-gate struct chtab **, struct nfs_clnt *); 2337c478bd9Sstevel@tonic-gate static void clreclaim(void *); 2347c478bd9Sstevel@tonic-gate static int nfs_feedback(int, int, mntinfo_t *); 2357c478bd9Sstevel@tonic-gate static int rfscall(mntinfo_t *, rpcproc_t, xdrproc_t, caddr_t, xdrproc_t, 2367c478bd9Sstevel@tonic-gate caddr_t, cred_t *, int *, enum clnt_stat *, int, 2377c478bd9Sstevel@tonic-gate failinfo_t *); 2387c478bd9Sstevel@tonic-gate static int aclcall(mntinfo_t *, rpcproc_t, xdrproc_t, caddr_t, xdrproc_t, 2397c478bd9Sstevel@tonic-gate caddr_t, cred_t *, int *, int, failinfo_t *); 2407c478bd9Sstevel@tonic-gate static void rinactive(rnode_t *, cred_t *); 2417c478bd9Sstevel@tonic-gate static int rtablehash(nfs_fhandle *); 2427c478bd9Sstevel@tonic-gate static vnode_t *make_rnode(nfs_fhandle *, rhashq_t *, struct vfs *, 2437c478bd9Sstevel@tonic-gate struct vnodeops *, 2447c478bd9Sstevel@tonic-gate int (*)(vnode_t *, page_t *, u_offset_t *, size_t *, int, 2457c478bd9Sstevel@tonic-gate cred_t *), 2467c478bd9Sstevel@tonic-gate int (*)(const void *, const void *), int *, cred_t *, 2477c478bd9Sstevel@tonic-gate char *, char *); 2487c478bd9Sstevel@tonic-gate static void rp_rmfree(rnode_t *); 2497c478bd9Sstevel@tonic-gate static void rp_addhash(rnode_t *); 2507c478bd9Sstevel@tonic-gate static void rp_rmhash_locked(rnode_t *); 2517c478bd9Sstevel@tonic-gate static rnode_t *rfind(rhashq_t *, nfs_fhandle *, struct vfs *); 2527c478bd9Sstevel@tonic-gate static void destroy_rnode(rnode_t *); 2537c478bd9Sstevel@tonic-gate static void rddir_cache_free(rddir_cache *); 2547c478bd9Sstevel@tonic-gate static int nfs_free_data_reclaim(rnode_t *); 2557c478bd9Sstevel@tonic-gate static int nfs_active_data_reclaim(rnode_t *); 2567c478bd9Sstevel@tonic-gate static int nfs_free_reclaim(void); 2577c478bd9Sstevel@tonic-gate static int nfs_active_reclaim(void); 2587c478bd9Sstevel@tonic-gate static int nfs_rnode_reclaim(void); 2597c478bd9Sstevel@tonic-gate static void nfs_reclaim(void *); 2607c478bd9Sstevel@tonic-gate static int failover_safe(failinfo_t *); 2617c478bd9Sstevel@tonic-gate static void failover_newserver(mntinfo_t *mi); 2627c478bd9Sstevel@tonic-gate static void failover_thread(mntinfo_t *mi); 2637c478bd9Sstevel@tonic-gate static int failover_wait(mntinfo_t *); 2647c478bd9Sstevel@tonic-gate static int failover_remap(failinfo_t *); 2657c478bd9Sstevel@tonic-gate static int failover_lookup(char *, vnode_t *, 2667c478bd9Sstevel@tonic-gate int (*)(vnode_t *, char *, vnode_t **, 2677c478bd9Sstevel@tonic-gate struct pathname *, int, vnode_t *, cred_t *, int), 2687c478bd9Sstevel@tonic-gate int (*)(vnode_t *, vnode_t **, bool_t, cred_t *, int), 2697c478bd9Sstevel@tonic-gate vnode_t **); 2707c478bd9Sstevel@tonic-gate static void nfs_free_r_path(rnode_t *); 2717c478bd9Sstevel@tonic-gate static void nfs_set_vroot(vnode_t *); 2727c478bd9Sstevel@tonic-gate static char *nfs_getsrvnames(mntinfo_t *, size_t *); 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate /* 2757c478bd9Sstevel@tonic-gate * from rpcsec module (common/rpcsec) 2767c478bd9Sstevel@tonic-gate */ 2777c478bd9Sstevel@tonic-gate extern int sec_clnt_geth(CLIENT *, struct sec_data *, cred_t *, AUTH **); 2787c478bd9Sstevel@tonic-gate extern void sec_clnt_freeh(AUTH *); 2797c478bd9Sstevel@tonic-gate extern void sec_clnt_freeinfo(struct sec_data *); 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate /* 2827c478bd9Sstevel@tonic-gate * EIO or EINTR are not recoverable errors. 2837c478bd9Sstevel@tonic-gate */ 2847c478bd9Sstevel@tonic-gate #define IS_RECOVERABLE_ERROR(error) !((error == EINTR) || (error == EIO)) 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate /* 2877c478bd9Sstevel@tonic-gate * Common handle get program for NFS, NFS ACL, and NFS AUTH client. 2887c478bd9Sstevel@tonic-gate */ 2897c478bd9Sstevel@tonic-gate static int 2907c478bd9Sstevel@tonic-gate clget_impl(clinfo_t *ci, servinfo_t *svp, cred_t *cr, CLIENT **newcl, 2917c478bd9Sstevel@tonic-gate struct chtab **chp, struct nfs_clnt *nfscl) 2927c478bd9Sstevel@tonic-gate { 2937c478bd9Sstevel@tonic-gate struct chhead *ch, *newch; 2947c478bd9Sstevel@tonic-gate struct chhead **plistp; 2957c478bd9Sstevel@tonic-gate struct chtab *cp; 2967c478bd9Sstevel@tonic-gate int error; 2977c478bd9Sstevel@tonic-gate k_sigset_t smask; 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate if (newcl == NULL || chp == NULL || ci == NULL) 3007c478bd9Sstevel@tonic-gate return (EINVAL); 3017c478bd9Sstevel@tonic-gate 3027c478bd9Sstevel@tonic-gate *newcl = NULL; 3037c478bd9Sstevel@tonic-gate *chp = NULL; 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate /* 3067c478bd9Sstevel@tonic-gate * Find an unused handle or create one 3077c478bd9Sstevel@tonic-gate */ 3087c478bd9Sstevel@tonic-gate newch = NULL; 3097c478bd9Sstevel@tonic-gate nfscl->nfscl_stat.clgets.value.ui64++; 3107c478bd9Sstevel@tonic-gate top: 3117c478bd9Sstevel@tonic-gate /* 3127c478bd9Sstevel@tonic-gate * Find the correct entry in the cache to check for free 3137c478bd9Sstevel@tonic-gate * client handles. The search is based on the RPC program 3147c478bd9Sstevel@tonic-gate * number, program version number, dev_t for the transport 3157c478bd9Sstevel@tonic-gate * device, and the protocol family. 3167c478bd9Sstevel@tonic-gate */ 3177c478bd9Sstevel@tonic-gate mutex_enter(&nfscl->nfscl_chtable_lock); 3187c478bd9Sstevel@tonic-gate plistp = &nfscl->nfscl_chtable; 3197c478bd9Sstevel@tonic-gate for (ch = nfscl->nfscl_chtable; ch != NULL; ch = ch->ch_next) { 3207c478bd9Sstevel@tonic-gate if (ch->ch_prog == ci->cl_prog && 3217c478bd9Sstevel@tonic-gate ch->ch_vers == ci->cl_vers && 3227c478bd9Sstevel@tonic-gate ch->ch_dev == svp->sv_knconf->knc_rdev && 3237c478bd9Sstevel@tonic-gate (strcmp(ch->ch_protofmly, 3247c478bd9Sstevel@tonic-gate svp->sv_knconf->knc_protofmly) == 0)) 3257c478bd9Sstevel@tonic-gate break; 3267c478bd9Sstevel@tonic-gate plistp = &ch->ch_next; 3277c478bd9Sstevel@tonic-gate } 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate /* 3307c478bd9Sstevel@tonic-gate * If we didn't find a cache entry for this quadruple, then 3317c478bd9Sstevel@tonic-gate * create one. If we don't have one already preallocated, 3327c478bd9Sstevel@tonic-gate * then drop the cache lock, create one, and then start over. 3337c478bd9Sstevel@tonic-gate * If we did have a preallocated entry, then just add it to 3347c478bd9Sstevel@tonic-gate * the front of the list. 3357c478bd9Sstevel@tonic-gate */ 3367c478bd9Sstevel@tonic-gate if (ch == NULL) { 3377c478bd9Sstevel@tonic-gate if (newch == NULL) { 3387c478bd9Sstevel@tonic-gate mutex_exit(&nfscl->nfscl_chtable_lock); 3397c478bd9Sstevel@tonic-gate newch = kmem_alloc(sizeof (*newch), KM_SLEEP); 3407c478bd9Sstevel@tonic-gate newch->ch_timesused = 0; 3417c478bd9Sstevel@tonic-gate newch->ch_prog = ci->cl_prog; 3427c478bd9Sstevel@tonic-gate newch->ch_vers = ci->cl_vers; 3437c478bd9Sstevel@tonic-gate newch->ch_dev = svp->sv_knconf->knc_rdev; 3447c478bd9Sstevel@tonic-gate newch->ch_protofmly = kmem_alloc( 3457c478bd9Sstevel@tonic-gate strlen(svp->sv_knconf->knc_protofmly) + 1, 3467c478bd9Sstevel@tonic-gate KM_SLEEP); 3477c478bd9Sstevel@tonic-gate (void) strcpy(newch->ch_protofmly, 3487c478bd9Sstevel@tonic-gate svp->sv_knconf->knc_protofmly); 3497c478bd9Sstevel@tonic-gate newch->ch_list = NULL; 3507c478bd9Sstevel@tonic-gate goto top; 3517c478bd9Sstevel@tonic-gate } 3527c478bd9Sstevel@tonic-gate ch = newch; 3537c478bd9Sstevel@tonic-gate newch = NULL; 3547c478bd9Sstevel@tonic-gate ch->ch_next = nfscl->nfscl_chtable; 3557c478bd9Sstevel@tonic-gate nfscl->nfscl_chtable = ch; 3567c478bd9Sstevel@tonic-gate /* 3577c478bd9Sstevel@tonic-gate * We found a cache entry, but if it isn't on the front of the 3587c478bd9Sstevel@tonic-gate * list, then move it to the front of the list to try to take 3597c478bd9Sstevel@tonic-gate * advantage of locality of operations. 3607c478bd9Sstevel@tonic-gate */ 3617c478bd9Sstevel@tonic-gate } else if (ch != nfscl->nfscl_chtable) { 3627c478bd9Sstevel@tonic-gate *plistp = ch->ch_next; 3637c478bd9Sstevel@tonic-gate ch->ch_next = nfscl->nfscl_chtable; 3647c478bd9Sstevel@tonic-gate nfscl->nfscl_chtable = ch; 3657c478bd9Sstevel@tonic-gate } 3667c478bd9Sstevel@tonic-gate 3677c478bd9Sstevel@tonic-gate /* 3687c478bd9Sstevel@tonic-gate * If there was a free client handle cached, then remove it 3697c478bd9Sstevel@tonic-gate * from the list, init it, and use it. 3707c478bd9Sstevel@tonic-gate */ 3717c478bd9Sstevel@tonic-gate if (ch->ch_list != NULL) { 3727c478bd9Sstevel@tonic-gate cp = ch->ch_list; 3737c478bd9Sstevel@tonic-gate ch->ch_list = cp->ch_list; 3747c478bd9Sstevel@tonic-gate mutex_exit(&nfscl->nfscl_chtable_lock); 3757c478bd9Sstevel@tonic-gate if (newch != NULL) { 3767c478bd9Sstevel@tonic-gate kmem_free(newch->ch_protofmly, 3777c478bd9Sstevel@tonic-gate strlen(newch->ch_protofmly) + 1); 3787c478bd9Sstevel@tonic-gate kmem_free(newch, sizeof (*newch)); 3797c478bd9Sstevel@tonic-gate } 3807c478bd9Sstevel@tonic-gate (void) clnt_tli_kinit(cp->ch_client, svp->sv_knconf, 3817c478bd9Sstevel@tonic-gate &svp->sv_addr, ci->cl_readsize, ci->cl_retrans, cr); 3827c478bd9Sstevel@tonic-gate error = sec_clnt_geth(cp->ch_client, svp->sv_secdata, cr, 3837c478bd9Sstevel@tonic-gate &cp->ch_client->cl_auth); 3847c478bd9Sstevel@tonic-gate if (error || cp->ch_client->cl_auth == NULL) { 3857c478bd9Sstevel@tonic-gate CLNT_DESTROY(cp->ch_client); 3867c478bd9Sstevel@tonic-gate kmem_cache_free(chtab_cache, cp); 3877c478bd9Sstevel@tonic-gate return ((error != 0) ? error : EINTR); 3887c478bd9Sstevel@tonic-gate } 3897c478bd9Sstevel@tonic-gate ch->ch_timesused++; 3907c478bd9Sstevel@tonic-gate *newcl = cp->ch_client; 3917c478bd9Sstevel@tonic-gate *chp = cp; 3927c478bd9Sstevel@tonic-gate return (0); 3937c478bd9Sstevel@tonic-gate } 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate /* 3967c478bd9Sstevel@tonic-gate * There weren't any free client handles which fit, so allocate 3977c478bd9Sstevel@tonic-gate * a new one and use that. 3987c478bd9Sstevel@tonic-gate */ 3997c478bd9Sstevel@tonic-gate #ifdef DEBUG 4007c478bd9Sstevel@tonic-gate atomic_add_64(&nfscl->nfscl_stat.clalloc.value.ui64, 1); 4017c478bd9Sstevel@tonic-gate #endif 4027c478bd9Sstevel@tonic-gate mutex_exit(&nfscl->nfscl_chtable_lock); 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate nfscl->nfscl_stat.cltoomany.value.ui64++; 4057c478bd9Sstevel@tonic-gate if (newch != NULL) { 4067c478bd9Sstevel@tonic-gate kmem_free(newch->ch_protofmly, strlen(newch->ch_protofmly) + 1); 4077c478bd9Sstevel@tonic-gate kmem_free(newch, sizeof (*newch)); 4087c478bd9Sstevel@tonic-gate } 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate cp = kmem_cache_alloc(chtab_cache, KM_SLEEP); 4117c478bd9Sstevel@tonic-gate cp->ch_head = ch; 4127c478bd9Sstevel@tonic-gate 4137c478bd9Sstevel@tonic-gate sigintr(&smask, (int)ci->cl_flags & MI_INT); 4147c478bd9Sstevel@tonic-gate error = clnt_tli_kcreate(svp->sv_knconf, &svp->sv_addr, ci->cl_prog, 4157c478bd9Sstevel@tonic-gate ci->cl_vers, ci->cl_readsize, ci->cl_retrans, cr, &cp->ch_client); 4167c478bd9Sstevel@tonic-gate sigunintr(&smask); 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate if (error != 0) { 4197c478bd9Sstevel@tonic-gate kmem_cache_free(chtab_cache, cp); 4207c478bd9Sstevel@tonic-gate #ifdef DEBUG 4217c478bd9Sstevel@tonic-gate atomic_add_64(&nfscl->nfscl_stat.clalloc.value.ui64, -1); 4227c478bd9Sstevel@tonic-gate #endif 4237c478bd9Sstevel@tonic-gate /* 4247c478bd9Sstevel@tonic-gate * Warning is unnecessary if error is EINTR. 4257c478bd9Sstevel@tonic-gate */ 4267c478bd9Sstevel@tonic-gate if (error != EINTR) { 4277c478bd9Sstevel@tonic-gate nfs_cmn_err(error, CE_WARN, 4287c478bd9Sstevel@tonic-gate "clget: couldn't create handle: %m\n"); 4297c478bd9Sstevel@tonic-gate } 4307c478bd9Sstevel@tonic-gate return (error); 4317c478bd9Sstevel@tonic-gate } 4327c478bd9Sstevel@tonic-gate (void) CLNT_CONTROL(cp->ch_client, CLSET_PROGRESS, NULL); 4337c478bd9Sstevel@tonic-gate auth_destroy(cp->ch_client->cl_auth); 4347c478bd9Sstevel@tonic-gate error = sec_clnt_geth(cp->ch_client, svp->sv_secdata, cr, 4357c478bd9Sstevel@tonic-gate &cp->ch_client->cl_auth); 4367c478bd9Sstevel@tonic-gate if (error || cp->ch_client->cl_auth == NULL) { 4377c478bd9Sstevel@tonic-gate CLNT_DESTROY(cp->ch_client); 4387c478bd9Sstevel@tonic-gate kmem_cache_free(chtab_cache, cp); 4397c478bd9Sstevel@tonic-gate #ifdef DEBUG 4407c478bd9Sstevel@tonic-gate atomic_add_64(&nfscl->nfscl_stat.clalloc.value.ui64, -1); 4417c478bd9Sstevel@tonic-gate #endif 4427c478bd9Sstevel@tonic-gate return ((error != 0) ? error : EINTR); 4437c478bd9Sstevel@tonic-gate } 4447c478bd9Sstevel@tonic-gate ch->ch_timesused++; 4457c478bd9Sstevel@tonic-gate *newcl = cp->ch_client; 4467c478bd9Sstevel@tonic-gate ASSERT(cp->ch_client->cl_nosignal == FALSE); 4477c478bd9Sstevel@tonic-gate *chp = cp; 4487c478bd9Sstevel@tonic-gate return (0); 4497c478bd9Sstevel@tonic-gate } 4507c478bd9Sstevel@tonic-gate 4517c478bd9Sstevel@tonic-gate int 4527c478bd9Sstevel@tonic-gate clget(clinfo_t *ci, servinfo_t *svp, cred_t *cr, CLIENT **newcl, 4537c478bd9Sstevel@tonic-gate struct chtab **chp) 4547c478bd9Sstevel@tonic-gate { 4557c478bd9Sstevel@tonic-gate struct nfs_clnt *nfscl; 4567c478bd9Sstevel@tonic-gate 457*108322fbScarlsonj nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone()); 4587c478bd9Sstevel@tonic-gate ASSERT(nfscl != NULL); 4597c478bd9Sstevel@tonic-gate 4607c478bd9Sstevel@tonic-gate return (clget_impl(ci, svp, cr, newcl, chp, nfscl)); 4617c478bd9Sstevel@tonic-gate } 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate static int 4647c478bd9Sstevel@tonic-gate acl_clget(mntinfo_t *mi, servinfo_t *svp, cred_t *cr, CLIENT **newcl, 4657c478bd9Sstevel@tonic-gate struct chtab **chp, struct nfs_clnt *nfscl) 4667c478bd9Sstevel@tonic-gate { 4677c478bd9Sstevel@tonic-gate clinfo_t ci; 4687c478bd9Sstevel@tonic-gate int error; 4697c478bd9Sstevel@tonic-gate 4707c478bd9Sstevel@tonic-gate /* 4717c478bd9Sstevel@tonic-gate * Set read buffer size to rsize 4727c478bd9Sstevel@tonic-gate * and add room for RPC headers. 4737c478bd9Sstevel@tonic-gate */ 4747c478bd9Sstevel@tonic-gate ci.cl_readsize = mi->mi_tsize; 4757c478bd9Sstevel@tonic-gate if (ci.cl_readsize != 0) 4767c478bd9Sstevel@tonic-gate ci.cl_readsize += (RPC_MAXDATASIZE - NFS_MAXDATA); 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate /* 4797c478bd9Sstevel@tonic-gate * If soft mount and server is down just try once. 4807c478bd9Sstevel@tonic-gate * meaning: do not retransmit. 4817c478bd9Sstevel@tonic-gate */ 4827c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_HARD) && (mi->mi_flags & MI_DOWN)) 4837c478bd9Sstevel@tonic-gate ci.cl_retrans = 0; 4847c478bd9Sstevel@tonic-gate else 4857c478bd9Sstevel@tonic-gate ci.cl_retrans = mi->mi_retrans; 4867c478bd9Sstevel@tonic-gate 4877c478bd9Sstevel@tonic-gate ci.cl_prog = NFS_ACL_PROGRAM; 4887c478bd9Sstevel@tonic-gate ci.cl_vers = mi->mi_vers; 4897c478bd9Sstevel@tonic-gate ci.cl_flags = mi->mi_flags; 4907c478bd9Sstevel@tonic-gate 4917c478bd9Sstevel@tonic-gate /* 4927c478bd9Sstevel@tonic-gate * clget calls sec_clnt_geth() to get an auth handle. For RPCSEC_GSS 4937c478bd9Sstevel@tonic-gate * security flavor, the client tries to establish a security context 4947c478bd9Sstevel@tonic-gate * by contacting the server. If the connection is timed out or reset, 4957c478bd9Sstevel@tonic-gate * e.g. server reboot, we will try again. 4967c478bd9Sstevel@tonic-gate */ 4977c478bd9Sstevel@tonic-gate do { 4987c478bd9Sstevel@tonic-gate error = clget_impl(&ci, svp, cr, newcl, chp, nfscl); 4997c478bd9Sstevel@tonic-gate 5007c478bd9Sstevel@tonic-gate if (error == 0) 5017c478bd9Sstevel@tonic-gate break; 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate /* 5047c478bd9Sstevel@tonic-gate * For forced unmount or zone shutdown, bail out, no retry. 5057c478bd9Sstevel@tonic-gate */ 5067c478bd9Sstevel@tonic-gate if (FS_OR_ZONE_GONE(mi->mi_vfsp)) { 5077c478bd9Sstevel@tonic-gate error = EIO; 5087c478bd9Sstevel@tonic-gate break; 5097c478bd9Sstevel@tonic-gate } 5107c478bd9Sstevel@tonic-gate 5117c478bd9Sstevel@tonic-gate /* do not retry for softmount */ 5127c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_HARD)) 5137c478bd9Sstevel@tonic-gate break; 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate /* let the caller deal with the failover case */ 5167c478bd9Sstevel@tonic-gate if (FAILOVER_MOUNT(mi)) 5177c478bd9Sstevel@tonic-gate break; 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate } while (error == ETIMEDOUT || error == ECONNRESET); 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate return (error); 5227c478bd9Sstevel@tonic-gate } 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate static int 5257c478bd9Sstevel@tonic-gate nfs_clget(mntinfo_t *mi, servinfo_t *svp, cred_t *cr, CLIENT **newcl, 5267c478bd9Sstevel@tonic-gate struct chtab **chp, struct nfs_clnt *nfscl) 5277c478bd9Sstevel@tonic-gate { 5287c478bd9Sstevel@tonic-gate clinfo_t ci; 5297c478bd9Sstevel@tonic-gate int error; 5307c478bd9Sstevel@tonic-gate 5317c478bd9Sstevel@tonic-gate /* 5327c478bd9Sstevel@tonic-gate * Set read buffer size to rsize 5337c478bd9Sstevel@tonic-gate * and add room for RPC headers. 5347c478bd9Sstevel@tonic-gate */ 5357c478bd9Sstevel@tonic-gate ci.cl_readsize = mi->mi_tsize; 5367c478bd9Sstevel@tonic-gate if (ci.cl_readsize != 0) 5377c478bd9Sstevel@tonic-gate ci.cl_readsize += (RPC_MAXDATASIZE - NFS_MAXDATA); 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate /* 5407c478bd9Sstevel@tonic-gate * If soft mount and server is down just try once. 5417c478bd9Sstevel@tonic-gate * meaning: do not retransmit. 5427c478bd9Sstevel@tonic-gate */ 5437c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_HARD) && (mi->mi_flags & MI_DOWN)) 5447c478bd9Sstevel@tonic-gate ci.cl_retrans = 0; 5457c478bd9Sstevel@tonic-gate else 5467c478bd9Sstevel@tonic-gate ci.cl_retrans = mi->mi_retrans; 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate ci.cl_prog = mi->mi_prog; 5497c478bd9Sstevel@tonic-gate ci.cl_vers = mi->mi_vers; 5507c478bd9Sstevel@tonic-gate ci.cl_flags = mi->mi_flags; 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate /* 5537c478bd9Sstevel@tonic-gate * clget calls sec_clnt_geth() to get an auth handle. For RPCSEC_GSS 5547c478bd9Sstevel@tonic-gate * security flavor, the client tries to establish a security context 5557c478bd9Sstevel@tonic-gate * by contacting the server. If the connection is timed out or reset, 5567c478bd9Sstevel@tonic-gate * e.g. server reboot, we will try again. 5577c478bd9Sstevel@tonic-gate */ 5587c478bd9Sstevel@tonic-gate do { 5597c478bd9Sstevel@tonic-gate error = clget_impl(&ci, svp, cr, newcl, chp, nfscl); 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate if (error == 0) 5627c478bd9Sstevel@tonic-gate break; 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate /* 5657c478bd9Sstevel@tonic-gate * For forced unmount or zone shutdown, bail out, no retry. 5667c478bd9Sstevel@tonic-gate */ 5677c478bd9Sstevel@tonic-gate if (FS_OR_ZONE_GONE(mi->mi_vfsp)) { 5687c478bd9Sstevel@tonic-gate error = EIO; 5697c478bd9Sstevel@tonic-gate break; 5707c478bd9Sstevel@tonic-gate } 5717c478bd9Sstevel@tonic-gate 5727c478bd9Sstevel@tonic-gate /* do not retry for softmount */ 5737c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_HARD)) 5747c478bd9Sstevel@tonic-gate break; 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate /* let the caller deal with the failover case */ 5777c478bd9Sstevel@tonic-gate if (FAILOVER_MOUNT(mi)) 5787c478bd9Sstevel@tonic-gate break; 5797c478bd9Sstevel@tonic-gate 5807c478bd9Sstevel@tonic-gate } while (error == ETIMEDOUT || error == ECONNRESET); 5817c478bd9Sstevel@tonic-gate 5827c478bd9Sstevel@tonic-gate return (error); 5837c478bd9Sstevel@tonic-gate } 5847c478bd9Sstevel@tonic-gate 5857c478bd9Sstevel@tonic-gate static void 5867c478bd9Sstevel@tonic-gate clfree_impl(CLIENT *cl, struct chtab *cp, struct nfs_clnt *nfscl) 5877c478bd9Sstevel@tonic-gate { 5887c478bd9Sstevel@tonic-gate if (cl->cl_auth != NULL) { 5897c478bd9Sstevel@tonic-gate sec_clnt_freeh(cl->cl_auth); 5907c478bd9Sstevel@tonic-gate cl->cl_auth = NULL; 5917c478bd9Sstevel@tonic-gate } 5927c478bd9Sstevel@tonic-gate 5937c478bd9Sstevel@tonic-gate /* 5947c478bd9Sstevel@tonic-gate * Timestamp this cache entry so that we know when it was last 5957c478bd9Sstevel@tonic-gate * used. 5967c478bd9Sstevel@tonic-gate */ 5977c478bd9Sstevel@tonic-gate cp->ch_freed = gethrestime_sec(); 5987c478bd9Sstevel@tonic-gate 5997c478bd9Sstevel@tonic-gate /* 6007c478bd9Sstevel@tonic-gate * Add the free client handle to the front of the list. 6017c478bd9Sstevel@tonic-gate * This way, the list will be sorted in youngest to oldest 6027c478bd9Sstevel@tonic-gate * order. 6037c478bd9Sstevel@tonic-gate */ 6047c478bd9Sstevel@tonic-gate mutex_enter(&nfscl->nfscl_chtable_lock); 6057c478bd9Sstevel@tonic-gate cp->ch_list = cp->ch_head->ch_list; 6067c478bd9Sstevel@tonic-gate cp->ch_head->ch_list = cp; 6077c478bd9Sstevel@tonic-gate mutex_exit(&nfscl->nfscl_chtable_lock); 6087c478bd9Sstevel@tonic-gate } 6097c478bd9Sstevel@tonic-gate 6107c478bd9Sstevel@tonic-gate void 6117c478bd9Sstevel@tonic-gate clfree(CLIENT *cl, struct chtab *cp) 6127c478bd9Sstevel@tonic-gate { 6137c478bd9Sstevel@tonic-gate struct nfs_clnt *nfscl; 6147c478bd9Sstevel@tonic-gate 615*108322fbScarlsonj nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone()); 6167c478bd9Sstevel@tonic-gate ASSERT(nfscl != NULL); 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate clfree_impl(cl, cp, nfscl); 6197c478bd9Sstevel@tonic-gate } 6207c478bd9Sstevel@tonic-gate 6217c478bd9Sstevel@tonic-gate #define CL_HOLDTIME 60 /* time to hold client handles */ 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate static void 6247c478bd9Sstevel@tonic-gate clreclaim_zone(struct nfs_clnt *nfscl, uint_t cl_holdtime) 6257c478bd9Sstevel@tonic-gate { 6267c478bd9Sstevel@tonic-gate struct chhead *ch; 6277c478bd9Sstevel@tonic-gate struct chtab *cp; /* list of objects that can be reclaimed */ 6287c478bd9Sstevel@tonic-gate struct chtab *cpe; 6297c478bd9Sstevel@tonic-gate struct chtab *cpl; 6307c478bd9Sstevel@tonic-gate struct chtab **cpp; 6317c478bd9Sstevel@tonic-gate #ifdef DEBUG 6327c478bd9Sstevel@tonic-gate int n = 0; 6337c478bd9Sstevel@tonic-gate #endif 6347c478bd9Sstevel@tonic-gate 6357c478bd9Sstevel@tonic-gate /* 6367c478bd9Sstevel@tonic-gate * Need to reclaim some memory, so step through the cache 6377c478bd9Sstevel@tonic-gate * looking through the lists for entries which can be freed. 6387c478bd9Sstevel@tonic-gate */ 6397c478bd9Sstevel@tonic-gate cp = NULL; 6407c478bd9Sstevel@tonic-gate 6417c478bd9Sstevel@tonic-gate mutex_enter(&nfscl->nfscl_chtable_lock); 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate /* 6447c478bd9Sstevel@tonic-gate * Here we step through each non-NULL quadruple and start to 6457c478bd9Sstevel@tonic-gate * construct the reclaim list pointed to by cp. Note that 6467c478bd9Sstevel@tonic-gate * cp will contain all eligible chtab entries. When this traversal 6477c478bd9Sstevel@tonic-gate * completes, chtab entries from the last quadruple will be at the 6487c478bd9Sstevel@tonic-gate * front of cp and entries from previously inspected quadruples have 6497c478bd9Sstevel@tonic-gate * been appended to the rear of cp. 6507c478bd9Sstevel@tonic-gate */ 6517c478bd9Sstevel@tonic-gate for (ch = nfscl->nfscl_chtable; ch != NULL; ch = ch->ch_next) { 6527c478bd9Sstevel@tonic-gate if (ch->ch_list == NULL) 6537c478bd9Sstevel@tonic-gate continue; 6547c478bd9Sstevel@tonic-gate /* 6557c478bd9Sstevel@tonic-gate * Search each list for entries older then 6567c478bd9Sstevel@tonic-gate * cl_holdtime seconds. The lists are maintained 6577c478bd9Sstevel@tonic-gate * in youngest to oldest order so that when the 6587c478bd9Sstevel@tonic-gate * first entry is found which is old enough, then 6597c478bd9Sstevel@tonic-gate * all of the rest of the entries on the list will 6607c478bd9Sstevel@tonic-gate * be old enough as well. 6617c478bd9Sstevel@tonic-gate */ 6627c478bd9Sstevel@tonic-gate cpl = ch->ch_list; 6637c478bd9Sstevel@tonic-gate cpp = &ch->ch_list; 6647c478bd9Sstevel@tonic-gate while (cpl != NULL && 6657c478bd9Sstevel@tonic-gate cpl->ch_freed + cl_holdtime > gethrestime_sec()) { 6667c478bd9Sstevel@tonic-gate cpp = &cpl->ch_list; 6677c478bd9Sstevel@tonic-gate cpl = cpl->ch_list; 6687c478bd9Sstevel@tonic-gate } 6697c478bd9Sstevel@tonic-gate if (cpl != NULL) { 6707c478bd9Sstevel@tonic-gate *cpp = NULL; 6717c478bd9Sstevel@tonic-gate if (cp != NULL) { 6727c478bd9Sstevel@tonic-gate cpe = cpl; 6737c478bd9Sstevel@tonic-gate while (cpe->ch_list != NULL) 6747c478bd9Sstevel@tonic-gate cpe = cpe->ch_list; 6757c478bd9Sstevel@tonic-gate cpe->ch_list = cp; 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate cp = cpl; 6787c478bd9Sstevel@tonic-gate } 6797c478bd9Sstevel@tonic-gate } 6807c478bd9Sstevel@tonic-gate 6817c478bd9Sstevel@tonic-gate mutex_exit(&nfscl->nfscl_chtable_lock); 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate /* 6847c478bd9Sstevel@tonic-gate * If cp is empty, then there is nothing to reclaim here. 6857c478bd9Sstevel@tonic-gate */ 6867c478bd9Sstevel@tonic-gate if (cp == NULL) 6877c478bd9Sstevel@tonic-gate return; 6887c478bd9Sstevel@tonic-gate 6897c478bd9Sstevel@tonic-gate /* 6907c478bd9Sstevel@tonic-gate * Step through the list of entries to free, destroying each client 6917c478bd9Sstevel@tonic-gate * handle and kmem_free'ing the memory for each entry. 6927c478bd9Sstevel@tonic-gate */ 6937c478bd9Sstevel@tonic-gate while (cp != NULL) { 6947c478bd9Sstevel@tonic-gate #ifdef DEBUG 6957c478bd9Sstevel@tonic-gate n++; 6967c478bd9Sstevel@tonic-gate #endif 6977c478bd9Sstevel@tonic-gate CLNT_DESTROY(cp->ch_client); 6987c478bd9Sstevel@tonic-gate cpl = cp->ch_list; 6997c478bd9Sstevel@tonic-gate kmem_cache_free(chtab_cache, cp); 7007c478bd9Sstevel@tonic-gate cp = cpl; 7017c478bd9Sstevel@tonic-gate } 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate #ifdef DEBUG 7047c478bd9Sstevel@tonic-gate /* 7057c478bd9Sstevel@tonic-gate * Update clalloc so that nfsstat shows the current number 7067c478bd9Sstevel@tonic-gate * of allocated client handles. 7077c478bd9Sstevel@tonic-gate */ 7087c478bd9Sstevel@tonic-gate atomic_add_64(&nfscl->nfscl_stat.clalloc.value.ui64, -n); 7097c478bd9Sstevel@tonic-gate #endif 7107c478bd9Sstevel@tonic-gate } 7117c478bd9Sstevel@tonic-gate 7127c478bd9Sstevel@tonic-gate /* ARGSUSED */ 7137c478bd9Sstevel@tonic-gate static void 7147c478bd9Sstevel@tonic-gate clreclaim(void *all) 7157c478bd9Sstevel@tonic-gate { 7167c478bd9Sstevel@tonic-gate struct nfs_clnt *nfscl; 7177c478bd9Sstevel@tonic-gate 7187c478bd9Sstevel@tonic-gate #ifdef DEBUG 7197c478bd9Sstevel@tonic-gate clstat_debug.clreclaim.value.ui64++; 7207c478bd9Sstevel@tonic-gate #endif 7217c478bd9Sstevel@tonic-gate /* 7227c478bd9Sstevel@tonic-gate * The system is low on memory; go through and try to reclaim some from 7237c478bd9Sstevel@tonic-gate * every zone on the system. 7247c478bd9Sstevel@tonic-gate */ 7257c478bd9Sstevel@tonic-gate mutex_enter(&nfs_clnt_list_lock); 7267c478bd9Sstevel@tonic-gate nfscl = list_head(&nfs_clnt_list); 7277c478bd9Sstevel@tonic-gate for (; nfscl != NULL; nfscl = list_next(&nfs_clnt_list, nfscl)) 7287c478bd9Sstevel@tonic-gate clreclaim_zone(nfscl, CL_HOLDTIME); 7297c478bd9Sstevel@tonic-gate mutex_exit(&nfs_clnt_list_lock); 7307c478bd9Sstevel@tonic-gate } 7317c478bd9Sstevel@tonic-gate 7327c478bd9Sstevel@tonic-gate /* 7337c478bd9Sstevel@tonic-gate * Minimum time-out values indexed by call type 7347c478bd9Sstevel@tonic-gate * These units are in "eights" of a second to avoid multiplies 7357c478bd9Sstevel@tonic-gate */ 7367c478bd9Sstevel@tonic-gate static unsigned int minimum_timeo[] = { 7377c478bd9Sstevel@tonic-gate 6, 7, 10 7387c478bd9Sstevel@tonic-gate }; 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate /* 7417c478bd9Sstevel@tonic-gate * Back off for retransmission timeout, MAXTIMO is in hz of a sec 7427c478bd9Sstevel@tonic-gate */ 7437c478bd9Sstevel@tonic-gate #define MAXTIMO (20*hz) 7447c478bd9Sstevel@tonic-gate #define backoff(tim) (((tim) < MAXTIMO) ? dobackoff(tim) : (tim)) 7457c478bd9Sstevel@tonic-gate #define dobackoff(tim) ((((tim) << 1) > MAXTIMO) ? MAXTIMO : ((tim) << 1)) 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate #define MIN_NFS_TSIZE 512 /* minimum "chunk" of NFS IO */ 7487c478bd9Sstevel@tonic-gate #define REDUCE_NFS_TIME (hz/2) /* rtxcur we try to keep under */ 7497c478bd9Sstevel@tonic-gate #define INCREASE_NFS_TIME (hz/3*8) /* srtt we try to keep under (scaled*8) */ 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate /* 7527c478bd9Sstevel@tonic-gate * Function called when rfscall notices that we have been 7537c478bd9Sstevel@tonic-gate * re-transmitting, or when we get a response without retransmissions. 7547c478bd9Sstevel@tonic-gate * Return 1 if the transfer size was adjusted down - 0 if no change. 7557c478bd9Sstevel@tonic-gate */ 7567c478bd9Sstevel@tonic-gate static int 7577c478bd9Sstevel@tonic-gate nfs_feedback(int flag, int which, mntinfo_t *mi) 7587c478bd9Sstevel@tonic-gate { 7597c478bd9Sstevel@tonic-gate int kind; 7607c478bd9Sstevel@tonic-gate int r = 0; 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 7637c478bd9Sstevel@tonic-gate if (flag == FEEDBACK_REXMIT1) { 7647c478bd9Sstevel@tonic-gate if (mi->mi_timers[NFS_CALLTYPES].rt_rtxcur != 0 && 7657c478bd9Sstevel@tonic-gate mi->mi_timers[NFS_CALLTYPES].rt_rtxcur < REDUCE_NFS_TIME) 7667c478bd9Sstevel@tonic-gate goto done; 7677c478bd9Sstevel@tonic-gate if (mi->mi_curread > MIN_NFS_TSIZE) { 7687c478bd9Sstevel@tonic-gate mi->mi_curread /= 2; 7697c478bd9Sstevel@tonic-gate if (mi->mi_curread < MIN_NFS_TSIZE) 7707c478bd9Sstevel@tonic-gate mi->mi_curread = MIN_NFS_TSIZE; 7717c478bd9Sstevel@tonic-gate r = 1; 7727c478bd9Sstevel@tonic-gate } 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate if (mi->mi_curwrite > MIN_NFS_TSIZE) { 7757c478bd9Sstevel@tonic-gate mi->mi_curwrite /= 2; 7767c478bd9Sstevel@tonic-gate if (mi->mi_curwrite < MIN_NFS_TSIZE) 7777c478bd9Sstevel@tonic-gate mi->mi_curwrite = MIN_NFS_TSIZE; 7787c478bd9Sstevel@tonic-gate r = 1; 7797c478bd9Sstevel@tonic-gate } 7807c478bd9Sstevel@tonic-gate } else if (flag == FEEDBACK_OK) { 7817c478bd9Sstevel@tonic-gate kind = mi->mi_timer_type[which]; 7827c478bd9Sstevel@tonic-gate if (kind == 0 || 7837c478bd9Sstevel@tonic-gate mi->mi_timers[kind].rt_srtt >= INCREASE_NFS_TIME) 7847c478bd9Sstevel@tonic-gate goto done; 7857c478bd9Sstevel@tonic-gate if (kind == 1) { 7867c478bd9Sstevel@tonic-gate if (mi->mi_curread >= mi->mi_tsize) 7877c478bd9Sstevel@tonic-gate goto done; 7887c478bd9Sstevel@tonic-gate mi->mi_curread += MIN_NFS_TSIZE; 7897c478bd9Sstevel@tonic-gate if (mi->mi_curread > mi->mi_tsize/2) 7907c478bd9Sstevel@tonic-gate mi->mi_curread = mi->mi_tsize; 7917c478bd9Sstevel@tonic-gate } else if (kind == 2) { 7927c478bd9Sstevel@tonic-gate if (mi->mi_curwrite >= mi->mi_stsize) 7937c478bd9Sstevel@tonic-gate goto done; 7947c478bd9Sstevel@tonic-gate mi->mi_curwrite += MIN_NFS_TSIZE; 7957c478bd9Sstevel@tonic-gate if (mi->mi_curwrite > mi->mi_stsize/2) 7967c478bd9Sstevel@tonic-gate mi->mi_curwrite = mi->mi_stsize; 7977c478bd9Sstevel@tonic-gate } 7987c478bd9Sstevel@tonic-gate } 7997c478bd9Sstevel@tonic-gate done: 8007c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 8017c478bd9Sstevel@tonic-gate return (r); 8027c478bd9Sstevel@tonic-gate } 8037c478bd9Sstevel@tonic-gate 8047c478bd9Sstevel@tonic-gate #ifdef DEBUG 8057c478bd9Sstevel@tonic-gate static int rfs2call_hits = 0; 8067c478bd9Sstevel@tonic-gate static int rfs2call_misses = 0; 8077c478bd9Sstevel@tonic-gate #endif 8087c478bd9Sstevel@tonic-gate 8097c478bd9Sstevel@tonic-gate int 8107c478bd9Sstevel@tonic-gate rfs2call(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp, 8117c478bd9Sstevel@tonic-gate xdrproc_t xdrres, caddr_t resp, cred_t *cr, int *douprintf, 8127c478bd9Sstevel@tonic-gate enum nfsstat *statusp, int flags, failinfo_t *fi) 8137c478bd9Sstevel@tonic-gate { 8147c478bd9Sstevel@tonic-gate int rpcerror; 8157c478bd9Sstevel@tonic-gate enum clnt_stat rpc_status; 8167c478bd9Sstevel@tonic-gate 8177c478bd9Sstevel@tonic-gate ASSERT(statusp != NULL); 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate rpcerror = rfscall(mi, which, xdrargs, argsp, xdrres, resp, 8207c478bd9Sstevel@tonic-gate cr, douprintf, &rpc_status, flags, fi); 8217c478bd9Sstevel@tonic-gate if (!rpcerror) { 8227c478bd9Sstevel@tonic-gate /* 8237c478bd9Sstevel@tonic-gate * See crnetadjust() for comments. 8247c478bd9Sstevel@tonic-gate */ 8257c478bd9Sstevel@tonic-gate if (*statusp == NFSERR_ACCES && 8267c478bd9Sstevel@tonic-gate (cr = crnetadjust(cr)) != NULL) { 8277c478bd9Sstevel@tonic-gate #ifdef DEBUG 8287c478bd9Sstevel@tonic-gate rfs2call_hits++; 8297c478bd9Sstevel@tonic-gate #endif 8307c478bd9Sstevel@tonic-gate rpcerror = rfscall(mi, which, xdrargs, argsp, xdrres, 8317c478bd9Sstevel@tonic-gate resp, cr, douprintf, NULL, flags, fi); 8327c478bd9Sstevel@tonic-gate crfree(cr); 8337c478bd9Sstevel@tonic-gate #ifdef DEBUG 8347c478bd9Sstevel@tonic-gate if (*statusp == NFSERR_ACCES) 8357c478bd9Sstevel@tonic-gate rfs2call_misses++; 8367c478bd9Sstevel@tonic-gate #endif 8377c478bd9Sstevel@tonic-gate } 8387c478bd9Sstevel@tonic-gate } else if (rpc_status == RPC_PROCUNAVAIL) { 8397c478bd9Sstevel@tonic-gate *statusp = NFSERR_OPNOTSUPP; 8407c478bd9Sstevel@tonic-gate rpcerror = 0; 8417c478bd9Sstevel@tonic-gate } 8427c478bd9Sstevel@tonic-gate 8437c478bd9Sstevel@tonic-gate return (rpcerror); 8447c478bd9Sstevel@tonic-gate } 8457c478bd9Sstevel@tonic-gate 8467c478bd9Sstevel@tonic-gate #define NFS3_JUKEBOX_DELAY 10 * hz 8477c478bd9Sstevel@tonic-gate 8487c478bd9Sstevel@tonic-gate static clock_t nfs3_jukebox_delay = 0; 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate #ifdef DEBUG 8517c478bd9Sstevel@tonic-gate static int rfs3call_hits = 0; 8527c478bd9Sstevel@tonic-gate static int rfs3call_misses = 0; 8537c478bd9Sstevel@tonic-gate #endif 8547c478bd9Sstevel@tonic-gate 8557c478bd9Sstevel@tonic-gate int 8567c478bd9Sstevel@tonic-gate rfs3call(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp, 8577c478bd9Sstevel@tonic-gate xdrproc_t xdrres, caddr_t resp, cred_t *cr, int *douprintf, 8587c478bd9Sstevel@tonic-gate nfsstat3 *statusp, int flags, failinfo_t *fi) 8597c478bd9Sstevel@tonic-gate { 8607c478bd9Sstevel@tonic-gate int rpcerror; 8617c478bd9Sstevel@tonic-gate int user_informed; 8627c478bd9Sstevel@tonic-gate 8637c478bd9Sstevel@tonic-gate user_informed = 0; 8647c478bd9Sstevel@tonic-gate do { 8657c478bd9Sstevel@tonic-gate rpcerror = rfscall(mi, which, xdrargs, argsp, xdrres, resp, 8667c478bd9Sstevel@tonic-gate cr, douprintf, NULL, flags, fi); 8677c478bd9Sstevel@tonic-gate if (!rpcerror) { 8687c478bd9Sstevel@tonic-gate cred_t *crr; 8697c478bd9Sstevel@tonic-gate if (*statusp == NFS3ERR_JUKEBOX) { 8707c478bd9Sstevel@tonic-gate if (ttoproc(curthread) == &p0) { 8717c478bd9Sstevel@tonic-gate rpcerror = EAGAIN; 8727c478bd9Sstevel@tonic-gate break; 8737c478bd9Sstevel@tonic-gate } 8747c478bd9Sstevel@tonic-gate if (!user_informed) { 8757c478bd9Sstevel@tonic-gate user_informed = 1; 8767c478bd9Sstevel@tonic-gate uprintf( 8777c478bd9Sstevel@tonic-gate "file temporarily unavailable on the server, retrying...\n"); 8787c478bd9Sstevel@tonic-gate } 8797c478bd9Sstevel@tonic-gate delay(nfs3_jukebox_delay); 8807c478bd9Sstevel@tonic-gate } 8817c478bd9Sstevel@tonic-gate /* 8827c478bd9Sstevel@tonic-gate * See crnetadjust() for comments. 8837c478bd9Sstevel@tonic-gate */ 8847c478bd9Sstevel@tonic-gate else if (*statusp == NFS3ERR_ACCES && 8857c478bd9Sstevel@tonic-gate (crr = crnetadjust(cr)) != NULL) { 8867c478bd9Sstevel@tonic-gate #ifdef DEBUG 8877c478bd9Sstevel@tonic-gate rfs3call_hits++; 8887c478bd9Sstevel@tonic-gate #endif 8897c478bd9Sstevel@tonic-gate rpcerror = rfscall(mi, which, xdrargs, argsp, 8907c478bd9Sstevel@tonic-gate xdrres, resp, crr, douprintf, 8917c478bd9Sstevel@tonic-gate NULL, flags, fi); 8927c478bd9Sstevel@tonic-gate 8937c478bd9Sstevel@tonic-gate crfree(crr); 8947c478bd9Sstevel@tonic-gate #ifdef DEBUG 8957c478bd9Sstevel@tonic-gate if (*statusp == NFS3ERR_ACCES) 8967c478bd9Sstevel@tonic-gate rfs3call_misses++; 8977c478bd9Sstevel@tonic-gate #endif 8987c478bd9Sstevel@tonic-gate } 8997c478bd9Sstevel@tonic-gate } 9007c478bd9Sstevel@tonic-gate } while (!rpcerror && *statusp == NFS3ERR_JUKEBOX); 9017c478bd9Sstevel@tonic-gate 9027c478bd9Sstevel@tonic-gate return (rpcerror); 9037c478bd9Sstevel@tonic-gate } 9047c478bd9Sstevel@tonic-gate 9057c478bd9Sstevel@tonic-gate #define VALID_FH(fi) (VTOR(fi->vp)->r_server == VTOMI(fi->vp)->mi_curr_serv) 9067c478bd9Sstevel@tonic-gate #define INC_READERS(mi) { \ 9077c478bd9Sstevel@tonic-gate mi->mi_readers++; \ 9087c478bd9Sstevel@tonic-gate } 9097c478bd9Sstevel@tonic-gate #define DEC_READERS(mi) { \ 9107c478bd9Sstevel@tonic-gate mi->mi_readers--; \ 9117c478bd9Sstevel@tonic-gate if (mi->mi_readers == 0) \ 9127c478bd9Sstevel@tonic-gate cv_broadcast(&mi->mi_failover_cv); \ 9137c478bd9Sstevel@tonic-gate } 9147c478bd9Sstevel@tonic-gate 9157c478bd9Sstevel@tonic-gate static int 9167c478bd9Sstevel@tonic-gate rfscall(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp, 9177c478bd9Sstevel@tonic-gate xdrproc_t xdrres, caddr_t resp, cred_t *cr, int *douprintf, 9187c478bd9Sstevel@tonic-gate enum clnt_stat *rpc_status, int flags, failinfo_t *fi) 9197c478bd9Sstevel@tonic-gate { 9207c478bd9Sstevel@tonic-gate CLIENT *client; 9217c478bd9Sstevel@tonic-gate struct chtab *ch; 9227c478bd9Sstevel@tonic-gate enum clnt_stat status; 9237c478bd9Sstevel@tonic-gate struct rpc_err rpcerr; 9247c478bd9Sstevel@tonic-gate struct timeval wait; 9257c478bd9Sstevel@tonic-gate int timeo; /* in units of hz */ 9267c478bd9Sstevel@tonic-gate int my_rsize, my_wsize; 9277c478bd9Sstevel@tonic-gate bool_t tryagain; 9287c478bd9Sstevel@tonic-gate k_sigset_t smask; 9297c478bd9Sstevel@tonic-gate servinfo_t *svp; 9307c478bd9Sstevel@tonic-gate struct nfs_clnt *nfscl; 9317c478bd9Sstevel@tonic-gate zoneid_t zoneid = getzoneid(); 9327c478bd9Sstevel@tonic-gate #ifdef DEBUG 9337c478bd9Sstevel@tonic-gate char *bufp; 9347c478bd9Sstevel@tonic-gate #endif 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_NFS, TR_RFSCALL_START, 9387c478bd9Sstevel@tonic-gate "rfscall_start:which %d mi %p", which, mi); 9397c478bd9Sstevel@tonic-gate 940*108322fbScarlsonj nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone()); 9417c478bd9Sstevel@tonic-gate ASSERT(nfscl != NULL); 9427c478bd9Sstevel@tonic-gate 9437c478bd9Sstevel@tonic-gate nfscl->nfscl_stat.calls.value.ui64++; 9447c478bd9Sstevel@tonic-gate mi->mi_reqs[which].value.ui64++; 9457c478bd9Sstevel@tonic-gate 9467c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_SUCCESS; 9477c478bd9Sstevel@tonic-gate 9487c478bd9Sstevel@tonic-gate /* 9497c478bd9Sstevel@tonic-gate * In case of forced unmount or zone shutdown, return EIO. 9507c478bd9Sstevel@tonic-gate */ 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate if (FS_OR_ZONE_GONE(mi->mi_vfsp)) { 9537c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_FAILED; 9547c478bd9Sstevel@tonic-gate rpcerr.re_errno = EIO; 9557c478bd9Sstevel@tonic-gate return (rpcerr.re_errno); 9567c478bd9Sstevel@tonic-gate } 9577c478bd9Sstevel@tonic-gate 9587c478bd9Sstevel@tonic-gate /* 9597c478bd9Sstevel@tonic-gate * Remember the transfer sizes in case 9607c478bd9Sstevel@tonic-gate * nfs_feedback changes them underneath us. 9617c478bd9Sstevel@tonic-gate */ 9627c478bd9Sstevel@tonic-gate my_rsize = mi->mi_curread; 9637c478bd9Sstevel@tonic-gate my_wsize = mi->mi_curwrite; 9647c478bd9Sstevel@tonic-gate 9657c478bd9Sstevel@tonic-gate /* 9667c478bd9Sstevel@tonic-gate * NFS client failover support 9677c478bd9Sstevel@tonic-gate * 9687c478bd9Sstevel@tonic-gate * If this rnode is not in sync with the current server (VALID_FH), 9697c478bd9Sstevel@tonic-gate * we'd like to do a remap to get in sync. We can be interrupted 9707c478bd9Sstevel@tonic-gate * in failover_remap(), and if so we'll bail. Otherwise, we'll 9717c478bd9Sstevel@tonic-gate * use the best info we have to try the RPC. Part of that is 9727c478bd9Sstevel@tonic-gate * unconditionally updating the filehandle copy kept for V3. 9737c478bd9Sstevel@tonic-gate * 9747c478bd9Sstevel@tonic-gate * Locking: INC_READERS/DEC_READERS is a poor man's interrruptible 9757c478bd9Sstevel@tonic-gate * rw_enter(); we're trying to keep the current server from being 9767c478bd9Sstevel@tonic-gate * changed on us until we're done with the remapping and have a 9777c478bd9Sstevel@tonic-gate * matching client handle. We don't want to sending a filehandle 9787c478bd9Sstevel@tonic-gate * to the wrong host. 9797c478bd9Sstevel@tonic-gate */ 9807c478bd9Sstevel@tonic-gate failoverretry: 9817c478bd9Sstevel@tonic-gate if (FAILOVER_MOUNT(mi)) { 9827c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 9837c478bd9Sstevel@tonic-gate if (!(flags & RFSCALL_SOFT) && failover_safe(fi)) { 9847c478bd9Sstevel@tonic-gate if (failover_wait(mi)) { 9857c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 9867c478bd9Sstevel@tonic-gate return (EINTR); 9877c478bd9Sstevel@tonic-gate } 9887c478bd9Sstevel@tonic-gate } 9897c478bd9Sstevel@tonic-gate INC_READERS(mi); 9907c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 9917c478bd9Sstevel@tonic-gate if (fi) { 9927c478bd9Sstevel@tonic-gate if (!VALID_FH(fi) && 9937c478bd9Sstevel@tonic-gate !(flags & RFSCALL_SOFT) && failover_safe(fi)) { 9947c478bd9Sstevel@tonic-gate int remaperr; 9957c478bd9Sstevel@tonic-gate 9967c478bd9Sstevel@tonic-gate svp = mi->mi_curr_serv; 9977c478bd9Sstevel@tonic-gate remaperr = failover_remap(fi); 9987c478bd9Sstevel@tonic-gate if (remaperr != 0) { 9997c478bd9Sstevel@tonic-gate #ifdef DEBUG 10007c478bd9Sstevel@tonic-gate if (remaperr != EINTR) 10017c478bd9Sstevel@tonic-gate nfs_cmn_err(remaperr, CE_WARN, 10027c478bd9Sstevel@tonic-gate "rfscall couldn't failover: %m"); 10037c478bd9Sstevel@tonic-gate #endif 10047c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 10057c478bd9Sstevel@tonic-gate DEC_READERS(mi); 10067c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 10077c478bd9Sstevel@tonic-gate /* 10087c478bd9Sstevel@tonic-gate * If failover_remap returns ETIMEDOUT 10097c478bd9Sstevel@tonic-gate * and the filesystem is hard mounted 10107c478bd9Sstevel@tonic-gate * we have to retry the call with a new 10117c478bd9Sstevel@tonic-gate * server. 10127c478bd9Sstevel@tonic-gate */ 10137c478bd9Sstevel@tonic-gate if ((mi->mi_flags & MI_HARD) && 10147c478bd9Sstevel@tonic-gate IS_RECOVERABLE_ERROR(remaperr)) { 10157c478bd9Sstevel@tonic-gate if (svp == mi->mi_curr_serv) 10167c478bd9Sstevel@tonic-gate failover_newserver(mi); 10177c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_SUCCESS; 10187c478bd9Sstevel@tonic-gate goto failoverretry; 10197c478bd9Sstevel@tonic-gate } 10207c478bd9Sstevel@tonic-gate rpcerr.re_errno = remaperr; 10217c478bd9Sstevel@tonic-gate return (remaperr); 10227c478bd9Sstevel@tonic-gate } 10237c478bd9Sstevel@tonic-gate } 10247c478bd9Sstevel@tonic-gate if (fi->fhp && fi->copyproc) 10257c478bd9Sstevel@tonic-gate (*fi->copyproc)(fi->fhp, fi->vp); 10267c478bd9Sstevel@tonic-gate } 10277c478bd9Sstevel@tonic-gate } 10287c478bd9Sstevel@tonic-gate 10297c478bd9Sstevel@tonic-gate /* 10307c478bd9Sstevel@tonic-gate * clget() calls clnt_tli_kinit() which clears the xid, so we 10317c478bd9Sstevel@tonic-gate * are guaranteed to reprocess the retry as a new request. 10327c478bd9Sstevel@tonic-gate */ 10337c478bd9Sstevel@tonic-gate svp = mi->mi_curr_serv; 10347c478bd9Sstevel@tonic-gate rpcerr.re_errno = nfs_clget(mi, svp, cr, &client, &ch, nfscl); 10357c478bd9Sstevel@tonic-gate 10367c478bd9Sstevel@tonic-gate if (FAILOVER_MOUNT(mi)) { 10377c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 10387c478bd9Sstevel@tonic-gate DEC_READERS(mi); 10397c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 10407c478bd9Sstevel@tonic-gate 10417c478bd9Sstevel@tonic-gate if ((rpcerr.re_errno == ETIMEDOUT || 10427c478bd9Sstevel@tonic-gate rpcerr.re_errno == ECONNRESET) && 10437c478bd9Sstevel@tonic-gate failover_safe(fi)) { 10447c478bd9Sstevel@tonic-gate if (svp == mi->mi_curr_serv) 10457c478bd9Sstevel@tonic-gate failover_newserver(mi); 10467c478bd9Sstevel@tonic-gate goto failoverretry; 10477c478bd9Sstevel@tonic-gate } 10487c478bd9Sstevel@tonic-gate } 10497c478bd9Sstevel@tonic-gate if (rpcerr.re_errno != 0) 10507c478bd9Sstevel@tonic-gate return (rpcerr.re_errno); 10517c478bd9Sstevel@tonic-gate 10527c478bd9Sstevel@tonic-gate if (svp->sv_knconf->knc_semantics == NC_TPI_COTS_ORD || 10537c478bd9Sstevel@tonic-gate svp->sv_knconf->knc_semantics == NC_TPI_COTS) { 10547c478bd9Sstevel@tonic-gate timeo = (mi->mi_timeo * hz) / 10; 10557c478bd9Sstevel@tonic-gate } else { 10567c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 10577c478bd9Sstevel@tonic-gate timeo = CLNT_SETTIMERS(client, 10587c478bd9Sstevel@tonic-gate &(mi->mi_timers[mi->mi_timer_type[which]]), 10597c478bd9Sstevel@tonic-gate &(mi->mi_timers[NFS_CALLTYPES]), 10607c478bd9Sstevel@tonic-gate (minimum_timeo[mi->mi_call_type[which]]*hz)>>3, 10617c478bd9Sstevel@tonic-gate (void (*)())NULL, (caddr_t)mi, 0); 10627c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 10637c478bd9Sstevel@tonic-gate } 10647c478bd9Sstevel@tonic-gate 10657c478bd9Sstevel@tonic-gate /* 10667c478bd9Sstevel@tonic-gate * If hard mounted fs, retry call forever unless hard error occurs. 10677c478bd9Sstevel@tonic-gate */ 10687c478bd9Sstevel@tonic-gate do { 10697c478bd9Sstevel@tonic-gate tryagain = FALSE; 10707c478bd9Sstevel@tonic-gate 10717c478bd9Sstevel@tonic-gate if (FS_OR_ZONE_GONE(mi->mi_vfsp)) { 10727c478bd9Sstevel@tonic-gate status = RPC_FAILED; 10737c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_FAILED; 10747c478bd9Sstevel@tonic-gate rpcerr.re_errno = EIO; 10757c478bd9Sstevel@tonic-gate break; 10767c478bd9Sstevel@tonic-gate } 10777c478bd9Sstevel@tonic-gate 10787c478bd9Sstevel@tonic-gate TICK_TO_TIMEVAL(timeo, &wait); 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate /* 10817c478bd9Sstevel@tonic-gate * Mask out all signals except SIGHUP, SIGINT, SIGQUIT 10827c478bd9Sstevel@tonic-gate * and SIGTERM. (Preserving the existing masks). 10837c478bd9Sstevel@tonic-gate * Mask out SIGINT if mount option nointr is specified. 10847c478bd9Sstevel@tonic-gate */ 10857c478bd9Sstevel@tonic-gate sigintr(&smask, (int)mi->mi_flags & MI_INT); 10867c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_INT)) 10877c478bd9Sstevel@tonic-gate client->cl_nosignal = TRUE; 10887c478bd9Sstevel@tonic-gate 10897c478bd9Sstevel@tonic-gate /* 10907c478bd9Sstevel@tonic-gate * If there is a current signal, then don't bother 10917c478bd9Sstevel@tonic-gate * even trying to send out the request because we 10927c478bd9Sstevel@tonic-gate * won't be able to block waiting for the response. 10937c478bd9Sstevel@tonic-gate * Simply assume RPC_INTR and get on with it. 10947c478bd9Sstevel@tonic-gate */ 10957c478bd9Sstevel@tonic-gate if (ttolwp(curthread) != NULL && ISSIG(curthread, JUSTLOOKING)) 10967c478bd9Sstevel@tonic-gate status = RPC_INTR; 10977c478bd9Sstevel@tonic-gate else { 10987c478bd9Sstevel@tonic-gate status = CLNT_CALL(client, which, xdrargs, argsp, 10997c478bd9Sstevel@tonic-gate xdrres, resp, wait); 11007c478bd9Sstevel@tonic-gate } 11017c478bd9Sstevel@tonic-gate 11027c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_INT)) 11037c478bd9Sstevel@tonic-gate client->cl_nosignal = FALSE; 11047c478bd9Sstevel@tonic-gate /* 11057c478bd9Sstevel@tonic-gate * restore original signal mask 11067c478bd9Sstevel@tonic-gate */ 11077c478bd9Sstevel@tonic-gate sigunintr(&smask); 11087c478bd9Sstevel@tonic-gate 11097c478bd9Sstevel@tonic-gate switch (status) { 11107c478bd9Sstevel@tonic-gate case RPC_SUCCESS: 11117c478bd9Sstevel@tonic-gate if ((mi->mi_flags & MI_DYNAMIC) && 11127c478bd9Sstevel@tonic-gate mi->mi_timer_type[which] != 0 && 11137c478bd9Sstevel@tonic-gate (mi->mi_curread != my_rsize || 11147c478bd9Sstevel@tonic-gate mi->mi_curwrite != my_wsize)) 11157c478bd9Sstevel@tonic-gate (void) nfs_feedback(FEEDBACK_OK, which, mi); 11167c478bd9Sstevel@tonic-gate break; 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate case RPC_INTR: 11197c478bd9Sstevel@tonic-gate /* 11207c478bd9Sstevel@tonic-gate * There is no way to recover from this error, 11217c478bd9Sstevel@tonic-gate * even if mount option nointr is specified. 11227c478bd9Sstevel@tonic-gate * SIGKILL, for example, cannot be blocked. 11237c478bd9Sstevel@tonic-gate */ 11247c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_INTR; 11257c478bd9Sstevel@tonic-gate rpcerr.re_errno = EINTR; 11267c478bd9Sstevel@tonic-gate break; 11277c478bd9Sstevel@tonic-gate 11287c478bd9Sstevel@tonic-gate case RPC_UDERROR: 11297c478bd9Sstevel@tonic-gate /* 11307c478bd9Sstevel@tonic-gate * If the NFS server is local (vold) and 11317c478bd9Sstevel@tonic-gate * it goes away then we get RPC_UDERROR. 11327c478bd9Sstevel@tonic-gate * This is a retryable error, so we would 11337c478bd9Sstevel@tonic-gate * loop, so check to see if the specific 11347c478bd9Sstevel@tonic-gate * error was ECONNRESET, indicating that 11357c478bd9Sstevel@tonic-gate * target did not exist at all. If so, 11367c478bd9Sstevel@tonic-gate * return with RPC_PROGUNAVAIL and 11377c478bd9Sstevel@tonic-gate * ECONNRESET to indicate why. 11387c478bd9Sstevel@tonic-gate */ 11397c478bd9Sstevel@tonic-gate CLNT_GETERR(client, &rpcerr); 11407c478bd9Sstevel@tonic-gate if (rpcerr.re_errno == ECONNRESET) { 11417c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_PROGUNAVAIL; 11427c478bd9Sstevel@tonic-gate rpcerr.re_errno = ECONNRESET; 11437c478bd9Sstevel@tonic-gate break; 11447c478bd9Sstevel@tonic-gate } 11457c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 11467c478bd9Sstevel@tonic-gate 11477c478bd9Sstevel@tonic-gate default: /* probably RPC_TIMEDOUT */ 11487c478bd9Sstevel@tonic-gate if (IS_UNRECOVERABLE_RPC(status)) 11497c478bd9Sstevel@tonic-gate break; 11507c478bd9Sstevel@tonic-gate 11517c478bd9Sstevel@tonic-gate /* 11527c478bd9Sstevel@tonic-gate * increment server not responding count 11537c478bd9Sstevel@tonic-gate */ 11547c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 11557c478bd9Sstevel@tonic-gate mi->mi_noresponse++; 11567c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 11577c478bd9Sstevel@tonic-gate #ifdef DEBUG 11587c478bd9Sstevel@tonic-gate nfscl->nfscl_stat.noresponse.value.ui64++; 11597c478bd9Sstevel@tonic-gate #endif 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_HARD)) { 11627c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_SEMISOFT) || 11637c478bd9Sstevel@tonic-gate (mi->mi_ss_call_type[which] == 0)) 11647c478bd9Sstevel@tonic-gate break; 11657c478bd9Sstevel@tonic-gate } 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate /* 11687c478bd9Sstevel@tonic-gate * The call is in progress (over COTS). 11697c478bd9Sstevel@tonic-gate * Try the CLNT_CALL again, but don't 11707c478bd9Sstevel@tonic-gate * print a noisy error message. 11717c478bd9Sstevel@tonic-gate */ 11727c478bd9Sstevel@tonic-gate if (status == RPC_INPROGRESS) { 11737c478bd9Sstevel@tonic-gate tryagain = TRUE; 11747c478bd9Sstevel@tonic-gate break; 11757c478bd9Sstevel@tonic-gate } 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate if (flags & RFSCALL_SOFT) 11787c478bd9Sstevel@tonic-gate break; 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate /* 11817c478bd9Sstevel@tonic-gate * On zone shutdown, just move on. 11827c478bd9Sstevel@tonic-gate */ 11837c478bd9Sstevel@tonic-gate if (zone_status_get(curproc->p_zone) >= 11847c478bd9Sstevel@tonic-gate ZONE_IS_SHUTTING_DOWN) { 11857c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_FAILED; 11867c478bd9Sstevel@tonic-gate rpcerr.re_errno = EIO; 11877c478bd9Sstevel@tonic-gate break; 11887c478bd9Sstevel@tonic-gate } 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate /* 11917c478bd9Sstevel@tonic-gate * NFS client failover support 11927c478bd9Sstevel@tonic-gate * 11937c478bd9Sstevel@tonic-gate * If the current server just failed us, we'll 11947c478bd9Sstevel@tonic-gate * start the process of finding a new server. 11957c478bd9Sstevel@tonic-gate * After that, we can just retry. 11967c478bd9Sstevel@tonic-gate */ 11977c478bd9Sstevel@tonic-gate if (FAILOVER_MOUNT(mi) && failover_safe(fi)) { 11987c478bd9Sstevel@tonic-gate if (svp == mi->mi_curr_serv) 11997c478bd9Sstevel@tonic-gate failover_newserver(mi); 12007c478bd9Sstevel@tonic-gate clfree_impl(client, ch, nfscl); 12017c478bd9Sstevel@tonic-gate goto failoverretry; 12027c478bd9Sstevel@tonic-gate } 12037c478bd9Sstevel@tonic-gate 12047c478bd9Sstevel@tonic-gate tryagain = TRUE; 12057c478bd9Sstevel@tonic-gate timeo = backoff(timeo); 12067c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 12077c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_PRINTED)) { 12087c478bd9Sstevel@tonic-gate mi->mi_flags |= MI_PRINTED; 12097c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 12107c478bd9Sstevel@tonic-gate #ifdef DEBUG 12117c478bd9Sstevel@tonic-gate zprintf(zoneid, 12127c478bd9Sstevel@tonic-gate "NFS%d server %s not responding still trying\n", 12137c478bd9Sstevel@tonic-gate mi->mi_vers, svp->sv_hostname); 12147c478bd9Sstevel@tonic-gate #else 12157c478bd9Sstevel@tonic-gate zprintf(zoneid, 12167c478bd9Sstevel@tonic-gate "NFS server %s not responding still trying\n", 12177c478bd9Sstevel@tonic-gate svp->sv_hostname); 12187c478bd9Sstevel@tonic-gate #endif 12197c478bd9Sstevel@tonic-gate } else 12207c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 12217c478bd9Sstevel@tonic-gate if (*douprintf && curproc->p_sessp->s_vp != NULL) { 12227c478bd9Sstevel@tonic-gate *douprintf = 0; 12237c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_NOPRINT)) 12247c478bd9Sstevel@tonic-gate #ifdef DEBUG 12257c478bd9Sstevel@tonic-gate uprintf( 12267c478bd9Sstevel@tonic-gate "NFS%d server %s not responding still trying\n", 12277c478bd9Sstevel@tonic-gate mi->mi_vers, svp->sv_hostname); 12287c478bd9Sstevel@tonic-gate #else 12297c478bd9Sstevel@tonic-gate uprintf( 12307c478bd9Sstevel@tonic-gate "NFS server %s not responding still trying\n", 12317c478bd9Sstevel@tonic-gate svp->sv_hostname); 12327c478bd9Sstevel@tonic-gate #endif 12337c478bd9Sstevel@tonic-gate } 12347c478bd9Sstevel@tonic-gate 12357c478bd9Sstevel@tonic-gate /* 12367c478bd9Sstevel@tonic-gate * If doing dynamic adjustment of transfer 12377c478bd9Sstevel@tonic-gate * size and if it's a read or write call 12387c478bd9Sstevel@tonic-gate * and if the transfer size changed while 12397c478bd9Sstevel@tonic-gate * retransmitting or if the feedback routine 12407c478bd9Sstevel@tonic-gate * changed the transfer size, 12417c478bd9Sstevel@tonic-gate * then exit rfscall so that the transfer 12427c478bd9Sstevel@tonic-gate * size can be adjusted at the vnops level. 12437c478bd9Sstevel@tonic-gate */ 12447c478bd9Sstevel@tonic-gate if ((mi->mi_flags & MI_DYNAMIC) && 12457c478bd9Sstevel@tonic-gate mi->mi_timer_type[which] != 0 && 12467c478bd9Sstevel@tonic-gate (mi->mi_curread != my_rsize || 12477c478bd9Sstevel@tonic-gate mi->mi_curwrite != my_wsize || 12487c478bd9Sstevel@tonic-gate nfs_feedback(FEEDBACK_REXMIT1, which, mi))) { 12497c478bd9Sstevel@tonic-gate /* 12507c478bd9Sstevel@tonic-gate * On read or write calls, return 12517c478bd9Sstevel@tonic-gate * back to the vnode ops level if 12527c478bd9Sstevel@tonic-gate * the transfer size changed. 12537c478bd9Sstevel@tonic-gate */ 12547c478bd9Sstevel@tonic-gate clfree_impl(client, ch, nfscl); 12557c478bd9Sstevel@tonic-gate return (ENFS_TRYAGAIN); 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate } 12587c478bd9Sstevel@tonic-gate } while (tryagain); 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate if (status != RPC_SUCCESS) { 12617c478bd9Sstevel@tonic-gate /* 12627c478bd9Sstevel@tonic-gate * Let soft mounts use the timed out message. 12637c478bd9Sstevel@tonic-gate */ 12647c478bd9Sstevel@tonic-gate if (status == RPC_INPROGRESS) 12657c478bd9Sstevel@tonic-gate status = RPC_TIMEDOUT; 12667c478bd9Sstevel@tonic-gate nfscl->nfscl_stat.badcalls.value.ui64++; 12677c478bd9Sstevel@tonic-gate if (status != RPC_INTR) { 12687c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 12697c478bd9Sstevel@tonic-gate mi->mi_flags |= MI_DOWN; 12707c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 12717c478bd9Sstevel@tonic-gate CLNT_GETERR(client, &rpcerr); 12727c478bd9Sstevel@tonic-gate #ifdef DEBUG 12737c478bd9Sstevel@tonic-gate bufp = clnt_sperror(client, svp->sv_hostname); 12747c478bd9Sstevel@tonic-gate zprintf(zoneid, "NFS%d %s failed for %s\n", 12757c478bd9Sstevel@tonic-gate mi->mi_vers, mi->mi_rfsnames[which], bufp); 12767c478bd9Sstevel@tonic-gate if (curproc->p_sessp->s_vp != NULL) { 12777c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_NOPRINT)) { 12787c478bd9Sstevel@tonic-gate uprintf("NFS%d %s failed for %s\n", 12797c478bd9Sstevel@tonic-gate mi->mi_vers, mi->mi_rfsnames[which], 12807c478bd9Sstevel@tonic-gate bufp); 12817c478bd9Sstevel@tonic-gate } 12827c478bd9Sstevel@tonic-gate } 12837c478bd9Sstevel@tonic-gate kmem_free(bufp, MAXPATHLEN); 12847c478bd9Sstevel@tonic-gate #else 12857c478bd9Sstevel@tonic-gate zprintf(zoneid, 12867c478bd9Sstevel@tonic-gate "NFS %s failed for server %s: error %d (%s)\n", 12877c478bd9Sstevel@tonic-gate mi->mi_rfsnames[which], svp->sv_hostname, 12887c478bd9Sstevel@tonic-gate status, clnt_sperrno(status)); 12897c478bd9Sstevel@tonic-gate if (curproc->p_sessp->s_vp != NULL) { 12907c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_NOPRINT)) { 12917c478bd9Sstevel@tonic-gate uprintf( 12927c478bd9Sstevel@tonic-gate "NFS %s failed for server %s: error %d (%s)\n", 12937c478bd9Sstevel@tonic-gate mi->mi_rfsnames[which], 12947c478bd9Sstevel@tonic-gate svp->sv_hostname, status, 12957c478bd9Sstevel@tonic-gate clnt_sperrno(status)); 12967c478bd9Sstevel@tonic-gate } 12977c478bd9Sstevel@tonic-gate } 12987c478bd9Sstevel@tonic-gate #endif 12997c478bd9Sstevel@tonic-gate /* 13007c478bd9Sstevel@tonic-gate * when CLNT_CALL() fails with RPC_AUTHERROR, 13017c478bd9Sstevel@tonic-gate * re_errno is set appropriately depending on 13027c478bd9Sstevel@tonic-gate * the authentication error 13037c478bd9Sstevel@tonic-gate */ 13047c478bd9Sstevel@tonic-gate if (status == RPC_VERSMISMATCH || 13057c478bd9Sstevel@tonic-gate status == RPC_PROGVERSMISMATCH) 13067c478bd9Sstevel@tonic-gate rpcerr.re_errno = EIO; 13077c478bd9Sstevel@tonic-gate } 13087c478bd9Sstevel@tonic-gate } else { 13097c478bd9Sstevel@tonic-gate /* 13107c478bd9Sstevel@tonic-gate * Test the value of mi_down and mi_printed without 13117c478bd9Sstevel@tonic-gate * holding the mi_lock mutex. If they are both zero, 13127c478bd9Sstevel@tonic-gate * then it is okay to skip the down and printed 13137c478bd9Sstevel@tonic-gate * processing. This saves on a mutex_enter and 13147c478bd9Sstevel@tonic-gate * mutex_exit pair for a normal, successful RPC. 13157c478bd9Sstevel@tonic-gate * This was just complete overhead. 13167c478bd9Sstevel@tonic-gate */ 13177c478bd9Sstevel@tonic-gate if (mi->mi_flags & (MI_DOWN | MI_PRINTED)) { 13187c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 13197c478bd9Sstevel@tonic-gate mi->mi_flags &= ~MI_DOWN; 13207c478bd9Sstevel@tonic-gate if (mi->mi_flags & MI_PRINTED) { 13217c478bd9Sstevel@tonic-gate mi->mi_flags &= ~MI_PRINTED; 13227c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 13237c478bd9Sstevel@tonic-gate #ifdef DEBUG 13247c478bd9Sstevel@tonic-gate if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED)) 13257c478bd9Sstevel@tonic-gate zprintf(zoneid, "NFS%d server %s ok\n", 13267c478bd9Sstevel@tonic-gate mi->mi_vers, svp->sv_hostname); 13277c478bd9Sstevel@tonic-gate #else 13287c478bd9Sstevel@tonic-gate if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED)) 13297c478bd9Sstevel@tonic-gate zprintf(zoneid, "NFS server %s ok\n", 13307c478bd9Sstevel@tonic-gate svp->sv_hostname); 13317c478bd9Sstevel@tonic-gate #endif 13327c478bd9Sstevel@tonic-gate } else 13337c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 13347c478bd9Sstevel@tonic-gate } 13357c478bd9Sstevel@tonic-gate 13367c478bd9Sstevel@tonic-gate if (*douprintf == 0) { 13377c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_NOPRINT)) 13387c478bd9Sstevel@tonic-gate #ifdef DEBUG 13397c478bd9Sstevel@tonic-gate if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED)) 13407c478bd9Sstevel@tonic-gate uprintf("NFS%d server %s ok\n", 13417c478bd9Sstevel@tonic-gate mi->mi_vers, svp->sv_hostname); 13427c478bd9Sstevel@tonic-gate #else 13437c478bd9Sstevel@tonic-gate if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED)) 13447c478bd9Sstevel@tonic-gate uprintf("NFS server %s ok\n", svp->sv_hostname); 13457c478bd9Sstevel@tonic-gate #endif 13467c478bd9Sstevel@tonic-gate *douprintf = 1; 13477c478bd9Sstevel@tonic-gate } 13487c478bd9Sstevel@tonic-gate } 13497c478bd9Sstevel@tonic-gate 13507c478bd9Sstevel@tonic-gate clfree_impl(client, ch, nfscl); 13517c478bd9Sstevel@tonic-gate 13527c478bd9Sstevel@tonic-gate ASSERT(rpcerr.re_status == RPC_SUCCESS || rpcerr.re_errno != 0); 13537c478bd9Sstevel@tonic-gate 13547c478bd9Sstevel@tonic-gate if (rpc_status != NULL) 13557c478bd9Sstevel@tonic-gate *rpc_status = rpcerr.re_status; 13567c478bd9Sstevel@tonic-gate 13577c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_NFS, TR_RFSCALL_END, "rfscall_end:errno %d", 13587c478bd9Sstevel@tonic-gate rpcerr.re_errno); 13597c478bd9Sstevel@tonic-gate 13607c478bd9Sstevel@tonic-gate return (rpcerr.re_errno); 13617c478bd9Sstevel@tonic-gate } 13627c478bd9Sstevel@tonic-gate 13637c478bd9Sstevel@tonic-gate #ifdef DEBUG 13647c478bd9Sstevel@tonic-gate static int acl2call_hits = 0; 13657c478bd9Sstevel@tonic-gate static int acl2call_misses = 0; 13667c478bd9Sstevel@tonic-gate #endif 13677c478bd9Sstevel@tonic-gate 13687c478bd9Sstevel@tonic-gate int 13697c478bd9Sstevel@tonic-gate acl2call(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp, 13707c478bd9Sstevel@tonic-gate xdrproc_t xdrres, caddr_t resp, cred_t *cr, int *douprintf, 13717c478bd9Sstevel@tonic-gate enum nfsstat *statusp, int flags, failinfo_t *fi) 13727c478bd9Sstevel@tonic-gate { 13737c478bd9Sstevel@tonic-gate int rpcerror; 13747c478bd9Sstevel@tonic-gate 13757c478bd9Sstevel@tonic-gate rpcerror = aclcall(mi, which, xdrargs, argsp, xdrres, resp, 13767c478bd9Sstevel@tonic-gate cr, douprintf, flags, fi); 13777c478bd9Sstevel@tonic-gate if (!rpcerror) { 13787c478bd9Sstevel@tonic-gate /* 13797c478bd9Sstevel@tonic-gate * See comments with crnetadjust(). 13807c478bd9Sstevel@tonic-gate */ 13817c478bd9Sstevel@tonic-gate if (*statusp == NFSERR_ACCES && 13827c478bd9Sstevel@tonic-gate (cr = crnetadjust(cr)) != NULL) { 13837c478bd9Sstevel@tonic-gate #ifdef DEBUG 13847c478bd9Sstevel@tonic-gate acl2call_hits++; 13857c478bd9Sstevel@tonic-gate #endif 13867c478bd9Sstevel@tonic-gate rpcerror = aclcall(mi, which, xdrargs, argsp, xdrres, 13877c478bd9Sstevel@tonic-gate resp, cr, douprintf, flags, fi); 13887c478bd9Sstevel@tonic-gate crfree(cr); 13897c478bd9Sstevel@tonic-gate #ifdef DEBUG 13907c478bd9Sstevel@tonic-gate if (*statusp == NFSERR_ACCES) 13917c478bd9Sstevel@tonic-gate acl2call_misses++; 13927c478bd9Sstevel@tonic-gate #endif 13937c478bd9Sstevel@tonic-gate } 13947c478bd9Sstevel@tonic-gate } 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate return (rpcerror); 13977c478bd9Sstevel@tonic-gate } 13987c478bd9Sstevel@tonic-gate 13997c478bd9Sstevel@tonic-gate #ifdef DEBUG 14007c478bd9Sstevel@tonic-gate static int acl3call_hits = 0; 14017c478bd9Sstevel@tonic-gate static int acl3call_misses = 0; 14027c478bd9Sstevel@tonic-gate #endif 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate int 14057c478bd9Sstevel@tonic-gate acl3call(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp, 14067c478bd9Sstevel@tonic-gate xdrproc_t xdrres, caddr_t resp, cred_t *cr, int *douprintf, 14077c478bd9Sstevel@tonic-gate nfsstat3 *statusp, int flags, failinfo_t *fi) 14087c478bd9Sstevel@tonic-gate { 14097c478bd9Sstevel@tonic-gate int rpcerror; 14107c478bd9Sstevel@tonic-gate int user_informed; 14117c478bd9Sstevel@tonic-gate 14127c478bd9Sstevel@tonic-gate user_informed = 0; 14137c478bd9Sstevel@tonic-gate 14147c478bd9Sstevel@tonic-gate do { 14157c478bd9Sstevel@tonic-gate rpcerror = aclcall(mi, which, xdrargs, argsp, xdrres, resp, 14167c478bd9Sstevel@tonic-gate cr, douprintf, flags, fi); 14177c478bd9Sstevel@tonic-gate if (!rpcerror) { 14187c478bd9Sstevel@tonic-gate cred_t *crr; 14197c478bd9Sstevel@tonic-gate if (*statusp == NFS3ERR_JUKEBOX) { 14207c478bd9Sstevel@tonic-gate if (!user_informed) { 14217c478bd9Sstevel@tonic-gate user_informed = 1; 14227c478bd9Sstevel@tonic-gate uprintf( 14237c478bd9Sstevel@tonic-gate "file temporarily unavailable on the server, retrying...\n"); 14247c478bd9Sstevel@tonic-gate } 14257c478bd9Sstevel@tonic-gate delay(nfs3_jukebox_delay); 14267c478bd9Sstevel@tonic-gate } 14277c478bd9Sstevel@tonic-gate /* 14287c478bd9Sstevel@tonic-gate * See crnetadjust() for comments. 14297c478bd9Sstevel@tonic-gate */ 14307c478bd9Sstevel@tonic-gate else if (*statusp == NFS3ERR_ACCES && 14317c478bd9Sstevel@tonic-gate (crr = crnetadjust(cr)) != NULL) { 14327c478bd9Sstevel@tonic-gate #ifdef DEBUG 14337c478bd9Sstevel@tonic-gate acl3call_hits++; 14347c478bd9Sstevel@tonic-gate #endif 14357c478bd9Sstevel@tonic-gate rpcerror = aclcall(mi, which, xdrargs, argsp, 14367c478bd9Sstevel@tonic-gate xdrres, resp, crr, douprintf, flags, fi); 14377c478bd9Sstevel@tonic-gate 14387c478bd9Sstevel@tonic-gate crfree(crr); 14397c478bd9Sstevel@tonic-gate #ifdef DEBUG 14407c478bd9Sstevel@tonic-gate if (*statusp == NFS3ERR_ACCES) 14417c478bd9Sstevel@tonic-gate acl3call_misses++; 14427c478bd9Sstevel@tonic-gate #endif 14437c478bd9Sstevel@tonic-gate } 14447c478bd9Sstevel@tonic-gate } 14457c478bd9Sstevel@tonic-gate } while (!rpcerror && *statusp == NFS3ERR_JUKEBOX); 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate return (rpcerror); 14487c478bd9Sstevel@tonic-gate } 14497c478bd9Sstevel@tonic-gate 14507c478bd9Sstevel@tonic-gate static int 14517c478bd9Sstevel@tonic-gate aclcall(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp, 14527c478bd9Sstevel@tonic-gate xdrproc_t xdrres, caddr_t resp, cred_t *cr, int *douprintf, 14537c478bd9Sstevel@tonic-gate int flags, failinfo_t *fi) 14547c478bd9Sstevel@tonic-gate { 14557c478bd9Sstevel@tonic-gate CLIENT *client; 14567c478bd9Sstevel@tonic-gate struct chtab *ch; 14577c478bd9Sstevel@tonic-gate enum clnt_stat status; 14587c478bd9Sstevel@tonic-gate struct rpc_err rpcerr; 14597c478bd9Sstevel@tonic-gate struct timeval wait; 14607c478bd9Sstevel@tonic-gate int timeo; /* in units of hz */ 14617c478bd9Sstevel@tonic-gate #if 0 /* notyet */ 14627c478bd9Sstevel@tonic-gate int my_rsize, my_wsize; 14637c478bd9Sstevel@tonic-gate #endif 14647c478bd9Sstevel@tonic-gate bool_t tryagain; 14657c478bd9Sstevel@tonic-gate k_sigset_t smask; 14667c478bd9Sstevel@tonic-gate servinfo_t *svp; 14677c478bd9Sstevel@tonic-gate struct nfs_clnt *nfscl; 14687c478bd9Sstevel@tonic-gate zoneid_t zoneid = getzoneid(); 14697c478bd9Sstevel@tonic-gate #ifdef DEBUG 14707c478bd9Sstevel@tonic-gate char *bufp; 14717c478bd9Sstevel@tonic-gate #endif 14727c478bd9Sstevel@tonic-gate 14737c478bd9Sstevel@tonic-gate #if 0 /* notyet */ 14747c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_NFS, TR_RFSCALL_START, 14757c478bd9Sstevel@tonic-gate "rfscall_start:which %d mi %p", which, mi); 14767c478bd9Sstevel@tonic-gate #endif 14777c478bd9Sstevel@tonic-gate 1478*108322fbScarlsonj nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone()); 14797c478bd9Sstevel@tonic-gate ASSERT(nfscl != NULL); 14807c478bd9Sstevel@tonic-gate 14817c478bd9Sstevel@tonic-gate nfscl->nfscl_stat.calls.value.ui64++; 14827c478bd9Sstevel@tonic-gate mi->mi_aclreqs[which].value.ui64++; 14837c478bd9Sstevel@tonic-gate 14847c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_SUCCESS; 14857c478bd9Sstevel@tonic-gate 14867c478bd9Sstevel@tonic-gate if (FS_OR_ZONE_GONE(mi->mi_vfsp)) { 14877c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_FAILED; 14887c478bd9Sstevel@tonic-gate rpcerr.re_errno = EIO; 14897c478bd9Sstevel@tonic-gate return (rpcerr.re_errno); 14907c478bd9Sstevel@tonic-gate } 14917c478bd9Sstevel@tonic-gate 14927c478bd9Sstevel@tonic-gate #if 0 /* notyet */ 14937c478bd9Sstevel@tonic-gate /* 14947c478bd9Sstevel@tonic-gate * Remember the transfer sizes in case 14957c478bd9Sstevel@tonic-gate * nfs_feedback changes them underneath us. 14967c478bd9Sstevel@tonic-gate */ 14977c478bd9Sstevel@tonic-gate my_rsize = mi->mi_curread; 14987c478bd9Sstevel@tonic-gate my_wsize = mi->mi_curwrite; 14997c478bd9Sstevel@tonic-gate #endif 15007c478bd9Sstevel@tonic-gate 15017c478bd9Sstevel@tonic-gate /* 15027c478bd9Sstevel@tonic-gate * NFS client failover support 15037c478bd9Sstevel@tonic-gate * 15047c478bd9Sstevel@tonic-gate * If this rnode is not in sync with the current server (VALID_FH), 15057c478bd9Sstevel@tonic-gate * we'd like to do a remap to get in sync. We can be interrupted 15067c478bd9Sstevel@tonic-gate * in failover_remap(), and if so we'll bail. Otherwise, we'll 15077c478bd9Sstevel@tonic-gate * use the best info we have to try the RPC. Part of that is 15087c478bd9Sstevel@tonic-gate * unconditionally updating the filehandle copy kept for V3. 15097c478bd9Sstevel@tonic-gate * 15107c478bd9Sstevel@tonic-gate * Locking: INC_READERS/DEC_READERS is a poor man's interrruptible 15117c478bd9Sstevel@tonic-gate * rw_enter(); we're trying to keep the current server from being 15127c478bd9Sstevel@tonic-gate * changed on us until we're done with the remapping and have a 15137c478bd9Sstevel@tonic-gate * matching client handle. We don't want to sending a filehandle 15147c478bd9Sstevel@tonic-gate * to the wrong host. 15157c478bd9Sstevel@tonic-gate */ 15167c478bd9Sstevel@tonic-gate failoverretry: 15177c478bd9Sstevel@tonic-gate if (FAILOVER_MOUNT(mi)) { 15187c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 15197c478bd9Sstevel@tonic-gate if (!(flags & RFSCALL_SOFT) && failover_safe(fi)) { 15207c478bd9Sstevel@tonic-gate if (failover_wait(mi)) { 15217c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 15227c478bd9Sstevel@tonic-gate return (EINTR); 15237c478bd9Sstevel@tonic-gate } 15247c478bd9Sstevel@tonic-gate } 15257c478bd9Sstevel@tonic-gate INC_READERS(mi); 15267c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 15277c478bd9Sstevel@tonic-gate if (fi) { 15287c478bd9Sstevel@tonic-gate if (!VALID_FH(fi) && 15297c478bd9Sstevel@tonic-gate !(flags & RFSCALL_SOFT) && failover_safe(fi)) { 15307c478bd9Sstevel@tonic-gate int remaperr; 15317c478bd9Sstevel@tonic-gate 15327c478bd9Sstevel@tonic-gate svp = mi->mi_curr_serv; 15337c478bd9Sstevel@tonic-gate remaperr = failover_remap(fi); 15347c478bd9Sstevel@tonic-gate if (remaperr != 0) { 15357c478bd9Sstevel@tonic-gate #ifdef DEBUG 15367c478bd9Sstevel@tonic-gate if (remaperr != EINTR) 15377c478bd9Sstevel@tonic-gate nfs_cmn_err(remaperr, CE_WARN, 15387c478bd9Sstevel@tonic-gate "aclcall couldn't failover: %m"); 15397c478bd9Sstevel@tonic-gate #endif 15407c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 15417c478bd9Sstevel@tonic-gate DEC_READERS(mi); 15427c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 15437c478bd9Sstevel@tonic-gate 15447c478bd9Sstevel@tonic-gate /* 15457c478bd9Sstevel@tonic-gate * If failover_remap returns ETIMEDOUT 15467c478bd9Sstevel@tonic-gate * and the filesystem is hard mounted 15477c478bd9Sstevel@tonic-gate * we have to retry the call with a new 15487c478bd9Sstevel@tonic-gate * server. 15497c478bd9Sstevel@tonic-gate */ 15507c478bd9Sstevel@tonic-gate if ((mi->mi_flags & MI_HARD) && 15517c478bd9Sstevel@tonic-gate IS_RECOVERABLE_ERROR(remaperr)) { 15527c478bd9Sstevel@tonic-gate if (svp == mi->mi_curr_serv) 15537c478bd9Sstevel@tonic-gate failover_newserver(mi); 15547c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_SUCCESS; 15557c478bd9Sstevel@tonic-gate goto failoverretry; 15567c478bd9Sstevel@tonic-gate } 15577c478bd9Sstevel@tonic-gate return (remaperr); 15587c478bd9Sstevel@tonic-gate } 15597c478bd9Sstevel@tonic-gate } 15607c478bd9Sstevel@tonic-gate if (fi->fhp && fi->copyproc) 15617c478bd9Sstevel@tonic-gate (*fi->copyproc)(fi->fhp, fi->vp); 15627c478bd9Sstevel@tonic-gate } 15637c478bd9Sstevel@tonic-gate } 15647c478bd9Sstevel@tonic-gate 15657c478bd9Sstevel@tonic-gate /* 15667c478bd9Sstevel@tonic-gate * acl_clget() calls clnt_tli_kinit() which clears the xid, so we 15677c478bd9Sstevel@tonic-gate * are guaranteed to reprocess the retry as a new request. 15687c478bd9Sstevel@tonic-gate */ 15697c478bd9Sstevel@tonic-gate svp = mi->mi_curr_serv; 15707c478bd9Sstevel@tonic-gate rpcerr.re_errno = acl_clget(mi, svp, cr, &client, &ch, nfscl); 15717c478bd9Sstevel@tonic-gate if (FAILOVER_MOUNT(mi)) { 15727c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 15737c478bd9Sstevel@tonic-gate DEC_READERS(mi); 15747c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 15757c478bd9Sstevel@tonic-gate 15767c478bd9Sstevel@tonic-gate if ((rpcerr.re_errno == ETIMEDOUT || 15777c478bd9Sstevel@tonic-gate rpcerr.re_errno == ECONNRESET) && 15787c478bd9Sstevel@tonic-gate failover_safe(fi)) { 15797c478bd9Sstevel@tonic-gate if (svp == mi->mi_curr_serv) 15807c478bd9Sstevel@tonic-gate failover_newserver(mi); 15817c478bd9Sstevel@tonic-gate goto failoverretry; 15827c478bd9Sstevel@tonic-gate } 15837c478bd9Sstevel@tonic-gate } 15847c478bd9Sstevel@tonic-gate if (rpcerr.re_errno != 0) 15857c478bd9Sstevel@tonic-gate return (rpcerr.re_errno); 15867c478bd9Sstevel@tonic-gate 15877c478bd9Sstevel@tonic-gate if (svp->sv_knconf->knc_semantics == NC_TPI_COTS_ORD || 15887c478bd9Sstevel@tonic-gate svp->sv_knconf->knc_semantics == NC_TPI_COTS) { 15897c478bd9Sstevel@tonic-gate timeo = (mi->mi_timeo * hz) / 10; 15907c478bd9Sstevel@tonic-gate } else { 15917c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 15927c478bd9Sstevel@tonic-gate timeo = CLNT_SETTIMERS(client, 15937c478bd9Sstevel@tonic-gate &(mi->mi_timers[mi->mi_acl_timer_type[which]]), 15947c478bd9Sstevel@tonic-gate &(mi->mi_timers[NFS_CALLTYPES]), 15957c478bd9Sstevel@tonic-gate (minimum_timeo[mi->mi_acl_call_type[which]]*hz)>>3, 15967c478bd9Sstevel@tonic-gate (void (*)()) 0, (caddr_t)mi, 0); 15977c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 15987c478bd9Sstevel@tonic-gate } 15997c478bd9Sstevel@tonic-gate 16007c478bd9Sstevel@tonic-gate /* 16017c478bd9Sstevel@tonic-gate * If hard mounted fs, retry call forever unless hard error occurs. 16027c478bd9Sstevel@tonic-gate */ 16037c478bd9Sstevel@tonic-gate do { 16047c478bd9Sstevel@tonic-gate tryagain = FALSE; 16057c478bd9Sstevel@tonic-gate 16067c478bd9Sstevel@tonic-gate if (FS_OR_ZONE_GONE(mi->mi_vfsp)) { 16077c478bd9Sstevel@tonic-gate status = RPC_FAILED; 16087c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_FAILED; 16097c478bd9Sstevel@tonic-gate rpcerr.re_errno = EIO; 16107c478bd9Sstevel@tonic-gate break; 16117c478bd9Sstevel@tonic-gate } 16127c478bd9Sstevel@tonic-gate 16137c478bd9Sstevel@tonic-gate TICK_TO_TIMEVAL(timeo, &wait); 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate /* 16167c478bd9Sstevel@tonic-gate * Mask out all signals except SIGHUP, SIGINT, SIGQUIT 16177c478bd9Sstevel@tonic-gate * and SIGTERM. (Preserving the existing masks). 16187c478bd9Sstevel@tonic-gate * Mask out SIGINT if mount option nointr is specified. 16197c478bd9Sstevel@tonic-gate */ 16207c478bd9Sstevel@tonic-gate sigintr(&smask, (int)mi->mi_flags & MI_INT); 16217c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_INT)) 16227c478bd9Sstevel@tonic-gate client->cl_nosignal = TRUE; 16237c478bd9Sstevel@tonic-gate 16247c478bd9Sstevel@tonic-gate /* 16257c478bd9Sstevel@tonic-gate * If there is a current signal, then don't bother 16267c478bd9Sstevel@tonic-gate * even trying to send out the request because we 16277c478bd9Sstevel@tonic-gate * won't be able to block waiting for the response. 16287c478bd9Sstevel@tonic-gate * Simply assume RPC_INTR and get on with it. 16297c478bd9Sstevel@tonic-gate */ 16307c478bd9Sstevel@tonic-gate if (ttolwp(curthread) != NULL && ISSIG(curthread, JUSTLOOKING)) 16317c478bd9Sstevel@tonic-gate status = RPC_INTR; 16327c478bd9Sstevel@tonic-gate else { 16337c478bd9Sstevel@tonic-gate status = CLNT_CALL(client, which, xdrargs, argsp, 16347c478bd9Sstevel@tonic-gate xdrres, resp, wait); 16357c478bd9Sstevel@tonic-gate } 16367c478bd9Sstevel@tonic-gate 16377c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_INT)) 16387c478bd9Sstevel@tonic-gate client->cl_nosignal = FALSE; 16397c478bd9Sstevel@tonic-gate /* 16407c478bd9Sstevel@tonic-gate * restore original signal mask 16417c478bd9Sstevel@tonic-gate */ 16427c478bd9Sstevel@tonic-gate sigunintr(&smask); 16437c478bd9Sstevel@tonic-gate 16447c478bd9Sstevel@tonic-gate switch (status) { 16457c478bd9Sstevel@tonic-gate case RPC_SUCCESS: 16467c478bd9Sstevel@tonic-gate #if 0 /* notyet */ 16477c478bd9Sstevel@tonic-gate if ((mi->mi_flags & MI_DYNAMIC) && 16487c478bd9Sstevel@tonic-gate mi->mi_timer_type[which] != 0 && 16497c478bd9Sstevel@tonic-gate (mi->mi_curread != my_rsize || 16507c478bd9Sstevel@tonic-gate mi->mi_curwrite != my_wsize)) 16517c478bd9Sstevel@tonic-gate (void) nfs_feedback(FEEDBACK_OK, which, mi); 16527c478bd9Sstevel@tonic-gate #endif 16537c478bd9Sstevel@tonic-gate break; 16547c478bd9Sstevel@tonic-gate 16557c478bd9Sstevel@tonic-gate /* 16567c478bd9Sstevel@tonic-gate * Unfortunately, there are servers in the world which 16577c478bd9Sstevel@tonic-gate * are not coded correctly. They are not prepared to 16587c478bd9Sstevel@tonic-gate * handle RPC requests to the NFS port which are not 16597c478bd9Sstevel@tonic-gate * NFS requests. Thus, they may try to process the 16607c478bd9Sstevel@tonic-gate * NFS_ACL request as if it were an NFS request. This 16617c478bd9Sstevel@tonic-gate * does not work. Generally, an error will be generated 16627c478bd9Sstevel@tonic-gate * on the client because it will not be able to decode 16637c478bd9Sstevel@tonic-gate * the response from the server. However, it seems 16647c478bd9Sstevel@tonic-gate * possible that the server may not be able to decode 16657c478bd9Sstevel@tonic-gate * the arguments. Thus, the criteria for deciding 16667c478bd9Sstevel@tonic-gate * whether the server supports NFS_ACL or not is whether 16677c478bd9Sstevel@tonic-gate * the following RPC errors are returned from CLNT_CALL. 16687c478bd9Sstevel@tonic-gate */ 16697c478bd9Sstevel@tonic-gate case RPC_CANTDECODERES: 16707c478bd9Sstevel@tonic-gate case RPC_PROGUNAVAIL: 16717c478bd9Sstevel@tonic-gate case RPC_CANTDECODEARGS: 16727c478bd9Sstevel@tonic-gate case RPC_PROGVERSMISMATCH: 16737c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 16747c478bd9Sstevel@tonic-gate mi->mi_flags &= ~(MI_ACL | MI_EXTATTR); 16757c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 16767c478bd9Sstevel@tonic-gate break; 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate /* 16797c478bd9Sstevel@tonic-gate * If the server supports NFS_ACL but not the new ops 16807c478bd9Sstevel@tonic-gate * for extended attributes, make sure we don't retry. 16817c478bd9Sstevel@tonic-gate */ 16827c478bd9Sstevel@tonic-gate case RPC_PROCUNAVAIL: 16837c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 16847c478bd9Sstevel@tonic-gate mi->mi_flags &= ~MI_EXTATTR; 16857c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 16867c478bd9Sstevel@tonic-gate break; 16877c478bd9Sstevel@tonic-gate 16887c478bd9Sstevel@tonic-gate case RPC_INTR: 16897c478bd9Sstevel@tonic-gate /* 16907c478bd9Sstevel@tonic-gate * There is no way to recover from this error, 16917c478bd9Sstevel@tonic-gate * even if mount option nointr is specified. 16927c478bd9Sstevel@tonic-gate * SIGKILL, for example, cannot be blocked. 16937c478bd9Sstevel@tonic-gate */ 16947c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_INTR; 16957c478bd9Sstevel@tonic-gate rpcerr.re_errno = EINTR; 16967c478bd9Sstevel@tonic-gate break; 16977c478bd9Sstevel@tonic-gate 16987c478bd9Sstevel@tonic-gate case RPC_UDERROR: 16997c478bd9Sstevel@tonic-gate /* 17007c478bd9Sstevel@tonic-gate * If the NFS server is local (vold) and 17017c478bd9Sstevel@tonic-gate * it goes away then we get RPC_UDERROR. 17027c478bd9Sstevel@tonic-gate * This is a retryable error, so we would 17037c478bd9Sstevel@tonic-gate * loop, so check to see if the specific 17047c478bd9Sstevel@tonic-gate * error was ECONNRESET, indicating that 17057c478bd9Sstevel@tonic-gate * target did not exist at all. If so, 17067c478bd9Sstevel@tonic-gate * return with RPC_PROGUNAVAIL and 17077c478bd9Sstevel@tonic-gate * ECONNRESET to indicate why. 17087c478bd9Sstevel@tonic-gate */ 17097c478bd9Sstevel@tonic-gate CLNT_GETERR(client, &rpcerr); 17107c478bd9Sstevel@tonic-gate if (rpcerr.re_errno == ECONNRESET) { 17117c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_PROGUNAVAIL; 17127c478bd9Sstevel@tonic-gate rpcerr.re_errno = ECONNRESET; 17137c478bd9Sstevel@tonic-gate break; 17147c478bd9Sstevel@tonic-gate } 17157c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 17167c478bd9Sstevel@tonic-gate 17177c478bd9Sstevel@tonic-gate default: /* probably RPC_TIMEDOUT */ 17187c478bd9Sstevel@tonic-gate if (IS_UNRECOVERABLE_RPC(status)) 17197c478bd9Sstevel@tonic-gate break; 17207c478bd9Sstevel@tonic-gate 17217c478bd9Sstevel@tonic-gate /* 17227c478bd9Sstevel@tonic-gate * increment server not responding count 17237c478bd9Sstevel@tonic-gate */ 17247c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 17257c478bd9Sstevel@tonic-gate mi->mi_noresponse++; 17267c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 17277c478bd9Sstevel@tonic-gate #ifdef DEBUG 17287c478bd9Sstevel@tonic-gate nfscl->nfscl_stat.noresponse.value.ui64++; 17297c478bd9Sstevel@tonic-gate #endif 17307c478bd9Sstevel@tonic-gate 17317c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_HARD)) { 17327c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_SEMISOFT) || 17337c478bd9Sstevel@tonic-gate (mi->mi_acl_ss_call_type[which] == 0)) 17347c478bd9Sstevel@tonic-gate break; 17357c478bd9Sstevel@tonic-gate } 17367c478bd9Sstevel@tonic-gate 17377c478bd9Sstevel@tonic-gate /* 17387c478bd9Sstevel@tonic-gate * The call is in progress (over COTS). 17397c478bd9Sstevel@tonic-gate * Try the CLNT_CALL again, but don't 17407c478bd9Sstevel@tonic-gate * print a noisy error message. 17417c478bd9Sstevel@tonic-gate */ 17427c478bd9Sstevel@tonic-gate if (status == RPC_INPROGRESS) { 17437c478bd9Sstevel@tonic-gate tryagain = TRUE; 17447c478bd9Sstevel@tonic-gate break; 17457c478bd9Sstevel@tonic-gate } 17467c478bd9Sstevel@tonic-gate 17477c478bd9Sstevel@tonic-gate if (flags & RFSCALL_SOFT) 17487c478bd9Sstevel@tonic-gate break; 17497c478bd9Sstevel@tonic-gate 17507c478bd9Sstevel@tonic-gate /* 17517c478bd9Sstevel@tonic-gate * On zone shutdown, just move on. 17527c478bd9Sstevel@tonic-gate */ 17537c478bd9Sstevel@tonic-gate if (zone_status_get(curproc->p_zone) >= 17547c478bd9Sstevel@tonic-gate ZONE_IS_SHUTTING_DOWN) { 17557c478bd9Sstevel@tonic-gate rpcerr.re_status = RPC_FAILED; 17567c478bd9Sstevel@tonic-gate rpcerr.re_errno = EIO; 17577c478bd9Sstevel@tonic-gate break; 17587c478bd9Sstevel@tonic-gate } 17597c478bd9Sstevel@tonic-gate 17607c478bd9Sstevel@tonic-gate /* 17617c478bd9Sstevel@tonic-gate * NFS client failover support 17627c478bd9Sstevel@tonic-gate * 17637c478bd9Sstevel@tonic-gate * If the current server just failed us, we'll 17647c478bd9Sstevel@tonic-gate * start the process of finding a new server. 17657c478bd9Sstevel@tonic-gate * After that, we can just retry. 17667c478bd9Sstevel@tonic-gate */ 17677c478bd9Sstevel@tonic-gate if (FAILOVER_MOUNT(mi) && failover_safe(fi)) { 17687c478bd9Sstevel@tonic-gate if (svp == mi->mi_curr_serv) 17697c478bd9Sstevel@tonic-gate failover_newserver(mi); 17707c478bd9Sstevel@tonic-gate clfree_impl(client, ch, nfscl); 17717c478bd9Sstevel@tonic-gate goto failoverretry; 17727c478bd9Sstevel@tonic-gate } 17737c478bd9Sstevel@tonic-gate 17747c478bd9Sstevel@tonic-gate tryagain = TRUE; 17757c478bd9Sstevel@tonic-gate timeo = backoff(timeo); 17767c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 17777c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_PRINTED)) { 17787c478bd9Sstevel@tonic-gate mi->mi_flags |= MI_PRINTED; 17797c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 17807c478bd9Sstevel@tonic-gate #ifdef DEBUG 17817c478bd9Sstevel@tonic-gate zprintf(zoneid, 17827c478bd9Sstevel@tonic-gate "NFS_ACL%d server %s not responding still trying\n", 17837c478bd9Sstevel@tonic-gate mi->mi_vers, svp->sv_hostname); 17847c478bd9Sstevel@tonic-gate #else 17857c478bd9Sstevel@tonic-gate zprintf(zoneid, 17867c478bd9Sstevel@tonic-gate "NFS server %s not responding still trying\n", 17877c478bd9Sstevel@tonic-gate svp->sv_hostname); 17887c478bd9Sstevel@tonic-gate #endif 17897c478bd9Sstevel@tonic-gate } else 17907c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 17917c478bd9Sstevel@tonic-gate if (*douprintf && curproc->p_sessp->s_vp != NULL) { 17927c478bd9Sstevel@tonic-gate *douprintf = 0; 17937c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_NOPRINT)) 17947c478bd9Sstevel@tonic-gate #ifdef DEBUG 17957c478bd9Sstevel@tonic-gate uprintf( 17967c478bd9Sstevel@tonic-gate "NFS_ACL%d server %s not responding still trying\n", 17977c478bd9Sstevel@tonic-gate mi->mi_vers, svp->sv_hostname); 17987c478bd9Sstevel@tonic-gate #else 17997c478bd9Sstevel@tonic-gate uprintf( 18007c478bd9Sstevel@tonic-gate "NFS server %s not responding still trying\n", 18017c478bd9Sstevel@tonic-gate svp->sv_hostname); 18027c478bd9Sstevel@tonic-gate #endif 18037c478bd9Sstevel@tonic-gate } 18047c478bd9Sstevel@tonic-gate 18057c478bd9Sstevel@tonic-gate #if 0 /* notyet */ 18067c478bd9Sstevel@tonic-gate /* 18077c478bd9Sstevel@tonic-gate * If doing dynamic adjustment of transfer 18087c478bd9Sstevel@tonic-gate * size and if it's a read or write call 18097c478bd9Sstevel@tonic-gate * and if the transfer size changed while 18107c478bd9Sstevel@tonic-gate * retransmitting or if the feedback routine 18117c478bd9Sstevel@tonic-gate * changed the transfer size, 18127c478bd9Sstevel@tonic-gate * then exit rfscall so that the transfer 18137c478bd9Sstevel@tonic-gate * size can be adjusted at the vnops level. 18147c478bd9Sstevel@tonic-gate */ 18157c478bd9Sstevel@tonic-gate if ((mi->mi_flags & MI_DYNAMIC) && 18167c478bd9Sstevel@tonic-gate mi->mi_acl_timer_type[which] != 0 && 18177c478bd9Sstevel@tonic-gate (mi->mi_curread != my_rsize || 18187c478bd9Sstevel@tonic-gate mi->mi_curwrite != my_wsize || 18197c478bd9Sstevel@tonic-gate nfs_feedback(FEEDBACK_REXMIT1, which, mi))) { 18207c478bd9Sstevel@tonic-gate /* 18217c478bd9Sstevel@tonic-gate * On read or write calls, return 18227c478bd9Sstevel@tonic-gate * back to the vnode ops level if 18237c478bd9Sstevel@tonic-gate * the transfer size changed. 18247c478bd9Sstevel@tonic-gate */ 18257c478bd9Sstevel@tonic-gate clfree_impl(client, ch, nfscl); 18267c478bd9Sstevel@tonic-gate return (ENFS_TRYAGAIN); 18277c478bd9Sstevel@tonic-gate } 18287c478bd9Sstevel@tonic-gate #endif 18297c478bd9Sstevel@tonic-gate } 18307c478bd9Sstevel@tonic-gate } while (tryagain); 18317c478bd9Sstevel@tonic-gate 18327c478bd9Sstevel@tonic-gate if (status != RPC_SUCCESS) { 18337c478bd9Sstevel@tonic-gate /* 18347c478bd9Sstevel@tonic-gate * Let soft mounts use the timed out message. 18357c478bd9Sstevel@tonic-gate */ 18367c478bd9Sstevel@tonic-gate if (status == RPC_INPROGRESS) 18377c478bd9Sstevel@tonic-gate status = RPC_TIMEDOUT; 18387c478bd9Sstevel@tonic-gate nfscl->nfscl_stat.badcalls.value.ui64++; 18397c478bd9Sstevel@tonic-gate if (status == RPC_CANTDECODERES || 18407c478bd9Sstevel@tonic-gate status == RPC_PROGUNAVAIL || 18417c478bd9Sstevel@tonic-gate status == RPC_PROCUNAVAIL || 18427c478bd9Sstevel@tonic-gate status == RPC_CANTDECODEARGS || 18437c478bd9Sstevel@tonic-gate status == RPC_PROGVERSMISMATCH) 18447c478bd9Sstevel@tonic-gate CLNT_GETERR(client, &rpcerr); 18457c478bd9Sstevel@tonic-gate else if (status != RPC_INTR) { 18467c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 18477c478bd9Sstevel@tonic-gate mi->mi_flags |= MI_DOWN; 18487c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 18497c478bd9Sstevel@tonic-gate CLNT_GETERR(client, &rpcerr); 18507c478bd9Sstevel@tonic-gate #ifdef DEBUG 18517c478bd9Sstevel@tonic-gate bufp = clnt_sperror(client, svp->sv_hostname); 18527c478bd9Sstevel@tonic-gate zprintf(zoneid, "NFS_ACL%d %s failed for %s\n", 18537c478bd9Sstevel@tonic-gate mi->mi_vers, mi->mi_aclnames[which], bufp); 18547c478bd9Sstevel@tonic-gate if (curproc->p_sessp->s_vp != NULL) { 18557c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_NOPRINT)) { 18567c478bd9Sstevel@tonic-gate uprintf("NFS_ACL%d %s failed for %s\n", 18577c478bd9Sstevel@tonic-gate mi->mi_vers, mi->mi_aclnames[which], 18587c478bd9Sstevel@tonic-gate bufp); 18597c478bd9Sstevel@tonic-gate } 18607c478bd9Sstevel@tonic-gate } 18617c478bd9Sstevel@tonic-gate kmem_free(bufp, MAXPATHLEN); 18627c478bd9Sstevel@tonic-gate #else 18637c478bd9Sstevel@tonic-gate zprintf(zoneid, 18647c478bd9Sstevel@tonic-gate "NFS %s failed for server %s: error %d (%s)\n", 18657c478bd9Sstevel@tonic-gate mi->mi_aclnames[which], svp->sv_hostname, 18667c478bd9Sstevel@tonic-gate status, clnt_sperrno(status)); 18677c478bd9Sstevel@tonic-gate if (curproc->p_sessp->s_vp != NULL) { 18687c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_NOPRINT)) 18697c478bd9Sstevel@tonic-gate uprintf( 18707c478bd9Sstevel@tonic-gate "NFS %s failed for server %s: error %d (%s)\n", 18717c478bd9Sstevel@tonic-gate mi->mi_aclnames[which], 18727c478bd9Sstevel@tonic-gate svp->sv_hostname, status, 18737c478bd9Sstevel@tonic-gate clnt_sperrno(status)); 18747c478bd9Sstevel@tonic-gate } 18757c478bd9Sstevel@tonic-gate #endif 18767c478bd9Sstevel@tonic-gate /* 18777c478bd9Sstevel@tonic-gate * when CLNT_CALL() fails with RPC_AUTHERROR, 18787c478bd9Sstevel@tonic-gate * re_errno is set appropriately depending on 18797c478bd9Sstevel@tonic-gate * the authentication error 18807c478bd9Sstevel@tonic-gate */ 18817c478bd9Sstevel@tonic-gate if (status == RPC_VERSMISMATCH || 18827c478bd9Sstevel@tonic-gate status == RPC_PROGVERSMISMATCH) 18837c478bd9Sstevel@tonic-gate rpcerr.re_errno = EIO; 18847c478bd9Sstevel@tonic-gate } 18857c478bd9Sstevel@tonic-gate } else { 18867c478bd9Sstevel@tonic-gate /* 18877c478bd9Sstevel@tonic-gate * Test the value of mi_down and mi_printed without 18887c478bd9Sstevel@tonic-gate * holding the mi_lock mutex. If they are both zero, 18897c478bd9Sstevel@tonic-gate * then it is okay to skip the down and printed 18907c478bd9Sstevel@tonic-gate * processing. This saves on a mutex_enter and 18917c478bd9Sstevel@tonic-gate * mutex_exit pair for a normal, successful RPC. 18927c478bd9Sstevel@tonic-gate * This was just complete overhead. 18937c478bd9Sstevel@tonic-gate */ 18947c478bd9Sstevel@tonic-gate if (mi->mi_flags & (MI_DOWN | MI_PRINTED)) { 18957c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 18967c478bd9Sstevel@tonic-gate mi->mi_flags &= ~MI_DOWN; 18977c478bd9Sstevel@tonic-gate if (mi->mi_flags & MI_PRINTED) { 18987c478bd9Sstevel@tonic-gate mi->mi_flags &= ~MI_PRINTED; 18997c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 19007c478bd9Sstevel@tonic-gate #ifdef DEBUG 19017c478bd9Sstevel@tonic-gate zprintf(zoneid, "NFS_ACL%d server %s ok\n", 19027c478bd9Sstevel@tonic-gate mi->mi_vers, svp->sv_hostname); 19037c478bd9Sstevel@tonic-gate #else 19047c478bd9Sstevel@tonic-gate zprintf(zoneid, "NFS server %s ok\n", 19057c478bd9Sstevel@tonic-gate svp->sv_hostname); 19067c478bd9Sstevel@tonic-gate #endif 19077c478bd9Sstevel@tonic-gate } else 19087c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 19097c478bd9Sstevel@tonic-gate } 19107c478bd9Sstevel@tonic-gate 19117c478bd9Sstevel@tonic-gate if (*douprintf == 0) { 19127c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_NOPRINT)) 19137c478bd9Sstevel@tonic-gate #ifdef DEBUG 19147c478bd9Sstevel@tonic-gate uprintf("NFS_ACL%d server %s ok\n", 19157c478bd9Sstevel@tonic-gate mi->mi_vers, svp->sv_hostname); 19167c478bd9Sstevel@tonic-gate #else 19177c478bd9Sstevel@tonic-gate uprintf("NFS server %s ok\n", svp->sv_hostname); 19187c478bd9Sstevel@tonic-gate #endif 19197c478bd9Sstevel@tonic-gate *douprintf = 1; 19207c478bd9Sstevel@tonic-gate } 19217c478bd9Sstevel@tonic-gate } 19227c478bd9Sstevel@tonic-gate 19237c478bd9Sstevel@tonic-gate clfree_impl(client, ch, nfscl); 19247c478bd9Sstevel@tonic-gate 19257c478bd9Sstevel@tonic-gate ASSERT(rpcerr.re_status == RPC_SUCCESS || rpcerr.re_errno != 0); 19267c478bd9Sstevel@tonic-gate 19277c478bd9Sstevel@tonic-gate #if 0 /* notyet */ 19287c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_NFS, TR_RFSCALL_END, "rfscall_end:errno %d", 19297c478bd9Sstevel@tonic-gate rpcerr.re_errno); 19307c478bd9Sstevel@tonic-gate #endif 19317c478bd9Sstevel@tonic-gate 19327c478bd9Sstevel@tonic-gate return (rpcerr.re_errno); 19337c478bd9Sstevel@tonic-gate } 19347c478bd9Sstevel@tonic-gate 19357c478bd9Sstevel@tonic-gate int 19367c478bd9Sstevel@tonic-gate vattr_to_sattr(struct vattr *vap, struct nfssattr *sa) 19377c478bd9Sstevel@tonic-gate { 19387c478bd9Sstevel@tonic-gate uint_t mask = vap->va_mask; 19397c478bd9Sstevel@tonic-gate 19407c478bd9Sstevel@tonic-gate if (!(mask & AT_MODE)) 19417c478bd9Sstevel@tonic-gate sa->sa_mode = (uint32_t)-1; 19427c478bd9Sstevel@tonic-gate else 19437c478bd9Sstevel@tonic-gate sa->sa_mode = vap->va_mode; 19447c478bd9Sstevel@tonic-gate if (!(mask & AT_UID)) 19457c478bd9Sstevel@tonic-gate sa->sa_uid = (uint32_t)-1; 19467c478bd9Sstevel@tonic-gate else 19477c478bd9Sstevel@tonic-gate sa->sa_uid = (uint32_t)vap->va_uid; 19487c478bd9Sstevel@tonic-gate if (!(mask & AT_GID)) 19497c478bd9Sstevel@tonic-gate sa->sa_gid = (uint32_t)-1; 19507c478bd9Sstevel@tonic-gate else 19517c478bd9Sstevel@tonic-gate sa->sa_gid = (uint32_t)vap->va_gid; 19527c478bd9Sstevel@tonic-gate if (!(mask & AT_SIZE)) 19537c478bd9Sstevel@tonic-gate sa->sa_size = (uint32_t)-1; 19547c478bd9Sstevel@tonic-gate else 19557c478bd9Sstevel@tonic-gate sa->sa_size = (uint32_t)vap->va_size; 19567c478bd9Sstevel@tonic-gate if (!(mask & AT_ATIME)) 19577c478bd9Sstevel@tonic-gate sa->sa_atime.tv_sec = sa->sa_atime.tv_usec = (int32_t)-1; 19587c478bd9Sstevel@tonic-gate else { 19597c478bd9Sstevel@tonic-gate /* check time validity */ 19607c478bd9Sstevel@tonic-gate if (! NFS_TIME_T_OK(vap->va_atime.tv_sec)) { 19617c478bd9Sstevel@tonic-gate return (EOVERFLOW); 19627c478bd9Sstevel@tonic-gate } 19637c478bd9Sstevel@tonic-gate sa->sa_atime.tv_sec = vap->va_atime.tv_sec; 19647c478bd9Sstevel@tonic-gate sa->sa_atime.tv_usec = vap->va_atime.tv_nsec / 1000; 19657c478bd9Sstevel@tonic-gate } 19667c478bd9Sstevel@tonic-gate if (!(mask & AT_MTIME)) 19677c478bd9Sstevel@tonic-gate sa->sa_mtime.tv_sec = sa->sa_mtime.tv_usec = (int32_t)-1; 19687c478bd9Sstevel@tonic-gate else { 19697c478bd9Sstevel@tonic-gate /* check time validity */ 19707c478bd9Sstevel@tonic-gate if (! NFS_TIME_T_OK(vap->va_mtime.tv_sec)) { 19717c478bd9Sstevel@tonic-gate return (EOVERFLOW); 19727c478bd9Sstevel@tonic-gate } 19737c478bd9Sstevel@tonic-gate sa->sa_mtime.tv_sec = vap->va_mtime.tv_sec; 19747c478bd9Sstevel@tonic-gate sa->sa_mtime.tv_usec = vap->va_mtime.tv_nsec / 1000; 19757c478bd9Sstevel@tonic-gate } 19767c478bd9Sstevel@tonic-gate return (0); 19777c478bd9Sstevel@tonic-gate } 19787c478bd9Sstevel@tonic-gate 19797c478bd9Sstevel@tonic-gate int 19807c478bd9Sstevel@tonic-gate vattr_to_sattr3(struct vattr *vap, sattr3 *sa) 19817c478bd9Sstevel@tonic-gate { 19827c478bd9Sstevel@tonic-gate uint_t mask = vap->va_mask; 19837c478bd9Sstevel@tonic-gate 19847c478bd9Sstevel@tonic-gate if (!(mask & AT_MODE)) 19857c478bd9Sstevel@tonic-gate sa->mode.set_it = FALSE; 19867c478bd9Sstevel@tonic-gate else { 19877c478bd9Sstevel@tonic-gate sa->mode.set_it = TRUE; 19887c478bd9Sstevel@tonic-gate sa->mode.mode = (mode3)vap->va_mode; 19897c478bd9Sstevel@tonic-gate } 19907c478bd9Sstevel@tonic-gate if (!(mask & AT_UID)) 19917c478bd9Sstevel@tonic-gate sa->uid.set_it = FALSE; 19927c478bd9Sstevel@tonic-gate else { 19937c478bd9Sstevel@tonic-gate sa->uid.set_it = TRUE; 19947c478bd9Sstevel@tonic-gate sa->uid.uid = (uid3)vap->va_uid; 19957c478bd9Sstevel@tonic-gate } 19967c478bd9Sstevel@tonic-gate if (!(mask & AT_GID)) 19977c478bd9Sstevel@tonic-gate sa->gid.set_it = FALSE; 19987c478bd9Sstevel@tonic-gate else { 19997c478bd9Sstevel@tonic-gate sa->gid.set_it = TRUE; 20007c478bd9Sstevel@tonic-gate sa->gid.gid = (gid3)vap->va_gid; 20017c478bd9Sstevel@tonic-gate } 20027c478bd9Sstevel@tonic-gate if (!(mask & AT_SIZE)) 20037c478bd9Sstevel@tonic-gate sa->size.set_it = FALSE; 20047c478bd9Sstevel@tonic-gate else { 20057c478bd9Sstevel@tonic-gate sa->size.set_it = TRUE; 20067c478bd9Sstevel@tonic-gate sa->size.size = (size3)vap->va_size; 20077c478bd9Sstevel@tonic-gate } 20087c478bd9Sstevel@tonic-gate if (!(mask & AT_ATIME)) 20097c478bd9Sstevel@tonic-gate sa->atime.set_it = DONT_CHANGE; 20107c478bd9Sstevel@tonic-gate else { 20117c478bd9Sstevel@tonic-gate /* check time validity */ 20127c478bd9Sstevel@tonic-gate if (! NFS_TIME_T_OK(vap->va_atime.tv_sec)) { 20137c478bd9Sstevel@tonic-gate return (EOVERFLOW); 20147c478bd9Sstevel@tonic-gate } 20157c478bd9Sstevel@tonic-gate sa->atime.set_it = SET_TO_CLIENT_TIME; 20167c478bd9Sstevel@tonic-gate sa->atime.atime.seconds = (uint32)vap->va_atime.tv_sec; 20177c478bd9Sstevel@tonic-gate sa->atime.atime.nseconds = (uint32)vap->va_atime.tv_nsec; 20187c478bd9Sstevel@tonic-gate } 20197c478bd9Sstevel@tonic-gate if (!(mask & AT_MTIME)) 20207c478bd9Sstevel@tonic-gate sa->mtime.set_it = DONT_CHANGE; 20217c478bd9Sstevel@tonic-gate else { 20227c478bd9Sstevel@tonic-gate /* check time validity */ 20237c478bd9Sstevel@tonic-gate if (! NFS_TIME_T_OK(vap->va_mtime.tv_sec)) { 20247c478bd9Sstevel@tonic-gate return (EOVERFLOW); 20257c478bd9Sstevel@tonic-gate } 20267c478bd9Sstevel@tonic-gate sa->mtime.set_it = SET_TO_CLIENT_TIME; 20277c478bd9Sstevel@tonic-gate sa->mtime.mtime.seconds = (uint32)vap->va_mtime.tv_sec; 20287c478bd9Sstevel@tonic-gate sa->mtime.mtime.nseconds = (uint32)vap->va_mtime.tv_nsec; 20297c478bd9Sstevel@tonic-gate } 20307c478bd9Sstevel@tonic-gate return (0); 20317c478bd9Sstevel@tonic-gate } 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate void 20347c478bd9Sstevel@tonic-gate setdiropargs(struct nfsdiropargs *da, char *nm, vnode_t *dvp) 20357c478bd9Sstevel@tonic-gate { 20367c478bd9Sstevel@tonic-gate 20377c478bd9Sstevel@tonic-gate da->da_fhandle = VTOFH(dvp); 20387c478bd9Sstevel@tonic-gate da->da_name = nm; 20397c478bd9Sstevel@tonic-gate da->da_flags = 0; 20407c478bd9Sstevel@tonic-gate } 20417c478bd9Sstevel@tonic-gate 20427c478bd9Sstevel@tonic-gate void 20437c478bd9Sstevel@tonic-gate setdiropargs3(diropargs3 *da, char *nm, vnode_t *dvp) 20447c478bd9Sstevel@tonic-gate { 20457c478bd9Sstevel@tonic-gate 20467c478bd9Sstevel@tonic-gate da->dirp = VTOFH3(dvp); 20477c478bd9Sstevel@tonic-gate da->name = nm; 20487c478bd9Sstevel@tonic-gate } 20497c478bd9Sstevel@tonic-gate 20507c478bd9Sstevel@tonic-gate int 20517c478bd9Sstevel@tonic-gate setdirgid(vnode_t *dvp, gid_t *gidp, cred_t *cr) 20527c478bd9Sstevel@tonic-gate { 20537c478bd9Sstevel@tonic-gate int error; 20547c478bd9Sstevel@tonic-gate rnode_t *rp; 20557c478bd9Sstevel@tonic-gate struct vattr va; 20567c478bd9Sstevel@tonic-gate 20577c478bd9Sstevel@tonic-gate va.va_mask = AT_MODE | AT_GID; 20587c478bd9Sstevel@tonic-gate error = VOP_GETATTR(dvp, &va, 0, cr); 20597c478bd9Sstevel@tonic-gate if (error) 20607c478bd9Sstevel@tonic-gate return (error); 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate /* 20637c478bd9Sstevel@tonic-gate * To determine the expected group-id of the created file: 20647c478bd9Sstevel@tonic-gate * 1) If the filesystem was not mounted with the Old-BSD-compatible 20657c478bd9Sstevel@tonic-gate * GRPID option, and the directory's set-gid bit is clear, 20667c478bd9Sstevel@tonic-gate * then use the process's gid. 20677c478bd9Sstevel@tonic-gate * 2) Otherwise, set the group-id to the gid of the parent directory. 20687c478bd9Sstevel@tonic-gate */ 20697c478bd9Sstevel@tonic-gate rp = VTOR(dvp); 20707c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 20717c478bd9Sstevel@tonic-gate if (!(VTOMI(dvp)->mi_flags & MI_GRPID) && !(va.va_mode & VSGID)) 20727c478bd9Sstevel@tonic-gate *gidp = crgetgid(cr); 20737c478bd9Sstevel@tonic-gate else 20747c478bd9Sstevel@tonic-gate *gidp = va.va_gid; 20757c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 20767c478bd9Sstevel@tonic-gate return (0); 20777c478bd9Sstevel@tonic-gate } 20787c478bd9Sstevel@tonic-gate 20797c478bd9Sstevel@tonic-gate int 20807c478bd9Sstevel@tonic-gate setdirmode(vnode_t *dvp, mode_t *omp, cred_t *cr) 20817c478bd9Sstevel@tonic-gate { 20827c478bd9Sstevel@tonic-gate int error; 20837c478bd9Sstevel@tonic-gate struct vattr va; 20847c478bd9Sstevel@tonic-gate 20857c478bd9Sstevel@tonic-gate va.va_mask = AT_MODE; 20867c478bd9Sstevel@tonic-gate error = VOP_GETATTR(dvp, &va, 0, cr); 20877c478bd9Sstevel@tonic-gate if (error) 20887c478bd9Sstevel@tonic-gate return (error); 20897c478bd9Sstevel@tonic-gate 20907c478bd9Sstevel@tonic-gate /* 20917c478bd9Sstevel@tonic-gate * Modify the expected mode (om) so that the set-gid bit matches 20927c478bd9Sstevel@tonic-gate * that of the parent directory (dvp). 20937c478bd9Sstevel@tonic-gate */ 20947c478bd9Sstevel@tonic-gate if (va.va_mode & VSGID) 20957c478bd9Sstevel@tonic-gate *omp |= VSGID; 20967c478bd9Sstevel@tonic-gate else 20977c478bd9Sstevel@tonic-gate *omp &= ~VSGID; 20987c478bd9Sstevel@tonic-gate return (0); 20997c478bd9Sstevel@tonic-gate } 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate void 21027c478bd9Sstevel@tonic-gate nfs_setswaplike(vnode_t *vp, vattr_t *vap) 21037c478bd9Sstevel@tonic-gate { 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate if (vp->v_type == VREG && (vap->va_mode & (VEXEC | VSVTX)) == VSVTX) { 21067c478bd9Sstevel@tonic-gate if (!(vp->v_flag & VSWAPLIKE)) { 21077c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 21087c478bd9Sstevel@tonic-gate vp->v_flag |= VSWAPLIKE; 21097c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 21107c478bd9Sstevel@tonic-gate } 21117c478bd9Sstevel@tonic-gate } else { 21127c478bd9Sstevel@tonic-gate if (vp->v_flag & VSWAPLIKE) { 21137c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 21147c478bd9Sstevel@tonic-gate vp->v_flag &= ~VSWAPLIKE; 21157c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 21167c478bd9Sstevel@tonic-gate } 21177c478bd9Sstevel@tonic-gate } 21187c478bd9Sstevel@tonic-gate } 21197c478bd9Sstevel@tonic-gate 21207c478bd9Sstevel@tonic-gate /* 21217c478bd9Sstevel@tonic-gate * Free the resources associated with an rnode. 21227c478bd9Sstevel@tonic-gate */ 21237c478bd9Sstevel@tonic-gate static void 21247c478bd9Sstevel@tonic-gate rinactive(rnode_t *rp, cred_t *cr) 21257c478bd9Sstevel@tonic-gate { 21267c478bd9Sstevel@tonic-gate vnode_t *vp; 21277c478bd9Sstevel@tonic-gate cred_t *cred; 21287c478bd9Sstevel@tonic-gate char *contents; 21297c478bd9Sstevel@tonic-gate int size; 21307c478bd9Sstevel@tonic-gate vsecattr_t *vsp; 21317c478bd9Sstevel@tonic-gate int error; 21327c478bd9Sstevel@tonic-gate nfs3_pathconf_info *info; 21337c478bd9Sstevel@tonic-gate 21347c478bd9Sstevel@tonic-gate /* 21357c478bd9Sstevel@tonic-gate * Before freeing anything, wait until all asynchronous 21367c478bd9Sstevel@tonic-gate * activity is done on this rnode. This will allow all 21377c478bd9Sstevel@tonic-gate * asynchronous read ahead and write behind i/o's to 21387c478bd9Sstevel@tonic-gate * finish. 21397c478bd9Sstevel@tonic-gate */ 21407c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 21417c478bd9Sstevel@tonic-gate while (rp->r_count > 0) 21427c478bd9Sstevel@tonic-gate cv_wait(&rp->r_cv, &rp->r_statelock); 21437c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 21447c478bd9Sstevel@tonic-gate 21457c478bd9Sstevel@tonic-gate /* 21467c478bd9Sstevel@tonic-gate * Flush and invalidate all pages associated with the vnode. 21477c478bd9Sstevel@tonic-gate */ 21487c478bd9Sstevel@tonic-gate vp = RTOV(rp); 21497c478bd9Sstevel@tonic-gate if (vn_has_cached_data(vp)) { 21507c478bd9Sstevel@tonic-gate ASSERT(vp->v_type != VCHR); 21517c478bd9Sstevel@tonic-gate if ((rp->r_flags & RDIRTY) && !rp->r_error) { 21527c478bd9Sstevel@tonic-gate error = VOP_PUTPAGE(vp, (u_offset_t)0, 0, 0, cr); 21537c478bd9Sstevel@tonic-gate if (error && (error == ENOSPC || error == EDQUOT)) { 21547c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 21557c478bd9Sstevel@tonic-gate if (!rp->r_error) 21567c478bd9Sstevel@tonic-gate rp->r_error = error; 21577c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 21587c478bd9Sstevel@tonic-gate } 21597c478bd9Sstevel@tonic-gate } 21607c478bd9Sstevel@tonic-gate nfs_invalidate_pages(vp, (u_offset_t)0, cr); 21617c478bd9Sstevel@tonic-gate } 21627c478bd9Sstevel@tonic-gate 21637c478bd9Sstevel@tonic-gate /* 21647c478bd9Sstevel@tonic-gate * Free any held credentials and caches which may be associated 21657c478bd9Sstevel@tonic-gate * with this rnode. 21667c478bd9Sstevel@tonic-gate */ 21677c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 21687c478bd9Sstevel@tonic-gate cred = rp->r_cred; 21697c478bd9Sstevel@tonic-gate rp->r_cred = NULL; 21707c478bd9Sstevel@tonic-gate contents = rp->r_symlink.contents; 21717c478bd9Sstevel@tonic-gate size = rp->r_symlink.size; 21727c478bd9Sstevel@tonic-gate rp->r_symlink.contents = NULL; 21737c478bd9Sstevel@tonic-gate vsp = rp->r_secattr; 21747c478bd9Sstevel@tonic-gate rp->r_secattr = NULL; 21757c478bd9Sstevel@tonic-gate info = rp->r_pathconf; 21767c478bd9Sstevel@tonic-gate rp->r_pathconf = NULL; 21777c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 21787c478bd9Sstevel@tonic-gate 21797c478bd9Sstevel@tonic-gate /* 21807c478bd9Sstevel@tonic-gate * Free the held credential. 21817c478bd9Sstevel@tonic-gate */ 21827c478bd9Sstevel@tonic-gate if (cred != NULL) 21837c478bd9Sstevel@tonic-gate crfree(cred); 21847c478bd9Sstevel@tonic-gate 21857c478bd9Sstevel@tonic-gate /* 21867c478bd9Sstevel@tonic-gate * Free the access cache entries. 21877c478bd9Sstevel@tonic-gate */ 21887c478bd9Sstevel@tonic-gate (void) nfs_access_purge_rp(rp); 21897c478bd9Sstevel@tonic-gate 21907c478bd9Sstevel@tonic-gate /* 21917c478bd9Sstevel@tonic-gate * Free the readdir cache entries. 21927c478bd9Sstevel@tonic-gate */ 21937c478bd9Sstevel@tonic-gate if (HAVE_RDDIR_CACHE(rp)) 21947c478bd9Sstevel@tonic-gate nfs_purge_rddir_cache(vp); 21957c478bd9Sstevel@tonic-gate 21967c478bd9Sstevel@tonic-gate /* 21977c478bd9Sstevel@tonic-gate * Free the symbolic link cache. 21987c478bd9Sstevel@tonic-gate */ 21997c478bd9Sstevel@tonic-gate if (contents != NULL) { 22007c478bd9Sstevel@tonic-gate 22017c478bd9Sstevel@tonic-gate kmem_free((void *)contents, size); 22027c478bd9Sstevel@tonic-gate } 22037c478bd9Sstevel@tonic-gate 22047c478bd9Sstevel@tonic-gate /* 22057c478bd9Sstevel@tonic-gate * Free any cached ACL. 22067c478bd9Sstevel@tonic-gate */ 22077c478bd9Sstevel@tonic-gate if (vsp != NULL) 22087c478bd9Sstevel@tonic-gate nfs_acl_free(vsp); 22097c478bd9Sstevel@tonic-gate 22107c478bd9Sstevel@tonic-gate /* 22117c478bd9Sstevel@tonic-gate * Free any cached pathconf information. 22127c478bd9Sstevel@tonic-gate */ 22137c478bd9Sstevel@tonic-gate if (info != NULL) 22147c478bd9Sstevel@tonic-gate kmem_free(info, sizeof (*info)); 22157c478bd9Sstevel@tonic-gate } 22167c478bd9Sstevel@tonic-gate 22177c478bd9Sstevel@tonic-gate /* 22187c478bd9Sstevel@tonic-gate * Return a vnode for the given NFS Version 2 file handle. 22197c478bd9Sstevel@tonic-gate * If no rnode exists for this fhandle, create one and put it 22207c478bd9Sstevel@tonic-gate * into the hash queues. If the rnode for this fhandle 22217c478bd9Sstevel@tonic-gate * already exists, return it. 22227c478bd9Sstevel@tonic-gate * 22237c478bd9Sstevel@tonic-gate * Note: make_rnode() may upgrade the hash bucket lock to exclusive. 22247c478bd9Sstevel@tonic-gate */ 22257c478bd9Sstevel@tonic-gate vnode_t * 22267c478bd9Sstevel@tonic-gate makenfsnode(fhandle_t *fh, struct nfsfattr *attr, struct vfs *vfsp, 22277c478bd9Sstevel@tonic-gate hrtime_t t, cred_t *cr, char *dnm, char *nm) 22287c478bd9Sstevel@tonic-gate { 22297c478bd9Sstevel@tonic-gate int newnode; 22307c478bd9Sstevel@tonic-gate int index; 22317c478bd9Sstevel@tonic-gate vnode_t *vp; 22327c478bd9Sstevel@tonic-gate nfs_fhandle nfh; 22337c478bd9Sstevel@tonic-gate vattr_t va; 22347c478bd9Sstevel@tonic-gate 22357c478bd9Sstevel@tonic-gate nfh.fh_len = NFS_FHSIZE; 22367c478bd9Sstevel@tonic-gate bcopy(fh, nfh.fh_buf, NFS_FHSIZE); 22377c478bd9Sstevel@tonic-gate 22387c478bd9Sstevel@tonic-gate index = rtablehash(&nfh); 22397c478bd9Sstevel@tonic-gate rw_enter(&rtable[index].r_lock, RW_READER); 22407c478bd9Sstevel@tonic-gate 22417c478bd9Sstevel@tonic-gate vp = make_rnode(&nfh, &rtable[index], vfsp, nfs_vnodeops, 22427c478bd9Sstevel@tonic-gate nfs_putapage, nfs_rddir_compar, &newnode, cr, dnm, nm); 22437c478bd9Sstevel@tonic-gate 22447c478bd9Sstevel@tonic-gate if (attr != NULL) { 22457c478bd9Sstevel@tonic-gate if (!newnode) { 22467c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 22477c478bd9Sstevel@tonic-gate (void) nfs_cache_fattr(vp, attr, &va, t, cr); 22487c478bd9Sstevel@tonic-gate } else { 22497c478bd9Sstevel@tonic-gate if (attr->na_type < NFNON || attr->na_type > NFSOC) 22507c478bd9Sstevel@tonic-gate vp->v_type = VBAD; 22517c478bd9Sstevel@tonic-gate else 22527c478bd9Sstevel@tonic-gate vp->v_type = n2v_type(attr); 22537c478bd9Sstevel@tonic-gate /* 22547c478bd9Sstevel@tonic-gate * A translation here seems to be necessary 22557c478bd9Sstevel@tonic-gate * because this function can be called 22567c478bd9Sstevel@tonic-gate * with `attr' that has come from the wire, 22577c478bd9Sstevel@tonic-gate * and been operated on by vattr_to_nattr(). 22587c478bd9Sstevel@tonic-gate * See nfsrootvp()->VOP_GETTATTR()->nfsgetattr() 22597c478bd9Sstevel@tonic-gate * ->nfs_getattr_otw()->rfscall()->vattr_to_nattr() 22607c478bd9Sstevel@tonic-gate * ->makenfsnode(). 22617c478bd9Sstevel@tonic-gate */ 22627c478bd9Sstevel@tonic-gate if ((attr->na_rdev & 0xffff0000) == 0) 22637c478bd9Sstevel@tonic-gate vp->v_rdev = nfsv2_expdev(attr->na_rdev); 22647c478bd9Sstevel@tonic-gate else 22657c478bd9Sstevel@tonic-gate vp->v_rdev = expldev(n2v_rdev(attr)); 22667c478bd9Sstevel@tonic-gate nfs_attrcache(vp, attr, t); 22677c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 22687c478bd9Sstevel@tonic-gate } 22697c478bd9Sstevel@tonic-gate } else { 22707c478bd9Sstevel@tonic-gate if (newnode) { 22717c478bd9Sstevel@tonic-gate PURGE_ATTRCACHE(vp); 22727c478bd9Sstevel@tonic-gate } 22737c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 22747c478bd9Sstevel@tonic-gate } 22757c478bd9Sstevel@tonic-gate 22767c478bd9Sstevel@tonic-gate return (vp); 22777c478bd9Sstevel@tonic-gate } 22787c478bd9Sstevel@tonic-gate 22797c478bd9Sstevel@tonic-gate /* 22807c478bd9Sstevel@tonic-gate * Return a vnode for the given NFS Version 3 file handle. 22817c478bd9Sstevel@tonic-gate * If no rnode exists for this fhandle, create one and put it 22827c478bd9Sstevel@tonic-gate * into the hash queues. If the rnode for this fhandle 22837c478bd9Sstevel@tonic-gate * already exists, return it. 22847c478bd9Sstevel@tonic-gate * 22857c478bd9Sstevel@tonic-gate * Note: make_rnode() may upgrade the hash bucket lock to exclusive. 22867c478bd9Sstevel@tonic-gate */ 22877c478bd9Sstevel@tonic-gate vnode_t * 22887c478bd9Sstevel@tonic-gate makenfs3node_va(nfs_fh3 *fh, vattr_t *vap, struct vfs *vfsp, hrtime_t t, 22897c478bd9Sstevel@tonic-gate cred_t *cr, char *dnm, char *nm) 22907c478bd9Sstevel@tonic-gate { 22917c478bd9Sstevel@tonic-gate int newnode; 22927c478bd9Sstevel@tonic-gate int index; 22937c478bd9Sstevel@tonic-gate vnode_t *vp; 22947c478bd9Sstevel@tonic-gate 22957c478bd9Sstevel@tonic-gate index = rtablehash((nfs_fhandle *)fh); 22967c478bd9Sstevel@tonic-gate rw_enter(&rtable[index].r_lock, RW_READER); 22977c478bd9Sstevel@tonic-gate 22987c478bd9Sstevel@tonic-gate vp = make_rnode((nfs_fhandle *)fh, &rtable[index], vfsp, 22997c478bd9Sstevel@tonic-gate nfs3_vnodeops, nfs3_putapage, nfs3_rddir_compar, &newnode, cr, 23007c478bd9Sstevel@tonic-gate dnm, nm); 23017c478bd9Sstevel@tonic-gate 23027c478bd9Sstevel@tonic-gate if (vap == NULL) { 23037c478bd9Sstevel@tonic-gate if (newnode) { 23047c478bd9Sstevel@tonic-gate PURGE_ATTRCACHE(vp); 23057c478bd9Sstevel@tonic-gate } 23067c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 23077c478bd9Sstevel@tonic-gate return (vp); 23087c478bd9Sstevel@tonic-gate } 23097c478bd9Sstevel@tonic-gate 23107c478bd9Sstevel@tonic-gate if (!newnode) { 23117c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 23127c478bd9Sstevel@tonic-gate nfs_attr_cache(vp, vap, t, cr); 23137c478bd9Sstevel@tonic-gate } else { 23147c478bd9Sstevel@tonic-gate rnode_t *rp = VTOR(vp); 23157c478bd9Sstevel@tonic-gate 23167c478bd9Sstevel@tonic-gate vp->v_type = vap->va_type; 23177c478bd9Sstevel@tonic-gate vp->v_rdev = vap->va_rdev; 23187c478bd9Sstevel@tonic-gate 23197c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 23207c478bd9Sstevel@tonic-gate if (rp->r_mtime <= t) 23217c478bd9Sstevel@tonic-gate nfs_attrcache_va(vp, vap); 23227c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 23237c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 23247c478bd9Sstevel@tonic-gate } 23257c478bd9Sstevel@tonic-gate 23267c478bd9Sstevel@tonic-gate return (vp); 23277c478bd9Sstevel@tonic-gate } 23287c478bd9Sstevel@tonic-gate 23297c478bd9Sstevel@tonic-gate vnode_t * 23307c478bd9Sstevel@tonic-gate makenfs3node(nfs_fh3 *fh, fattr3 *attr, struct vfs *vfsp, hrtime_t t, 23317c478bd9Sstevel@tonic-gate cred_t *cr, char *dnm, char *nm) 23327c478bd9Sstevel@tonic-gate { 23337c478bd9Sstevel@tonic-gate int newnode; 23347c478bd9Sstevel@tonic-gate int index; 23357c478bd9Sstevel@tonic-gate vnode_t *vp; 23367c478bd9Sstevel@tonic-gate vattr_t va; 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate index = rtablehash((nfs_fhandle *)fh); 23397c478bd9Sstevel@tonic-gate rw_enter(&rtable[index].r_lock, RW_READER); 23407c478bd9Sstevel@tonic-gate 23417c478bd9Sstevel@tonic-gate vp = make_rnode((nfs_fhandle *)fh, &rtable[index], vfsp, 23427c478bd9Sstevel@tonic-gate nfs3_vnodeops, nfs3_putapage, nfs3_rddir_compar, &newnode, cr, 23437c478bd9Sstevel@tonic-gate dnm, nm); 23447c478bd9Sstevel@tonic-gate 23457c478bd9Sstevel@tonic-gate if (attr == NULL) { 23467c478bd9Sstevel@tonic-gate if (newnode) { 23477c478bd9Sstevel@tonic-gate PURGE_ATTRCACHE(vp); 23487c478bd9Sstevel@tonic-gate } 23497c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 23507c478bd9Sstevel@tonic-gate return (vp); 23517c478bd9Sstevel@tonic-gate } 23527c478bd9Sstevel@tonic-gate 23537c478bd9Sstevel@tonic-gate if (!newnode) { 23547c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 23557c478bd9Sstevel@tonic-gate (void) nfs3_cache_fattr3(vp, attr, &va, t, cr); 23567c478bd9Sstevel@tonic-gate } else { 23577c478bd9Sstevel@tonic-gate if (attr->type < NF3REG || attr->type > NF3FIFO) 23587c478bd9Sstevel@tonic-gate vp->v_type = VBAD; 23597c478bd9Sstevel@tonic-gate else 23607c478bd9Sstevel@tonic-gate vp->v_type = nf3_to_vt[attr->type]; 23617c478bd9Sstevel@tonic-gate vp->v_rdev = makedevice(attr->rdev.specdata1, 23627c478bd9Sstevel@tonic-gate attr->rdev.specdata2); 23637c478bd9Sstevel@tonic-gate nfs3_attrcache(vp, attr, t); 23647c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 23657c478bd9Sstevel@tonic-gate } 23667c478bd9Sstevel@tonic-gate 23677c478bd9Sstevel@tonic-gate return (vp); 23687c478bd9Sstevel@tonic-gate } 23697c478bd9Sstevel@tonic-gate 23707c478bd9Sstevel@tonic-gate /* 23717c478bd9Sstevel@tonic-gate * Read this comment before making changes to rtablehash()! 23727c478bd9Sstevel@tonic-gate * This is a hash function in which seemingly obvious and harmless 23737c478bd9Sstevel@tonic-gate * changes can cause escalations costing million dollars! 23747c478bd9Sstevel@tonic-gate * Know what you are doing. 23757c478bd9Sstevel@tonic-gate * 23767c478bd9Sstevel@tonic-gate * rtablehash() implements Jenkins' one-at-a-time hash algorithm. The 23777c478bd9Sstevel@tonic-gate * algorithm is currently detailed here: 23787c478bd9Sstevel@tonic-gate * 23797c478bd9Sstevel@tonic-gate * http://burtleburtle.net/bob/hash/doobs.html 23807c478bd9Sstevel@tonic-gate * 23817c478bd9Sstevel@tonic-gate * Of course, the above link may not be valid by the time you are reading 23827c478bd9Sstevel@tonic-gate * this, but suffice it to say that the one-at-a-time algorithm works well in 23837c478bd9Sstevel@tonic-gate * almost all cases. If you are changing the algorithm be sure to verify that 23847c478bd9Sstevel@tonic-gate * the hash algorithm still provides even distribution in all cases and with 23857c478bd9Sstevel@tonic-gate * any server returning filehandles in whatever order (sequential or random). 23867c478bd9Sstevel@tonic-gate */ 23877c478bd9Sstevel@tonic-gate static int 23887c478bd9Sstevel@tonic-gate rtablehash(nfs_fhandle *fh) 23897c478bd9Sstevel@tonic-gate { 23907c478bd9Sstevel@tonic-gate ulong_t hash, len, i; 23917c478bd9Sstevel@tonic-gate char *key; 23927c478bd9Sstevel@tonic-gate 23937c478bd9Sstevel@tonic-gate key = fh->fh_buf; 23947c478bd9Sstevel@tonic-gate len = (ulong_t)fh->fh_len; 23957c478bd9Sstevel@tonic-gate for (hash = 0, i = 0; i < len; i++) { 23967c478bd9Sstevel@tonic-gate hash += key[i]; 23977c478bd9Sstevel@tonic-gate hash += (hash << 10); 23987c478bd9Sstevel@tonic-gate hash ^= (hash >> 6); 23997c478bd9Sstevel@tonic-gate } 24007c478bd9Sstevel@tonic-gate hash += (hash << 3); 24017c478bd9Sstevel@tonic-gate hash ^= (hash >> 11); 24027c478bd9Sstevel@tonic-gate hash += (hash << 15); 24037c478bd9Sstevel@tonic-gate return (hash & rtablemask); 24047c478bd9Sstevel@tonic-gate } 24057c478bd9Sstevel@tonic-gate 24067c478bd9Sstevel@tonic-gate static vnode_t * 24077c478bd9Sstevel@tonic-gate make_rnode(nfs_fhandle *fh, rhashq_t *rhtp, struct vfs *vfsp, 24087c478bd9Sstevel@tonic-gate struct vnodeops *vops, 24097c478bd9Sstevel@tonic-gate int (*putapage)(vnode_t *, page_t *, u_offset_t *, size_t *, int, cred_t *), 24107c478bd9Sstevel@tonic-gate int (*compar)(const void *, const void *), 24117c478bd9Sstevel@tonic-gate int *newnode, cred_t *cr, char *dnm, char *nm) 24127c478bd9Sstevel@tonic-gate { 24137c478bd9Sstevel@tonic-gate rnode_t *rp; 24147c478bd9Sstevel@tonic-gate rnode_t *trp; 24157c478bd9Sstevel@tonic-gate vnode_t *vp; 24167c478bd9Sstevel@tonic-gate mntinfo_t *mi; 24177c478bd9Sstevel@tonic-gate 24187c478bd9Sstevel@tonic-gate ASSERT(RW_READ_HELD(&rhtp->r_lock)); 24197c478bd9Sstevel@tonic-gate 24207c478bd9Sstevel@tonic-gate mi = VFTOMI(vfsp); 24217c478bd9Sstevel@tonic-gate start: 24227c478bd9Sstevel@tonic-gate if ((rp = rfind(rhtp, fh, vfsp)) != NULL) { 24237c478bd9Sstevel@tonic-gate vp = RTOV(rp); 24247c478bd9Sstevel@tonic-gate nfs_set_vroot(vp); 24257c478bd9Sstevel@tonic-gate *newnode = 0; 24267c478bd9Sstevel@tonic-gate return (vp); 24277c478bd9Sstevel@tonic-gate } 24287c478bd9Sstevel@tonic-gate rw_exit(&rhtp->r_lock); 24297c478bd9Sstevel@tonic-gate 24307c478bd9Sstevel@tonic-gate mutex_enter(&rpfreelist_lock); 24317c478bd9Sstevel@tonic-gate if (rpfreelist != NULL && rnew >= nrnode) { 24327c478bd9Sstevel@tonic-gate rp = rpfreelist; 24337c478bd9Sstevel@tonic-gate rp_rmfree(rp); 24347c478bd9Sstevel@tonic-gate mutex_exit(&rpfreelist_lock); 24357c478bd9Sstevel@tonic-gate 24367c478bd9Sstevel@tonic-gate vp = RTOV(rp); 24377c478bd9Sstevel@tonic-gate 24387c478bd9Sstevel@tonic-gate if (rp->r_flags & RHASHED) { 24397c478bd9Sstevel@tonic-gate rw_enter(&rp->r_hashq->r_lock, RW_WRITER); 24407c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 24417c478bd9Sstevel@tonic-gate if (vp->v_count > 1) { 24427c478bd9Sstevel@tonic-gate vp->v_count--; 24437c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 24447c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 24457c478bd9Sstevel@tonic-gate rw_enter(&rhtp->r_lock, RW_READER); 24467c478bd9Sstevel@tonic-gate goto start; 24477c478bd9Sstevel@tonic-gate } 24487c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 24497c478bd9Sstevel@tonic-gate rp_rmhash_locked(rp); 24507c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 24517c478bd9Sstevel@tonic-gate } 24527c478bd9Sstevel@tonic-gate 24537c478bd9Sstevel@tonic-gate rinactive(rp, cr); 24547c478bd9Sstevel@tonic-gate 24557c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 24567c478bd9Sstevel@tonic-gate if (vp->v_count > 1) { 24577c478bd9Sstevel@tonic-gate vp->v_count--; 24587c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 24597c478bd9Sstevel@tonic-gate rw_enter(&rhtp->r_lock, RW_READER); 24607c478bd9Sstevel@tonic-gate goto start; 24617c478bd9Sstevel@tonic-gate } 24627c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 24637c478bd9Sstevel@tonic-gate vn_invalid(vp); 24647c478bd9Sstevel@tonic-gate /* 24657c478bd9Sstevel@tonic-gate * destroy old locks before bzero'ing and 24667c478bd9Sstevel@tonic-gate * recreating the locks below. 24677c478bd9Sstevel@tonic-gate */ 24687c478bd9Sstevel@tonic-gate nfs_rw_destroy(&rp->r_rwlock); 24697c478bd9Sstevel@tonic-gate nfs_rw_destroy(&rp->r_lkserlock); 24707c478bd9Sstevel@tonic-gate mutex_destroy(&rp->r_statelock); 24717c478bd9Sstevel@tonic-gate cv_destroy(&rp->r_cv); 24727c478bd9Sstevel@tonic-gate cv_destroy(&rp->r_commit.c_cv); 24737c478bd9Sstevel@tonic-gate nfs_free_r_path(rp); 24747c478bd9Sstevel@tonic-gate avl_destroy(&rp->r_dir); 24757c478bd9Sstevel@tonic-gate /* 24767c478bd9Sstevel@tonic-gate * Make sure that if rnode is recycled then 24777c478bd9Sstevel@tonic-gate * VFS count is decremented properly before 24787c478bd9Sstevel@tonic-gate * reuse. 24797c478bd9Sstevel@tonic-gate */ 24807c478bd9Sstevel@tonic-gate VFS_RELE(vp->v_vfsp); 24817c478bd9Sstevel@tonic-gate vn_reinit(vp); 24827c478bd9Sstevel@tonic-gate } else { 24837c478bd9Sstevel@tonic-gate vnode_t *new_vp; 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate mutex_exit(&rpfreelist_lock); 24867c478bd9Sstevel@tonic-gate 24877c478bd9Sstevel@tonic-gate rp = kmem_cache_alloc(rnode_cache, KM_SLEEP); 24887c478bd9Sstevel@tonic-gate new_vp = vn_alloc(KM_SLEEP); 24897c478bd9Sstevel@tonic-gate 24907c478bd9Sstevel@tonic-gate atomic_add_long((ulong_t *)&rnew, 1); 24917c478bd9Sstevel@tonic-gate #ifdef DEBUG 24927c478bd9Sstevel@tonic-gate clstat_debug.nrnode.value.ui64++; 24937c478bd9Sstevel@tonic-gate #endif 24947c478bd9Sstevel@tonic-gate vp = new_vp; 24957c478bd9Sstevel@tonic-gate } 24967c478bd9Sstevel@tonic-gate 24977c478bd9Sstevel@tonic-gate bzero(rp, sizeof (*rp)); 24987c478bd9Sstevel@tonic-gate rp->r_vnode = vp; 24997c478bd9Sstevel@tonic-gate nfs_rw_init(&rp->r_rwlock, NULL, RW_DEFAULT, NULL); 25007c478bd9Sstevel@tonic-gate nfs_rw_init(&rp->r_lkserlock, NULL, RW_DEFAULT, NULL); 25017c478bd9Sstevel@tonic-gate mutex_init(&rp->r_statelock, NULL, MUTEX_DEFAULT, NULL); 25027c478bd9Sstevel@tonic-gate cv_init(&rp->r_cv, NULL, CV_DEFAULT, NULL); 25037c478bd9Sstevel@tonic-gate cv_init(&rp->r_commit.c_cv, NULL, CV_DEFAULT, NULL); 25047c478bd9Sstevel@tonic-gate rp->r_fh.fh_len = fh->fh_len; 25057c478bd9Sstevel@tonic-gate bcopy(fh->fh_buf, rp->r_fh.fh_buf, fh->fh_len); 25067c478bd9Sstevel@tonic-gate rp->r_server = mi->mi_curr_serv; 25077c478bd9Sstevel@tonic-gate if (FAILOVER_MOUNT(mi)) { 25087c478bd9Sstevel@tonic-gate /* 25097c478bd9Sstevel@tonic-gate * If replicated servers, stash pathnames 25107c478bd9Sstevel@tonic-gate */ 25117c478bd9Sstevel@tonic-gate if (dnm != NULL && nm != NULL) { 25127c478bd9Sstevel@tonic-gate char *s, *p; 25137c478bd9Sstevel@tonic-gate uint_t len; 25147c478bd9Sstevel@tonic-gate 25157c478bd9Sstevel@tonic-gate len = (uint_t)(strlen(dnm) + strlen(nm) + 2); 25167c478bd9Sstevel@tonic-gate rp->r_path = kmem_alloc(len, KM_SLEEP); 25177c478bd9Sstevel@tonic-gate #ifdef DEBUG 25187c478bd9Sstevel@tonic-gate clstat_debug.rpath.value.ui64 += len; 25197c478bd9Sstevel@tonic-gate #endif 25207c478bd9Sstevel@tonic-gate s = rp->r_path; 25217c478bd9Sstevel@tonic-gate for (p = dnm; *p; p++) 25227c478bd9Sstevel@tonic-gate *s++ = *p; 25237c478bd9Sstevel@tonic-gate *s++ = '/'; 25247c478bd9Sstevel@tonic-gate for (p = nm; *p; p++) 25257c478bd9Sstevel@tonic-gate *s++ = *p; 25267c478bd9Sstevel@tonic-gate *s = '\0'; 25277c478bd9Sstevel@tonic-gate } else { 25287c478bd9Sstevel@tonic-gate /* special case for root */ 25297c478bd9Sstevel@tonic-gate rp->r_path = kmem_alloc(2, KM_SLEEP); 25307c478bd9Sstevel@tonic-gate #ifdef DEBUG 25317c478bd9Sstevel@tonic-gate clstat_debug.rpath.value.ui64 += 2; 25327c478bd9Sstevel@tonic-gate #endif 25337c478bd9Sstevel@tonic-gate *rp->r_path = '.'; 25347c478bd9Sstevel@tonic-gate *(rp->r_path + 1) = '\0'; 25357c478bd9Sstevel@tonic-gate } 25367c478bd9Sstevel@tonic-gate } 25377c478bd9Sstevel@tonic-gate VFS_HOLD(vfsp); 25387c478bd9Sstevel@tonic-gate rp->r_putapage = putapage; 25397c478bd9Sstevel@tonic-gate rp->r_hashq = rhtp; 25407c478bd9Sstevel@tonic-gate rp->r_flags = RREADDIRPLUS; 25417c478bd9Sstevel@tonic-gate avl_create(&rp->r_dir, compar, sizeof (rddir_cache), 25427c478bd9Sstevel@tonic-gate offsetof(rddir_cache, tree)); 25437c478bd9Sstevel@tonic-gate vn_setops(vp, vops); 25447c478bd9Sstevel@tonic-gate vp->v_data = (caddr_t)rp; 25457c478bd9Sstevel@tonic-gate vp->v_vfsp = vfsp; 25467c478bd9Sstevel@tonic-gate vp->v_type = VNON; 25477c478bd9Sstevel@tonic-gate nfs_set_vroot(vp); 25487c478bd9Sstevel@tonic-gate 25497c478bd9Sstevel@tonic-gate /* 25507c478bd9Sstevel@tonic-gate * There is a race condition if someone else 25517c478bd9Sstevel@tonic-gate * alloc's the rnode while no locks are held, so we 25527c478bd9Sstevel@tonic-gate * check again and recover if found. 25537c478bd9Sstevel@tonic-gate */ 25547c478bd9Sstevel@tonic-gate rw_enter(&rhtp->r_lock, RW_WRITER); 25557c478bd9Sstevel@tonic-gate if ((trp = rfind(rhtp, fh, vfsp)) != NULL) { 25567c478bd9Sstevel@tonic-gate vp = RTOV(trp); 25577c478bd9Sstevel@tonic-gate nfs_set_vroot(vp); 25587c478bd9Sstevel@tonic-gate *newnode = 0; 25597c478bd9Sstevel@tonic-gate rw_exit(&rhtp->r_lock); 25607c478bd9Sstevel@tonic-gate rp_addfree(rp, cr); 25617c478bd9Sstevel@tonic-gate rw_enter(&rhtp->r_lock, RW_READER); 25627c478bd9Sstevel@tonic-gate return (vp); 25637c478bd9Sstevel@tonic-gate } 25647c478bd9Sstevel@tonic-gate rp_addhash(rp); 25657c478bd9Sstevel@tonic-gate *newnode = 1; 25667c478bd9Sstevel@tonic-gate return (vp); 25677c478bd9Sstevel@tonic-gate } 25687c478bd9Sstevel@tonic-gate 25697c478bd9Sstevel@tonic-gate static void 25707c478bd9Sstevel@tonic-gate nfs_set_vroot(vnode_t *vp) 25717c478bd9Sstevel@tonic-gate { 25727c478bd9Sstevel@tonic-gate rnode_t *rp; 25737c478bd9Sstevel@tonic-gate nfs_fhandle *rootfh; 25747c478bd9Sstevel@tonic-gate 25757c478bd9Sstevel@tonic-gate rp = VTOR(vp); 25767c478bd9Sstevel@tonic-gate rootfh = &rp->r_server->sv_fhandle; 25777c478bd9Sstevel@tonic-gate if (rootfh->fh_len == rp->r_fh.fh_len && 25787c478bd9Sstevel@tonic-gate bcmp(rootfh->fh_buf, rp->r_fh.fh_buf, rp->r_fh.fh_len) == 0) { 25797c478bd9Sstevel@tonic-gate if (!(vp->v_flag & VROOT)) { 25807c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 25817c478bd9Sstevel@tonic-gate vp->v_flag |= VROOT; 25827c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 25837c478bd9Sstevel@tonic-gate } 25847c478bd9Sstevel@tonic-gate } 25857c478bd9Sstevel@tonic-gate } 25867c478bd9Sstevel@tonic-gate 25877c478bd9Sstevel@tonic-gate static void 25887c478bd9Sstevel@tonic-gate nfs_free_r_path(rnode_t *rp) 25897c478bd9Sstevel@tonic-gate { 25907c478bd9Sstevel@tonic-gate char *path; 25917c478bd9Sstevel@tonic-gate size_t len; 25927c478bd9Sstevel@tonic-gate 25937c478bd9Sstevel@tonic-gate path = rp->r_path; 25947c478bd9Sstevel@tonic-gate if (path) { 25957c478bd9Sstevel@tonic-gate rp->r_path = NULL; 25967c478bd9Sstevel@tonic-gate len = strlen(path) + 1; 25977c478bd9Sstevel@tonic-gate kmem_free(path, len); 25987c478bd9Sstevel@tonic-gate #ifdef DEBUG 25997c478bd9Sstevel@tonic-gate clstat_debug.rpath.value.ui64 -= len; 26007c478bd9Sstevel@tonic-gate #endif 26017c478bd9Sstevel@tonic-gate } 26027c478bd9Sstevel@tonic-gate } 26037c478bd9Sstevel@tonic-gate 26047c478bd9Sstevel@tonic-gate /* 26057c478bd9Sstevel@tonic-gate * Put an rnode on the free list. 26067c478bd9Sstevel@tonic-gate * 26077c478bd9Sstevel@tonic-gate * Rnodes which were allocated above and beyond the normal limit 26087c478bd9Sstevel@tonic-gate * are immediately freed. 26097c478bd9Sstevel@tonic-gate */ 26107c478bd9Sstevel@tonic-gate void 26117c478bd9Sstevel@tonic-gate rp_addfree(rnode_t *rp, cred_t *cr) 26127c478bd9Sstevel@tonic-gate { 26137c478bd9Sstevel@tonic-gate vnode_t *vp; 26147c478bd9Sstevel@tonic-gate struct vfs *vfsp; 26157c478bd9Sstevel@tonic-gate 26167c478bd9Sstevel@tonic-gate vp = RTOV(rp); 26177c478bd9Sstevel@tonic-gate ASSERT(vp->v_count >= 1); 26187c478bd9Sstevel@tonic-gate ASSERT(rp->r_freef == NULL && rp->r_freeb == NULL); 26197c478bd9Sstevel@tonic-gate 26207c478bd9Sstevel@tonic-gate /* 26217c478bd9Sstevel@tonic-gate * If we have too many rnodes allocated and there are no 26227c478bd9Sstevel@tonic-gate * references to this rnode, or if the rnode is no longer 26237c478bd9Sstevel@tonic-gate * accessible by it does not reside in the hash queues, 26247c478bd9Sstevel@tonic-gate * or if an i/o error occurred while writing to the file, 26257c478bd9Sstevel@tonic-gate * then just free it instead of putting it on the rnode 26267c478bd9Sstevel@tonic-gate * freelist. 26277c478bd9Sstevel@tonic-gate */ 26287c478bd9Sstevel@tonic-gate vfsp = vp->v_vfsp; 26297c478bd9Sstevel@tonic-gate if (((rnew > nrnode || !(rp->r_flags & RHASHED) || rp->r_error || 26307c478bd9Sstevel@tonic-gate (vfsp->vfs_flag & VFS_UNMOUNTED)) && rp->r_count == 0)) { 26317c478bd9Sstevel@tonic-gate if (rp->r_flags & RHASHED) { 26327c478bd9Sstevel@tonic-gate rw_enter(&rp->r_hashq->r_lock, RW_WRITER); 26337c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 26347c478bd9Sstevel@tonic-gate if (vp->v_count > 1) { 26357c478bd9Sstevel@tonic-gate vp->v_count--; 26367c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 26377c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 26387c478bd9Sstevel@tonic-gate return; 26397c478bd9Sstevel@tonic-gate } 26407c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 26417c478bd9Sstevel@tonic-gate rp_rmhash_locked(rp); 26427c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 26437c478bd9Sstevel@tonic-gate } 26447c478bd9Sstevel@tonic-gate 26457c478bd9Sstevel@tonic-gate rinactive(rp, cr); 26467c478bd9Sstevel@tonic-gate 26477c478bd9Sstevel@tonic-gate /* 26487c478bd9Sstevel@tonic-gate * Recheck the vnode reference count. We need to 26497c478bd9Sstevel@tonic-gate * make sure that another reference has not been 26507c478bd9Sstevel@tonic-gate * acquired while we were not holding v_lock. The 26517c478bd9Sstevel@tonic-gate * rnode is not in the rnode hash queues, so the 26527c478bd9Sstevel@tonic-gate * only way for a reference to have been acquired 26537c478bd9Sstevel@tonic-gate * is for a VOP_PUTPAGE because the rnode was marked 26547c478bd9Sstevel@tonic-gate * with RDIRTY or for a modified page. This 26557c478bd9Sstevel@tonic-gate * reference may have been acquired before our call 26567c478bd9Sstevel@tonic-gate * to rinactive. The i/o may have been completed, 26577c478bd9Sstevel@tonic-gate * thus allowing rinactive to complete, but the 26587c478bd9Sstevel@tonic-gate * reference to the vnode may not have been released 26597c478bd9Sstevel@tonic-gate * yet. In any case, the rnode can not be destroyed 26607c478bd9Sstevel@tonic-gate * until the other references to this vnode have been 26617c478bd9Sstevel@tonic-gate * released. The other references will take care of 26627c478bd9Sstevel@tonic-gate * either destroying the rnode or placing it on the 26637c478bd9Sstevel@tonic-gate * rnode freelist. If there are no other references, 26647c478bd9Sstevel@tonic-gate * then the rnode may be safely destroyed. 26657c478bd9Sstevel@tonic-gate */ 26667c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 26677c478bd9Sstevel@tonic-gate if (vp->v_count > 1) { 26687c478bd9Sstevel@tonic-gate vp->v_count--; 26697c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 26707c478bd9Sstevel@tonic-gate return; 26717c478bd9Sstevel@tonic-gate } 26727c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 26737c478bd9Sstevel@tonic-gate 26747c478bd9Sstevel@tonic-gate destroy_rnode(rp); 26757c478bd9Sstevel@tonic-gate return; 26767c478bd9Sstevel@tonic-gate } 26777c478bd9Sstevel@tonic-gate 26787c478bd9Sstevel@tonic-gate /* 26797c478bd9Sstevel@tonic-gate * Lock the hash queue and then recheck the reference count 26807c478bd9Sstevel@tonic-gate * to ensure that no other threads have acquired a reference 26817c478bd9Sstevel@tonic-gate * to indicate that the rnode should not be placed on the 26827c478bd9Sstevel@tonic-gate * freelist. If another reference has been acquired, then 26837c478bd9Sstevel@tonic-gate * just release this one and let the other thread complete 26847c478bd9Sstevel@tonic-gate * the processing of adding this rnode to the freelist. 26857c478bd9Sstevel@tonic-gate */ 26867c478bd9Sstevel@tonic-gate rw_enter(&rp->r_hashq->r_lock, RW_WRITER); 26877c478bd9Sstevel@tonic-gate 26887c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 26897c478bd9Sstevel@tonic-gate if (vp->v_count > 1) { 26907c478bd9Sstevel@tonic-gate vp->v_count--; 26917c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 26927c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 26937c478bd9Sstevel@tonic-gate return; 26947c478bd9Sstevel@tonic-gate } 26957c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 26967c478bd9Sstevel@tonic-gate 26977c478bd9Sstevel@tonic-gate /* 26987c478bd9Sstevel@tonic-gate * If there is no cached data or metadata for this file, then 26997c478bd9Sstevel@tonic-gate * put the rnode on the front of the freelist so that it will 27007c478bd9Sstevel@tonic-gate * be reused before other rnodes which may have cached data or 27017c478bd9Sstevel@tonic-gate * metadata associated with them. 27027c478bd9Sstevel@tonic-gate */ 27037c478bd9Sstevel@tonic-gate mutex_enter(&rpfreelist_lock); 27047c478bd9Sstevel@tonic-gate if (rpfreelist == NULL) { 27057c478bd9Sstevel@tonic-gate rp->r_freef = rp; 27067c478bd9Sstevel@tonic-gate rp->r_freeb = rp; 27077c478bd9Sstevel@tonic-gate rpfreelist = rp; 27087c478bd9Sstevel@tonic-gate } else { 27097c478bd9Sstevel@tonic-gate rp->r_freef = rpfreelist; 27107c478bd9Sstevel@tonic-gate rp->r_freeb = rpfreelist->r_freeb; 27117c478bd9Sstevel@tonic-gate rpfreelist->r_freeb->r_freef = rp; 27127c478bd9Sstevel@tonic-gate rpfreelist->r_freeb = rp; 27137c478bd9Sstevel@tonic-gate if (!vn_has_cached_data(vp) && 27147c478bd9Sstevel@tonic-gate !HAVE_RDDIR_CACHE(rp) && 27157c478bd9Sstevel@tonic-gate rp->r_symlink.contents == NULL && 27167c478bd9Sstevel@tonic-gate rp->r_secattr == NULL && 27177c478bd9Sstevel@tonic-gate rp->r_pathconf == NULL) 27187c478bd9Sstevel@tonic-gate rpfreelist = rp; 27197c478bd9Sstevel@tonic-gate } 27207c478bd9Sstevel@tonic-gate mutex_exit(&rpfreelist_lock); 27217c478bd9Sstevel@tonic-gate 27227c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 27237c478bd9Sstevel@tonic-gate } 27247c478bd9Sstevel@tonic-gate 27257c478bd9Sstevel@tonic-gate /* 27267c478bd9Sstevel@tonic-gate * Remove an rnode from the free list. 27277c478bd9Sstevel@tonic-gate * 27287c478bd9Sstevel@tonic-gate * The caller must be holding rpfreelist_lock and the rnode 27297c478bd9Sstevel@tonic-gate * must be on the freelist. 27307c478bd9Sstevel@tonic-gate */ 27317c478bd9Sstevel@tonic-gate static void 27327c478bd9Sstevel@tonic-gate rp_rmfree(rnode_t *rp) 27337c478bd9Sstevel@tonic-gate { 27347c478bd9Sstevel@tonic-gate 27357c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&rpfreelist_lock)); 27367c478bd9Sstevel@tonic-gate ASSERT(rp->r_freef != NULL && rp->r_freeb != NULL); 27377c478bd9Sstevel@tonic-gate 27387c478bd9Sstevel@tonic-gate if (rp == rpfreelist) { 27397c478bd9Sstevel@tonic-gate rpfreelist = rp->r_freef; 27407c478bd9Sstevel@tonic-gate if (rp == rpfreelist) 27417c478bd9Sstevel@tonic-gate rpfreelist = NULL; 27427c478bd9Sstevel@tonic-gate } 27437c478bd9Sstevel@tonic-gate 27447c478bd9Sstevel@tonic-gate rp->r_freeb->r_freef = rp->r_freef; 27457c478bd9Sstevel@tonic-gate rp->r_freef->r_freeb = rp->r_freeb; 27467c478bd9Sstevel@tonic-gate 27477c478bd9Sstevel@tonic-gate rp->r_freef = rp->r_freeb = NULL; 27487c478bd9Sstevel@tonic-gate } 27497c478bd9Sstevel@tonic-gate 27507c478bd9Sstevel@tonic-gate /* 27517c478bd9Sstevel@tonic-gate * Put a rnode in the hash table. 27527c478bd9Sstevel@tonic-gate * 27537c478bd9Sstevel@tonic-gate * The caller must be holding the exclusive hash queue lock. 27547c478bd9Sstevel@tonic-gate */ 27557c478bd9Sstevel@tonic-gate static void 27567c478bd9Sstevel@tonic-gate rp_addhash(rnode_t *rp) 27577c478bd9Sstevel@tonic-gate { 27587c478bd9Sstevel@tonic-gate 27597c478bd9Sstevel@tonic-gate ASSERT(RW_WRITE_HELD(&rp->r_hashq->r_lock)); 27607c478bd9Sstevel@tonic-gate ASSERT(!(rp->r_flags & RHASHED)); 27617c478bd9Sstevel@tonic-gate 27627c478bd9Sstevel@tonic-gate rp->r_hashf = rp->r_hashq->r_hashf; 27637c478bd9Sstevel@tonic-gate rp->r_hashq->r_hashf = rp; 27647c478bd9Sstevel@tonic-gate rp->r_hashb = (rnode_t *)rp->r_hashq; 27657c478bd9Sstevel@tonic-gate rp->r_hashf->r_hashb = rp; 27667c478bd9Sstevel@tonic-gate 27677c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 27687c478bd9Sstevel@tonic-gate rp->r_flags |= RHASHED; 27697c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 27707c478bd9Sstevel@tonic-gate } 27717c478bd9Sstevel@tonic-gate 27727c478bd9Sstevel@tonic-gate /* 27737c478bd9Sstevel@tonic-gate * Remove a rnode from the hash table. 27747c478bd9Sstevel@tonic-gate * 27757c478bd9Sstevel@tonic-gate * The caller must be holding the hash queue lock. 27767c478bd9Sstevel@tonic-gate */ 27777c478bd9Sstevel@tonic-gate static void 27787c478bd9Sstevel@tonic-gate rp_rmhash_locked(rnode_t *rp) 27797c478bd9Sstevel@tonic-gate { 27807c478bd9Sstevel@tonic-gate 27817c478bd9Sstevel@tonic-gate ASSERT(RW_WRITE_HELD(&rp->r_hashq->r_lock)); 27827c478bd9Sstevel@tonic-gate ASSERT(rp->r_flags & RHASHED); 27837c478bd9Sstevel@tonic-gate 27847c478bd9Sstevel@tonic-gate rp->r_hashb->r_hashf = rp->r_hashf; 27857c478bd9Sstevel@tonic-gate rp->r_hashf->r_hashb = rp->r_hashb; 27867c478bd9Sstevel@tonic-gate 27877c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 27887c478bd9Sstevel@tonic-gate rp->r_flags &= ~RHASHED; 27897c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 27907c478bd9Sstevel@tonic-gate } 27917c478bd9Sstevel@tonic-gate 27927c478bd9Sstevel@tonic-gate /* 27937c478bd9Sstevel@tonic-gate * Remove a rnode from the hash table. 27947c478bd9Sstevel@tonic-gate * 27957c478bd9Sstevel@tonic-gate * The caller must not be holding the hash queue lock. 27967c478bd9Sstevel@tonic-gate */ 27977c478bd9Sstevel@tonic-gate void 27987c478bd9Sstevel@tonic-gate rp_rmhash(rnode_t *rp) 27997c478bd9Sstevel@tonic-gate { 28007c478bd9Sstevel@tonic-gate 28017c478bd9Sstevel@tonic-gate rw_enter(&rp->r_hashq->r_lock, RW_WRITER); 28027c478bd9Sstevel@tonic-gate rp_rmhash_locked(rp); 28037c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 28047c478bd9Sstevel@tonic-gate } 28057c478bd9Sstevel@tonic-gate 28067c478bd9Sstevel@tonic-gate /* 28077c478bd9Sstevel@tonic-gate * Lookup a rnode by fhandle. 28087c478bd9Sstevel@tonic-gate * 28097c478bd9Sstevel@tonic-gate * The caller must be holding the hash queue lock, either shared or exclusive. 28107c478bd9Sstevel@tonic-gate */ 28117c478bd9Sstevel@tonic-gate static rnode_t * 28127c478bd9Sstevel@tonic-gate rfind(rhashq_t *rhtp, nfs_fhandle *fh, struct vfs *vfsp) 28137c478bd9Sstevel@tonic-gate { 28147c478bd9Sstevel@tonic-gate rnode_t *rp; 28157c478bd9Sstevel@tonic-gate vnode_t *vp; 28167c478bd9Sstevel@tonic-gate 28177c478bd9Sstevel@tonic-gate ASSERT(RW_LOCK_HELD(&rhtp->r_lock)); 28187c478bd9Sstevel@tonic-gate 28197c478bd9Sstevel@tonic-gate for (rp = rhtp->r_hashf; rp != (rnode_t *)rhtp; rp = rp->r_hashf) { 28207c478bd9Sstevel@tonic-gate vp = RTOV(rp); 28217c478bd9Sstevel@tonic-gate if (vp->v_vfsp == vfsp && 28227c478bd9Sstevel@tonic-gate rp->r_fh.fh_len == fh->fh_len && 28237c478bd9Sstevel@tonic-gate bcmp(rp->r_fh.fh_buf, fh->fh_buf, fh->fh_len) == 0) { 28247c478bd9Sstevel@tonic-gate /* 28257c478bd9Sstevel@tonic-gate * remove rnode from free list, if necessary. 28267c478bd9Sstevel@tonic-gate */ 28277c478bd9Sstevel@tonic-gate if (rp->r_freef != NULL) { 28287c478bd9Sstevel@tonic-gate mutex_enter(&rpfreelist_lock); 28297c478bd9Sstevel@tonic-gate /* 28307c478bd9Sstevel@tonic-gate * If the rnode is on the freelist, 28317c478bd9Sstevel@tonic-gate * then remove it and use that reference 28327c478bd9Sstevel@tonic-gate * as the new reference. Otherwise, 28337c478bd9Sstevel@tonic-gate * need to increment the reference count. 28347c478bd9Sstevel@tonic-gate */ 28357c478bd9Sstevel@tonic-gate if (rp->r_freef != NULL) { 28367c478bd9Sstevel@tonic-gate rp_rmfree(rp); 28377c478bd9Sstevel@tonic-gate mutex_exit(&rpfreelist_lock); 28387c478bd9Sstevel@tonic-gate } else { 28397c478bd9Sstevel@tonic-gate mutex_exit(&rpfreelist_lock); 28407c478bd9Sstevel@tonic-gate VN_HOLD(vp); 28417c478bd9Sstevel@tonic-gate } 28427c478bd9Sstevel@tonic-gate } else 28437c478bd9Sstevel@tonic-gate VN_HOLD(vp); 28447c478bd9Sstevel@tonic-gate return (rp); 28457c478bd9Sstevel@tonic-gate } 28467c478bd9Sstevel@tonic-gate } 28477c478bd9Sstevel@tonic-gate return (NULL); 28487c478bd9Sstevel@tonic-gate } 28497c478bd9Sstevel@tonic-gate 28507c478bd9Sstevel@tonic-gate /* 28517c478bd9Sstevel@tonic-gate * Return 1 if there is a active vnode belonging to this vfs in the 28527c478bd9Sstevel@tonic-gate * rtable cache. 28537c478bd9Sstevel@tonic-gate * 28547c478bd9Sstevel@tonic-gate * Several of these checks are done without holding the usual 28557c478bd9Sstevel@tonic-gate * locks. This is safe because destroy_rtable(), rp_addfree(), 28567c478bd9Sstevel@tonic-gate * etc. will redo the necessary checks before actually destroying 28577c478bd9Sstevel@tonic-gate * any rnodes. 28587c478bd9Sstevel@tonic-gate */ 28597c478bd9Sstevel@tonic-gate int 28607c478bd9Sstevel@tonic-gate check_rtable(struct vfs *vfsp) 28617c478bd9Sstevel@tonic-gate { 28627c478bd9Sstevel@tonic-gate int index; 28637c478bd9Sstevel@tonic-gate rnode_t *rp; 28647c478bd9Sstevel@tonic-gate vnode_t *vp; 28657c478bd9Sstevel@tonic-gate 28667c478bd9Sstevel@tonic-gate for (index = 0; index < rtablesize; index++) { 28677c478bd9Sstevel@tonic-gate rw_enter(&rtable[index].r_lock, RW_READER); 28687c478bd9Sstevel@tonic-gate for (rp = rtable[index].r_hashf; 28697c478bd9Sstevel@tonic-gate rp != (rnode_t *)(&rtable[index]); 28707c478bd9Sstevel@tonic-gate rp = rp->r_hashf) { 28717c478bd9Sstevel@tonic-gate vp = RTOV(rp); 28727c478bd9Sstevel@tonic-gate if (vp->v_vfsp == vfsp) { 28737c478bd9Sstevel@tonic-gate if (rp->r_freef == NULL || 28747c478bd9Sstevel@tonic-gate (vn_has_cached_data(vp) && 28757c478bd9Sstevel@tonic-gate (rp->r_flags & RDIRTY)) || 28767c478bd9Sstevel@tonic-gate rp->r_count > 0) { 28777c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 28787c478bd9Sstevel@tonic-gate return (1); 28797c478bd9Sstevel@tonic-gate } 28807c478bd9Sstevel@tonic-gate } 28817c478bd9Sstevel@tonic-gate } 28827c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 28837c478bd9Sstevel@tonic-gate } 28847c478bd9Sstevel@tonic-gate return (0); 28857c478bd9Sstevel@tonic-gate } 28867c478bd9Sstevel@tonic-gate 28877c478bd9Sstevel@tonic-gate /* 28887c478bd9Sstevel@tonic-gate * Destroy inactive vnodes from the hash queues which belong to this 28897c478bd9Sstevel@tonic-gate * vfs. It is essential that we destroy all inactive vnodes during a 28907c478bd9Sstevel@tonic-gate * forced unmount as well as during a normal unmount. 28917c478bd9Sstevel@tonic-gate */ 28927c478bd9Sstevel@tonic-gate void 28937c478bd9Sstevel@tonic-gate destroy_rtable(struct vfs *vfsp, cred_t *cr) 28947c478bd9Sstevel@tonic-gate { 28957c478bd9Sstevel@tonic-gate int index; 28967c478bd9Sstevel@tonic-gate rnode_t *rp; 28977c478bd9Sstevel@tonic-gate rnode_t *rlist; 28987c478bd9Sstevel@tonic-gate rnode_t *r_hashf; 28997c478bd9Sstevel@tonic-gate vnode_t *vp; 29007c478bd9Sstevel@tonic-gate 29017c478bd9Sstevel@tonic-gate rlist = NULL; 29027c478bd9Sstevel@tonic-gate 29037c478bd9Sstevel@tonic-gate for (index = 0; index < rtablesize; index++) { 29047c478bd9Sstevel@tonic-gate rw_enter(&rtable[index].r_lock, RW_WRITER); 29057c478bd9Sstevel@tonic-gate for (rp = rtable[index].r_hashf; 29067c478bd9Sstevel@tonic-gate rp != (rnode_t *)(&rtable[index]); 29077c478bd9Sstevel@tonic-gate rp = r_hashf) { 29087c478bd9Sstevel@tonic-gate /* save the hash pointer before destroying */ 29097c478bd9Sstevel@tonic-gate r_hashf = rp->r_hashf; 29107c478bd9Sstevel@tonic-gate vp = RTOV(rp); 29117c478bd9Sstevel@tonic-gate if (vp->v_vfsp == vfsp) { 29127c478bd9Sstevel@tonic-gate mutex_enter(&rpfreelist_lock); 29137c478bd9Sstevel@tonic-gate if (rp->r_freef != NULL) { 29147c478bd9Sstevel@tonic-gate rp_rmfree(rp); 29157c478bd9Sstevel@tonic-gate mutex_exit(&rpfreelist_lock); 29167c478bd9Sstevel@tonic-gate rp_rmhash_locked(rp); 29177c478bd9Sstevel@tonic-gate rp->r_hashf = rlist; 29187c478bd9Sstevel@tonic-gate rlist = rp; 29197c478bd9Sstevel@tonic-gate } else 29207c478bd9Sstevel@tonic-gate mutex_exit(&rpfreelist_lock); 29217c478bd9Sstevel@tonic-gate } 29227c478bd9Sstevel@tonic-gate } 29237c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 29247c478bd9Sstevel@tonic-gate } 29257c478bd9Sstevel@tonic-gate 29267c478bd9Sstevel@tonic-gate for (rp = rlist; rp != NULL; rp = rlist) { 29277c478bd9Sstevel@tonic-gate rlist = rp->r_hashf; 29287c478bd9Sstevel@tonic-gate /* 29297c478bd9Sstevel@tonic-gate * This call to rp_addfree will end up destroying the 29307c478bd9Sstevel@tonic-gate * rnode, but in a safe way with the appropriate set 29317c478bd9Sstevel@tonic-gate * of checks done. 29327c478bd9Sstevel@tonic-gate */ 29337c478bd9Sstevel@tonic-gate rp_addfree(rp, cr); 29347c478bd9Sstevel@tonic-gate } 29357c478bd9Sstevel@tonic-gate 29367c478bd9Sstevel@tonic-gate } 29377c478bd9Sstevel@tonic-gate 29387c478bd9Sstevel@tonic-gate /* 29397c478bd9Sstevel@tonic-gate * This routine destroys all the resources associated with the rnode 29407c478bd9Sstevel@tonic-gate * and then the rnode itself. 29417c478bd9Sstevel@tonic-gate */ 29427c478bd9Sstevel@tonic-gate static void 29437c478bd9Sstevel@tonic-gate destroy_rnode(rnode_t *rp) 29447c478bd9Sstevel@tonic-gate { 29457c478bd9Sstevel@tonic-gate vnode_t *vp; 29467c478bd9Sstevel@tonic-gate vfs_t *vfsp; 29477c478bd9Sstevel@tonic-gate 29487c478bd9Sstevel@tonic-gate vp = RTOV(rp); 29497c478bd9Sstevel@tonic-gate vfsp = vp->v_vfsp; 29507c478bd9Sstevel@tonic-gate 29517c478bd9Sstevel@tonic-gate ASSERT(vp->v_count == 1); 29527c478bd9Sstevel@tonic-gate ASSERT(rp->r_count == 0); 29537c478bd9Sstevel@tonic-gate ASSERT(rp->r_lmpl == NULL); 29547c478bd9Sstevel@tonic-gate ASSERT(rp->r_mapcnt == 0); 29557c478bd9Sstevel@tonic-gate ASSERT(!(rp->r_flags & RHASHED)); 29567c478bd9Sstevel@tonic-gate ASSERT(rp->r_freef == NULL && rp->r_freeb == NULL); 29577c478bd9Sstevel@tonic-gate atomic_add_long((ulong_t *)&rnew, -1); 29587c478bd9Sstevel@tonic-gate #ifdef DEBUG 29597c478bd9Sstevel@tonic-gate clstat_debug.nrnode.value.ui64--; 29607c478bd9Sstevel@tonic-gate #endif 29617c478bd9Sstevel@tonic-gate nfs_rw_destroy(&rp->r_rwlock); 29627c478bd9Sstevel@tonic-gate nfs_rw_destroy(&rp->r_lkserlock); 29637c478bd9Sstevel@tonic-gate mutex_destroy(&rp->r_statelock); 29647c478bd9Sstevel@tonic-gate cv_destroy(&rp->r_cv); 29657c478bd9Sstevel@tonic-gate cv_destroy(&rp->r_commit.c_cv); 29667c478bd9Sstevel@tonic-gate if (rp->r_flags & RDELMAPLIST) 29677c478bd9Sstevel@tonic-gate list_destroy(&rp->r_indelmap); 29687c478bd9Sstevel@tonic-gate nfs_free_r_path(rp); 29697c478bd9Sstevel@tonic-gate avl_destroy(&rp->r_dir); 29707c478bd9Sstevel@tonic-gate vn_invalid(vp); 29717c478bd9Sstevel@tonic-gate vn_free(vp); 29727c478bd9Sstevel@tonic-gate kmem_cache_free(rnode_cache, rp); 29737c478bd9Sstevel@tonic-gate VFS_RELE(vfsp); 29747c478bd9Sstevel@tonic-gate } 29757c478bd9Sstevel@tonic-gate 29767c478bd9Sstevel@tonic-gate /* 29777c478bd9Sstevel@tonic-gate * Flush all vnodes in this (or every) vfs. 29787c478bd9Sstevel@tonic-gate * Used by nfs_sync and by nfs_unmount. 29797c478bd9Sstevel@tonic-gate */ 29807c478bd9Sstevel@tonic-gate void 29817c478bd9Sstevel@tonic-gate rflush(struct vfs *vfsp, cred_t *cr) 29827c478bd9Sstevel@tonic-gate { 29837c478bd9Sstevel@tonic-gate int index; 29847c478bd9Sstevel@tonic-gate rnode_t *rp; 29857c478bd9Sstevel@tonic-gate vnode_t *vp, **vplist; 29867c478bd9Sstevel@tonic-gate long num, cnt; 29877c478bd9Sstevel@tonic-gate 29887c478bd9Sstevel@tonic-gate /* 29897c478bd9Sstevel@tonic-gate * Check to see whether there is anything to do. 29907c478bd9Sstevel@tonic-gate */ 29917c478bd9Sstevel@tonic-gate num = rnew; 29927c478bd9Sstevel@tonic-gate if (num == 0) 29937c478bd9Sstevel@tonic-gate return; 29947c478bd9Sstevel@tonic-gate 29957c478bd9Sstevel@tonic-gate /* 29967c478bd9Sstevel@tonic-gate * Allocate a slot for all currently active rnodes on the 29977c478bd9Sstevel@tonic-gate * supposition that they all may need flushing. 29987c478bd9Sstevel@tonic-gate */ 29997c478bd9Sstevel@tonic-gate vplist = kmem_alloc(num * sizeof (*vplist), KM_SLEEP); 30007c478bd9Sstevel@tonic-gate cnt = 0; 30017c478bd9Sstevel@tonic-gate 30027c478bd9Sstevel@tonic-gate /* 30037c478bd9Sstevel@tonic-gate * Walk the hash queues looking for rnodes with page 30047c478bd9Sstevel@tonic-gate * lists associated with them. Make a list of these 30057c478bd9Sstevel@tonic-gate * files. 30067c478bd9Sstevel@tonic-gate */ 30077c478bd9Sstevel@tonic-gate for (index = 0; index < rtablesize; index++) { 30087c478bd9Sstevel@tonic-gate rw_enter(&rtable[index].r_lock, RW_READER); 30097c478bd9Sstevel@tonic-gate for (rp = rtable[index].r_hashf; 30107c478bd9Sstevel@tonic-gate rp != (rnode_t *)(&rtable[index]); 30117c478bd9Sstevel@tonic-gate rp = rp->r_hashf) { 30127c478bd9Sstevel@tonic-gate vp = RTOV(rp); 30137c478bd9Sstevel@tonic-gate /* 30147c478bd9Sstevel@tonic-gate * Don't bother sync'ing a vp if it 30157c478bd9Sstevel@tonic-gate * is part of virtual swap device or 30167c478bd9Sstevel@tonic-gate * if VFS is read-only 30177c478bd9Sstevel@tonic-gate */ 30187c478bd9Sstevel@tonic-gate if (IS_SWAPVP(vp) || vn_is_readonly(vp)) 30197c478bd9Sstevel@tonic-gate continue; 30207c478bd9Sstevel@tonic-gate /* 30217c478bd9Sstevel@tonic-gate * If flushing all mounted file systems or 30227c478bd9Sstevel@tonic-gate * the vnode belongs to this vfs, has pages 30237c478bd9Sstevel@tonic-gate * and is marked as either dirty or mmap'd, 30247c478bd9Sstevel@tonic-gate * hold and add this vnode to the list of 30257c478bd9Sstevel@tonic-gate * vnodes to flush. 30267c478bd9Sstevel@tonic-gate */ 30277c478bd9Sstevel@tonic-gate if ((vfsp == NULL || vp->v_vfsp == vfsp) && 30287c478bd9Sstevel@tonic-gate vn_has_cached_data(vp) && 30297c478bd9Sstevel@tonic-gate ((rp->r_flags & RDIRTY) || rp->r_mapcnt > 0)) { 30307c478bd9Sstevel@tonic-gate VN_HOLD(vp); 30317c478bd9Sstevel@tonic-gate vplist[cnt++] = vp; 30327c478bd9Sstevel@tonic-gate if (cnt == num) { 30337c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 30347c478bd9Sstevel@tonic-gate goto toomany; 30357c478bd9Sstevel@tonic-gate } 30367c478bd9Sstevel@tonic-gate } 30377c478bd9Sstevel@tonic-gate } 30387c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 30397c478bd9Sstevel@tonic-gate } 30407c478bd9Sstevel@tonic-gate toomany: 30417c478bd9Sstevel@tonic-gate 30427c478bd9Sstevel@tonic-gate /* 30437c478bd9Sstevel@tonic-gate * Flush and release all of the files on the list. 30447c478bd9Sstevel@tonic-gate */ 30457c478bd9Sstevel@tonic-gate while (cnt-- > 0) { 30467c478bd9Sstevel@tonic-gate vp = vplist[cnt]; 30477c478bd9Sstevel@tonic-gate (void) VOP_PUTPAGE(vp, (u_offset_t)0, 0, B_ASYNC, cr); 30487c478bd9Sstevel@tonic-gate VN_RELE(vp); 30497c478bd9Sstevel@tonic-gate } 30507c478bd9Sstevel@tonic-gate 30517c478bd9Sstevel@tonic-gate /* 30527c478bd9Sstevel@tonic-gate * Free the space allocated to hold the list. 30537c478bd9Sstevel@tonic-gate */ 30547c478bd9Sstevel@tonic-gate kmem_free(vplist, num * sizeof (*vplist)); 30557c478bd9Sstevel@tonic-gate } 30567c478bd9Sstevel@tonic-gate 30577c478bd9Sstevel@tonic-gate /* 30587c478bd9Sstevel@tonic-gate * This probably needs to be larger than or equal to 30597c478bd9Sstevel@tonic-gate * log2(sizeof (struct rnode)) due to the way that rnodes are 30607c478bd9Sstevel@tonic-gate * allocated. 30617c478bd9Sstevel@tonic-gate */ 30627c478bd9Sstevel@tonic-gate #define ACACHE_SHIFT_BITS 9 30637c478bd9Sstevel@tonic-gate 30647c478bd9Sstevel@tonic-gate static int 30657c478bd9Sstevel@tonic-gate acachehash(rnode_t *rp, cred_t *cr) 30667c478bd9Sstevel@tonic-gate { 30677c478bd9Sstevel@tonic-gate 30687c478bd9Sstevel@tonic-gate return ((((intptr_t)rp >> ACACHE_SHIFT_BITS) + crgetuid(cr)) & 30697c478bd9Sstevel@tonic-gate acachemask); 30707c478bd9Sstevel@tonic-gate } 30717c478bd9Sstevel@tonic-gate 30727c478bd9Sstevel@tonic-gate #ifdef DEBUG 30737c478bd9Sstevel@tonic-gate static long nfs_access_cache_hits = 0; 30747c478bd9Sstevel@tonic-gate static long nfs_access_cache_misses = 0; 30757c478bd9Sstevel@tonic-gate #endif 30767c478bd9Sstevel@tonic-gate 30777c478bd9Sstevel@tonic-gate nfs_access_type_t 30787c478bd9Sstevel@tonic-gate nfs_access_check(rnode_t *rp, uint32_t acc, cred_t *cr) 30797c478bd9Sstevel@tonic-gate { 30807c478bd9Sstevel@tonic-gate vnode_t *vp; 30817c478bd9Sstevel@tonic-gate acache_t *ap; 30827c478bd9Sstevel@tonic-gate acache_hash_t *hp; 30837c478bd9Sstevel@tonic-gate nfs_access_type_t all; 30847c478bd9Sstevel@tonic-gate 30857c478bd9Sstevel@tonic-gate vp = RTOV(rp); 30867c478bd9Sstevel@tonic-gate if (!ATTRCACHE_VALID(vp) || nfs_waitfor_purge_complete(vp)) 30877c478bd9Sstevel@tonic-gate return (NFS_ACCESS_UNKNOWN); 30887c478bd9Sstevel@tonic-gate 30897c478bd9Sstevel@tonic-gate if (rp->r_acache != NULL) { 30907c478bd9Sstevel@tonic-gate hp = &acache[acachehash(rp, cr)]; 30917c478bd9Sstevel@tonic-gate rw_enter(&hp->lock, RW_READER); 30927c478bd9Sstevel@tonic-gate ap = hp->next; 30937c478bd9Sstevel@tonic-gate while (ap != (acache_t *)hp) { 30947c478bd9Sstevel@tonic-gate if (crcmp(ap->cred, cr) == 0 && ap->rnode == rp) { 30957c478bd9Sstevel@tonic-gate if ((ap->known & acc) == acc) { 30967c478bd9Sstevel@tonic-gate #ifdef DEBUG 30977c478bd9Sstevel@tonic-gate nfs_access_cache_hits++; 30987c478bd9Sstevel@tonic-gate #endif 30997c478bd9Sstevel@tonic-gate if ((ap->allowed & acc) == acc) 31007c478bd9Sstevel@tonic-gate all = NFS_ACCESS_ALLOWED; 31017c478bd9Sstevel@tonic-gate else 31027c478bd9Sstevel@tonic-gate all = NFS_ACCESS_DENIED; 31037c478bd9Sstevel@tonic-gate } else { 31047c478bd9Sstevel@tonic-gate #ifdef DEBUG 31057c478bd9Sstevel@tonic-gate nfs_access_cache_misses++; 31067c478bd9Sstevel@tonic-gate #endif 31077c478bd9Sstevel@tonic-gate all = NFS_ACCESS_UNKNOWN; 31087c478bd9Sstevel@tonic-gate } 31097c478bd9Sstevel@tonic-gate rw_exit(&hp->lock); 31107c478bd9Sstevel@tonic-gate return (all); 31117c478bd9Sstevel@tonic-gate } 31127c478bd9Sstevel@tonic-gate ap = ap->next; 31137c478bd9Sstevel@tonic-gate } 31147c478bd9Sstevel@tonic-gate rw_exit(&hp->lock); 31157c478bd9Sstevel@tonic-gate } 31167c478bd9Sstevel@tonic-gate 31177c478bd9Sstevel@tonic-gate #ifdef DEBUG 31187c478bd9Sstevel@tonic-gate nfs_access_cache_misses++; 31197c478bd9Sstevel@tonic-gate #endif 31207c478bd9Sstevel@tonic-gate return (NFS_ACCESS_UNKNOWN); 31217c478bd9Sstevel@tonic-gate } 31227c478bd9Sstevel@tonic-gate 31237c478bd9Sstevel@tonic-gate void 31247c478bd9Sstevel@tonic-gate nfs_access_cache(rnode_t *rp, uint32_t acc, uint32_t resacc, cred_t *cr) 31257c478bd9Sstevel@tonic-gate { 31267c478bd9Sstevel@tonic-gate acache_t *ap; 31277c478bd9Sstevel@tonic-gate acache_t *nap; 31287c478bd9Sstevel@tonic-gate acache_hash_t *hp; 31297c478bd9Sstevel@tonic-gate 31307c478bd9Sstevel@tonic-gate hp = &acache[acachehash(rp, cr)]; 31317c478bd9Sstevel@tonic-gate 31327c478bd9Sstevel@tonic-gate /* 31337c478bd9Sstevel@tonic-gate * Allocate now assuming that mostly an allocation will be 31347c478bd9Sstevel@tonic-gate * required. This allows the allocation to happen without 31357c478bd9Sstevel@tonic-gate * holding the hash bucket locked. 31367c478bd9Sstevel@tonic-gate */ 31377c478bd9Sstevel@tonic-gate nap = kmem_cache_alloc(acache_cache, KM_NOSLEEP); 31387c478bd9Sstevel@tonic-gate if (nap != NULL) { 31397c478bd9Sstevel@tonic-gate nap->known = acc; 31407c478bd9Sstevel@tonic-gate nap->allowed = resacc; 31417c478bd9Sstevel@tonic-gate nap->rnode = rp; 31427c478bd9Sstevel@tonic-gate crhold(cr); 31437c478bd9Sstevel@tonic-gate nap->cred = cr; 31447c478bd9Sstevel@tonic-gate nap->hashq = hp; 31457c478bd9Sstevel@tonic-gate } 31467c478bd9Sstevel@tonic-gate 31477c478bd9Sstevel@tonic-gate rw_enter(&hp->lock, RW_WRITER); 31487c478bd9Sstevel@tonic-gate 31497c478bd9Sstevel@tonic-gate if (rp->r_acache != NULL) { 31507c478bd9Sstevel@tonic-gate ap = hp->next; 31517c478bd9Sstevel@tonic-gate while (ap != (acache_t *)hp) { 31527c478bd9Sstevel@tonic-gate if (crcmp(ap->cred, cr) == 0 && ap->rnode == rp) { 31537c478bd9Sstevel@tonic-gate ap->known |= acc; 31547c478bd9Sstevel@tonic-gate ap->allowed &= ~acc; 31557c478bd9Sstevel@tonic-gate ap->allowed |= resacc; 31567c478bd9Sstevel@tonic-gate rw_exit(&hp->lock); 31577c478bd9Sstevel@tonic-gate if (nap != NULL) { 31587c478bd9Sstevel@tonic-gate crfree(nap->cred); 31597c478bd9Sstevel@tonic-gate kmem_cache_free(acache_cache, nap); 31607c478bd9Sstevel@tonic-gate } 31617c478bd9Sstevel@tonic-gate return; 31627c478bd9Sstevel@tonic-gate } 31637c478bd9Sstevel@tonic-gate ap = ap->next; 31647c478bd9Sstevel@tonic-gate } 31657c478bd9Sstevel@tonic-gate } 31667c478bd9Sstevel@tonic-gate 31677c478bd9Sstevel@tonic-gate if (nap != NULL) { 31687c478bd9Sstevel@tonic-gate #ifdef DEBUG 31697c478bd9Sstevel@tonic-gate clstat_debug.access.value.ui64++; 31707c478bd9Sstevel@tonic-gate #endif 31717c478bd9Sstevel@tonic-gate nap->next = hp->next; 31727c478bd9Sstevel@tonic-gate hp->next = nap; 31737c478bd9Sstevel@tonic-gate nap->next->prev = nap; 31747c478bd9Sstevel@tonic-gate nap->prev = (acache_t *)hp; 31757c478bd9Sstevel@tonic-gate 31767c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 31777c478bd9Sstevel@tonic-gate nap->list = rp->r_acache; 31787c478bd9Sstevel@tonic-gate rp->r_acache = nap; 31797c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 31807c478bd9Sstevel@tonic-gate } 31817c478bd9Sstevel@tonic-gate 31827c478bd9Sstevel@tonic-gate rw_exit(&hp->lock); 31837c478bd9Sstevel@tonic-gate } 31847c478bd9Sstevel@tonic-gate 31857c478bd9Sstevel@tonic-gate int 31867c478bd9Sstevel@tonic-gate nfs_access_purge_rp(rnode_t *rp) 31877c478bd9Sstevel@tonic-gate { 31887c478bd9Sstevel@tonic-gate acache_t *ap; 31897c478bd9Sstevel@tonic-gate acache_t *tmpap; 31907c478bd9Sstevel@tonic-gate acache_t *rplist; 31917c478bd9Sstevel@tonic-gate 31927c478bd9Sstevel@tonic-gate /* 31937c478bd9Sstevel@tonic-gate * If there aren't any cached entries, then there is nothing 31947c478bd9Sstevel@tonic-gate * to free. 31957c478bd9Sstevel@tonic-gate */ 31967c478bd9Sstevel@tonic-gate if (rp->r_acache == NULL) 31977c478bd9Sstevel@tonic-gate return (0); 31987c478bd9Sstevel@tonic-gate 31997c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 32007c478bd9Sstevel@tonic-gate rplist = rp->r_acache; 32017c478bd9Sstevel@tonic-gate rp->r_acache = NULL; 32027c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 32037c478bd9Sstevel@tonic-gate 32047c478bd9Sstevel@tonic-gate /* 32057c478bd9Sstevel@tonic-gate * Loop through each entry in the list pointed to in the 32067c478bd9Sstevel@tonic-gate * rnode. Remove each of these entries from the hash 32077c478bd9Sstevel@tonic-gate * queue that it is on and remove it from the list in 32087c478bd9Sstevel@tonic-gate * the rnode. 32097c478bd9Sstevel@tonic-gate */ 32107c478bd9Sstevel@tonic-gate for (ap = rplist; ap != NULL; ap = tmpap) { 32117c478bd9Sstevel@tonic-gate rw_enter(&ap->hashq->lock, RW_WRITER); 32127c478bd9Sstevel@tonic-gate ap->prev->next = ap->next; 32137c478bd9Sstevel@tonic-gate ap->next->prev = ap->prev; 32147c478bd9Sstevel@tonic-gate rw_exit(&ap->hashq->lock); 32157c478bd9Sstevel@tonic-gate 32167c478bd9Sstevel@tonic-gate tmpap = ap->list; 32177c478bd9Sstevel@tonic-gate crfree(ap->cred); 32187c478bd9Sstevel@tonic-gate kmem_cache_free(acache_cache, ap); 32197c478bd9Sstevel@tonic-gate #ifdef DEBUG 32207c478bd9Sstevel@tonic-gate clstat_debug.access.value.ui64--; 32217c478bd9Sstevel@tonic-gate #endif 32227c478bd9Sstevel@tonic-gate } 32237c478bd9Sstevel@tonic-gate 32247c478bd9Sstevel@tonic-gate return (1); 32257c478bd9Sstevel@tonic-gate } 32267c478bd9Sstevel@tonic-gate 32277c478bd9Sstevel@tonic-gate static const char prefix[] = ".nfs"; 32287c478bd9Sstevel@tonic-gate 32297c478bd9Sstevel@tonic-gate static kmutex_t newnum_lock; 32307c478bd9Sstevel@tonic-gate 32317c478bd9Sstevel@tonic-gate int 32327c478bd9Sstevel@tonic-gate newnum(void) 32337c478bd9Sstevel@tonic-gate { 32347c478bd9Sstevel@tonic-gate static uint_t newnum = 0; 32357c478bd9Sstevel@tonic-gate uint_t id; 32367c478bd9Sstevel@tonic-gate 32377c478bd9Sstevel@tonic-gate mutex_enter(&newnum_lock); 32387c478bd9Sstevel@tonic-gate if (newnum == 0) 32397c478bd9Sstevel@tonic-gate newnum = gethrestime_sec() & 0xffff; 32407c478bd9Sstevel@tonic-gate id = newnum++; 32417c478bd9Sstevel@tonic-gate mutex_exit(&newnum_lock); 32427c478bd9Sstevel@tonic-gate return (id); 32437c478bd9Sstevel@tonic-gate } 32447c478bd9Sstevel@tonic-gate 32457c478bd9Sstevel@tonic-gate char * 32467c478bd9Sstevel@tonic-gate newname(void) 32477c478bd9Sstevel@tonic-gate { 32487c478bd9Sstevel@tonic-gate char *news; 32497c478bd9Sstevel@tonic-gate char *s; 32507c478bd9Sstevel@tonic-gate const char *p; 32517c478bd9Sstevel@tonic-gate uint_t id; 32527c478bd9Sstevel@tonic-gate 32537c478bd9Sstevel@tonic-gate id = newnum(); 32547c478bd9Sstevel@tonic-gate news = kmem_alloc(MAXNAMELEN, KM_SLEEP); 32557c478bd9Sstevel@tonic-gate s = news; 32567c478bd9Sstevel@tonic-gate p = prefix; 32577c478bd9Sstevel@tonic-gate while (*p != '\0') 32587c478bd9Sstevel@tonic-gate *s++ = *p++; 32597c478bd9Sstevel@tonic-gate while (id != 0) { 32607c478bd9Sstevel@tonic-gate *s++ = "0123456789ABCDEF"[id & 0x0f]; 32617c478bd9Sstevel@tonic-gate id >>= 4; 32627c478bd9Sstevel@tonic-gate } 32637c478bd9Sstevel@tonic-gate *s = '\0'; 32647c478bd9Sstevel@tonic-gate return (news); 32657c478bd9Sstevel@tonic-gate } 32667c478bd9Sstevel@tonic-gate 32677c478bd9Sstevel@tonic-gate int 32687c478bd9Sstevel@tonic-gate nfs_atoi(char *cp) 32697c478bd9Sstevel@tonic-gate { 32707c478bd9Sstevel@tonic-gate int n; 32717c478bd9Sstevel@tonic-gate 32727c478bd9Sstevel@tonic-gate n = 0; 32737c478bd9Sstevel@tonic-gate while (*cp != '\0') { 32747c478bd9Sstevel@tonic-gate n = n * 10 + (*cp - '0'); 32757c478bd9Sstevel@tonic-gate cp++; 32767c478bd9Sstevel@tonic-gate } 32777c478bd9Sstevel@tonic-gate 32787c478bd9Sstevel@tonic-gate return (n); 32797c478bd9Sstevel@tonic-gate } 32807c478bd9Sstevel@tonic-gate 32817c478bd9Sstevel@tonic-gate /* 32827c478bd9Sstevel@tonic-gate * Snapshot callback for nfs:0:nfs_client as registered with the kstat 32837c478bd9Sstevel@tonic-gate * framework. 32847c478bd9Sstevel@tonic-gate */ 32857c478bd9Sstevel@tonic-gate static int 32867c478bd9Sstevel@tonic-gate cl_snapshot(kstat_t *ksp, void *buf, int rw) 32877c478bd9Sstevel@tonic-gate { 32887c478bd9Sstevel@tonic-gate ksp->ks_snaptime = gethrtime(); 32897c478bd9Sstevel@tonic-gate if (rw == KSTAT_WRITE) { 32907c478bd9Sstevel@tonic-gate bcopy(buf, ksp->ks_private, sizeof (clstat_tmpl)); 32917c478bd9Sstevel@tonic-gate #ifdef DEBUG 32927c478bd9Sstevel@tonic-gate /* 32937c478bd9Sstevel@tonic-gate * Currently only the global zone can write to kstats, but we 32947c478bd9Sstevel@tonic-gate * add the check just for paranoia. 32957c478bd9Sstevel@tonic-gate */ 32967c478bd9Sstevel@tonic-gate if (INGLOBALZONE(curproc)) 32977c478bd9Sstevel@tonic-gate bcopy((char *)buf + sizeof (clstat_tmpl), &clstat_debug, 32987c478bd9Sstevel@tonic-gate sizeof (clstat_debug)); 32997c478bd9Sstevel@tonic-gate #endif 33007c478bd9Sstevel@tonic-gate } else { 33017c478bd9Sstevel@tonic-gate bcopy(ksp->ks_private, buf, sizeof (clstat_tmpl)); 33027c478bd9Sstevel@tonic-gate #ifdef DEBUG 33037c478bd9Sstevel@tonic-gate /* 33047c478bd9Sstevel@tonic-gate * If we're displaying the "global" debug kstat values, we 33057c478bd9Sstevel@tonic-gate * display them as-is to all zones since in fact they apply to 33067c478bd9Sstevel@tonic-gate * the system as a whole. 33077c478bd9Sstevel@tonic-gate */ 33087c478bd9Sstevel@tonic-gate bcopy(&clstat_debug, (char *)buf + sizeof (clstat_tmpl), 33097c478bd9Sstevel@tonic-gate sizeof (clstat_debug)); 33107c478bd9Sstevel@tonic-gate #endif 33117c478bd9Sstevel@tonic-gate } 33127c478bd9Sstevel@tonic-gate return (0); 33137c478bd9Sstevel@tonic-gate } 33147c478bd9Sstevel@tonic-gate 33157c478bd9Sstevel@tonic-gate static void * 33167c478bd9Sstevel@tonic-gate clinit_zone(zoneid_t zoneid) 33177c478bd9Sstevel@tonic-gate { 33187c478bd9Sstevel@tonic-gate kstat_t *nfs_client_kstat; 33197c478bd9Sstevel@tonic-gate struct nfs_clnt *nfscl; 33207c478bd9Sstevel@tonic-gate uint_t ndata; 33217c478bd9Sstevel@tonic-gate 33227c478bd9Sstevel@tonic-gate nfscl = kmem_alloc(sizeof (*nfscl), KM_SLEEP); 33237c478bd9Sstevel@tonic-gate mutex_init(&nfscl->nfscl_chtable_lock, NULL, MUTEX_DEFAULT, NULL); 33247c478bd9Sstevel@tonic-gate nfscl->nfscl_chtable = NULL; 33257c478bd9Sstevel@tonic-gate nfscl->nfscl_zoneid = zoneid; 33267c478bd9Sstevel@tonic-gate 33277c478bd9Sstevel@tonic-gate bcopy(&clstat_tmpl, &nfscl->nfscl_stat, sizeof (clstat_tmpl)); 33287c478bd9Sstevel@tonic-gate ndata = sizeof (clstat_tmpl) / sizeof (kstat_named_t); 33297c478bd9Sstevel@tonic-gate #ifdef DEBUG 33307c478bd9Sstevel@tonic-gate ndata += sizeof (clstat_debug) / sizeof (kstat_named_t); 33317c478bd9Sstevel@tonic-gate #endif 33327c478bd9Sstevel@tonic-gate if ((nfs_client_kstat = kstat_create_zone("nfs", 0, "nfs_client", 33337c478bd9Sstevel@tonic-gate "misc", KSTAT_TYPE_NAMED, ndata, 33347c478bd9Sstevel@tonic-gate KSTAT_FLAG_VIRTUAL | KSTAT_FLAG_WRITABLE, zoneid)) != NULL) { 33357c478bd9Sstevel@tonic-gate nfs_client_kstat->ks_private = &nfscl->nfscl_stat; 33367c478bd9Sstevel@tonic-gate nfs_client_kstat->ks_snapshot = cl_snapshot; 33377c478bd9Sstevel@tonic-gate kstat_install(nfs_client_kstat); 33387c478bd9Sstevel@tonic-gate } 33397c478bd9Sstevel@tonic-gate mutex_enter(&nfs_clnt_list_lock); 33407c478bd9Sstevel@tonic-gate list_insert_head(&nfs_clnt_list, nfscl); 33417c478bd9Sstevel@tonic-gate mutex_exit(&nfs_clnt_list_lock); 33427c478bd9Sstevel@tonic-gate return (nfscl); 33437c478bd9Sstevel@tonic-gate } 33447c478bd9Sstevel@tonic-gate 33457c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 33467c478bd9Sstevel@tonic-gate static void 33477c478bd9Sstevel@tonic-gate clfini_zone(zoneid_t zoneid, void *arg) 33487c478bd9Sstevel@tonic-gate { 33497c478bd9Sstevel@tonic-gate struct nfs_clnt *nfscl = arg; 33507c478bd9Sstevel@tonic-gate chhead_t *chp, *next; 33517c478bd9Sstevel@tonic-gate 33527c478bd9Sstevel@tonic-gate if (nfscl == NULL) 33537c478bd9Sstevel@tonic-gate return; 33547c478bd9Sstevel@tonic-gate mutex_enter(&nfs_clnt_list_lock); 33557c478bd9Sstevel@tonic-gate list_remove(&nfs_clnt_list, nfscl); 33567c478bd9Sstevel@tonic-gate mutex_exit(&nfs_clnt_list_lock); 33577c478bd9Sstevel@tonic-gate clreclaim_zone(nfscl, 0); 33587c478bd9Sstevel@tonic-gate for (chp = nfscl->nfscl_chtable; chp != NULL; chp = next) { 33597c478bd9Sstevel@tonic-gate ASSERT(chp->ch_list == NULL); 33607c478bd9Sstevel@tonic-gate kmem_free(chp->ch_protofmly, strlen(chp->ch_protofmly) + 1); 33617c478bd9Sstevel@tonic-gate next = chp->ch_next; 33627c478bd9Sstevel@tonic-gate kmem_free(chp, sizeof (*chp)); 33637c478bd9Sstevel@tonic-gate } 33647c478bd9Sstevel@tonic-gate kstat_delete_byname_zone("nfs", 0, "nfs_client", zoneid); 33657c478bd9Sstevel@tonic-gate mutex_destroy(&nfscl->nfscl_chtable_lock); 33667c478bd9Sstevel@tonic-gate kmem_free(nfscl, sizeof (*nfscl)); 33677c478bd9Sstevel@tonic-gate } 33687c478bd9Sstevel@tonic-gate 33697c478bd9Sstevel@tonic-gate /* 33707c478bd9Sstevel@tonic-gate * Called by endpnt_destructor to make sure the client handles are 33717c478bd9Sstevel@tonic-gate * cleaned up before the RPC endpoints. This becomes a no-op if 33727c478bd9Sstevel@tonic-gate * clfini_zone (above) is called first. This function is needed 33737c478bd9Sstevel@tonic-gate * (rather than relying on clfini_zone to clean up) because the ZSD 33747c478bd9Sstevel@tonic-gate * callbacks have no ordering mechanism, so we have no way to ensure 33757c478bd9Sstevel@tonic-gate * that clfini_zone is called before endpnt_destructor. 33767c478bd9Sstevel@tonic-gate */ 33777c478bd9Sstevel@tonic-gate void 33787c478bd9Sstevel@tonic-gate clcleanup_zone(zoneid_t zoneid) 33797c478bd9Sstevel@tonic-gate { 33807c478bd9Sstevel@tonic-gate struct nfs_clnt *nfscl; 33817c478bd9Sstevel@tonic-gate 33827c478bd9Sstevel@tonic-gate mutex_enter(&nfs_clnt_list_lock); 33837c478bd9Sstevel@tonic-gate nfscl = list_head(&nfs_clnt_list); 33847c478bd9Sstevel@tonic-gate for (; nfscl != NULL; nfscl = list_next(&nfs_clnt_list, nfscl)) { 33857c478bd9Sstevel@tonic-gate if (nfscl->nfscl_zoneid == zoneid) { 33867c478bd9Sstevel@tonic-gate clreclaim_zone(nfscl, 0); 33877c478bd9Sstevel@tonic-gate break; 33887c478bd9Sstevel@tonic-gate } 33897c478bd9Sstevel@tonic-gate } 33907c478bd9Sstevel@tonic-gate mutex_exit(&nfs_clnt_list_lock); 33917c478bd9Sstevel@tonic-gate } 33927c478bd9Sstevel@tonic-gate 33937c478bd9Sstevel@tonic-gate int 33947c478bd9Sstevel@tonic-gate nfs_subrinit(void) 33957c478bd9Sstevel@tonic-gate { 33967c478bd9Sstevel@tonic-gate int i; 33977c478bd9Sstevel@tonic-gate ulong_t nrnode_max; 33987c478bd9Sstevel@tonic-gate 33997c478bd9Sstevel@tonic-gate /* 34007c478bd9Sstevel@tonic-gate * Allocate and initialize the rnode hash queues 34017c478bd9Sstevel@tonic-gate */ 34027c478bd9Sstevel@tonic-gate if (nrnode <= 0) 34037c478bd9Sstevel@tonic-gate nrnode = ncsize; 34047c478bd9Sstevel@tonic-gate nrnode_max = (ulong_t)((kmem_maxavail() >> 2) / sizeof (struct rnode)); 34057c478bd9Sstevel@tonic-gate if (nrnode > nrnode_max || (nrnode == 0 && ncsize == 0)) { 34067c478bd9Sstevel@tonic-gate zcmn_err(GLOBAL_ZONEID, CE_NOTE, 34077c478bd9Sstevel@tonic-gate "setting nrnode to max value of %ld", nrnode_max); 34087c478bd9Sstevel@tonic-gate nrnode = nrnode_max; 34097c478bd9Sstevel@tonic-gate } 34107c478bd9Sstevel@tonic-gate 34117c478bd9Sstevel@tonic-gate rtablesize = 1 << highbit(nrnode / hashlen); 34127c478bd9Sstevel@tonic-gate rtablemask = rtablesize - 1; 34137c478bd9Sstevel@tonic-gate rtable = kmem_alloc(rtablesize * sizeof (*rtable), KM_SLEEP); 34147c478bd9Sstevel@tonic-gate for (i = 0; i < rtablesize; i++) { 34157c478bd9Sstevel@tonic-gate rtable[i].r_hashf = (rnode_t *)(&rtable[i]); 34167c478bd9Sstevel@tonic-gate rtable[i].r_hashb = (rnode_t *)(&rtable[i]); 34177c478bd9Sstevel@tonic-gate rw_init(&rtable[i].r_lock, NULL, RW_DEFAULT, NULL); 34187c478bd9Sstevel@tonic-gate } 34197c478bd9Sstevel@tonic-gate rnode_cache = kmem_cache_create("rnode_cache", sizeof (rnode_t), 34207c478bd9Sstevel@tonic-gate 0, NULL, NULL, nfs_reclaim, NULL, NULL, 0); 34217c478bd9Sstevel@tonic-gate 34227c478bd9Sstevel@tonic-gate /* 34237c478bd9Sstevel@tonic-gate * Allocate and initialize the access cache 34247c478bd9Sstevel@tonic-gate */ 34257c478bd9Sstevel@tonic-gate 34267c478bd9Sstevel@tonic-gate /* 34277c478bd9Sstevel@tonic-gate * Initial guess is one access cache entry per rnode unless 34287c478bd9Sstevel@tonic-gate * nacache is set to a non-zero value and then it is used to 34297c478bd9Sstevel@tonic-gate * indicate a guess at the number of access cache entries. 34307c478bd9Sstevel@tonic-gate */ 34317c478bd9Sstevel@tonic-gate if (nacache > 0) 34327c478bd9Sstevel@tonic-gate acachesize = 1 << highbit(nacache / hashlen); 34337c478bd9Sstevel@tonic-gate else 34347c478bd9Sstevel@tonic-gate acachesize = rtablesize; 34357c478bd9Sstevel@tonic-gate acachemask = acachesize - 1; 34367c478bd9Sstevel@tonic-gate acache = kmem_alloc(acachesize * sizeof (*acache), KM_SLEEP); 34377c478bd9Sstevel@tonic-gate for (i = 0; i < acachesize; i++) { 34387c478bd9Sstevel@tonic-gate acache[i].next = (acache_t *)&acache[i]; 34397c478bd9Sstevel@tonic-gate acache[i].prev = (acache_t *)&acache[i]; 34407c478bd9Sstevel@tonic-gate rw_init(&acache[i].lock, NULL, RW_DEFAULT, NULL); 34417c478bd9Sstevel@tonic-gate } 34427c478bd9Sstevel@tonic-gate acache_cache = kmem_cache_create("nfs_access_cache", 34437c478bd9Sstevel@tonic-gate sizeof (acache_t), 0, NULL, NULL, NULL, NULL, NULL, 0); 34447c478bd9Sstevel@tonic-gate /* 34457c478bd9Sstevel@tonic-gate * Allocate and initialize the client handle cache 34467c478bd9Sstevel@tonic-gate */ 34477c478bd9Sstevel@tonic-gate chtab_cache = kmem_cache_create("client_handle_cache", 34487c478bd9Sstevel@tonic-gate sizeof (struct chtab), 0, NULL, NULL, clreclaim, NULL, 34497c478bd9Sstevel@tonic-gate NULL, 0); 34507c478bd9Sstevel@tonic-gate /* 34517c478bd9Sstevel@tonic-gate * Initialize the list of per-zone client handles (and associated data). 34527c478bd9Sstevel@tonic-gate * This needs to be done before we call zone_key_create(). 34537c478bd9Sstevel@tonic-gate */ 34547c478bd9Sstevel@tonic-gate list_create(&nfs_clnt_list, sizeof (struct nfs_clnt), 34557c478bd9Sstevel@tonic-gate offsetof(struct nfs_clnt, nfscl_node)); 34567c478bd9Sstevel@tonic-gate /* 34577c478bd9Sstevel@tonic-gate * Initialize the zone_key for per-zone client handle lists. 34587c478bd9Sstevel@tonic-gate */ 34597c478bd9Sstevel@tonic-gate zone_key_create(&nfsclnt_zone_key, clinit_zone, NULL, clfini_zone); 34607c478bd9Sstevel@tonic-gate /* 34617c478bd9Sstevel@tonic-gate * Initialize the various mutexes and reader/writer locks 34627c478bd9Sstevel@tonic-gate */ 34637c478bd9Sstevel@tonic-gate mutex_init(&rpfreelist_lock, NULL, MUTEX_DEFAULT, NULL); 34647c478bd9Sstevel@tonic-gate mutex_init(&newnum_lock, NULL, MUTEX_DEFAULT, NULL); 34657c478bd9Sstevel@tonic-gate mutex_init(&nfs_minor_lock, NULL, MUTEX_DEFAULT, NULL); 34667c478bd9Sstevel@tonic-gate 34677c478bd9Sstevel@tonic-gate /* 34687c478bd9Sstevel@tonic-gate * Assign unique major number for all nfs mounts 34697c478bd9Sstevel@tonic-gate */ 34707c478bd9Sstevel@tonic-gate if ((nfs_major = getudev()) == -1) { 34717c478bd9Sstevel@tonic-gate zcmn_err(GLOBAL_ZONEID, CE_WARN, 34727c478bd9Sstevel@tonic-gate "nfs: init: can't get unique device number"); 34737c478bd9Sstevel@tonic-gate nfs_major = 0; 34747c478bd9Sstevel@tonic-gate } 34757c478bd9Sstevel@tonic-gate nfs_minor = 0; 34767c478bd9Sstevel@tonic-gate 34777c478bd9Sstevel@tonic-gate if (nfs3_jukebox_delay == 0) 34787c478bd9Sstevel@tonic-gate nfs3_jukebox_delay = NFS3_JUKEBOX_DELAY; 34797c478bd9Sstevel@tonic-gate 34807c478bd9Sstevel@tonic-gate return (0); 34817c478bd9Sstevel@tonic-gate } 34827c478bd9Sstevel@tonic-gate 34837c478bd9Sstevel@tonic-gate void 34847c478bd9Sstevel@tonic-gate nfs_subrfini(void) 34857c478bd9Sstevel@tonic-gate { 34867c478bd9Sstevel@tonic-gate int i; 34877c478bd9Sstevel@tonic-gate 34887c478bd9Sstevel@tonic-gate /* 34897c478bd9Sstevel@tonic-gate * Deallocate the rnode hash queues 34907c478bd9Sstevel@tonic-gate */ 34917c478bd9Sstevel@tonic-gate kmem_cache_destroy(rnode_cache); 34927c478bd9Sstevel@tonic-gate 34937c478bd9Sstevel@tonic-gate for (i = 0; i < rtablesize; i++) 34947c478bd9Sstevel@tonic-gate rw_destroy(&rtable[i].r_lock); 34957c478bd9Sstevel@tonic-gate kmem_free(rtable, rtablesize * sizeof (*rtable)); 34967c478bd9Sstevel@tonic-gate 34977c478bd9Sstevel@tonic-gate /* 34987c478bd9Sstevel@tonic-gate * Deallocated the access cache 34997c478bd9Sstevel@tonic-gate */ 35007c478bd9Sstevel@tonic-gate kmem_cache_destroy(acache_cache); 35017c478bd9Sstevel@tonic-gate 35027c478bd9Sstevel@tonic-gate for (i = 0; i < acachesize; i++) 35037c478bd9Sstevel@tonic-gate rw_destroy(&acache[i].lock); 35047c478bd9Sstevel@tonic-gate kmem_free(acache, acachesize * sizeof (*acache)); 35057c478bd9Sstevel@tonic-gate 35067c478bd9Sstevel@tonic-gate /* 35077c478bd9Sstevel@tonic-gate * Deallocate the client handle cache 35087c478bd9Sstevel@tonic-gate */ 35097c478bd9Sstevel@tonic-gate kmem_cache_destroy(chtab_cache); 35107c478bd9Sstevel@tonic-gate 35117c478bd9Sstevel@tonic-gate /* 35127c478bd9Sstevel@tonic-gate * Destroy the various mutexes and reader/writer locks 35137c478bd9Sstevel@tonic-gate */ 35147c478bd9Sstevel@tonic-gate mutex_destroy(&rpfreelist_lock); 35157c478bd9Sstevel@tonic-gate mutex_destroy(&newnum_lock); 35167c478bd9Sstevel@tonic-gate mutex_destroy(&nfs_minor_lock); 35177c478bd9Sstevel@tonic-gate (void) zone_key_delete(nfsclnt_zone_key); 35187c478bd9Sstevel@tonic-gate } 35197c478bd9Sstevel@tonic-gate 35207c478bd9Sstevel@tonic-gate enum nfsstat 35217c478bd9Sstevel@tonic-gate puterrno(int error) 35227c478bd9Sstevel@tonic-gate { 35237c478bd9Sstevel@tonic-gate 35247c478bd9Sstevel@tonic-gate switch (error) { 35257c478bd9Sstevel@tonic-gate case EOPNOTSUPP: 35267c478bd9Sstevel@tonic-gate return (NFSERR_OPNOTSUPP); 35277c478bd9Sstevel@tonic-gate case ENAMETOOLONG: 35287c478bd9Sstevel@tonic-gate return (NFSERR_NAMETOOLONG); 35297c478bd9Sstevel@tonic-gate case ENOTEMPTY: 35307c478bd9Sstevel@tonic-gate return (NFSERR_NOTEMPTY); 35317c478bd9Sstevel@tonic-gate case EDQUOT: 35327c478bd9Sstevel@tonic-gate return (NFSERR_DQUOT); 35337c478bd9Sstevel@tonic-gate case ESTALE: 35347c478bd9Sstevel@tonic-gate return (NFSERR_STALE); 35357c478bd9Sstevel@tonic-gate case EREMOTE: 35367c478bd9Sstevel@tonic-gate return (NFSERR_REMOTE); 35377c478bd9Sstevel@tonic-gate case ENOSYS: 35387c478bd9Sstevel@tonic-gate return (NFSERR_OPNOTSUPP); 35397c478bd9Sstevel@tonic-gate case EOVERFLOW: 35407c478bd9Sstevel@tonic-gate return (NFSERR_INVAL); 35417c478bd9Sstevel@tonic-gate default: 35427c478bd9Sstevel@tonic-gate return ((enum nfsstat)error); 35437c478bd9Sstevel@tonic-gate } 35447c478bd9Sstevel@tonic-gate /* NOTREACHED */ 35457c478bd9Sstevel@tonic-gate } 35467c478bd9Sstevel@tonic-gate 35477c478bd9Sstevel@tonic-gate int 35487c478bd9Sstevel@tonic-gate geterrno(enum nfsstat status) 35497c478bd9Sstevel@tonic-gate { 35507c478bd9Sstevel@tonic-gate 35517c478bd9Sstevel@tonic-gate switch (status) { 35527c478bd9Sstevel@tonic-gate case NFSERR_OPNOTSUPP: 35537c478bd9Sstevel@tonic-gate return (EOPNOTSUPP); 35547c478bd9Sstevel@tonic-gate case NFSERR_NAMETOOLONG: 35557c478bd9Sstevel@tonic-gate return (ENAMETOOLONG); 35567c478bd9Sstevel@tonic-gate case NFSERR_NOTEMPTY: 35577c478bd9Sstevel@tonic-gate return (ENOTEMPTY); 35587c478bd9Sstevel@tonic-gate case NFSERR_DQUOT: 35597c478bd9Sstevel@tonic-gate return (EDQUOT); 35607c478bd9Sstevel@tonic-gate case NFSERR_STALE: 35617c478bd9Sstevel@tonic-gate return (ESTALE); 35627c478bd9Sstevel@tonic-gate case NFSERR_REMOTE: 35637c478bd9Sstevel@tonic-gate return (EREMOTE); 35647c478bd9Sstevel@tonic-gate case NFSERR_WFLUSH: 35657c478bd9Sstevel@tonic-gate return (EIO); 35667c478bd9Sstevel@tonic-gate default: 35677c478bd9Sstevel@tonic-gate return ((int)status); 35687c478bd9Sstevel@tonic-gate } 35697c478bd9Sstevel@tonic-gate /* NOTREACHED */ 35707c478bd9Sstevel@tonic-gate } 35717c478bd9Sstevel@tonic-gate 35727c478bd9Sstevel@tonic-gate enum nfsstat3 35737c478bd9Sstevel@tonic-gate puterrno3(int error) 35747c478bd9Sstevel@tonic-gate { 35757c478bd9Sstevel@tonic-gate 35767c478bd9Sstevel@tonic-gate #ifdef DEBUG 35777c478bd9Sstevel@tonic-gate switch (error) { 35787c478bd9Sstevel@tonic-gate case 0: 35797c478bd9Sstevel@tonic-gate return (NFS3_OK); 35807c478bd9Sstevel@tonic-gate case EPERM: 35817c478bd9Sstevel@tonic-gate return (NFS3ERR_PERM); 35827c478bd9Sstevel@tonic-gate case ENOENT: 35837c478bd9Sstevel@tonic-gate return (NFS3ERR_NOENT); 35847c478bd9Sstevel@tonic-gate case EIO: 35857c478bd9Sstevel@tonic-gate return (NFS3ERR_IO); 35867c478bd9Sstevel@tonic-gate case ENXIO: 35877c478bd9Sstevel@tonic-gate return (NFS3ERR_NXIO); 35887c478bd9Sstevel@tonic-gate case EACCES: 35897c478bd9Sstevel@tonic-gate return (NFS3ERR_ACCES); 35907c478bd9Sstevel@tonic-gate case EEXIST: 35917c478bd9Sstevel@tonic-gate return (NFS3ERR_EXIST); 35927c478bd9Sstevel@tonic-gate case EXDEV: 35937c478bd9Sstevel@tonic-gate return (NFS3ERR_XDEV); 35947c478bd9Sstevel@tonic-gate case ENODEV: 35957c478bd9Sstevel@tonic-gate return (NFS3ERR_NODEV); 35967c478bd9Sstevel@tonic-gate case ENOTDIR: 35977c478bd9Sstevel@tonic-gate return (NFS3ERR_NOTDIR); 35987c478bd9Sstevel@tonic-gate case EISDIR: 35997c478bd9Sstevel@tonic-gate return (NFS3ERR_ISDIR); 36007c478bd9Sstevel@tonic-gate case EINVAL: 36017c478bd9Sstevel@tonic-gate return (NFS3ERR_INVAL); 36027c478bd9Sstevel@tonic-gate case EFBIG: 36037c478bd9Sstevel@tonic-gate return (NFS3ERR_FBIG); 36047c478bd9Sstevel@tonic-gate case ENOSPC: 36057c478bd9Sstevel@tonic-gate return (NFS3ERR_NOSPC); 36067c478bd9Sstevel@tonic-gate case EROFS: 36077c478bd9Sstevel@tonic-gate return (NFS3ERR_ROFS); 36087c478bd9Sstevel@tonic-gate case EMLINK: 36097c478bd9Sstevel@tonic-gate return (NFS3ERR_MLINK); 36107c478bd9Sstevel@tonic-gate case ENAMETOOLONG: 36117c478bd9Sstevel@tonic-gate return (NFS3ERR_NAMETOOLONG); 36127c478bd9Sstevel@tonic-gate case ENOTEMPTY: 36137c478bd9Sstevel@tonic-gate return (NFS3ERR_NOTEMPTY); 36147c478bd9Sstevel@tonic-gate case EDQUOT: 36157c478bd9Sstevel@tonic-gate return (NFS3ERR_DQUOT); 36167c478bd9Sstevel@tonic-gate case ESTALE: 36177c478bd9Sstevel@tonic-gate return (NFS3ERR_STALE); 36187c478bd9Sstevel@tonic-gate case EREMOTE: 36197c478bd9Sstevel@tonic-gate return (NFS3ERR_REMOTE); 36207c478bd9Sstevel@tonic-gate case EOPNOTSUPP: 36217c478bd9Sstevel@tonic-gate return (NFS3ERR_NOTSUPP); 36227c478bd9Sstevel@tonic-gate case EOVERFLOW: 36237c478bd9Sstevel@tonic-gate return (NFS3ERR_INVAL); 36247c478bd9Sstevel@tonic-gate default: 36257c478bd9Sstevel@tonic-gate zcmn_err(getzoneid(), CE_WARN, 36267c478bd9Sstevel@tonic-gate "puterrno3: got error %d", error); 36277c478bd9Sstevel@tonic-gate return ((enum nfsstat3)error); 36287c478bd9Sstevel@tonic-gate } 36297c478bd9Sstevel@tonic-gate #else 36307c478bd9Sstevel@tonic-gate switch (error) { 36317c478bd9Sstevel@tonic-gate case ENAMETOOLONG: 36327c478bd9Sstevel@tonic-gate return (NFS3ERR_NAMETOOLONG); 36337c478bd9Sstevel@tonic-gate case ENOTEMPTY: 36347c478bd9Sstevel@tonic-gate return (NFS3ERR_NOTEMPTY); 36357c478bd9Sstevel@tonic-gate case EDQUOT: 36367c478bd9Sstevel@tonic-gate return (NFS3ERR_DQUOT); 36377c478bd9Sstevel@tonic-gate case ESTALE: 36387c478bd9Sstevel@tonic-gate return (NFS3ERR_STALE); 36397c478bd9Sstevel@tonic-gate case EOPNOTSUPP: 36407c478bd9Sstevel@tonic-gate return (NFS3ERR_NOTSUPP); 36417c478bd9Sstevel@tonic-gate case EREMOTE: 36427c478bd9Sstevel@tonic-gate return (NFS3ERR_REMOTE); 36437c478bd9Sstevel@tonic-gate case EOVERFLOW: 36447c478bd9Sstevel@tonic-gate return (NFS3ERR_INVAL); 36457c478bd9Sstevel@tonic-gate default: 36467c478bd9Sstevel@tonic-gate return ((enum nfsstat3)error); 36477c478bd9Sstevel@tonic-gate } 36487c478bd9Sstevel@tonic-gate #endif 36497c478bd9Sstevel@tonic-gate } 36507c478bd9Sstevel@tonic-gate 36517c478bd9Sstevel@tonic-gate int 36527c478bd9Sstevel@tonic-gate geterrno3(enum nfsstat3 status) 36537c478bd9Sstevel@tonic-gate { 36547c478bd9Sstevel@tonic-gate 36557c478bd9Sstevel@tonic-gate #ifdef DEBUG 36567c478bd9Sstevel@tonic-gate switch (status) { 36577c478bd9Sstevel@tonic-gate case NFS3_OK: 36587c478bd9Sstevel@tonic-gate return (0); 36597c478bd9Sstevel@tonic-gate case NFS3ERR_PERM: 36607c478bd9Sstevel@tonic-gate return (EPERM); 36617c478bd9Sstevel@tonic-gate case NFS3ERR_NOENT: 36627c478bd9Sstevel@tonic-gate return (ENOENT); 36637c478bd9Sstevel@tonic-gate case NFS3ERR_IO: 36647c478bd9Sstevel@tonic-gate return (EIO); 36657c478bd9Sstevel@tonic-gate case NFS3ERR_NXIO: 36667c478bd9Sstevel@tonic-gate return (ENXIO); 36677c478bd9Sstevel@tonic-gate case NFS3ERR_ACCES: 36687c478bd9Sstevel@tonic-gate return (EACCES); 36697c478bd9Sstevel@tonic-gate case NFS3ERR_EXIST: 36707c478bd9Sstevel@tonic-gate return (EEXIST); 36717c478bd9Sstevel@tonic-gate case NFS3ERR_XDEV: 36727c478bd9Sstevel@tonic-gate return (EXDEV); 36737c478bd9Sstevel@tonic-gate case NFS3ERR_NODEV: 36747c478bd9Sstevel@tonic-gate return (ENODEV); 36757c478bd9Sstevel@tonic-gate case NFS3ERR_NOTDIR: 36767c478bd9Sstevel@tonic-gate return (ENOTDIR); 36777c478bd9Sstevel@tonic-gate case NFS3ERR_ISDIR: 36787c478bd9Sstevel@tonic-gate return (EISDIR); 36797c478bd9Sstevel@tonic-gate case NFS3ERR_INVAL: 36807c478bd9Sstevel@tonic-gate return (EINVAL); 36817c478bd9Sstevel@tonic-gate case NFS3ERR_FBIG: 36827c478bd9Sstevel@tonic-gate return (EFBIG); 36837c478bd9Sstevel@tonic-gate case NFS3ERR_NOSPC: 36847c478bd9Sstevel@tonic-gate return (ENOSPC); 36857c478bd9Sstevel@tonic-gate case NFS3ERR_ROFS: 36867c478bd9Sstevel@tonic-gate return (EROFS); 36877c478bd9Sstevel@tonic-gate case NFS3ERR_MLINK: 36887c478bd9Sstevel@tonic-gate return (EMLINK); 36897c478bd9Sstevel@tonic-gate case NFS3ERR_NAMETOOLONG: 36907c478bd9Sstevel@tonic-gate return (ENAMETOOLONG); 36917c478bd9Sstevel@tonic-gate case NFS3ERR_NOTEMPTY: 36927c478bd9Sstevel@tonic-gate return (ENOTEMPTY); 36937c478bd9Sstevel@tonic-gate case NFS3ERR_DQUOT: 36947c478bd9Sstevel@tonic-gate return (EDQUOT); 36957c478bd9Sstevel@tonic-gate case NFS3ERR_STALE: 36967c478bd9Sstevel@tonic-gate return (ESTALE); 36977c478bd9Sstevel@tonic-gate case NFS3ERR_REMOTE: 36987c478bd9Sstevel@tonic-gate return (EREMOTE); 36997c478bd9Sstevel@tonic-gate case NFS3ERR_BADHANDLE: 37007c478bd9Sstevel@tonic-gate return (ESTALE); 37017c478bd9Sstevel@tonic-gate case NFS3ERR_NOT_SYNC: 37027c478bd9Sstevel@tonic-gate return (EINVAL); 37037c478bd9Sstevel@tonic-gate case NFS3ERR_BAD_COOKIE: 37047c478bd9Sstevel@tonic-gate return (ENOENT); 37057c478bd9Sstevel@tonic-gate case NFS3ERR_NOTSUPP: 37067c478bd9Sstevel@tonic-gate return (EOPNOTSUPP); 37077c478bd9Sstevel@tonic-gate case NFS3ERR_TOOSMALL: 37087c478bd9Sstevel@tonic-gate return (EINVAL); 37097c478bd9Sstevel@tonic-gate case NFS3ERR_SERVERFAULT: 37107c478bd9Sstevel@tonic-gate return (EIO); 37117c478bd9Sstevel@tonic-gate case NFS3ERR_BADTYPE: 37127c478bd9Sstevel@tonic-gate return (EINVAL); 37137c478bd9Sstevel@tonic-gate case NFS3ERR_JUKEBOX: 37147c478bd9Sstevel@tonic-gate return (ENXIO); 37157c478bd9Sstevel@tonic-gate default: 37167c478bd9Sstevel@tonic-gate zcmn_err(getzoneid(), CE_WARN, 37177c478bd9Sstevel@tonic-gate "geterrno3: got status %d", status); 37187c478bd9Sstevel@tonic-gate return ((int)status); 37197c478bd9Sstevel@tonic-gate } 37207c478bd9Sstevel@tonic-gate #else 37217c478bd9Sstevel@tonic-gate switch (status) { 37227c478bd9Sstevel@tonic-gate case NFS3ERR_NAMETOOLONG: 37237c478bd9Sstevel@tonic-gate return (ENAMETOOLONG); 37247c478bd9Sstevel@tonic-gate case NFS3ERR_NOTEMPTY: 37257c478bd9Sstevel@tonic-gate return (ENOTEMPTY); 37267c478bd9Sstevel@tonic-gate case NFS3ERR_DQUOT: 37277c478bd9Sstevel@tonic-gate return (EDQUOT); 37287c478bd9Sstevel@tonic-gate case NFS3ERR_STALE: 37297c478bd9Sstevel@tonic-gate case NFS3ERR_BADHANDLE: 37307c478bd9Sstevel@tonic-gate return (ESTALE); 37317c478bd9Sstevel@tonic-gate case NFS3ERR_NOTSUPP: 37327c478bd9Sstevel@tonic-gate return (EOPNOTSUPP); 37337c478bd9Sstevel@tonic-gate case NFS3ERR_REMOTE: 37347c478bd9Sstevel@tonic-gate return (EREMOTE); 37357c478bd9Sstevel@tonic-gate case NFS3ERR_NOT_SYNC: 37367c478bd9Sstevel@tonic-gate case NFS3ERR_TOOSMALL: 37377c478bd9Sstevel@tonic-gate case NFS3ERR_BADTYPE: 37387c478bd9Sstevel@tonic-gate return (EINVAL); 37397c478bd9Sstevel@tonic-gate case NFS3ERR_BAD_COOKIE: 37407c478bd9Sstevel@tonic-gate return (ENOENT); 37417c478bd9Sstevel@tonic-gate case NFS3ERR_SERVERFAULT: 37427c478bd9Sstevel@tonic-gate return (EIO); 37437c478bd9Sstevel@tonic-gate case NFS3ERR_JUKEBOX: 37447c478bd9Sstevel@tonic-gate return (ENXIO); 37457c478bd9Sstevel@tonic-gate default: 37467c478bd9Sstevel@tonic-gate return ((int)status); 37477c478bd9Sstevel@tonic-gate } 37487c478bd9Sstevel@tonic-gate #endif 37497c478bd9Sstevel@tonic-gate } 37507c478bd9Sstevel@tonic-gate 37517c478bd9Sstevel@tonic-gate rddir_cache * 37527c478bd9Sstevel@tonic-gate rddir_cache_alloc(int flags) 37537c478bd9Sstevel@tonic-gate { 37547c478bd9Sstevel@tonic-gate rddir_cache *rc; 37557c478bd9Sstevel@tonic-gate 37567c478bd9Sstevel@tonic-gate rc = kmem_alloc(sizeof (*rc), flags); 37577c478bd9Sstevel@tonic-gate if (rc != NULL) { 37587c478bd9Sstevel@tonic-gate rc->entries = NULL; 37597c478bd9Sstevel@tonic-gate rc->flags = RDDIR; 37607c478bd9Sstevel@tonic-gate cv_init(&rc->cv, NULL, CV_DEFAULT, NULL); 37617c478bd9Sstevel@tonic-gate mutex_init(&rc->lock, NULL, MUTEX_DEFAULT, NULL); 37627c478bd9Sstevel@tonic-gate rc->count = 1; 37637c478bd9Sstevel@tonic-gate #ifdef DEBUG 37647c478bd9Sstevel@tonic-gate atomic_add_64(&clstat_debug.dirent.value.ui64, 1); 37657c478bd9Sstevel@tonic-gate #endif 37667c478bd9Sstevel@tonic-gate } 37677c478bd9Sstevel@tonic-gate return (rc); 37687c478bd9Sstevel@tonic-gate } 37697c478bd9Sstevel@tonic-gate 37707c478bd9Sstevel@tonic-gate static void 37717c478bd9Sstevel@tonic-gate rddir_cache_free(rddir_cache *rc) 37727c478bd9Sstevel@tonic-gate { 37737c478bd9Sstevel@tonic-gate 37747c478bd9Sstevel@tonic-gate #ifdef DEBUG 37757c478bd9Sstevel@tonic-gate atomic_add_64(&clstat_debug.dirent.value.ui64, -1); 37767c478bd9Sstevel@tonic-gate #endif 37777c478bd9Sstevel@tonic-gate if (rc->entries != NULL) { 37787c478bd9Sstevel@tonic-gate #ifdef DEBUG 37797c478bd9Sstevel@tonic-gate rddir_cache_buf_free(rc->entries, rc->buflen); 37807c478bd9Sstevel@tonic-gate #else 37817c478bd9Sstevel@tonic-gate kmem_free(rc->entries, rc->buflen); 37827c478bd9Sstevel@tonic-gate #endif 37837c478bd9Sstevel@tonic-gate } 37847c478bd9Sstevel@tonic-gate cv_destroy(&rc->cv); 37857c478bd9Sstevel@tonic-gate mutex_destroy(&rc->lock); 37867c478bd9Sstevel@tonic-gate kmem_free(rc, sizeof (*rc)); 37877c478bd9Sstevel@tonic-gate } 37887c478bd9Sstevel@tonic-gate 37897c478bd9Sstevel@tonic-gate void 37907c478bd9Sstevel@tonic-gate rddir_cache_hold(rddir_cache *rc) 37917c478bd9Sstevel@tonic-gate { 37927c478bd9Sstevel@tonic-gate 37937c478bd9Sstevel@tonic-gate mutex_enter(&rc->lock); 37947c478bd9Sstevel@tonic-gate rc->count++; 37957c478bd9Sstevel@tonic-gate mutex_exit(&rc->lock); 37967c478bd9Sstevel@tonic-gate } 37977c478bd9Sstevel@tonic-gate 37987c478bd9Sstevel@tonic-gate void 37997c478bd9Sstevel@tonic-gate rddir_cache_rele(rddir_cache *rc) 38007c478bd9Sstevel@tonic-gate { 38017c478bd9Sstevel@tonic-gate 38027c478bd9Sstevel@tonic-gate mutex_enter(&rc->lock); 38037c478bd9Sstevel@tonic-gate ASSERT(rc->count > 0); 38047c478bd9Sstevel@tonic-gate if (--rc->count == 0) { 38057c478bd9Sstevel@tonic-gate mutex_exit(&rc->lock); 38067c478bd9Sstevel@tonic-gate rddir_cache_free(rc); 38077c478bd9Sstevel@tonic-gate } else 38087c478bd9Sstevel@tonic-gate mutex_exit(&rc->lock); 38097c478bd9Sstevel@tonic-gate } 38107c478bd9Sstevel@tonic-gate 38117c478bd9Sstevel@tonic-gate #ifdef DEBUG 38127c478bd9Sstevel@tonic-gate char * 38137c478bd9Sstevel@tonic-gate rddir_cache_buf_alloc(size_t size, int flags) 38147c478bd9Sstevel@tonic-gate { 38157c478bd9Sstevel@tonic-gate char *rc; 38167c478bd9Sstevel@tonic-gate 38177c478bd9Sstevel@tonic-gate rc = kmem_alloc(size, flags); 38187c478bd9Sstevel@tonic-gate if (rc != NULL) 38197c478bd9Sstevel@tonic-gate atomic_add_64(&clstat_debug.dirents.value.ui64, size); 38207c478bd9Sstevel@tonic-gate return (rc); 38217c478bd9Sstevel@tonic-gate } 38227c478bd9Sstevel@tonic-gate 38237c478bd9Sstevel@tonic-gate void 38247c478bd9Sstevel@tonic-gate rddir_cache_buf_free(void *addr, size_t size) 38257c478bd9Sstevel@tonic-gate { 38267c478bd9Sstevel@tonic-gate 38277c478bd9Sstevel@tonic-gate atomic_add_64(&clstat_debug.dirents.value.ui64, -(int64_t)size); 38287c478bd9Sstevel@tonic-gate kmem_free(addr, size); 38297c478bd9Sstevel@tonic-gate } 38307c478bd9Sstevel@tonic-gate #endif 38317c478bd9Sstevel@tonic-gate 38327c478bd9Sstevel@tonic-gate static int 38337c478bd9Sstevel@tonic-gate nfs_free_data_reclaim(rnode_t *rp) 38347c478bd9Sstevel@tonic-gate { 38357c478bd9Sstevel@tonic-gate char *contents; 38367c478bd9Sstevel@tonic-gate int size; 38377c478bd9Sstevel@tonic-gate vsecattr_t *vsp; 38387c478bd9Sstevel@tonic-gate nfs3_pathconf_info *info; 38397c478bd9Sstevel@tonic-gate int freed; 38407c478bd9Sstevel@tonic-gate cred_t *cred; 38417c478bd9Sstevel@tonic-gate 38427c478bd9Sstevel@tonic-gate /* 38437c478bd9Sstevel@tonic-gate * Free any held credentials and caches which 38447c478bd9Sstevel@tonic-gate * may be associated with this rnode. 38457c478bd9Sstevel@tonic-gate */ 38467c478bd9Sstevel@tonic-gate mutex_enter(&rp->r_statelock); 38477c478bd9Sstevel@tonic-gate cred = rp->r_cred; 38487c478bd9Sstevel@tonic-gate rp->r_cred = NULL; 38497c478bd9Sstevel@tonic-gate contents = rp->r_symlink.contents; 38507c478bd9Sstevel@tonic-gate size = rp->r_symlink.size; 38517c478bd9Sstevel@tonic-gate rp->r_symlink.contents = NULL; 38527c478bd9Sstevel@tonic-gate vsp = rp->r_secattr; 38537c478bd9Sstevel@tonic-gate rp->r_secattr = NULL; 38547c478bd9Sstevel@tonic-gate info = rp->r_pathconf; 38557c478bd9Sstevel@tonic-gate rp->r_pathconf = NULL; 38567c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 38577c478bd9Sstevel@tonic-gate 38587c478bd9Sstevel@tonic-gate if (cred != NULL) 38597c478bd9Sstevel@tonic-gate crfree(cred); 38607c478bd9Sstevel@tonic-gate 38617c478bd9Sstevel@tonic-gate /* 38627c478bd9Sstevel@tonic-gate * Free the access cache entries. 38637c478bd9Sstevel@tonic-gate */ 38647c478bd9Sstevel@tonic-gate freed = nfs_access_purge_rp(rp); 38657c478bd9Sstevel@tonic-gate 38667c478bd9Sstevel@tonic-gate if (!HAVE_RDDIR_CACHE(rp) && 38677c478bd9Sstevel@tonic-gate contents == NULL && 38687c478bd9Sstevel@tonic-gate vsp == NULL && 38697c478bd9Sstevel@tonic-gate info == NULL) 38707c478bd9Sstevel@tonic-gate return (freed); 38717c478bd9Sstevel@tonic-gate 38727c478bd9Sstevel@tonic-gate /* 38737c478bd9Sstevel@tonic-gate * Free the readdir cache entries 38747c478bd9Sstevel@tonic-gate */ 38757c478bd9Sstevel@tonic-gate if (HAVE_RDDIR_CACHE(rp)) 38767c478bd9Sstevel@tonic-gate nfs_purge_rddir_cache(RTOV(rp)); 38777c478bd9Sstevel@tonic-gate 38787c478bd9Sstevel@tonic-gate /* 38797c478bd9Sstevel@tonic-gate * Free the symbolic link cache. 38807c478bd9Sstevel@tonic-gate */ 38817c478bd9Sstevel@tonic-gate if (contents != NULL) { 38827c478bd9Sstevel@tonic-gate 38837c478bd9Sstevel@tonic-gate kmem_free((void *)contents, size); 38847c478bd9Sstevel@tonic-gate } 38857c478bd9Sstevel@tonic-gate 38867c478bd9Sstevel@tonic-gate /* 38877c478bd9Sstevel@tonic-gate * Free any cached ACL. 38887c478bd9Sstevel@tonic-gate */ 38897c478bd9Sstevel@tonic-gate if (vsp != NULL) 38907c478bd9Sstevel@tonic-gate nfs_acl_free(vsp); 38917c478bd9Sstevel@tonic-gate 38927c478bd9Sstevel@tonic-gate /* 38937c478bd9Sstevel@tonic-gate * Free any cached pathconf information. 38947c478bd9Sstevel@tonic-gate */ 38957c478bd9Sstevel@tonic-gate if (info != NULL) 38967c478bd9Sstevel@tonic-gate kmem_free(info, sizeof (*info)); 38977c478bd9Sstevel@tonic-gate 38987c478bd9Sstevel@tonic-gate return (1); 38997c478bd9Sstevel@tonic-gate } 39007c478bd9Sstevel@tonic-gate 39017c478bd9Sstevel@tonic-gate static int 39027c478bd9Sstevel@tonic-gate nfs_active_data_reclaim(rnode_t *rp) 39037c478bd9Sstevel@tonic-gate { 39047c478bd9Sstevel@tonic-gate char *contents; 39057c478bd9Sstevel@tonic-gate int size; 39067c478bd9Sstevel@tonic-gate vsecattr_t *vsp; 39077c478bd9Sstevel@tonic-gate nfs3_pathconf_info *info; 39087c478bd9Sstevel@tonic-gate int freed; 39097c478bd9Sstevel@tonic-gate 39107c478bd9Sstevel@tonic-gate /* 39117c478bd9Sstevel@tonic-gate * Free any held credentials and caches which 39127c478bd9Sstevel@tonic-gate * may be associated with this rnode. 39137c478bd9Sstevel@tonic-gate */ 39147c478bd9Sstevel@tonic-gate if (!mutex_tryenter(&rp->r_statelock)) 39157c478bd9Sstevel@tonic-gate return (0); 39167c478bd9Sstevel@tonic-gate contents = rp->r_symlink.contents; 39177c478bd9Sstevel@tonic-gate size = rp->r_symlink.size; 39187c478bd9Sstevel@tonic-gate rp->r_symlink.contents = NULL; 39197c478bd9Sstevel@tonic-gate vsp = rp->r_secattr; 39207c478bd9Sstevel@tonic-gate rp->r_secattr = NULL; 39217c478bd9Sstevel@tonic-gate info = rp->r_pathconf; 39227c478bd9Sstevel@tonic-gate rp->r_pathconf = NULL; 39237c478bd9Sstevel@tonic-gate mutex_exit(&rp->r_statelock); 39247c478bd9Sstevel@tonic-gate 39257c478bd9Sstevel@tonic-gate /* 39267c478bd9Sstevel@tonic-gate * Free the access cache entries. 39277c478bd9Sstevel@tonic-gate */ 39287c478bd9Sstevel@tonic-gate freed = nfs_access_purge_rp(rp); 39297c478bd9Sstevel@tonic-gate 39307c478bd9Sstevel@tonic-gate if (!HAVE_RDDIR_CACHE(rp) && 39317c478bd9Sstevel@tonic-gate contents == NULL && 39327c478bd9Sstevel@tonic-gate vsp == NULL && 39337c478bd9Sstevel@tonic-gate info == NULL) 39347c478bd9Sstevel@tonic-gate return (freed); 39357c478bd9Sstevel@tonic-gate 39367c478bd9Sstevel@tonic-gate /* 39377c478bd9Sstevel@tonic-gate * Free the readdir cache entries 39387c478bd9Sstevel@tonic-gate */ 39397c478bd9Sstevel@tonic-gate if (HAVE_RDDIR_CACHE(rp)) 39407c478bd9Sstevel@tonic-gate nfs_purge_rddir_cache(RTOV(rp)); 39417c478bd9Sstevel@tonic-gate 39427c478bd9Sstevel@tonic-gate /* 39437c478bd9Sstevel@tonic-gate * Free the symbolic link cache. 39447c478bd9Sstevel@tonic-gate */ 39457c478bd9Sstevel@tonic-gate if (contents != NULL) { 39467c478bd9Sstevel@tonic-gate 39477c478bd9Sstevel@tonic-gate kmem_free((void *)contents, size); 39487c478bd9Sstevel@tonic-gate } 39497c478bd9Sstevel@tonic-gate 39507c478bd9Sstevel@tonic-gate /* 39517c478bd9Sstevel@tonic-gate * Free any cached ACL. 39527c478bd9Sstevel@tonic-gate */ 39537c478bd9Sstevel@tonic-gate if (vsp != NULL) 39547c478bd9Sstevel@tonic-gate nfs_acl_free(vsp); 39557c478bd9Sstevel@tonic-gate 39567c478bd9Sstevel@tonic-gate /* 39577c478bd9Sstevel@tonic-gate * Free any cached pathconf information. 39587c478bd9Sstevel@tonic-gate */ 39597c478bd9Sstevel@tonic-gate if (info != NULL) 39607c478bd9Sstevel@tonic-gate kmem_free(info, sizeof (*info)); 39617c478bd9Sstevel@tonic-gate 39627c478bd9Sstevel@tonic-gate return (1); 39637c478bd9Sstevel@tonic-gate } 39647c478bd9Sstevel@tonic-gate 39657c478bd9Sstevel@tonic-gate static int 39667c478bd9Sstevel@tonic-gate nfs_free_reclaim(void) 39677c478bd9Sstevel@tonic-gate { 39687c478bd9Sstevel@tonic-gate int freed; 39697c478bd9Sstevel@tonic-gate rnode_t *rp; 39707c478bd9Sstevel@tonic-gate 39717c478bd9Sstevel@tonic-gate #ifdef DEBUG 39727c478bd9Sstevel@tonic-gate clstat_debug.f_reclaim.value.ui64++; 39737c478bd9Sstevel@tonic-gate #endif 39747c478bd9Sstevel@tonic-gate freed = 0; 39757c478bd9Sstevel@tonic-gate mutex_enter(&rpfreelist_lock); 39767c478bd9Sstevel@tonic-gate rp = rpfreelist; 39777c478bd9Sstevel@tonic-gate if (rp != NULL) { 39787c478bd9Sstevel@tonic-gate do { 39797c478bd9Sstevel@tonic-gate if (nfs_free_data_reclaim(rp)) 39807c478bd9Sstevel@tonic-gate freed = 1; 39817c478bd9Sstevel@tonic-gate } while ((rp = rp->r_freef) != rpfreelist); 39827c478bd9Sstevel@tonic-gate } 39837c478bd9Sstevel@tonic-gate mutex_exit(&rpfreelist_lock); 39847c478bd9Sstevel@tonic-gate return (freed); 39857c478bd9Sstevel@tonic-gate } 39867c478bd9Sstevel@tonic-gate 39877c478bd9Sstevel@tonic-gate static int 39887c478bd9Sstevel@tonic-gate nfs_active_reclaim(void) 39897c478bd9Sstevel@tonic-gate { 39907c478bd9Sstevel@tonic-gate int freed; 39917c478bd9Sstevel@tonic-gate int index; 39927c478bd9Sstevel@tonic-gate rnode_t *rp; 39937c478bd9Sstevel@tonic-gate 39947c478bd9Sstevel@tonic-gate #ifdef DEBUG 39957c478bd9Sstevel@tonic-gate clstat_debug.a_reclaim.value.ui64++; 39967c478bd9Sstevel@tonic-gate #endif 39977c478bd9Sstevel@tonic-gate freed = 0; 39987c478bd9Sstevel@tonic-gate for (index = 0; index < rtablesize; index++) { 39997c478bd9Sstevel@tonic-gate rw_enter(&rtable[index].r_lock, RW_READER); 40007c478bd9Sstevel@tonic-gate for (rp = rtable[index].r_hashf; 40017c478bd9Sstevel@tonic-gate rp != (rnode_t *)(&rtable[index]); 40027c478bd9Sstevel@tonic-gate rp = rp->r_hashf) { 40037c478bd9Sstevel@tonic-gate if (nfs_active_data_reclaim(rp)) 40047c478bd9Sstevel@tonic-gate freed = 1; 40057c478bd9Sstevel@tonic-gate } 40067c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 40077c478bd9Sstevel@tonic-gate } 40087c478bd9Sstevel@tonic-gate return (freed); 40097c478bd9Sstevel@tonic-gate } 40107c478bd9Sstevel@tonic-gate 40117c478bd9Sstevel@tonic-gate static int 40127c478bd9Sstevel@tonic-gate nfs_rnode_reclaim(void) 40137c478bd9Sstevel@tonic-gate { 40147c478bd9Sstevel@tonic-gate int freed; 40157c478bd9Sstevel@tonic-gate rnode_t *rp; 40167c478bd9Sstevel@tonic-gate vnode_t *vp; 40177c478bd9Sstevel@tonic-gate 40187c478bd9Sstevel@tonic-gate #ifdef DEBUG 40197c478bd9Sstevel@tonic-gate clstat_debug.r_reclaim.value.ui64++; 40207c478bd9Sstevel@tonic-gate #endif 40217c478bd9Sstevel@tonic-gate freed = 0; 40227c478bd9Sstevel@tonic-gate mutex_enter(&rpfreelist_lock); 40237c478bd9Sstevel@tonic-gate while ((rp = rpfreelist) != NULL) { 40247c478bd9Sstevel@tonic-gate rp_rmfree(rp); 40257c478bd9Sstevel@tonic-gate mutex_exit(&rpfreelist_lock); 40267c478bd9Sstevel@tonic-gate if (rp->r_flags & RHASHED) { 40277c478bd9Sstevel@tonic-gate vp = RTOV(rp); 40287c478bd9Sstevel@tonic-gate rw_enter(&rp->r_hashq->r_lock, RW_WRITER); 40297c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 40307c478bd9Sstevel@tonic-gate if (vp->v_count > 1) { 40317c478bd9Sstevel@tonic-gate vp->v_count--; 40327c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 40337c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 40347c478bd9Sstevel@tonic-gate mutex_enter(&rpfreelist_lock); 40357c478bd9Sstevel@tonic-gate continue; 40367c478bd9Sstevel@tonic-gate } 40377c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 40387c478bd9Sstevel@tonic-gate rp_rmhash_locked(rp); 40397c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 40407c478bd9Sstevel@tonic-gate } 40417c478bd9Sstevel@tonic-gate /* 40427c478bd9Sstevel@tonic-gate * This call to rp_addfree will end up destroying the 40437c478bd9Sstevel@tonic-gate * rnode, but in a safe way with the appropriate set 40447c478bd9Sstevel@tonic-gate * of checks done. 40457c478bd9Sstevel@tonic-gate */ 40467c478bd9Sstevel@tonic-gate rp_addfree(rp, CRED()); 40477c478bd9Sstevel@tonic-gate mutex_enter(&rpfreelist_lock); 40487c478bd9Sstevel@tonic-gate } 40497c478bd9Sstevel@tonic-gate mutex_exit(&rpfreelist_lock); 40507c478bd9Sstevel@tonic-gate return (freed); 40517c478bd9Sstevel@tonic-gate } 40527c478bd9Sstevel@tonic-gate 40537c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 40547c478bd9Sstevel@tonic-gate static void 40557c478bd9Sstevel@tonic-gate nfs_reclaim(void *cdrarg) 40567c478bd9Sstevel@tonic-gate { 40577c478bd9Sstevel@tonic-gate 40587c478bd9Sstevel@tonic-gate #ifdef DEBUG 40597c478bd9Sstevel@tonic-gate clstat_debug.reclaim.value.ui64++; 40607c478bd9Sstevel@tonic-gate #endif 40617c478bd9Sstevel@tonic-gate if (nfs_free_reclaim()) 40627c478bd9Sstevel@tonic-gate return; 40637c478bd9Sstevel@tonic-gate 40647c478bd9Sstevel@tonic-gate if (nfs_active_reclaim()) 40657c478bd9Sstevel@tonic-gate return; 40667c478bd9Sstevel@tonic-gate 40677c478bd9Sstevel@tonic-gate (void) nfs_rnode_reclaim(); 40687c478bd9Sstevel@tonic-gate } 40697c478bd9Sstevel@tonic-gate 40707c478bd9Sstevel@tonic-gate /* 40717c478bd9Sstevel@tonic-gate * NFS client failover support 40727c478bd9Sstevel@tonic-gate * 40737c478bd9Sstevel@tonic-gate * Routines to copy filehandles 40747c478bd9Sstevel@tonic-gate */ 40757c478bd9Sstevel@tonic-gate void 40767c478bd9Sstevel@tonic-gate nfscopyfh(caddr_t fhp, vnode_t *vp) 40777c478bd9Sstevel@tonic-gate { 40787c478bd9Sstevel@tonic-gate fhandle_t *dest = (fhandle_t *)fhp; 40797c478bd9Sstevel@tonic-gate 40807c478bd9Sstevel@tonic-gate if (dest != NULL) 40817c478bd9Sstevel@tonic-gate *dest = *VTOFH(vp); 40827c478bd9Sstevel@tonic-gate } 40837c478bd9Sstevel@tonic-gate 40847c478bd9Sstevel@tonic-gate void 40857c478bd9Sstevel@tonic-gate nfs3copyfh(caddr_t fhp, vnode_t *vp) 40867c478bd9Sstevel@tonic-gate { 40877c478bd9Sstevel@tonic-gate nfs_fh3 *dest = (nfs_fh3 *)fhp; 40887c478bd9Sstevel@tonic-gate 40897c478bd9Sstevel@tonic-gate if (dest != NULL) 40907c478bd9Sstevel@tonic-gate *dest = *VTOFH3(vp); 40917c478bd9Sstevel@tonic-gate } 40927c478bd9Sstevel@tonic-gate 40937c478bd9Sstevel@tonic-gate /* 40947c478bd9Sstevel@tonic-gate * NFS client failover support 40957c478bd9Sstevel@tonic-gate * 40967c478bd9Sstevel@tonic-gate * failover_safe() will test various conditions to ensure that 40977c478bd9Sstevel@tonic-gate * failover is permitted for this vnode. It will be denied 40987c478bd9Sstevel@tonic-gate * if: 40997c478bd9Sstevel@tonic-gate * 1) the operation in progress does not support failover (NULL fi) 41007c478bd9Sstevel@tonic-gate * 2) there are no available replicas (NULL mi_servers->sv_next) 41017c478bd9Sstevel@tonic-gate * 3) any locks are outstanding on this file 41027c478bd9Sstevel@tonic-gate */ 41037c478bd9Sstevel@tonic-gate static int 41047c478bd9Sstevel@tonic-gate failover_safe(failinfo_t *fi) 41057c478bd9Sstevel@tonic-gate { 41067c478bd9Sstevel@tonic-gate 41077c478bd9Sstevel@tonic-gate /* 41087c478bd9Sstevel@tonic-gate * Does this op permit failover? 41097c478bd9Sstevel@tonic-gate */ 41107c478bd9Sstevel@tonic-gate if (fi == NULL || fi->vp == NULL) 41117c478bd9Sstevel@tonic-gate return (0); 41127c478bd9Sstevel@tonic-gate 41137c478bd9Sstevel@tonic-gate /* 41147c478bd9Sstevel@tonic-gate * Are there any alternates to failover to? 41157c478bd9Sstevel@tonic-gate */ 41167c478bd9Sstevel@tonic-gate if (VTOMI(fi->vp)->mi_servers->sv_next == NULL) 41177c478bd9Sstevel@tonic-gate return (0); 41187c478bd9Sstevel@tonic-gate 41197c478bd9Sstevel@tonic-gate /* 41207c478bd9Sstevel@tonic-gate * Disable check; we've forced local locking 41217c478bd9Sstevel@tonic-gate * 41227c478bd9Sstevel@tonic-gate * if (flk_has_remote_locks(fi->vp)) 41237c478bd9Sstevel@tonic-gate * return (0); 41247c478bd9Sstevel@tonic-gate */ 41257c478bd9Sstevel@tonic-gate 41267c478bd9Sstevel@tonic-gate /* 41277c478bd9Sstevel@tonic-gate * If we have no partial path, we can't do anything 41287c478bd9Sstevel@tonic-gate */ 41297c478bd9Sstevel@tonic-gate if (VTOR(fi->vp)->r_path == NULL) 41307c478bd9Sstevel@tonic-gate return (0); 41317c478bd9Sstevel@tonic-gate 41327c478bd9Sstevel@tonic-gate return (1); 41337c478bd9Sstevel@tonic-gate } 41347c478bd9Sstevel@tonic-gate 41357c478bd9Sstevel@tonic-gate #include <sys/thread.h> 41367c478bd9Sstevel@tonic-gate 41377c478bd9Sstevel@tonic-gate /* 41387c478bd9Sstevel@tonic-gate * NFS client failover support 41397c478bd9Sstevel@tonic-gate * 41407c478bd9Sstevel@tonic-gate * failover_newserver() will start a search for a new server, 41417c478bd9Sstevel@tonic-gate * preferably by starting an async thread to do the work. If 41427c478bd9Sstevel@tonic-gate * someone is already doing this (recognizable by MI_BINDINPROG 41437c478bd9Sstevel@tonic-gate * being set), it will simply return and the calling thread 41447c478bd9Sstevel@tonic-gate * will queue on the mi_failover_cv condition variable. 41457c478bd9Sstevel@tonic-gate */ 41467c478bd9Sstevel@tonic-gate static void 41477c478bd9Sstevel@tonic-gate failover_newserver(mntinfo_t *mi) 41487c478bd9Sstevel@tonic-gate { 41497c478bd9Sstevel@tonic-gate /* 41507c478bd9Sstevel@tonic-gate * Check if someone else is doing this already 41517c478bd9Sstevel@tonic-gate */ 41527c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 41537c478bd9Sstevel@tonic-gate if (mi->mi_flags & MI_BINDINPROG) { 41547c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 41557c478bd9Sstevel@tonic-gate return; 41567c478bd9Sstevel@tonic-gate } 41577c478bd9Sstevel@tonic-gate mi->mi_flags |= MI_BINDINPROG; 41587c478bd9Sstevel@tonic-gate 41597c478bd9Sstevel@tonic-gate /* 41607c478bd9Sstevel@tonic-gate * Need to hold the vfs struct so that it can't be released 41617c478bd9Sstevel@tonic-gate * while the failover thread is selecting a new server. 41627c478bd9Sstevel@tonic-gate */ 41637c478bd9Sstevel@tonic-gate VFS_HOLD(mi->mi_vfsp); 41647c478bd9Sstevel@tonic-gate 41657c478bd9Sstevel@tonic-gate /* 41667c478bd9Sstevel@tonic-gate * Start a thread to do the real searching. 41677c478bd9Sstevel@tonic-gate */ 41687c478bd9Sstevel@tonic-gate (void) zthread_create(NULL, 0, failover_thread, mi, 0, minclsyspri); 41697c478bd9Sstevel@tonic-gate 41707c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 41717c478bd9Sstevel@tonic-gate } 41727c478bd9Sstevel@tonic-gate 41737c478bd9Sstevel@tonic-gate /* 41747c478bd9Sstevel@tonic-gate * NFS client failover support 41757c478bd9Sstevel@tonic-gate * 41767c478bd9Sstevel@tonic-gate * failover_thread() will find a new server to replace the one 41777c478bd9Sstevel@tonic-gate * currently in use, wake up other threads waiting on this mount 41787c478bd9Sstevel@tonic-gate * point, and die. It will start at the head of the server list 41797c478bd9Sstevel@tonic-gate * and poll servers until it finds one with an NFS server which is 41807c478bd9Sstevel@tonic-gate * registered and responds to a NULL procedure ping. 41817c478bd9Sstevel@tonic-gate * 41827c478bd9Sstevel@tonic-gate * XXX failover_thread is unsafe within the scope of the 41837c478bd9Sstevel@tonic-gate * present model defined for cpr to suspend the system. 41847c478bd9Sstevel@tonic-gate * Specifically, over-the-wire calls made by the thread 41857c478bd9Sstevel@tonic-gate * are unsafe. The thread needs to be reevaluated in case of 41867c478bd9Sstevel@tonic-gate * future updates to the cpr suspend model. 41877c478bd9Sstevel@tonic-gate */ 41887c478bd9Sstevel@tonic-gate static void 41897c478bd9Sstevel@tonic-gate failover_thread(mntinfo_t *mi) 41907c478bd9Sstevel@tonic-gate { 41917c478bd9Sstevel@tonic-gate servinfo_t *svp = NULL; 41927c478bd9Sstevel@tonic-gate CLIENT *cl; 41937c478bd9Sstevel@tonic-gate enum clnt_stat status; 41947c478bd9Sstevel@tonic-gate struct timeval tv; 41957c478bd9Sstevel@tonic-gate int error; 41967c478bd9Sstevel@tonic-gate int oncethru = 0; 41977c478bd9Sstevel@tonic-gate callb_cpr_t cprinfo; 41987c478bd9Sstevel@tonic-gate rnode_t *rp; 41997c478bd9Sstevel@tonic-gate int index; 42007c478bd9Sstevel@tonic-gate char *srvnames; 42017c478bd9Sstevel@tonic-gate size_t srvnames_len; 42027c478bd9Sstevel@tonic-gate struct nfs_clnt *nfscl = NULL; 42037c478bd9Sstevel@tonic-gate zoneid_t zoneid = getzoneid(); 42047c478bd9Sstevel@tonic-gate 42057c478bd9Sstevel@tonic-gate #ifdef DEBUG 42067c478bd9Sstevel@tonic-gate /* 42077c478bd9Sstevel@tonic-gate * This is currently only needed to access counters which exist on 42087c478bd9Sstevel@tonic-gate * DEBUG kernels, hence we don't want to pay the penalty of the lookup 42097c478bd9Sstevel@tonic-gate * on non-DEBUG kernels. 42107c478bd9Sstevel@tonic-gate */ 4211*108322fbScarlsonj nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone()); 42127c478bd9Sstevel@tonic-gate ASSERT(nfscl != NULL); 42137c478bd9Sstevel@tonic-gate #endif 42147c478bd9Sstevel@tonic-gate 42157c478bd9Sstevel@tonic-gate /* 42167c478bd9Sstevel@tonic-gate * Its safe to piggyback on the mi_lock since failover_newserver() 42177c478bd9Sstevel@tonic-gate * code guarantees that there will be only one failover thread 42187c478bd9Sstevel@tonic-gate * per mountinfo at any instance. 42197c478bd9Sstevel@tonic-gate */ 42207c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cprinfo, &mi->mi_lock, callb_generic_cpr, 42217c478bd9Sstevel@tonic-gate "failover_thread"); 42227c478bd9Sstevel@tonic-gate 42237c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 42247c478bd9Sstevel@tonic-gate while (mi->mi_readers) { 42257c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 42267c478bd9Sstevel@tonic-gate cv_wait(&mi->mi_failover_cv, &mi->mi_lock); 42277c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cprinfo, &mi->mi_lock); 42287c478bd9Sstevel@tonic-gate } 42297c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 42307c478bd9Sstevel@tonic-gate 42317c478bd9Sstevel@tonic-gate tv.tv_sec = 2; 42327c478bd9Sstevel@tonic-gate tv.tv_usec = 0; 42337c478bd9Sstevel@tonic-gate 42347c478bd9Sstevel@tonic-gate /* 42357c478bd9Sstevel@tonic-gate * Ping the null NFS procedure of every server in 42367c478bd9Sstevel@tonic-gate * the list until one responds. We always start 42377c478bd9Sstevel@tonic-gate * at the head of the list and always skip the one 42387c478bd9Sstevel@tonic-gate * that is current, since it's caused us a problem. 42397c478bd9Sstevel@tonic-gate */ 42407c478bd9Sstevel@tonic-gate while (svp == NULL) { 42417c478bd9Sstevel@tonic-gate for (svp = mi->mi_servers; svp; svp = svp->sv_next) { 42427c478bd9Sstevel@tonic-gate if (!oncethru && svp == mi->mi_curr_serv) 42437c478bd9Sstevel@tonic-gate continue; 42447c478bd9Sstevel@tonic-gate 42457c478bd9Sstevel@tonic-gate /* 42467c478bd9Sstevel@tonic-gate * If the file system was forcibly umounted 42477c478bd9Sstevel@tonic-gate * while trying to do a failover, then just 42487c478bd9Sstevel@tonic-gate * give up on the failover. It won't matter 42497c478bd9Sstevel@tonic-gate * what the server is. 42507c478bd9Sstevel@tonic-gate */ 42517c478bd9Sstevel@tonic-gate if (FS_OR_ZONE_GONE(mi->mi_vfsp)) { 42527c478bd9Sstevel@tonic-gate svp = NULL; 42537c478bd9Sstevel@tonic-gate goto done; 42547c478bd9Sstevel@tonic-gate } 42557c478bd9Sstevel@tonic-gate 42567c478bd9Sstevel@tonic-gate error = clnt_tli_kcreate(svp->sv_knconf, &svp->sv_addr, 42577c478bd9Sstevel@tonic-gate NFS_PROGRAM, NFS_VERSION, 0, 1, CRED(), &cl); 42587c478bd9Sstevel@tonic-gate if (error) 42597c478bd9Sstevel@tonic-gate continue; 42607c478bd9Sstevel@tonic-gate 42617c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_INT)) 42627c478bd9Sstevel@tonic-gate cl->cl_nosignal = TRUE; 42637c478bd9Sstevel@tonic-gate status = CLNT_CALL(cl, RFS_NULL, xdr_void, NULL, 42647c478bd9Sstevel@tonic-gate xdr_void, NULL, tv); 42657c478bd9Sstevel@tonic-gate if (!(mi->mi_flags & MI_INT)) 42667c478bd9Sstevel@tonic-gate cl->cl_nosignal = FALSE; 42677c478bd9Sstevel@tonic-gate AUTH_DESTROY(cl->cl_auth); 42687c478bd9Sstevel@tonic-gate CLNT_DESTROY(cl); 42697c478bd9Sstevel@tonic-gate if (status == RPC_SUCCESS) { 42707c478bd9Sstevel@tonic-gate if (svp == mi->mi_curr_serv) { 42717c478bd9Sstevel@tonic-gate #ifdef DEBUG 42727c478bd9Sstevel@tonic-gate zcmn_err(zoneid, CE_NOTE, 42737c478bd9Sstevel@tonic-gate "NFS%d: failing over: selecting original server %s", 42747c478bd9Sstevel@tonic-gate mi->mi_vers, svp->sv_hostname); 42757c478bd9Sstevel@tonic-gate #else 42767c478bd9Sstevel@tonic-gate zcmn_err(zoneid, CE_NOTE, 42777c478bd9Sstevel@tonic-gate "NFS: failing over: selecting original server %s", 42787c478bd9Sstevel@tonic-gate svp->sv_hostname); 42797c478bd9Sstevel@tonic-gate #endif 42807c478bd9Sstevel@tonic-gate } else { 42817c478bd9Sstevel@tonic-gate #ifdef DEBUG 42827c478bd9Sstevel@tonic-gate zcmn_err(zoneid, CE_NOTE, 42837c478bd9Sstevel@tonic-gate "NFS%d: failing over from %s to %s", 42847c478bd9Sstevel@tonic-gate mi->mi_vers, 42857c478bd9Sstevel@tonic-gate mi->mi_curr_serv->sv_hostname, 42867c478bd9Sstevel@tonic-gate svp->sv_hostname); 42877c478bd9Sstevel@tonic-gate #else 42887c478bd9Sstevel@tonic-gate zcmn_err(zoneid, CE_NOTE, 42897c478bd9Sstevel@tonic-gate "NFS: failing over from %s to %s", 42907c478bd9Sstevel@tonic-gate mi->mi_curr_serv->sv_hostname, 42917c478bd9Sstevel@tonic-gate svp->sv_hostname); 42927c478bd9Sstevel@tonic-gate #endif 42937c478bd9Sstevel@tonic-gate } 42947c478bd9Sstevel@tonic-gate break; 42957c478bd9Sstevel@tonic-gate } 42967c478bd9Sstevel@tonic-gate } 42977c478bd9Sstevel@tonic-gate 42987c478bd9Sstevel@tonic-gate if (svp == NULL) { 42997c478bd9Sstevel@tonic-gate if (!oncethru) { 43007c478bd9Sstevel@tonic-gate srvnames = nfs_getsrvnames(mi, &srvnames_len); 43017c478bd9Sstevel@tonic-gate #ifdef DEBUG 43027c478bd9Sstevel@tonic-gate zprintf(zoneid, 43037c478bd9Sstevel@tonic-gate "NFS%d servers %s not responding " 43047c478bd9Sstevel@tonic-gate "still trying\n", mi->mi_vers, srvnames); 43057c478bd9Sstevel@tonic-gate #else 43067c478bd9Sstevel@tonic-gate zprintf(zoneid, "NFS servers %s not responding " 43077c478bd9Sstevel@tonic-gate "still trying\n", srvnames); 43087c478bd9Sstevel@tonic-gate #endif 43097c478bd9Sstevel@tonic-gate oncethru = 1; 43107c478bd9Sstevel@tonic-gate } 43117c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 43127c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 43137c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 43147c478bd9Sstevel@tonic-gate delay(hz); 43157c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 43167c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cprinfo, &mi->mi_lock); 43177c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 43187c478bd9Sstevel@tonic-gate } 43197c478bd9Sstevel@tonic-gate } 43207c478bd9Sstevel@tonic-gate 43217c478bd9Sstevel@tonic-gate if (oncethru) { 43227c478bd9Sstevel@tonic-gate #ifdef DEBUG 43237c478bd9Sstevel@tonic-gate zprintf(zoneid, "NFS%d servers %s ok\n", mi->mi_vers, srvnames); 43247c478bd9Sstevel@tonic-gate #else 43257c478bd9Sstevel@tonic-gate zprintf(zoneid, "NFS servers %s ok\n", srvnames); 43267c478bd9Sstevel@tonic-gate #endif 43277c478bd9Sstevel@tonic-gate } 43287c478bd9Sstevel@tonic-gate 43297c478bd9Sstevel@tonic-gate if (svp != mi->mi_curr_serv) { 43307c478bd9Sstevel@tonic-gate (void) dnlc_purge_vfsp(mi->mi_vfsp, 0); 43317c478bd9Sstevel@tonic-gate index = rtablehash(&mi->mi_curr_serv->sv_fhandle); 43327c478bd9Sstevel@tonic-gate rw_enter(&rtable[index].r_lock, RW_WRITER); 43337c478bd9Sstevel@tonic-gate rp = rfind(&rtable[index], &mi->mi_curr_serv->sv_fhandle, 43347c478bd9Sstevel@tonic-gate mi->mi_vfsp); 43357c478bd9Sstevel@tonic-gate if (rp != NULL) { 43367c478bd9Sstevel@tonic-gate if (rp->r_flags & RHASHED) 43377c478bd9Sstevel@tonic-gate rp_rmhash_locked(rp); 43387c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 43397c478bd9Sstevel@tonic-gate rp->r_server = svp; 43407c478bd9Sstevel@tonic-gate rp->r_fh = svp->sv_fhandle; 43417c478bd9Sstevel@tonic-gate (void) nfs_free_data_reclaim(rp); 43427c478bd9Sstevel@tonic-gate index = rtablehash(&rp->r_fh); 43437c478bd9Sstevel@tonic-gate rp->r_hashq = &rtable[index]; 43447c478bd9Sstevel@tonic-gate rw_enter(&rp->r_hashq->r_lock, RW_WRITER); 43457c478bd9Sstevel@tonic-gate vn_exists(RTOV(rp)); 43467c478bd9Sstevel@tonic-gate rp_addhash(rp); 43477c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 43487c478bd9Sstevel@tonic-gate VN_RELE(RTOV(rp)); 43497c478bd9Sstevel@tonic-gate } else 43507c478bd9Sstevel@tonic-gate rw_exit(&rtable[index].r_lock); 43517c478bd9Sstevel@tonic-gate } 43527c478bd9Sstevel@tonic-gate 43537c478bd9Sstevel@tonic-gate done: 43547c478bd9Sstevel@tonic-gate if (oncethru) 43557c478bd9Sstevel@tonic-gate kmem_free(srvnames, srvnames_len); 43567c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 43577c478bd9Sstevel@tonic-gate mi->mi_flags &= ~MI_BINDINPROG; 43587c478bd9Sstevel@tonic-gate if (svp != NULL) { 43597c478bd9Sstevel@tonic-gate mi->mi_curr_serv = svp; 43607c478bd9Sstevel@tonic-gate mi->mi_failover++; 43617c478bd9Sstevel@tonic-gate #ifdef DEBUG 43627c478bd9Sstevel@tonic-gate nfscl->nfscl_stat.failover.value.ui64++; 43637c478bd9Sstevel@tonic-gate #endif 43647c478bd9Sstevel@tonic-gate } 43657c478bd9Sstevel@tonic-gate cv_broadcast(&mi->mi_failover_cv); 43667c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cprinfo); 43677c478bd9Sstevel@tonic-gate VFS_RELE(mi->mi_vfsp); 43687c478bd9Sstevel@tonic-gate zthread_exit(); 43697c478bd9Sstevel@tonic-gate /* NOTREACHED */ 43707c478bd9Sstevel@tonic-gate } 43717c478bd9Sstevel@tonic-gate 43727c478bd9Sstevel@tonic-gate /* 43737c478bd9Sstevel@tonic-gate * NFS client failover support 43747c478bd9Sstevel@tonic-gate * 43757c478bd9Sstevel@tonic-gate * failover_wait() will put the thread to sleep until MI_BINDINPROG 43767c478bd9Sstevel@tonic-gate * is cleared, meaning that failover is complete. Called with 43777c478bd9Sstevel@tonic-gate * mi_lock mutex held. 43787c478bd9Sstevel@tonic-gate */ 43797c478bd9Sstevel@tonic-gate static int 43807c478bd9Sstevel@tonic-gate failover_wait(mntinfo_t *mi) 43817c478bd9Sstevel@tonic-gate { 43827c478bd9Sstevel@tonic-gate k_sigset_t smask; 43837c478bd9Sstevel@tonic-gate 43847c478bd9Sstevel@tonic-gate /* 43857c478bd9Sstevel@tonic-gate * If someone else is hunting for a living server, 43867c478bd9Sstevel@tonic-gate * sleep until it's done. After our sleep, we may 43877c478bd9Sstevel@tonic-gate * be bound to the right server and get off cheaply. 43887c478bd9Sstevel@tonic-gate */ 43897c478bd9Sstevel@tonic-gate while (mi->mi_flags & MI_BINDINPROG) { 43907c478bd9Sstevel@tonic-gate /* 43917c478bd9Sstevel@tonic-gate * Mask out all signals except SIGHUP, SIGINT, SIGQUIT 43927c478bd9Sstevel@tonic-gate * and SIGTERM. (Preserving the existing masks). 43937c478bd9Sstevel@tonic-gate * Mask out SIGINT if mount option nointr is specified. 43947c478bd9Sstevel@tonic-gate */ 43957c478bd9Sstevel@tonic-gate sigintr(&smask, (int)mi->mi_flags & MI_INT); 43967c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&mi->mi_failover_cv, &mi->mi_lock)) { 43977c478bd9Sstevel@tonic-gate /* 43987c478bd9Sstevel@tonic-gate * restore original signal mask 43997c478bd9Sstevel@tonic-gate */ 44007c478bd9Sstevel@tonic-gate sigunintr(&smask); 44017c478bd9Sstevel@tonic-gate return (EINTR); 44027c478bd9Sstevel@tonic-gate } 44037c478bd9Sstevel@tonic-gate /* 44047c478bd9Sstevel@tonic-gate * restore original signal mask 44057c478bd9Sstevel@tonic-gate */ 44067c478bd9Sstevel@tonic-gate sigunintr(&smask); 44077c478bd9Sstevel@tonic-gate } 44087c478bd9Sstevel@tonic-gate return (0); 44097c478bd9Sstevel@tonic-gate } 44107c478bd9Sstevel@tonic-gate 44117c478bd9Sstevel@tonic-gate /* 44127c478bd9Sstevel@tonic-gate * NFS client failover support 44137c478bd9Sstevel@tonic-gate * 44147c478bd9Sstevel@tonic-gate * failover_remap() will do a partial pathname lookup and find the 44157c478bd9Sstevel@tonic-gate * desired vnode on the current server. The interim vnode will be 44167c478bd9Sstevel@tonic-gate * discarded after we pilfer the new filehandle. 44177c478bd9Sstevel@tonic-gate * 44187c478bd9Sstevel@tonic-gate * Side effects: 44197c478bd9Sstevel@tonic-gate * - This routine will also update the filehandle in the args structure 44207c478bd9Sstevel@tonic-gate * pointed to by the fi->fhp pointer if it is non-NULL. 44217c478bd9Sstevel@tonic-gate */ 44227c478bd9Sstevel@tonic-gate 44237c478bd9Sstevel@tonic-gate static int 44247c478bd9Sstevel@tonic-gate failover_remap(failinfo_t *fi) 44257c478bd9Sstevel@tonic-gate { 44267c478bd9Sstevel@tonic-gate vnode_t *vp, *nvp, *rootvp; 44277c478bd9Sstevel@tonic-gate rnode_t *rp, *nrp; 44287c478bd9Sstevel@tonic-gate mntinfo_t *mi; 44297c478bd9Sstevel@tonic-gate int error; 44307c478bd9Sstevel@tonic-gate int index; 44317c478bd9Sstevel@tonic-gate #ifdef DEBUG 44327c478bd9Sstevel@tonic-gate struct nfs_clnt *nfscl; 44337c478bd9Sstevel@tonic-gate 4434*108322fbScarlsonj nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone()); 44357c478bd9Sstevel@tonic-gate ASSERT(nfscl != NULL); 44367c478bd9Sstevel@tonic-gate #endif 44377c478bd9Sstevel@tonic-gate /* 44387c478bd9Sstevel@tonic-gate * Sanity check 44397c478bd9Sstevel@tonic-gate */ 44407c478bd9Sstevel@tonic-gate if (fi == NULL || fi->vp == NULL || fi->lookupproc == NULL) 44417c478bd9Sstevel@tonic-gate return (EINVAL); 44427c478bd9Sstevel@tonic-gate vp = fi->vp; 44437c478bd9Sstevel@tonic-gate rp = VTOR(vp); 44447c478bd9Sstevel@tonic-gate mi = VTOMI(vp); 44457c478bd9Sstevel@tonic-gate 44467c478bd9Sstevel@tonic-gate if (!(vp->v_flag & VROOT)) { 44477c478bd9Sstevel@tonic-gate /* 44487c478bd9Sstevel@tonic-gate * Given the root fh, use the path stored in 44497c478bd9Sstevel@tonic-gate * the rnode to find the fh for the new server. 44507c478bd9Sstevel@tonic-gate */ 44517c478bd9Sstevel@tonic-gate error = VFS_ROOT(mi->mi_vfsp, &rootvp); 44527c478bd9Sstevel@tonic-gate if (error) 44537c478bd9Sstevel@tonic-gate return (error); 44547c478bd9Sstevel@tonic-gate 44557c478bd9Sstevel@tonic-gate error = failover_lookup(rp->r_path, rootvp, 44567c478bd9Sstevel@tonic-gate fi->lookupproc, fi->xattrdirproc, &nvp); 44577c478bd9Sstevel@tonic-gate 44587c478bd9Sstevel@tonic-gate VN_RELE(rootvp); 44597c478bd9Sstevel@tonic-gate 44607c478bd9Sstevel@tonic-gate if (error) 44617c478bd9Sstevel@tonic-gate return (error); 44627c478bd9Sstevel@tonic-gate 44637c478bd9Sstevel@tonic-gate /* 44647c478bd9Sstevel@tonic-gate * If we found the same rnode, we're done now 44657c478bd9Sstevel@tonic-gate */ 44667c478bd9Sstevel@tonic-gate if (nvp == vp) { 44677c478bd9Sstevel@tonic-gate /* 44687c478bd9Sstevel@tonic-gate * Failed and the new server may physically be same 44697c478bd9Sstevel@tonic-gate * OR may share a same disk subsystem. In this case 44707c478bd9Sstevel@tonic-gate * file handle for a particular file path is not going 44717c478bd9Sstevel@tonic-gate * to change, given the same filehandle lookup will 44727c478bd9Sstevel@tonic-gate * always locate the same rnode as the existing one. 44737c478bd9Sstevel@tonic-gate * All we might need to do is to update the r_server 44747c478bd9Sstevel@tonic-gate * with the current servinfo. 44757c478bd9Sstevel@tonic-gate */ 44767c478bd9Sstevel@tonic-gate if (!VALID_FH(fi)) { 44777c478bd9Sstevel@tonic-gate rp->r_server = mi->mi_curr_serv; 44787c478bd9Sstevel@tonic-gate } 44797c478bd9Sstevel@tonic-gate VN_RELE(nvp); 44807c478bd9Sstevel@tonic-gate return (0); 44817c478bd9Sstevel@tonic-gate } 44827c478bd9Sstevel@tonic-gate 44837c478bd9Sstevel@tonic-gate /* 44847c478bd9Sstevel@tonic-gate * Try to make it so that no one else will find this 44857c478bd9Sstevel@tonic-gate * vnode because it is just a temporary to hold the 44867c478bd9Sstevel@tonic-gate * new file handle until that file handle can be 44877c478bd9Sstevel@tonic-gate * copied to the original vnode/rnode. 44887c478bd9Sstevel@tonic-gate */ 44897c478bd9Sstevel@tonic-gate nrp = VTOR(nvp); 44907c478bd9Sstevel@tonic-gate if (nrp->r_flags & RHASHED) 44917c478bd9Sstevel@tonic-gate rp_rmhash(nrp); 44927c478bd9Sstevel@tonic-gate 44937c478bd9Sstevel@tonic-gate /* 44947c478bd9Sstevel@tonic-gate * As a heuristic check on the validity of the new 44957c478bd9Sstevel@tonic-gate * file, check that the size and type match against 44967c478bd9Sstevel@tonic-gate * that we remember from the old version. 44977c478bd9Sstevel@tonic-gate */ 44987c478bd9Sstevel@tonic-gate if (rp->r_size != nrp->r_size || vp->v_type != nvp->v_type) { 44997c478bd9Sstevel@tonic-gate zcmn_err(mi->mi_zone->zone_id, CE_WARN, 45007c478bd9Sstevel@tonic-gate "NFS replicas %s and %s: file %s not same.", 45017c478bd9Sstevel@tonic-gate rp->r_server->sv_hostname, 45027c478bd9Sstevel@tonic-gate nrp->r_server->sv_hostname, rp->r_path); 45037c478bd9Sstevel@tonic-gate VN_RELE(nvp); 45047c478bd9Sstevel@tonic-gate return (EINVAL); 45057c478bd9Sstevel@tonic-gate } 45067c478bd9Sstevel@tonic-gate 45077c478bd9Sstevel@tonic-gate /* 45087c478bd9Sstevel@tonic-gate * snarf the filehandle from the new rnode 45097c478bd9Sstevel@tonic-gate * then release it, again while updating the 45107c478bd9Sstevel@tonic-gate * hash queues for the rnode. 45117c478bd9Sstevel@tonic-gate */ 45127c478bd9Sstevel@tonic-gate if (rp->r_flags & RHASHED) 45137c478bd9Sstevel@tonic-gate rp_rmhash(rp); 45147c478bd9Sstevel@tonic-gate rp->r_server = mi->mi_curr_serv; 45157c478bd9Sstevel@tonic-gate rp->r_fh = nrp->r_fh; 45167c478bd9Sstevel@tonic-gate index = rtablehash(&rp->r_fh); 45177c478bd9Sstevel@tonic-gate rp->r_hashq = &rtable[index]; 45187c478bd9Sstevel@tonic-gate /* 45197c478bd9Sstevel@tonic-gate * Copy the attributes from the new rnode to the old 45207c478bd9Sstevel@tonic-gate * rnode. This will help to reduce unnecessary page 45217c478bd9Sstevel@tonic-gate * cache flushes. 45227c478bd9Sstevel@tonic-gate */ 45237c478bd9Sstevel@tonic-gate rp->r_attr = nrp->r_attr; 45247c478bd9Sstevel@tonic-gate rp->r_attrtime = nrp->r_attrtime; 45257c478bd9Sstevel@tonic-gate rp->r_mtime = nrp->r_mtime; 45267c478bd9Sstevel@tonic-gate (void) nfs_free_data_reclaim(rp); 45277c478bd9Sstevel@tonic-gate nfs_setswaplike(vp, &rp->r_attr); 45287c478bd9Sstevel@tonic-gate rw_enter(&rp->r_hashq->r_lock, RW_WRITER); 45297c478bd9Sstevel@tonic-gate rp_addhash(rp); 45307c478bd9Sstevel@tonic-gate rw_exit(&rp->r_hashq->r_lock); 45317c478bd9Sstevel@tonic-gate VN_RELE(nvp); 45327c478bd9Sstevel@tonic-gate } 45337c478bd9Sstevel@tonic-gate 45347c478bd9Sstevel@tonic-gate /* 45357c478bd9Sstevel@tonic-gate * Update successful failover remap count 45367c478bd9Sstevel@tonic-gate */ 45377c478bd9Sstevel@tonic-gate mutex_enter(&mi->mi_lock); 45387c478bd9Sstevel@tonic-gate mi->mi_remap++; 45397c478bd9Sstevel@tonic-gate mutex_exit(&mi->mi_lock); 45407c478bd9Sstevel@tonic-gate #ifdef DEBUG 45417c478bd9Sstevel@tonic-gate nfscl->nfscl_stat.remap.value.ui64++; 45427c478bd9Sstevel@tonic-gate #endif 45437c478bd9Sstevel@tonic-gate 45447c478bd9Sstevel@tonic-gate /* 45457c478bd9Sstevel@tonic-gate * If we have a copied filehandle to update, do it now. 45467c478bd9Sstevel@tonic-gate */ 45477c478bd9Sstevel@tonic-gate if (fi->fhp != NULL && fi->copyproc != NULL) 45487c478bd9Sstevel@tonic-gate (*fi->copyproc)(fi->fhp, vp); 45497c478bd9Sstevel@tonic-gate 45507c478bd9Sstevel@tonic-gate return (0); 45517c478bd9Sstevel@tonic-gate } 45527c478bd9Sstevel@tonic-gate 45537c478bd9Sstevel@tonic-gate /* 45547c478bd9Sstevel@tonic-gate * NFS client failover support 45557c478bd9Sstevel@tonic-gate * 45567c478bd9Sstevel@tonic-gate * We want a simple pathname lookup routine to parse the pieces 45577c478bd9Sstevel@tonic-gate * of path in rp->r_path. We know that the path was a created 45587c478bd9Sstevel@tonic-gate * as rnodes were made, so we know we have only to deal with 45597c478bd9Sstevel@tonic-gate * paths that look like: 45607c478bd9Sstevel@tonic-gate * dir1/dir2/dir3/file 45617c478bd9Sstevel@tonic-gate * Any evidence of anything like .., symlinks, and ENOTDIR 45627c478bd9Sstevel@tonic-gate * are hard errors, because they mean something in this filesystem 45637c478bd9Sstevel@tonic-gate * is different from the one we came from, or has changed under 45647c478bd9Sstevel@tonic-gate * us in some way. If this is true, we want the failure. 45657c478bd9Sstevel@tonic-gate * 45667c478bd9Sstevel@tonic-gate * Extended attributes: if the filesystem is mounted with extended 45677c478bd9Sstevel@tonic-gate * attributes enabled (-o xattr), the attribute directory will be 45687c478bd9Sstevel@tonic-gate * represented in the r_path as the magic name XATTR_RPATH. So if 45697c478bd9Sstevel@tonic-gate * we see that name in the pathname, is must be because this node 45707c478bd9Sstevel@tonic-gate * is an extended attribute. Therefore, look it up that way. 45717c478bd9Sstevel@tonic-gate */ 45727c478bd9Sstevel@tonic-gate static int 45737c478bd9Sstevel@tonic-gate failover_lookup(char *path, vnode_t *root, 45747c478bd9Sstevel@tonic-gate int (*lookupproc)(vnode_t *, char *, vnode_t **, struct pathname *, int, 45757c478bd9Sstevel@tonic-gate vnode_t *, cred_t *, int), 45767c478bd9Sstevel@tonic-gate int (*xattrdirproc)(vnode_t *, vnode_t **, bool_t, cred_t *, int), 45777c478bd9Sstevel@tonic-gate vnode_t **new) 45787c478bd9Sstevel@tonic-gate { 45797c478bd9Sstevel@tonic-gate vnode_t *dvp, *nvp; 45807c478bd9Sstevel@tonic-gate int error = EINVAL; 45817c478bd9Sstevel@tonic-gate char *s, *p, *tmppath; 45827c478bd9Sstevel@tonic-gate size_t len; 45837c478bd9Sstevel@tonic-gate mntinfo_t *mi; 45847c478bd9Sstevel@tonic-gate bool_t xattr; 45857c478bd9Sstevel@tonic-gate 45867c478bd9Sstevel@tonic-gate /* Make local copy of path */ 45877c478bd9Sstevel@tonic-gate len = strlen(path) + 1; 45887c478bd9Sstevel@tonic-gate tmppath = kmem_alloc(len, KM_SLEEP); 45897c478bd9Sstevel@tonic-gate (void) strcpy(tmppath, path); 45907c478bd9Sstevel@tonic-gate s = tmppath; 45917c478bd9Sstevel@tonic-gate 45927c478bd9Sstevel@tonic-gate dvp = root; 45937c478bd9Sstevel@tonic-gate VN_HOLD(dvp); 45947c478bd9Sstevel@tonic-gate mi = VTOMI(root); 45957c478bd9Sstevel@tonic-gate xattr = mi->mi_flags & MI_EXTATTR; 45967c478bd9Sstevel@tonic-gate 45977c478bd9Sstevel@tonic-gate do { 45987c478bd9Sstevel@tonic-gate p = strchr(s, '/'); 45997c478bd9Sstevel@tonic-gate if (p != NULL) 46007c478bd9Sstevel@tonic-gate *p = '\0'; 46017c478bd9Sstevel@tonic-gate if (xattr && strcmp(s, XATTR_RPATH) == 0) { 46027c478bd9Sstevel@tonic-gate error = (*xattrdirproc)(dvp, &nvp, FALSE, CRED(), 46037c478bd9Sstevel@tonic-gate RFSCALL_SOFT); 46047c478bd9Sstevel@tonic-gate } else { 46057c478bd9Sstevel@tonic-gate error = (*lookupproc)(dvp, s, &nvp, NULL, 0, NULL, 46067c478bd9Sstevel@tonic-gate CRED(), RFSCALL_SOFT); 46077c478bd9Sstevel@tonic-gate } 46087c478bd9Sstevel@tonic-gate if (p != NULL) 46097c478bd9Sstevel@tonic-gate *p++ = '/'; 46107c478bd9Sstevel@tonic-gate if (error) { 46117c478bd9Sstevel@tonic-gate VN_RELE(dvp); 46127c478bd9Sstevel@tonic-gate kmem_free(tmppath, len); 46137c478bd9Sstevel@tonic-gate return (error); 46147c478bd9Sstevel@tonic-gate } 46157c478bd9Sstevel@tonic-gate s = p; 46167c478bd9Sstevel@tonic-gate VN_RELE(dvp); 46177c478bd9Sstevel@tonic-gate dvp = nvp; 46187c478bd9Sstevel@tonic-gate } while (p != NULL); 46197c478bd9Sstevel@tonic-gate 46207c478bd9Sstevel@tonic-gate if (nvp != NULL && new != NULL) 46217c478bd9Sstevel@tonic-gate *new = nvp; 46227c478bd9Sstevel@tonic-gate kmem_free(tmppath, len); 46237c478bd9Sstevel@tonic-gate return (0); 46247c478bd9Sstevel@tonic-gate } 46257c478bd9Sstevel@tonic-gate 46267c478bd9Sstevel@tonic-gate /* 46277c478bd9Sstevel@tonic-gate * NFS client failover support 46287c478bd9Sstevel@tonic-gate * 46297c478bd9Sstevel@tonic-gate * sv_free() frees the malloc'd portion of a "servinfo_t". 46307c478bd9Sstevel@tonic-gate */ 46317c478bd9Sstevel@tonic-gate void 46327c478bd9Sstevel@tonic-gate sv_free(servinfo_t *svp) 46337c478bd9Sstevel@tonic-gate { 46347c478bd9Sstevel@tonic-gate servinfo_t *next; 46357c478bd9Sstevel@tonic-gate struct knetconfig *knconf; 46367c478bd9Sstevel@tonic-gate 46377c478bd9Sstevel@tonic-gate while (svp != NULL) { 46387c478bd9Sstevel@tonic-gate next = svp->sv_next; 46397c478bd9Sstevel@tonic-gate if (svp->sv_secdata) 46407c478bd9Sstevel@tonic-gate sec_clnt_freeinfo(svp->sv_secdata); 46417c478bd9Sstevel@tonic-gate if (svp->sv_hostname && svp->sv_hostnamelen > 0) 46427c478bd9Sstevel@tonic-gate kmem_free(svp->sv_hostname, svp->sv_hostnamelen); 46437c478bd9Sstevel@tonic-gate knconf = svp->sv_knconf; 46447c478bd9Sstevel@tonic-gate if (knconf != NULL) { 46457c478bd9Sstevel@tonic-gate if (knconf->knc_protofmly != NULL) 46467c478bd9Sstevel@tonic-gate kmem_free(knconf->knc_protofmly, KNC_STRSIZE); 46477c478bd9Sstevel@tonic-gate if (knconf->knc_proto != NULL) 46487c478bd9Sstevel@tonic-gate kmem_free(knconf->knc_proto, KNC_STRSIZE); 46497c478bd9Sstevel@tonic-gate kmem_free(knconf, sizeof (*knconf)); 46507c478bd9Sstevel@tonic-gate } 46517c478bd9Sstevel@tonic-gate knconf = svp->sv_origknconf; 46527c478bd9Sstevel@tonic-gate if (knconf != NULL) { 46537c478bd9Sstevel@tonic-gate if (knconf->knc_protofmly != NULL) 46547c478bd9Sstevel@tonic-gate kmem_free(knconf->knc_protofmly, KNC_STRSIZE); 46557c478bd9Sstevel@tonic-gate if (knconf->knc_proto != NULL) 46567c478bd9Sstevel@tonic-gate kmem_free(knconf->knc_proto, KNC_STRSIZE); 46577c478bd9Sstevel@tonic-gate kmem_free(knconf, sizeof (*knconf)); 46587c478bd9Sstevel@tonic-gate } 46597c478bd9Sstevel@tonic-gate if (svp->sv_addr.buf != NULL && svp->sv_addr.maxlen != 0) 46607c478bd9Sstevel@tonic-gate kmem_free(svp->sv_addr.buf, svp->sv_addr.maxlen); 46617c478bd9Sstevel@tonic-gate mutex_destroy(&svp->sv_lock); 46627c478bd9Sstevel@tonic-gate kmem_free(svp, sizeof (*svp)); 46637c478bd9Sstevel@tonic-gate svp = next; 46647c478bd9Sstevel@tonic-gate } 46657c478bd9Sstevel@tonic-gate } 46667c478bd9Sstevel@tonic-gate 46677c478bd9Sstevel@tonic-gate /* 46687c478bd9Sstevel@tonic-gate * Only can return non-zero if intr != 0. 46697c478bd9Sstevel@tonic-gate */ 46707c478bd9Sstevel@tonic-gate int 46717c478bd9Sstevel@tonic-gate nfs_rw_enter_sig(nfs_rwlock_t *l, krw_t rw, int intr) 46727c478bd9Sstevel@tonic-gate { 46737c478bd9Sstevel@tonic-gate 46747c478bd9Sstevel@tonic-gate mutex_enter(&l->lock); 46757c478bd9Sstevel@tonic-gate 46767c478bd9Sstevel@tonic-gate /* 46777c478bd9Sstevel@tonic-gate * If this is a nested enter, then allow it. There 46787c478bd9Sstevel@tonic-gate * must be as many exits as enters through. 46797c478bd9Sstevel@tonic-gate */ 46807c478bd9Sstevel@tonic-gate if (l->owner == curthread) { 46817c478bd9Sstevel@tonic-gate /* lock is held for writing by current thread */ 46827c478bd9Sstevel@tonic-gate ASSERT(rw == RW_READER || rw == RW_WRITER); 46837c478bd9Sstevel@tonic-gate l->count--; 46847c478bd9Sstevel@tonic-gate } else if (rw == RW_READER) { 46857c478bd9Sstevel@tonic-gate /* 46867c478bd9Sstevel@tonic-gate * While there is a writer active or writers waiting, 46877c478bd9Sstevel@tonic-gate * then wait for them to finish up and move on. Then, 46887c478bd9Sstevel@tonic-gate * increment the count to indicate that a reader is 46897c478bd9Sstevel@tonic-gate * active. 46907c478bd9Sstevel@tonic-gate */ 46917c478bd9Sstevel@tonic-gate while (l->count < 0 || l->waiters > 0) { 46927c478bd9Sstevel@tonic-gate if (intr) { 46937c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread); 46947c478bd9Sstevel@tonic-gate 46957c478bd9Sstevel@tonic-gate if (lwp != NULL) 46967c478bd9Sstevel@tonic-gate lwp->lwp_nostop++; 46977c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&l->cv, &l->lock)) { 46987c478bd9Sstevel@tonic-gate if (lwp != NULL) 46997c478bd9Sstevel@tonic-gate lwp->lwp_nostop--; 47007c478bd9Sstevel@tonic-gate mutex_exit(&l->lock); 47017c478bd9Sstevel@tonic-gate return (EINTR); 47027c478bd9Sstevel@tonic-gate } 47037c478bd9Sstevel@tonic-gate if (lwp != NULL) 47047c478bd9Sstevel@tonic-gate lwp->lwp_nostop--; 47057c478bd9Sstevel@tonic-gate } else 47067c478bd9Sstevel@tonic-gate cv_wait(&l->cv, &l->lock); 47077c478bd9Sstevel@tonic-gate } 47087c478bd9Sstevel@tonic-gate ASSERT(l->count < INT_MAX); 47097c478bd9Sstevel@tonic-gate #ifdef DEBUG 47107c478bd9Sstevel@tonic-gate if ((l->count % 10000) == 9999) 47117c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "nfs_rw_enter_sig: count %d on" 47127c478bd9Sstevel@tonic-gate "rwlock @ %p\n", l->count, (void *)&l); 47137c478bd9Sstevel@tonic-gate #endif 47147c478bd9Sstevel@tonic-gate l->count++; 47157c478bd9Sstevel@tonic-gate } else { 47167c478bd9Sstevel@tonic-gate ASSERT(rw == RW_WRITER); 47177c478bd9Sstevel@tonic-gate /* 47187c478bd9Sstevel@tonic-gate * While there are readers active or a writer 47197c478bd9Sstevel@tonic-gate * active, then wait for all of the readers 47207c478bd9Sstevel@tonic-gate * to finish or for the writer to finish. 47217c478bd9Sstevel@tonic-gate * Then, set the owner field to curthread and 47227c478bd9Sstevel@tonic-gate * decrement count to indicate that a writer 47237c478bd9Sstevel@tonic-gate * is active. 47247c478bd9Sstevel@tonic-gate */ 47257c478bd9Sstevel@tonic-gate while (l->count > 0 || l->owner != NULL) { 47267c478bd9Sstevel@tonic-gate l->waiters++; 47277c478bd9Sstevel@tonic-gate if (intr) { 47287c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread); 47297c478bd9Sstevel@tonic-gate 47307c478bd9Sstevel@tonic-gate if (lwp != NULL) 47317c478bd9Sstevel@tonic-gate lwp->lwp_nostop++; 47327c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&l->cv, &l->lock)) { 47337c478bd9Sstevel@tonic-gate if (lwp != NULL) 47347c478bd9Sstevel@tonic-gate lwp->lwp_nostop--; 47357c478bd9Sstevel@tonic-gate l->waiters--; 47367c478bd9Sstevel@tonic-gate cv_broadcast(&l->cv); 47377c478bd9Sstevel@tonic-gate mutex_exit(&l->lock); 47387c478bd9Sstevel@tonic-gate return (EINTR); 47397c478bd9Sstevel@tonic-gate } 47407c478bd9Sstevel@tonic-gate if (lwp != NULL) 47417c478bd9Sstevel@tonic-gate lwp->lwp_nostop--; 47427c478bd9Sstevel@tonic-gate } else 47437c478bd9Sstevel@tonic-gate cv_wait(&l->cv, &l->lock); 47447c478bd9Sstevel@tonic-gate l->waiters--; 47457c478bd9Sstevel@tonic-gate } 47467c478bd9Sstevel@tonic-gate l->owner = curthread; 47477c478bd9Sstevel@tonic-gate l->count--; 47487c478bd9Sstevel@tonic-gate } 47497c478bd9Sstevel@tonic-gate 47507c478bd9Sstevel@tonic-gate mutex_exit(&l->lock); 47517c478bd9Sstevel@tonic-gate 47527c478bd9Sstevel@tonic-gate return (0); 47537c478bd9Sstevel@tonic-gate } 47547c478bd9Sstevel@tonic-gate 47557c478bd9Sstevel@tonic-gate /* 47567c478bd9Sstevel@tonic-gate * If the lock is available, obtain it and return non-zero. If there is 47577c478bd9Sstevel@tonic-gate * already a conflicting lock, return 0 immediately. 47587c478bd9Sstevel@tonic-gate */ 47597c478bd9Sstevel@tonic-gate 47607c478bd9Sstevel@tonic-gate int 47617c478bd9Sstevel@tonic-gate nfs_rw_tryenter(nfs_rwlock_t *l, krw_t rw) 47627c478bd9Sstevel@tonic-gate { 47637c478bd9Sstevel@tonic-gate mutex_enter(&l->lock); 47647c478bd9Sstevel@tonic-gate 47657c478bd9Sstevel@tonic-gate /* 47667c478bd9Sstevel@tonic-gate * If this is a nested enter, then allow it. There 47677c478bd9Sstevel@tonic-gate * must be as many exits as enters through. 47687c478bd9Sstevel@tonic-gate */ 47697c478bd9Sstevel@tonic-gate if (l->owner == curthread) { 47707c478bd9Sstevel@tonic-gate /* lock is held for writing by current thread */ 47717c478bd9Sstevel@tonic-gate ASSERT(rw == RW_READER || rw == RW_WRITER); 47727c478bd9Sstevel@tonic-gate l->count--; 47737c478bd9Sstevel@tonic-gate } else if (rw == RW_READER) { 47747c478bd9Sstevel@tonic-gate /* 47757c478bd9Sstevel@tonic-gate * If there is a writer active or writers waiting, deny the 47767c478bd9Sstevel@tonic-gate * lock. Otherwise, bump the count of readers. 47777c478bd9Sstevel@tonic-gate */ 47787c478bd9Sstevel@tonic-gate if (l->count < 0 || l->waiters > 0) { 47797c478bd9Sstevel@tonic-gate mutex_exit(&l->lock); 47807c478bd9Sstevel@tonic-gate return (0); 47817c478bd9Sstevel@tonic-gate } 47827c478bd9Sstevel@tonic-gate l->count++; 47837c478bd9Sstevel@tonic-gate } else { 47847c478bd9Sstevel@tonic-gate ASSERT(rw == RW_WRITER); 47857c478bd9Sstevel@tonic-gate /* 47867c478bd9Sstevel@tonic-gate * If there are readers active or a writer active, deny the 47877c478bd9Sstevel@tonic-gate * lock. Otherwise, set the owner field to curthread and 47887c478bd9Sstevel@tonic-gate * decrement count to indicate that a writer is active. 47897c478bd9Sstevel@tonic-gate */ 47907c478bd9Sstevel@tonic-gate if (l->count > 0 || l->owner != NULL) { 47917c478bd9Sstevel@tonic-gate mutex_exit(&l->lock); 47927c478bd9Sstevel@tonic-gate return (0); 47937c478bd9Sstevel@tonic-gate } 47947c478bd9Sstevel@tonic-gate l->owner = curthread; 47957c478bd9Sstevel@tonic-gate l->count--; 47967c478bd9Sstevel@tonic-gate } 47977c478bd9Sstevel@tonic-gate 47987c478bd9Sstevel@tonic-gate mutex_exit(&l->lock); 47997c478bd9Sstevel@tonic-gate 48007c478bd9Sstevel@tonic-gate return (1); 48017c478bd9Sstevel@tonic-gate } 48027c478bd9Sstevel@tonic-gate 48037c478bd9Sstevel@tonic-gate void 48047c478bd9Sstevel@tonic-gate nfs_rw_exit(nfs_rwlock_t *l) 48057c478bd9Sstevel@tonic-gate { 48067c478bd9Sstevel@tonic-gate 48077c478bd9Sstevel@tonic-gate mutex_enter(&l->lock); 48087c478bd9Sstevel@tonic-gate /* 48097c478bd9Sstevel@tonic-gate * If this is releasing a writer lock, then increment count to 48107c478bd9Sstevel@tonic-gate * indicate that there is one less writer active. If this was 48117c478bd9Sstevel@tonic-gate * the last of possibly nested writer locks, then clear the owner 48127c478bd9Sstevel@tonic-gate * field as well to indicate that there is no writer active 48137c478bd9Sstevel@tonic-gate * and wakeup any possible waiting writers or readers. 48147c478bd9Sstevel@tonic-gate * 48157c478bd9Sstevel@tonic-gate * If releasing a reader lock, then just decrement count to 48167c478bd9Sstevel@tonic-gate * indicate that there is one less reader active. If this was 48177c478bd9Sstevel@tonic-gate * the last active reader and there are writer(s) waiting, 48187c478bd9Sstevel@tonic-gate * then wake up the first. 48197c478bd9Sstevel@tonic-gate */ 48207c478bd9Sstevel@tonic-gate if (l->owner != NULL) { 48217c478bd9Sstevel@tonic-gate ASSERT(l->owner == curthread); 48227c478bd9Sstevel@tonic-gate l->count++; 48237c478bd9Sstevel@tonic-gate if (l->count == 0) { 48247c478bd9Sstevel@tonic-gate l->owner = NULL; 48257c478bd9Sstevel@tonic-gate cv_broadcast(&l->cv); 48267c478bd9Sstevel@tonic-gate } 48277c478bd9Sstevel@tonic-gate } else { 48287c478bd9Sstevel@tonic-gate ASSERT(l->count > 0); 48297c478bd9Sstevel@tonic-gate l->count--; 48307c478bd9Sstevel@tonic-gate if (l->count == 0 && l->waiters > 0) 48317c478bd9Sstevel@tonic-gate cv_broadcast(&l->cv); 48327c478bd9Sstevel@tonic-gate } 48337c478bd9Sstevel@tonic-gate mutex_exit(&l->lock); 48347c478bd9Sstevel@tonic-gate } 48357c478bd9Sstevel@tonic-gate 48367c478bd9Sstevel@tonic-gate int 48377c478bd9Sstevel@tonic-gate nfs_rw_lock_held(nfs_rwlock_t *l, krw_t rw) 48387c478bd9Sstevel@tonic-gate { 48397c478bd9Sstevel@tonic-gate 48407c478bd9Sstevel@tonic-gate if (rw == RW_READER) 48417c478bd9Sstevel@tonic-gate return (l->count > 0); 48427c478bd9Sstevel@tonic-gate ASSERT(rw == RW_WRITER); 48437c478bd9Sstevel@tonic-gate return (l->count < 0); 48447c478bd9Sstevel@tonic-gate } 48457c478bd9Sstevel@tonic-gate 48467c478bd9Sstevel@tonic-gate /* ARGSUSED */ 48477c478bd9Sstevel@tonic-gate void 48487c478bd9Sstevel@tonic-gate nfs_rw_init(nfs_rwlock_t *l, char *name, krw_type_t type, void *arg) 48497c478bd9Sstevel@tonic-gate { 48507c478bd9Sstevel@tonic-gate 48517c478bd9Sstevel@tonic-gate l->count = 0; 48527c478bd9Sstevel@tonic-gate l->waiters = 0; 48537c478bd9Sstevel@tonic-gate l->owner = NULL; 48547c478bd9Sstevel@tonic-gate mutex_init(&l->lock, NULL, MUTEX_DEFAULT, NULL); 48557c478bd9Sstevel@tonic-gate cv_init(&l->cv, NULL, CV_DEFAULT, NULL); 48567c478bd9Sstevel@tonic-gate } 48577c478bd9Sstevel@tonic-gate 48587c478bd9Sstevel@tonic-gate void 48597c478bd9Sstevel@tonic-gate nfs_rw_destroy(nfs_rwlock_t *l) 48607c478bd9Sstevel@tonic-gate { 48617c478bd9Sstevel@tonic-gate 48627c478bd9Sstevel@tonic-gate mutex_destroy(&l->lock); 48637c478bd9Sstevel@tonic-gate cv_destroy(&l->cv); 48647c478bd9Sstevel@tonic-gate } 48657c478bd9Sstevel@tonic-gate 48667c478bd9Sstevel@tonic-gate int 48677c478bd9Sstevel@tonic-gate nfs3_rddir_compar(const void *x, const void *y) 48687c478bd9Sstevel@tonic-gate { 48697c478bd9Sstevel@tonic-gate rddir_cache *a = (rddir_cache *)x; 48707c478bd9Sstevel@tonic-gate rddir_cache *b = (rddir_cache *)y; 48717c478bd9Sstevel@tonic-gate 48727c478bd9Sstevel@tonic-gate if (a->nfs3_cookie == b->nfs3_cookie) { 48737c478bd9Sstevel@tonic-gate if (a->buflen == b->buflen) 48747c478bd9Sstevel@tonic-gate return (0); 48757c478bd9Sstevel@tonic-gate if (a->buflen < b->buflen) 48767c478bd9Sstevel@tonic-gate return (-1); 48777c478bd9Sstevel@tonic-gate return (1); 48787c478bd9Sstevel@tonic-gate } 48797c478bd9Sstevel@tonic-gate 48807c478bd9Sstevel@tonic-gate if (a->nfs3_cookie < b->nfs3_cookie) 48817c478bd9Sstevel@tonic-gate return (-1); 48827c478bd9Sstevel@tonic-gate 48837c478bd9Sstevel@tonic-gate return (1); 48847c478bd9Sstevel@tonic-gate } 48857c478bd9Sstevel@tonic-gate 48867c478bd9Sstevel@tonic-gate int 48877c478bd9Sstevel@tonic-gate nfs_rddir_compar(const void *x, const void *y) 48887c478bd9Sstevel@tonic-gate { 48897c478bd9Sstevel@tonic-gate rddir_cache *a = (rddir_cache *)x; 48907c478bd9Sstevel@tonic-gate rddir_cache *b = (rddir_cache *)y; 48917c478bd9Sstevel@tonic-gate 48927c478bd9Sstevel@tonic-gate if (a->nfs_cookie == b->nfs_cookie) { 48937c478bd9Sstevel@tonic-gate if (a->buflen == b->buflen) 48947c478bd9Sstevel@tonic-gate return (0); 48957c478bd9Sstevel@tonic-gate if (a->buflen < b->buflen) 48967c478bd9Sstevel@tonic-gate return (-1); 48977c478bd9Sstevel@tonic-gate return (1); 48987c478bd9Sstevel@tonic-gate } 48997c478bd9Sstevel@tonic-gate 49007c478bd9Sstevel@tonic-gate if (a->nfs_cookie < b->nfs_cookie) 49017c478bd9Sstevel@tonic-gate return (-1); 49027c478bd9Sstevel@tonic-gate 49037c478bd9Sstevel@tonic-gate return (1); 49047c478bd9Sstevel@tonic-gate } 49057c478bd9Sstevel@tonic-gate 49067c478bd9Sstevel@tonic-gate static char * 49077c478bd9Sstevel@tonic-gate nfs_getsrvnames(mntinfo_t *mi, size_t *len) 49087c478bd9Sstevel@tonic-gate { 49097c478bd9Sstevel@tonic-gate servinfo_t *s; 49107c478bd9Sstevel@tonic-gate char *srvnames; 49117c478bd9Sstevel@tonic-gate char *namep; 49127c478bd9Sstevel@tonic-gate size_t length; 49137c478bd9Sstevel@tonic-gate 49147c478bd9Sstevel@tonic-gate /* 49157c478bd9Sstevel@tonic-gate * Calculate the length of the string required to hold all 49167c478bd9Sstevel@tonic-gate * of the server names plus either a comma or a null 49177c478bd9Sstevel@tonic-gate * character following each individual one. 49187c478bd9Sstevel@tonic-gate */ 49197c478bd9Sstevel@tonic-gate length = 0; 49207c478bd9Sstevel@tonic-gate for (s = mi->mi_servers; s != NULL; s = s->sv_next) 49217c478bd9Sstevel@tonic-gate length += s->sv_hostnamelen; 49227c478bd9Sstevel@tonic-gate 49237c478bd9Sstevel@tonic-gate srvnames = kmem_alloc(length, KM_SLEEP); 49247c478bd9Sstevel@tonic-gate 49257c478bd9Sstevel@tonic-gate namep = srvnames; 49267c478bd9Sstevel@tonic-gate for (s = mi->mi_servers; s != NULL; s = s->sv_next) { 49277c478bd9Sstevel@tonic-gate (void) strcpy(namep, s->sv_hostname); 49287c478bd9Sstevel@tonic-gate namep += s->sv_hostnamelen - 1; 49297c478bd9Sstevel@tonic-gate *namep++ = ','; 49307c478bd9Sstevel@tonic-gate } 49317c478bd9Sstevel@tonic-gate *--namep = '\0'; 49327c478bd9Sstevel@tonic-gate 49337c478bd9Sstevel@tonic-gate *len = length; 49347c478bd9Sstevel@tonic-gate 49357c478bd9Sstevel@tonic-gate return (srvnames); 49367c478bd9Sstevel@tonic-gate } 4937*108322fbScarlsonj 4938*108322fbScarlsonj /* 4939*108322fbScarlsonj * These two functions are temporary and designed for the upgrade-workaround 4940*108322fbScarlsonj * only. They cannot be used for general zone-crossing NFS client support, and 4941*108322fbScarlsonj * will be removed shortly. 4942*108322fbScarlsonj * 4943*108322fbScarlsonj * When the workaround is enabled, all NFS traffic is forced into the global 4944*108322fbScarlsonj * zone. These functions are called when the code needs to refer to the state 4945*108322fbScarlsonj * of the underlying network connection. They're not called when the function 4946*108322fbScarlsonj * needs to refer to the state of the process that invoked the system call. 4947*108322fbScarlsonj * (E.g., when checking whether the zone is shutting down during the mount() 4948*108322fbScarlsonj * call.) 4949*108322fbScarlsonj */ 4950*108322fbScarlsonj 4951*108322fbScarlsonj struct zone * 4952*108322fbScarlsonj nfs_zone(void) 4953*108322fbScarlsonj { 4954*108322fbScarlsonj return (nfs_global_client_only != 0 ? global_zone : curproc->p_zone); 4955*108322fbScarlsonj } 4956*108322fbScarlsonj 4957*108322fbScarlsonj zoneid_t 4958*108322fbScarlsonj nfs_zoneid(void) 4959*108322fbScarlsonj { 4960*108322fbScarlsonj return (nfs_global_client_only != 0 ? GLOBAL_ZONEID : getzoneid()); 4961*108322fbScarlsonj } 4962