xref: /illumos-gate/usr/src/uts/common/nfs/nfs_clnt.h (revision e010bda9)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 1986, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
26 /*	  All Rights Reserved	*/
27 
28 #ifndef	_NFS_NFS_CLNT_H
29 #define	_NFS_NFS_CLNT_H
30 
31 #include <sys/utsname.h>
32 #include <sys/kstat.h>
33 #include <sys/time.h>
34 #include <vm/page.h>
35 #include <sys/thread.h>
36 #include <nfs/rnode.h>
37 #include <sys/list.h>
38 #include <sys/condvar_impl.h>
39 #include <sys/zone.h>
40 
41 #ifdef	__cplusplus
42 extern "C" {
43 #endif
44 
45 #define	HOSTNAMESZ	32
46 #define	ACREGMIN	3	/* min secs to hold cached file attr */
47 #define	ACREGMAX	60	/* max secs to hold cached file attr */
48 #define	ACDIRMIN	30	/* min secs to hold cached dir attr */
49 #define	ACDIRMAX	60	/* max secs to hold cached dir attr */
50 #define	ACMINMAX	3600	/* 1 hr is longest min timeout */
51 #define	ACMAXMAX	36000	/* 10 hr is longest max timeout */
52 
53 #define	NFS_CALLTYPES	3	/* Lookups, Reads, Writes */
54 
55 /*
56  * rfscall() flags
57  */
58 #define	RFSCALL_SOFT	0x00000001	/* Do op as if fs was soft-mounted */
59 
60 /*
61  * Fake errno passed back from rfscall to indicate transfer size adjustment
62  */
63 #define	ENFS_TRYAGAIN	999
64 
65 /*
66  * The NFS specific async_reqs structure. iotype is grouped to support two
67  * types of async thread pools, please read comments section of mntinfo_t
68  * definition for more information. Care should be taken while adding new
69  * members to this group.
70  */
71 
72 enum iotype {
73 	NFS_PUTAPAGE,
74 	NFS_PAGEIO,
75 	NFS_COMMIT,
76 	NFS_READ_AHEAD,
77 	NFS_READDIR,
78 	NFS_INACTIVE,
79 	NFS_ASYNC_TYPES
80 };
81 #define	NFS_ASYNC_PGOPS_TYPES	(NFS_COMMIT + 1)
82 
83 /*
84  * NFS async requests queue type.
85  */
86 
87 enum ioqtype {
88 	NFS_ASYNC_QUEUE,
89 	NFS_ASYNC_PGOPS_QUEUE,
90 	NFS_MAX_ASYNC_QUEUES
91 };
92 
93 /*
94  * Number of NFS async threads operating exclusively on page op requests.
95  */
96 #define	NUM_ASYNC_PGOPS_THREADS	0x2
97 
98 struct nfs_async_read_req {
99 	void (*readahead)();		/* pointer to readahead function */
100 	u_offset_t blkoff;		/* offset in file */
101 	struct seg *seg;		/* segment to do i/o to */
102 	caddr_t addr;			/* address to do i/o to */
103 };
104 
105 struct nfs_pageio_req {
106 	int (*pageio)();		/* pointer to pageio function */
107 	page_t *pp;			/* page list */
108 	u_offset_t io_off;		/* offset in file */
109 	uint_t io_len;			/* size of request */
110 	int flags;
111 };
112 
113 struct nfs_readdir_req {
114 	int (*readdir)();		/* pointer to readdir function */
115 	struct rddir_cache *rdc;	/* pointer to cache entry to fill */
116 };
117 
118 struct nfs_commit_req {
119 	void (*commit)();		/* pointer to commit function */
120 	page_t *plist;			/* page list */
121 	offset3 offset;			/* starting offset */
122 	count3 count;			/* size of range to be commited */
123 };
124 
125 struct nfs_inactive_req {
126 	void (*inactive)();		/* pointer to inactive function */
127 };
128 
129 struct nfs_async_reqs {
130 	struct nfs_async_reqs *a_next;	/* pointer to next arg struct */
131 #ifdef DEBUG
132 	kthread_t *a_queuer;		/* thread id of queueing thread */
133 #endif
134 	struct vnode *a_vp;		/* vnode pointer */
135 	struct cred *a_cred;		/* cred pointer */
136 	enum iotype a_io;		/* i/o type */
137 	union {
138 		struct nfs_async_read_req a_read_args;
139 		struct nfs_pageio_req a_pageio_args;
140 		struct nfs_readdir_req a_readdir_args;
141 		struct nfs_commit_req a_commit_args;
142 		struct nfs_inactive_req a_inactive_args;
143 	} a_args;
144 };
145 
146 #define	a_nfs_readahead a_args.a_read_args.readahead
147 #define	a_nfs_blkoff a_args.a_read_args.blkoff
148 #define	a_nfs_seg a_args.a_read_args.seg
149 #define	a_nfs_addr a_args.a_read_args.addr
150 
151 #define	a_nfs_putapage a_args.a_pageio_args.pageio
152 #define	a_nfs_pageio a_args.a_pageio_args.pageio
153 #define	a_nfs_pp a_args.a_pageio_args.pp
154 #define	a_nfs_off a_args.a_pageio_args.io_off
155 #define	a_nfs_len a_args.a_pageio_args.io_len
156 #define	a_nfs_flags a_args.a_pageio_args.flags
157 
158 #define	a_nfs_readdir a_args.a_readdir_args.readdir
159 #define	a_nfs_rdc a_args.a_readdir_args.rdc
160 
161 #define	a_nfs_commit a_args.a_commit_args.commit
162 #define	a_nfs_plist a_args.a_commit_args.plist
163 #define	a_nfs_offset a_args.a_commit_args.offset
164 #define	a_nfs_count a_args.a_commit_args.count
165 
166 #define	a_nfs_inactive a_args.a_inactive_args.inactive
167 
168 /*
169  * Due to the way the address space callbacks are used to execute a delmap,
170  * we must keep track of how many times the same thread has called
171  * VOP_DELMAP()->nfs_delmap()/nfs3_delmap().  This is done by having a list of
172  * nfs_delmapcall_t's associated with each rnode_t.  This list is protected
173  * by the rnode_t's r_statelock.  The individual elements do not need to be
174  * protected as they will only ever be created, modified and destroyed by
175  * one thread (the call_id).
176  * See nfs_delmap()/nfs3_delmap() for further explanation.
177  */
178 typedef struct nfs_delmapcall {
179 	kthread_t	*call_id;
180 	int		error;	/* error from delmap */
181 	list_node_t	call_node;
182 } nfs_delmapcall_t;
183 
184 /*
185  * delmap address space callback args
186  */
187 typedef struct nfs_delmap_args {
188 	vnode_t			*vp;
189 	offset_t		off;
190 	caddr_t			addr;
191 	size_t			len;
192 	uint_t			prot;
193 	uint_t			maxprot;
194 	uint_t			flags;
195 	cred_t			*cr;
196 	nfs_delmapcall_t	*caller; /* to retrieve errors from the cb */
197 } nfs_delmap_args_t;
198 
199 #ifdef _KERNEL
200 extern nfs_delmapcall_t	*nfs_init_delmapcall(void);
201 extern void	nfs_free_delmapcall(nfs_delmapcall_t *);
202 extern int	nfs_find_and_delete_delmapcall(rnode_t *, int *errp);
203 #endif /* _KERNEL */
204 
205 /*
206  * The following structures, chhead and chtab,  make up the client handle
207  * cache.  chhead represents a quadruple(RPC program, RPC version, Protocol
208  * Family, and Transport).  For example, a chhead entry could represent
209  * NFS/V3/IPv4/TCP requests.  chhead nodes are linked together as a singly
210  * linked list and is referenced from chtable.
211  *
212  * chtab represents an allocated client handle bound to a particular
213  * quadruple. These nodes chain down from a chhead node.  chtab
214  * entries which are on the chain are considered free, so a thread may simply
215  * unlink the first node without traversing the chain.  When the thread is
216  * completed with its request, it puts the chtab node back on the chain.
217  */
218 typedef struct chhead {
219 	struct chhead *ch_next;	/* next quadruple */
220 	struct chtab *ch_list;	/* pointer to free client handle(s) */
221 	uint64_t ch_timesused;	/* times this quadruple was requested */
222 	rpcprog_t ch_prog;	/* RPC program number */
223 	rpcvers_t ch_vers;	/* RPC version number */
224 	dev_t ch_dev;		/* pseudo device number (i.e. /dev/udp) */
225 	char *ch_protofmly;	/* protocol (i.e. NC_INET, NC_LOOPBACK) */
226 } chhead_t;
227 
228 typedef struct chtab {
229 	struct chtab *ch_list;	/* next free client handle */
230 	struct chhead *ch_head;	/* associated quadruple */
231 	time_t ch_freed;	/* timestamp when freed */
232 	CLIENT *ch_client;	/* pointer to client handle */
233 } chtab_t;
234 
235 /*
236  * clinfo is a structure which encapsulates data that is needed to
237  * obtain a client handle from the cache
238  */
239 typedef struct clinfo {
240 	rpcprog_t cl_prog;	/* RPC program number */
241 	rpcvers_t cl_vers;	/* RPC version number */
242 	uint_t cl_readsize;	/* transfer size */
243 	int cl_retrans;		/* times to retry request */
244 	uint_t cl_flags;	/* info flags */
245 } clinfo_t;
246 
247 /*
248  * Failover information, passed opaquely through rfscall()
249  */
250 typedef struct failinfo {
251 	struct vnode	*vp;
252 	caddr_t		fhp;
253 	void (*copyproc)(caddr_t, vnode_t *);
254 	int (*lookupproc)(vnode_t *, char *, vnode_t **, struct pathname *,
255 			int, vnode_t *, struct cred *, int);
256 	int (*xattrdirproc)(vnode_t *, vnode_t **, bool_t, cred_t *, int);
257 } failinfo_t;
258 
259 /*
260  * Static server information
261  *
262  * These fields are protected by sv_lock:
263  *	sv_flags
264  */
265 typedef struct servinfo {
266 	struct knetconfig *sv_knconf;   /* bound TLI fd */
267 	struct knetconfig *sv_origknconf;	/* For RDMA save orig knconf */
268 	struct netbuf	sv_addr;	/* server's address */
269 	nfs_fhandle	sv_fhandle;	/* this server's filehandle */
270 	struct sec_data *sv_secdata;	/* security data for rpcsec module */
271 	char	*sv_hostname;		/* server's hostname */
272 	int	sv_hostnamelen;		/* server's hostname length */
273 	uint_t	sv_flags;		/* see below */
274 	struct servinfo	*sv_next;	/* next in list */
275 	kmutex_t sv_lock;
276 } servinfo_t;
277 
278 /*
279  * The values for sv_flags.
280  */
281 #define	SV_ROOT_STALE	0x1		/* root vnode got ESTALE */
282 
283 /*
284  * Switch from RDMA knconf to original mount knconf
285  */
286 
287 #define	ORIG_KNCONF(mi) (mi->mi_curr_serv->sv_origknconf ? \
288 	mi->mi_curr_serv->sv_origknconf : mi->mi_curr_serv->sv_knconf)
289 
290 #if	defined(_KERNEL)
291 /*
292  * NFS private data per mounted file system
293  *	The mi_lock mutex protects the following fields:
294  *		mi_flags
295  *		mi_printed
296  *		mi_down
297  *		mi_tsize
298  *		mi_stsize
299  *		mi_curread
300  *		mi_curwrite
301  *		mi_timers
302  *		mi_curr_serv
303  *		mi_readers
304  *		mi_klmconfig
305  *
306  *	The mi_async_lock mutex protects the following fields:
307  *		mi_async_reqs
308  *		mi_async_req_count
309  *		mi_async_tail
310  *		mi_async_curr[NFS_MAX_ASYNC_QUEUES]
311  *		mi_async_clusters
312  *		mi_async_init_clusters
313  *		mi_threads[NFS_MAX_ASYNC_QUEUES]
314  *		mi_manager_thread
315  *
316  *	Normally the netconfig information for the mount comes from
317  *	mi_curr_serv and mi_klmconfig is NULL.  If NLM calls need to use a
318  *	different transport, mi_klmconfig contains the necessary netconfig
319  *	information.
320  *
321  *	'mi_zone' is initialized at structure creation time, and never
322  *	changes; it may be read without a lock.
323  *
324  *	mi_zone_node is linkage into the mi4_globals.mig_list, and is
325  *	protected by mi4_globals.mig_list_lock.
326  *
327  *	Locking order:
328  *	  mi_globals::mig_lock > mi_async_lock > mi_lock
329  */
330 typedef struct mntinfo {
331 	kmutex_t	mi_lock;	/* protects mntinfo fields */
332 	struct servinfo *mi_servers;    /* server list */
333 	struct servinfo *mi_curr_serv;  /* current server */
334 	kcondvar_t	mi_failover_cv;	/* failover synchronization */
335 	int		mi_readers;	/* failover - users of mi_curr_serv */
336 	struct vfs	*mi_vfsp;	/* back pointer to vfs */
337 	enum vtype	mi_type;	/* file type of the root vnode */
338 	uint_t		mi_flags;	/* see below */
339 	uint_t		mi_tsize;	/* max read transfer size (bytes) */
340 	uint_t		mi_stsize;	/* max write transfer size (bytes) */
341 	int		mi_timeo;	/* inital timeout in 10th sec */
342 	int		mi_retrans;	/* times to retry request */
343 	hrtime_t	mi_acregmin;	/* min time to hold cached file attr */
344 	hrtime_t	mi_acregmax;	/* max time to hold cached file attr */
345 	hrtime_t	mi_acdirmin;	/* min time to hold cached dir attr */
346 	hrtime_t	mi_acdirmax;	/* max time to hold cached dir attr */
347 	len_t		mi_maxfilesize; /* for pathconf _PC_FILESIZEBITS */
348 	/*
349 	 * Extra fields for congestion control, one per NFS call type,
350 	 * plus one global one.
351 	 */
352 	struct rpc_timers mi_timers[NFS_CALLTYPES+1];
353 	int		mi_curread;	/* current read size */
354 	int		mi_curwrite;	/* current write size */
355 	/*
356 	 * Async I/O management
357 	 * We have 2 pools of threads working on async I/O:
358 	 *	(i) Threads which work on all async queues. Default number of
359 	 *	threads in this queue is 8. Threads in this pool work on async
360 	 *	queue pointed by mi_async_curr[NFS_ASYNC_QUEUE]. Number of
361 	 *	active threads in this pool is tracked by
362 	 *	mi_threads[NFS_ASYNC_QUEUE].
363 	 * 	(ii)Threads which work only on page op async queues.
364 	 *	Page ops queue comprises of NFS_PUTAPAGE, NFS_PAGEIO &
365 	 *	NFS_COMMIT. Default number of threads in this queue is 2
366 	 *	(NUM_ASYNC_PGOPS_THREADS). Threads in this pool work on async
367 	 *	queue pointed by mi_async_curr[NFS_ASYNC_PGOPS_QUEUE]. Number
368 	 *	of active threads in this pool is tracked by
369 	 *	mi_threads[NFS_ASYNC_PGOPS_QUEUE].
370 	 */
371 	struct nfs_async_reqs *mi_async_reqs[NFS_ASYNC_TYPES];
372 	struct nfs_async_reqs *mi_async_tail[NFS_ASYNC_TYPES];
373 	struct nfs_async_reqs **mi_async_curr[NFS_MAX_ASYNC_QUEUES];
374 						/* current async queue */
375 	uint_t		mi_async_clusters[NFS_ASYNC_TYPES];
376 	uint_t		mi_async_init_clusters;
377 	uint_t		mi_async_req_count; /* # outstanding work requests */
378 	kcondvar_t	mi_async_reqs_cv; /* signaled when there's work */
379 	ushort_t	mi_threads[NFS_MAX_ASYNC_QUEUES];
380 					/* number of active async threads */
381 	ushort_t	mi_max_threads;	/* max number of async worker threads */
382 	kthread_t	*mi_manager_thread;  /* async manager thread */
383 	kcondvar_t	mi_async_cv; /* signaled when the last worker dies */
384 	kcondvar_t	mi_async_work_cv[NFS_MAX_ASYNC_QUEUES];
385 					/* tell workers to work */
386 	kmutex_t	mi_async_lock;	/* lock to protect async list */
387 	/*
388 	 * Other stuff
389 	 */
390 	struct pathcnf *mi_pathconf;	/* static pathconf kludge */
391 	rpcprog_t	mi_prog;	/* RPC program number */
392 	rpcvers_t	mi_vers;	/* RPC program version number */
393 	char		**mi_rfsnames;	/* mapping to proc names */
394 	kstat_named_t	*mi_reqs;	/* count of requests */
395 	uchar_t		*mi_call_type;	/* dynamic retrans call types */
396 	uchar_t		*mi_ss_call_type;	/* semisoft call type */
397 	uchar_t		*mi_timer_type;	/* dynamic retrans timer types */
398 	clock_t		mi_printftime;	/* last error printf time */
399 	/*
400 	 * ACL entries
401 	 */
402 	char		**mi_aclnames;	/* mapping to proc names */
403 	kstat_named_t	*mi_aclreqs;	/* count of acl requests */
404 	uchar_t		*mi_acl_call_type; /* dynamic retrans call types */
405 	uchar_t		*mi_acl_ss_call_type; /* semisoft call types */
406 	uchar_t		*mi_acl_timer_type; /* dynamic retrans timer types */
407 	/*
408 	 * Client Side Failover stats
409 	 */
410 	uint_t		mi_noresponse;	/* server not responding count */
411 	uint_t		mi_failover; 	/* failover to new server count */
412 	uint_t		mi_remap;	/* remap to new server count */
413 	/*
414 	 * Kstat statistics
415 	 */
416 	struct kstat	*mi_io_kstats;
417 	struct kstat	*mi_ro_kstats;
418 	struct knetconfig *mi_klmconfig;
419 	/*
420 	 * Zones support.
421 	 */
422 	struct zone	*mi_zone;	/* Zone in which FS is mounted */
423 	zone_ref_t	mi_zone_ref;	/* Reference to aforementioned zone */
424 	list_node_t	mi_zone_node;	/* Linkage into per-zone mi list */
425 	/*
426 	 * Serializes threads in failover_remap.
427 	 * Need to acquire this lock first in failover_remap() function
428 	 * before acquiring any other rnode lock.
429 	 */
430 	kmutex_t	mi_remap_lock;
431 	/*
432 	 * List of rnode_t structures that belongs to this mntinfo
433 	 */
434 	kmutex_t	mi_rnodes_lock;	/* protects the mi_rnodes list */
435 	list_t		mi_rnodes;	/* the list */
436 } mntinfo_t;
437 #endif	/* _KERNEL */
438 
439 /*
440  * vfs pointer to mount info
441  */
442 #define	VFTOMI(vfsp)	((mntinfo_t *)((vfsp)->vfs_data))
443 
444 /*
445  * vnode pointer to mount info
446  */
447 #define	VTOMI(vp)	((mntinfo_t *)(((vp)->v_vfsp)->vfs_data))
448 
449 /*
450  * The values for mi_flags.
451  */
452 #define	MI_HARD		0x1		/* hard or soft mount */
453 #define	MI_PRINTED	0x2		/* not responding message printed */
454 #define	MI_INT		0x4		/* interrupts allowed on hard mount */
455 #define	MI_DOWN		0x8		/* server is down */
456 #define	MI_NOAC		0x10		/* don't cache attributes */
457 #define	MI_NOCTO	0x20		/* no close-to-open consistency */
458 #define	MI_DYNAMIC	0x40		/* dynamic transfer size adjustment */
459 #define	MI_LLOCK	0x80		/* local locking only (no lockmgr) */
460 #define	MI_GRPID	0x100		/* System V group id inheritance */
461 #define	MI_RPCTIMESYNC	0x200		/* RPC time sync */
462 #define	MI_LINK		0x400		/* server supports link */
463 #define	MI_SYMLINK	0x800		/* server supports symlink */
464 #define	MI_READDIRONLY	0x1000		/* use readdir instead of readdirplus */
465 #define	MI_ACL		0x2000		/* server supports NFS_ACL */
466 #define	MI_BINDINPROG	0x4000		/* binding to server is changing */
467 #define	MI_LOOPBACK	0x8000		/* Set if this is a loopback mount */
468 #define	MI_SEMISOFT	0x10000		/* soft reads, hard modify */
469 #define	MI_NOPRINT	0x20000		/* don't print messages */
470 #define	MI_DIRECTIO	0x40000		/* do direct I/O */
471 #define	MI_EXTATTR	0x80000		/* server supports extended attrs */
472 #define	MI_ASYNC_MGR_STOP	0x100000	/* tell async mgr to die */
473 #define	MI_DEAD		0x200000	/* mount has been terminated */
474 
475 /*
476  * Read-only mntinfo statistics
477  */
478 struct mntinfo_kstat {
479 	char		mik_proto[KNC_STRSIZE];
480 	uint32_t	mik_vers;
481 	uint_t		mik_flags;
482 	uint_t		mik_secmod;
483 	uint32_t	mik_curread;
484 	uint32_t	mik_curwrite;
485 	int		mik_timeo;
486 	int		mik_retrans;
487 	uint_t		mik_acregmin;
488 	uint_t		mik_acregmax;
489 	uint_t		mik_acdirmin;
490 	uint_t		mik_acdirmax;
491 	struct {
492 		uint32_t srtt;
493 		uint32_t deviate;
494 		uint32_t rtxcur;
495 	} mik_timers[NFS_CALLTYPES+1];
496 	uint32_t	mik_noresponse;
497 	uint32_t	mik_failover;
498 	uint32_t	mik_remap;
499 	char		mik_curserver[SYS_NMLN];
500 };
501 
502 /*
503  * Macro to wakeup sleeping async worker threads.
504  */
505 #define	NFS_WAKE_ASYNC_WORKER(work_cv)	{				\
506 	if (CV_HAS_WAITERS(&work_cv[NFS_ASYNC_QUEUE]))			\
507 		cv_signal(&work_cv[NFS_ASYNC_QUEUE]);			\
508 	else if (CV_HAS_WAITERS(&work_cv[NFS_ASYNC_PGOPS_QUEUE]))	\
509 		cv_signal(&work_cv[NFS_ASYNC_PGOPS_QUEUE]);		\
510 }
511 
512 #define	NFS_WAKEALL_ASYNC_WORKERS(work_cv) {				\
513 	cv_broadcast(&work_cv[NFS_ASYNC_QUEUE]);			\
514 	cv_broadcast(&work_cv[NFS_ASYNC_PGOPS_QUEUE]);			\
515 }
516 
517 /*
518  * Mark cached attributes as timed out
519  *
520  * The caller must not be holding the rnode r_statelock mutex.
521  */
522 #define	PURGE_ATTRCACHE(vp)	{				\
523 	rnode_t *rp = VTOR(vp);					\
524 	mutex_enter(&rp->r_statelock);				\
525 	PURGE_ATTRCACHE_LOCKED(rp);				\
526 	mutex_exit(&rp->r_statelock);				\
527 }
528 
529 #define	PURGE_ATTRCACHE_LOCKED(rp)	{			\
530 	ASSERT(MUTEX_HELD(&rp->r_statelock));			\
531 	rp->r_attrtime = gethrtime();				\
532 	rp->r_mtime = rp->r_attrtime;				\
533 }
534 
535 /*
536  * Is the attribute cache valid?
537  */
538 #define	ATTRCACHE_VALID(vp)	(gethrtime() < VTOR(vp)->r_attrtime)
539 
540 /*
541  * Flags to indicate whether to purge the DNLC for non-directory vnodes
542  * in a call to nfs_purge_caches.
543  */
544 #define	NFS_NOPURGE_DNLC	0
545 #define	NFS_PURGE_DNLC		1
546 
547 /*
548  * If returned error is ESTALE flush all caches.
549  */
550 #define	PURGE_STALE_FH(error, vp, cr)				\
551 	if ((error) == ESTALE) {				\
552 		struct rnode *rp = VTOR(vp);			\
553 		if (vp->v_flag & VROOT) {			\
554 			servinfo_t *svp = rp->r_server;		\
555 			mutex_enter(&svp->sv_lock);		\
556 			svp->sv_flags |= SV_ROOT_STALE;		\
557 			mutex_exit(&svp->sv_lock);		\
558 		}						\
559 		mutex_enter(&rp->r_statelock);			\
560 		rp->r_flags |= RSTALE;				\
561 		if (!rp->r_error)				\
562 			rp->r_error = (error);			\
563 		mutex_exit(&rp->r_statelock);			\
564 		if (vn_has_cached_data(vp))			\
565 			nfs_invalidate_pages((vp), (u_offset_t)0, (cr)); \
566 		nfs_purge_caches((vp), NFS_PURGE_DNLC, (cr));	\
567 	}
568 
569 /*
570  * Is cache valid?
571  * Swap is always valid, if no attributes (attrtime == 0) or
572  * if mtime matches cached mtime it is valid
573  * NOTE: mtime is now a timestruc_t.
574  * Caller should be holding the rnode r_statelock mutex.
575  */
576 #define	CACHE_VALID(rp, mtime, fsize)				\
577 	((RTOV(rp)->v_flag & VISSWAP) == VISSWAP ||		\
578 	(((mtime).tv_sec == (rp)->r_attr.va_mtime.tv_sec &&	\
579 	(mtime).tv_nsec == (rp)->r_attr.va_mtime.tv_nsec) &&	\
580 	((fsize) == (rp)->r_attr.va_size)))
581 
582 /*
583  * Macro to detect forced unmount or a zone shutdown.
584  */
585 #define	FS_OR_ZONE_GONE(vfsp) \
586 	(((vfsp)->vfs_flag & VFS_UNMOUNTED) || \
587 	zone_status_get(curproc->p_zone) >= ZONE_IS_SHUTTING_DOWN)
588 
589 /*
590  * Convert NFS tunables to hrtime_t units, seconds to nanoseconds.
591  */
592 #define	SEC2HR(sec)	((sec) * (long long)NANOSEC)
593 #define	HR2SEC(hr)	((hr) / (long long)NANOSEC)
594 
595 /*
596  * Structure to identify owner of a PC file share reservation.
597  */
598 struct nfs_owner {
599 	int	magic;		/* magic uniquifying number */
600 	char	hname[16];	/* first 16 bytes of hostname */
601 	char	lowner[8];	/* local owner from fcntl */
602 };
603 
604 /*
605  * Values for magic.
606  */
607 #define	NFS_OWNER_MAGIC	0x1D81E
608 
609 /*
610  * Support for extended attributes
611  */
612 #define	XATTR_DIR_NAME	"/@/"		/* used for DNLC entries */
613 #define	XATTR_RPATH	"ExTaTtR"	/* used for r_path for failover */
614 
615 /*
616  * Short hand for checking to see whether the file system was mounted
617  * interruptible or not.
618  */
619 #define	INTR(vp)	(VTOMI(vp)->mi_flags & MI_INT)
620 
621 /*
622  * Short hand for checking whether failover is enabled or not
623  */
624 #define	FAILOVER_MOUNT(mi)	(mi->mi_servers->sv_next)
625 
626 /*
627  * How long will async threads wait for additional work.
628  */
629 #define	NFS_ASYNC_TIMEOUT	(60 * 1 * hz)	/* 1 minute */
630 
631 #ifdef _KERNEL
632 extern int	clget(clinfo_t *, servinfo_t *, cred_t *, CLIENT **,
633 		    struct chtab **);
634 extern void	clfree(CLIENT *, struct chtab *);
635 extern void	nfs_mi_zonelist_add(mntinfo_t *);
636 extern void	nfs_free_mi(mntinfo_t *);
637 extern void	nfs_mnt_kstat_init(struct vfs *);
638 #endif
639 
640 /*
641  * Per-zone data for managing client handles.  Included here solely for the
642  * benefit of MDB.
643  */
644 /*
645  * client side statistics
646  */
647 struct clstat {
648 	kstat_named_t	calls;			/* client requests */
649 	kstat_named_t	badcalls;		/* rpc failures */
650 	kstat_named_t	clgets;			/* client handle gets */
651 	kstat_named_t	cltoomany;		/* client handle cache misses */
652 #ifdef DEBUG
653 	kstat_named_t	clalloc;		/* number of client handles */
654 	kstat_named_t	noresponse;		/* server not responding cnt */
655 	kstat_named_t	failover;		/* server failover count */
656 	kstat_named_t	remap;			/* server remap count */
657 #endif
658 };
659 
660 struct nfs_clnt {
661 	struct chhead	*nfscl_chtable;
662 	kmutex_t	nfscl_chtable_lock;
663 	zoneid_t	nfscl_zoneid;
664 	list_node_t	nfscl_node;
665 	struct clstat	nfscl_stat;
666 };
667 
668 #ifdef	__cplusplus
669 }
670 #endif
671 
672 #endif	/* _NFS_NFS_CLNT_H */
673