xref: /titanic_52/usr/src/uts/common/nfs/nfs_clnt.h (revision 3f7d54a6b84904c8f4d8daa4c7b577bede7df8b9)
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 2010 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
27 /*	  All Rights Reserved  	*/
28 
29 #ifndef	_NFS_NFS_CLNT_H
30 #define	_NFS_NFS_CLNT_H
31 
32 #include <sys/utsname.h>
33 #include <sys/kstat.h>
34 #include <sys/time.h>
35 #include <vm/page.h>
36 #include <sys/thread.h>
37 #include <nfs/rnode.h>
38 #include <sys/list.h>
39 #include <sys/condvar_impl.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 /*
291  * NFS private data per mounted file system
292  *	The mi_lock mutex protects the following fields:
293  *		mi_flags
294  *		mi_printed
295  *		mi_down
296  *		mi_tsize
297  *		mi_stsize
298  *		mi_curread
299  *		mi_curwrite
300  *		mi_timers
301  *		mi_curr_serv
302  *		mi_readers
303  *		mi_klmconfig
304  *
305  *	The mi_async_lock mutex protects the following fields:
306  *		mi_async_reqs
307  *		mi_async_req_count
308  *		mi_async_tail
309  *		mi_async_curr[NFS_MAX_ASYNC_QUEUES]
310  *		mi_async_clusters
311  *		mi_async_init_clusters
312  *		mi_threads[NFS_MAX_ASYNC_QUEUES]
313  *		mi_manager_thread
314  *
315  *	Normally the netconfig information for the mount comes from
316  *	mi_curr_serv and mi_klmconfig is NULL.  If NLM calls need to use a
317  *	different transport, mi_klmconfig contains the necessary netconfig
318  *	information.
319  *
320  *	'mi_zone' is initialized at structure creation time, and never
321  *	changes; it may be read without a lock.
322  *
323  *	mi_zone_node is linkage into the mi4_globals.mig_list, and is
324  *	protected by mi4_globals.mig_list_lock.
325  *
326  *	Locking order:
327  *	  mi_globals::mig_lock > mi_async_lock > mi_lock
328  */
329 typedef struct mntinfo {
330 	kmutex_t	mi_lock;	/* protects mntinfo fields */
331 	struct servinfo *mi_servers;    /* server list */
332 	struct servinfo *mi_curr_serv;  /* current server */
333 	kcondvar_t	mi_failover_cv;	/* failover synchronization */
334 	int		mi_readers;	/* failover - users of mi_curr_serv */
335 	struct vfs	*mi_vfsp;	/* back pointer to vfs */
336 	enum vtype	mi_type;	/* file type of the root vnode */
337 	uint_t		mi_flags;	/* see below */
338 	uint_t		mi_tsize;	/* max read transfer size (bytes) */
339 	uint_t		mi_stsize;	/* max write transfer size (bytes) */
340 	int		mi_timeo;	/* inital timeout in 10th sec */
341 	int		mi_retrans;	/* times to retry request */
342 	hrtime_t	mi_acregmin;	/* min time to hold cached file attr */
343 	hrtime_t	mi_acregmax;	/* max time to hold cached file attr */
344 	hrtime_t	mi_acdirmin;	/* min time to hold cached dir attr */
345 	hrtime_t	mi_acdirmax;	/* max time to hold cached dir attr */
346 	len_t		mi_maxfilesize; /* for pathconf _PC_FILESIZEBITS */
347 	/*
348 	 * Extra fields for congestion control, one per NFS call type,
349 	 * plus one global one.
350 	 */
351 	struct rpc_timers mi_timers[NFS_CALLTYPES+1];
352 	int		mi_curread;	/* current read size */
353 	int		mi_curwrite;	/* current write size */
354 	/*
355 	 * Async I/O management
356 	 * We have 2 pools of threads working on async I/O:
357 	 *	(i) Threads which work on all async queues. Default number of
358 	 *	threads in this queue is 8. Threads in this pool work on async
359 	 *	queue pointed by mi_async_curr[NFS_ASYNC_QUEUE]. Number of
360 	 *	active threads in this pool is tracked by
361 	 *	mi_threads[NFS_ASYNC_QUEUE].
362 	 * 	(ii)Threads which work only on page op async queues.
363 	 *	Page ops queue comprises of NFS_PUTAPAGE, NFS_PAGEIO &
364 	 *	NFS_COMMIT. Default number of threads in this queue is 2
365 	 *	(NUM_ASYNC_PGOPS_THREADS). Threads in this pool work on async
366 	 *	queue pointed by mi_async_curr[NFS_ASYNC_PGOPS_QUEUE]. Number
367 	 *	of active threads in this pool is tracked by
368 	 *	mi_threads[NFS_ASYNC_PGOPS_QUEUE].
369 	 */
370 	struct nfs_async_reqs *mi_async_reqs[NFS_ASYNC_TYPES];
371 	struct nfs_async_reqs *mi_async_tail[NFS_ASYNC_TYPES];
372 	struct nfs_async_reqs **mi_async_curr[NFS_MAX_ASYNC_QUEUES];
373 						/* current async queue */
374 	uint_t		mi_async_clusters[NFS_ASYNC_TYPES];
375 	uint_t		mi_async_init_clusters;
376 	uint_t		mi_async_req_count; /* # outstanding work requests */
377 	kcondvar_t	mi_async_reqs_cv; /* signaled when there's work */
378 	ushort_t	mi_threads[NFS_MAX_ASYNC_QUEUES];
379 					/* number of active async threads */
380 	ushort_t	mi_max_threads;	/* max number of async worker threads */
381 	kthread_t	*mi_manager_thread;  /* async manager thread */
382 	kcondvar_t	mi_async_cv; /* signaled when the last worker dies */
383 	kcondvar_t	mi_async_work_cv[NFS_MAX_ASYNC_QUEUES];
384 					/* tell workers to work */
385 	kmutex_t	mi_async_lock;	/* lock to protect async list */
386 	/*
387 	 * Other stuff
388 	 */
389 	struct pathcnf *mi_pathconf;	/* static pathconf kludge */
390 	rpcprog_t	mi_prog;	/* RPC program number */
391 	rpcvers_t	mi_vers;	/* RPC program version number */
392 	char		**mi_rfsnames;	/* mapping to proc names */
393 	kstat_named_t	*mi_reqs;	/* count of requests */
394 	uchar_t		*mi_call_type;	/* dynamic retrans call types */
395 	uchar_t		*mi_ss_call_type;	/* semisoft call type */
396 	uchar_t		*mi_timer_type;	/* dynamic retrans timer types */
397 	clock_t		mi_printftime;	/* last error printf time */
398 	/*
399 	 * ACL entries
400 	 */
401 	char		**mi_aclnames;	/* mapping to proc names */
402 	kstat_named_t	*mi_aclreqs;	/* count of acl requests */
403 	uchar_t		*mi_acl_call_type; /* dynamic retrans call types */
404 	uchar_t		*mi_acl_ss_call_type; /* semisoft call types */
405 	uchar_t		*mi_acl_timer_type; /* dynamic retrans timer types */
406 	/*
407 	 * Client Side Failover stats
408 	 */
409 	uint_t		mi_noresponse;	/* server not responding count */
410 	uint_t		mi_failover; 	/* failover to new server count */
411 	uint_t		mi_remap;	/* remap to new server count */
412 	/*
413 	 * Kstat statistics
414 	 */
415 	struct kstat	*mi_io_kstats;
416 	struct kstat	*mi_ro_kstats;
417 	struct knetconfig *mi_klmconfig;
418 	/*
419 	 * Zones support.
420 	 */
421 	struct zone	*mi_zone;	/* Zone mounted in */
422 	list_node_t	mi_zone_node;	/* Linkage into per-zone mi list */
423 	/*
424 	 * Serializes threads in failover_remap.
425 	 * Need to acquire this lock first in failover_remap() function
426 	 * before acquiring any other rnode lock.
427 	 */
428 	kmutex_t	mi_remap_lock;
429 } mntinfo_t;
430 
431 /*
432  * vfs pointer to mount info
433  */
434 #define	VFTOMI(vfsp)	((mntinfo_t *)((vfsp)->vfs_data))
435 
436 /*
437  * vnode pointer to mount info
438  */
439 #define	VTOMI(vp)	((mntinfo_t *)(((vp)->v_vfsp)->vfs_data))
440 
441 /*
442  * The values for mi_flags.
443  */
444 #define	MI_HARD		0x1		/* hard or soft mount */
445 #define	MI_PRINTED	0x2		/* not responding message printed */
446 #define	MI_INT		0x4		/* interrupts allowed on hard mount */
447 #define	MI_DOWN		0x8		/* server is down */
448 #define	MI_NOAC		0x10		/* don't cache attributes */
449 #define	MI_NOCTO	0x20		/* no close-to-open consistency */
450 #define	MI_DYNAMIC	0x40		/* dynamic transfer size adjustment */
451 #define	MI_LLOCK	0x80		/* local locking only (no lockmgr) */
452 #define	MI_GRPID	0x100		/* System V group id inheritance */
453 #define	MI_RPCTIMESYNC	0x200		/* RPC time sync */
454 #define	MI_LINK		0x400		/* server supports link */
455 #define	MI_SYMLINK	0x800		/* server supports symlink */
456 #define	MI_READDIRONLY	0x1000		/* use readdir instead of readdirplus */
457 #define	MI_ACL		0x2000		/* server supports NFS_ACL */
458 #define	MI_BINDINPROG	0x4000		/* binding to server is changing */
459 #define	MI_LOOPBACK	0x8000		/* Set if this is a loopback mount */
460 #define	MI_SEMISOFT	0x10000		/* soft reads, hard modify */
461 #define	MI_NOPRINT	0x20000		/* don't print messages */
462 #define	MI_DIRECTIO	0x40000		/* do direct I/O */
463 #define	MI_EXTATTR	0x80000		/* server supports extended attrs */
464 #define	MI_ASYNC_MGR_STOP	0x100000	/* tell async mgr to die */
465 #define	MI_DEAD		0x200000	/* mount has been terminated */
466 
467 /*
468  * Read-only mntinfo statistics
469  */
470 struct mntinfo_kstat {
471 	char		mik_proto[KNC_STRSIZE];
472 	uint32_t	mik_vers;
473 	uint_t		mik_flags;
474 	uint_t		mik_secmod;
475 	uint32_t	mik_curread;
476 	uint32_t	mik_curwrite;
477 	int		mik_timeo;
478 	int		mik_retrans;
479 	uint_t		mik_acregmin;
480 	uint_t		mik_acregmax;
481 	uint_t		mik_acdirmin;
482 	uint_t		mik_acdirmax;
483 	struct {
484 		uint32_t srtt;
485 		uint32_t deviate;
486 		uint32_t rtxcur;
487 	} mik_timers[NFS_CALLTYPES+1];
488 	uint32_t	mik_noresponse;
489 	uint32_t	mik_failover;
490 	uint32_t	mik_remap;
491 	char		mik_curserver[SYS_NMLN];
492 };
493 
494 /*
495  * Macro to wakeup sleeping async worker threads.
496  */
497 #define	NFS_WAKE_ASYNC_WORKER(work_cv)	{				\
498 	if (CV_HAS_WAITERS(&work_cv[NFS_ASYNC_QUEUE]))			\
499 		cv_signal(&work_cv[NFS_ASYNC_QUEUE]);			\
500 	else if (CV_HAS_WAITERS(&work_cv[NFS_ASYNC_PGOPS_QUEUE]))	\
501 		cv_signal(&work_cv[NFS_ASYNC_PGOPS_QUEUE]);		\
502 }
503 
504 #define	NFS_WAKEALL_ASYNC_WORKERS(work_cv) {				\
505 	cv_broadcast(&work_cv[NFS_ASYNC_QUEUE]);			\
506 	cv_broadcast(&work_cv[NFS_ASYNC_PGOPS_QUEUE]);			\
507 }
508 
509 /*
510  * Mark cached attributes as timed out
511  *
512  * The caller must not be holding the rnode r_statelock mutex.
513  */
514 #define	PURGE_ATTRCACHE(vp)	{				\
515 	rnode_t *rp = VTOR(vp);					\
516 	mutex_enter(&rp->r_statelock);				\
517 	PURGE_ATTRCACHE_LOCKED(rp);				\
518 	mutex_exit(&rp->r_statelock);				\
519 }
520 
521 #define	PURGE_ATTRCACHE_LOCKED(rp)	{			\
522 	ASSERT(MUTEX_HELD(&rp->r_statelock));			\
523 	rp->r_attrtime = gethrtime();				\
524 	rp->r_mtime = rp->r_attrtime;				\
525 }
526 
527 /*
528  * Is the attribute cache valid?
529  */
530 #define	ATTRCACHE_VALID(vp)	(gethrtime() < VTOR(vp)->r_attrtime)
531 
532 /*
533  * Flags to indicate whether to purge the DNLC for non-directory vnodes
534  * in a call to nfs_purge_caches.
535  */
536 #define	NFS_NOPURGE_DNLC	0
537 #define	NFS_PURGE_DNLC		1
538 
539 /*
540  * If returned error is ESTALE flush all caches.
541  */
542 #define	PURGE_STALE_FH(error, vp, cr)				\
543 	if ((error) == ESTALE) {				\
544 		struct rnode *rp = VTOR(vp);			\
545 		if (vp->v_flag & VROOT) {			\
546 			servinfo_t *svp = rp->r_server;		\
547 			mutex_enter(&svp->sv_lock);		\
548 			svp->sv_flags |= SV_ROOT_STALE;		\
549 			mutex_exit(&svp->sv_lock);		\
550 		}						\
551 		mutex_enter(&rp->r_statelock);			\
552 		rp->r_flags |= RSTALE;				\
553 		if (!rp->r_error)				\
554 			rp->r_error = (error);			\
555 		mutex_exit(&rp->r_statelock);			\
556 		if (vn_has_cached_data(vp))			\
557 			nfs_invalidate_pages((vp), (u_offset_t)0, (cr)); \
558 		nfs_purge_caches((vp), NFS_PURGE_DNLC, (cr));	\
559 	}
560 
561 /*
562  * Is cache valid?
563  * Swap is always valid, if no attributes (attrtime == 0) or
564  * if mtime matches cached mtime it is valid
565  * NOTE: mtime is now a timestruc_t.
566  * Caller should be holding the rnode r_statelock mutex.
567  */
568 #define	CACHE_VALID(rp, mtime, fsize)				\
569 	((RTOV(rp)->v_flag & VISSWAP) == VISSWAP ||		\
570 	(((mtime).tv_sec == (rp)->r_attr.va_mtime.tv_sec &&	\
571 	(mtime).tv_nsec == (rp)->r_attr.va_mtime.tv_nsec) &&	\
572 	((fsize) == (rp)->r_attr.va_size)))
573 
574 /*
575  * Macro to detect forced unmount or a zone shutdown.
576  */
577 #define	FS_OR_ZONE_GONE(vfsp) \
578 	(((vfsp)->vfs_flag & VFS_UNMOUNTED) || \
579 	zone_status_get(curproc->p_zone) >= ZONE_IS_SHUTTING_DOWN)
580 
581 /*
582  * Convert NFS tunables to hrtime_t units, seconds to nanoseconds.
583  */
584 #define	SEC2HR(sec)	((sec) * (long long)NANOSEC)
585 #define	HR2SEC(hr)	((hr) / (long long)NANOSEC)
586 
587 /*
588  * Structure to identify owner of a PC file share reservation.
589  */
590 struct nfs_owner {
591 	int	magic;		/* magic uniquifying number */
592 	char	hname[16];	/* first 16 bytes of hostname */
593 	char	lowner[8];	/* local owner from fcntl */
594 };
595 
596 /*
597  * Values for magic.
598  */
599 #define	NFS_OWNER_MAGIC	0x1D81E
600 
601 /*
602  * Support for extended attributes
603  */
604 #define	XATTR_DIR_NAME	"/@/"		/* used for DNLC entries */
605 #define	XATTR_RPATH	"ExTaTtR"	/* used for r_path for failover */
606 
607 /*
608  * Short hand for checking to see whether the file system was mounted
609  * interruptible or not.
610  */
611 #define	INTR(vp)	(VTOMI(vp)->mi_flags & MI_INT)
612 
613 /*
614  * Short hand for checking whether failover is enabled or not
615  */
616 #define	FAILOVER_MOUNT(mi)	(mi->mi_servers->sv_next)
617 
618 /*
619  * How long will async threads wait for additional work.
620  */
621 #define	NFS_ASYNC_TIMEOUT	(60 * 1 * hz)	/* 1 minute */
622 
623 #ifdef _KERNEL
624 extern int	clget(clinfo_t *, servinfo_t *, cred_t *, CLIENT **,
625 		    struct chtab **);
626 extern void	clfree(CLIENT *, struct chtab *);
627 extern void	nfs_mi_zonelist_add(mntinfo_t *);
628 extern void	nfs_free_mi(mntinfo_t *);
629 extern void	nfs_mnt_kstat_init(struct vfs *);
630 #endif
631 
632 /*
633  * Per-zone data for managing client handles.  Included here solely for the
634  * benefit of MDB.
635  */
636 /*
637  * client side statistics
638  */
639 struct clstat {
640 	kstat_named_t	calls;			/* client requests */
641 	kstat_named_t	badcalls;		/* rpc failures */
642 	kstat_named_t	clgets;			/* client handle gets */
643 	kstat_named_t	cltoomany;		/* client handle cache misses */
644 #ifdef DEBUG
645 	kstat_named_t	clalloc;		/* number of client handles */
646 	kstat_named_t	noresponse;		/* server not responding cnt */
647 	kstat_named_t	failover;		/* server failover count */
648 	kstat_named_t	remap;			/* server remap count */
649 #endif
650 };
651 
652 struct nfs_clnt {
653 	struct chhead	*nfscl_chtable;
654 	kmutex_t	nfscl_chtable_lock;
655 	zoneid_t	nfscl_zoneid;
656 	list_node_t	nfscl_node;
657 	struct clstat	nfscl_stat;
658 };
659 
660 #ifdef	__cplusplus
661 }
662 #endif
663 
664 #endif	/* _NFS_NFS_CLNT_H */
665