xref: /illumos-gate/usr/src/uts/common/nfs/nfs4.h (revision f44e1126d9eae71c48c5d1de51e24750c6ec20a4)
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 /*
23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Copyright 2018 Nexenta Systems, Inc.
29  * Copyright 2019 Nexenta by DDN, Inc.
30  */
31 
32 #ifndef _NFS4_H
33 #define	_NFS4_H
34 
35 #include <sys/types.h>
36 #include <sys/vnode.h>
37 #include <sys/fem.h>
38 #include <rpc/rpc.h>
39 #include <nfs/nfs.h>
40 
41 #ifdef _KERNEL
42 #include <nfs/nfs4_kprot.h>
43 #include <sys/nvpair.h>
44 #else
45 #include <rpcsvc/nfs4_prot.h>
46 #endif
47 #include <nfs/nfs4_attr.h>
48 #include <sys/acl.h>
49 #include <sys/list.h>
50 #include <nfs/nfs4x.h>
51 
52 #ifdef	__cplusplus
53 extern "C" {
54 #endif
55 
56 #define	NFS4_MAX_SECOID4	65536
57 #define	NFS4_MAX_UTF8STRING	65536
58 #define	NFS4_MAX_LINKTEXT4	65536
59 #define	NFS4_MAX_PATHNAME4	65536
60 
61 struct nfs_fsl_info {
62 	uint_t netbuf_len;
63 	uint_t netnm_len;
64 	uint_t knconf_len;
65 	char *netname;
66 	struct netbuf *addr;
67 	struct knetconfig *knconf;
68 };
69 
70 #ifdef _KERNEL
71 
72 typedef struct nfs4_fhandle {
73 	int fh_len;
74 	char fh_buf[NFS4_FHSIZE];
75 } nfs4_fhandle_t;
76 
77 typedef uint8_t nfs4_minor_t;
78 
79 #define	NFS4_MINORVERSION	0
80 #define	CB4_MINORVERSION	0
81 
82 #define	FIRST_NFS4_OP   OP_ACCESS
83 #define	LAST_NFS40_OP   OP_RELEASE_LOCKOWNER
84 #define	LAST_NFS41_OP   OP_RECLAIM_COMPLETE
85 #define	LAST_NFS42_OP   OP_RECLAIM_COMPLETE
86 #define	LAST_NFS4_OP    LAST_NFS42_OP
87 
88 /*
89  * Set the fattr4_change variable using a time struct. Note that change
90  * is 64 bits, but timestruc_t is 128 bits in a 64-bit kernel.
91  */
92 #define	NFS4_SET_FATTR4_CHANGE(change, ts)			\
93 {							\
94 	change = (ts).tv_sec;				\
95 	change <<= 32;					\
96 	change |= (uint32_t)((ts).tv_nsec);		\
97 }
98 
99 /*
100  * Server lease period.  Value is in seconds;  Also used for grace period
101  */
102 extern time_t rfs4_lease_time;
103 
104 /*
105  * This set of typedefs and interfaces represent the core or base set
106  * of functionality that backs the NFSv4 server's state related data
107  * structures.  Since the NFSv4 server needs inter-RPC state to be
108  * available that is unrelated to the filesystem (in other words,
109  * soft-state), this functionality is needed to maintain that and is
110  * written to be somewhat flexible to adapt to the various types of
111  * data structures contained within the server.
112  *
113  * The basic structure at this level is that the server maintains a
114  * global "database" which consists of a set of tables.  Each table
115  * contains a set of like data structures.  Each table is indexed by
116  * at least one hash function and in most cases two hashes.  Each
117  * table's characteristics is set when it is created at run-time via
118  * rfs4_table_create().  All table creation and related functions are
119  * located in nfs4_state.c.  The generic database functionality is
120  * located in nfs4_db.c.
121  */
122 
123 typedef struct rfs4_dbe rfs4_dbe_t;		/* basic opaque db entry */
124 typedef struct rfs4_table rfs4_table_t;		/* basic table type */
125 typedef struct rfs4_index rfs4_index_t;		/* index */
126 typedef struct rfs4_database rfs4_database_t;	/* and database */
127 
128 typedef struct {		/* opaque entry type for later use */
129 	rfs4_dbe_t *dbe;
130 } *rfs4_entry_t;
131 
132 /*
133  * NFSv4 server state databases
134  *
135  * Initialized when the module is loaded and used by NFSv4 state tables.
136  * These kmem_cache free pools are used globally, the NFSv4 state tables
137  * which make use of these kmem_cache free pools are per zone.
138  */
139 extern kmem_cache_t *rfs4_client_mem_cache;
140 extern kmem_cache_t *rfs4_clntIP_mem_cache;
141 extern kmem_cache_t *rfs4_openown_mem_cache;
142 extern kmem_cache_t *rfs4_openstID_mem_cache;
143 extern kmem_cache_t *rfs4_lockstID_mem_cache;
144 extern kmem_cache_t *rfs4_lockown_mem_cache;
145 extern kmem_cache_t *rfs4_file_mem_cache;
146 extern kmem_cache_t *rfs4_delegstID_mem_cache;
147 extern kmem_cache_t *rfs4_session_mem_cache;
148 
149 /* database, table, index creation entry points */
150 extern rfs4_database_t *rfs4_database_create(uint32_t);
151 extern void		rfs4_database_shutdown(rfs4_database_t *);
152 extern void		rfs4_database_destroy(rfs4_database_t *);
153 
154 extern void		rfs4_database_destroy(rfs4_database_t *);
155 
156 extern kmem_cache_t	*nfs4_init_mem_cache(char *, uint32_t, uint32_t,
157 				uint32_t);
158 extern rfs4_table_t	*rfs4_table_create(rfs4_database_t *, char *,
159 				time_t, uint32_t,
160 				bool_t (*create)(rfs4_entry_t, void *),
161 				void (*destroy)(rfs4_entry_t),
162 				bool_t (*expiry)(rfs4_entry_t),
163 				uint32_t, uint32_t, uint32_t, id_t);
164 extern void		rfs4_table_destroy(rfs4_database_t *, rfs4_table_t *);
165 extern rfs4_index_t	*rfs4_index_create(rfs4_table_t *, char *,
166 				uint32_t (*hash)(void *),
167 				bool_t (compare)(rfs4_entry_t, void *),
168 				void *(*mkkey)(rfs4_entry_t), bool_t);
169 extern void		rfs4_index_destroy(rfs4_index_t *);
170 
171 /* Type used to direct rfs4_dbsearch() in what types of records to inspect */
172 typedef enum {RFS4_DBS_VALID, RFS4_DBS_INVALID} rfs4_dbsearch_type_t;
173 /* search and db entry manipulation entry points */
174 extern rfs4_entry_t	rfs4_dbsearch(rfs4_index_t *, void *,
175 				bool_t *, void *, rfs4_dbsearch_type_t);
176 extern void		rfs4_dbe_lock(rfs4_dbe_t *);
177 extern void		rfs4_dbe_unlock(rfs4_dbe_t *);
178 extern clock_t		rfs4_dbe_twait(rfs4_dbe_t *, clock_t);
179 extern void		rfs4_dbe_cv_broadcast(rfs4_dbe_t *);
180 extern void		rfs4_dbe_hold(rfs4_dbe_t *);
181 extern void		rfs4_dbe_hold_nolock(rfs4_dbe_t *);
182 extern void		rfs4_dbe_rele_nolock(rfs4_dbe_t *);
183 extern void		rfs4_dbe_rele(rfs4_dbe_t *);
184 extern uint32_t	rfs4_dbe_refcnt(rfs4_dbe_t *);
185 extern id_t		rfs4_dbe_getid(rfs4_dbe_t *);
186 extern void		rfs4_dbe_invalidate(rfs4_dbe_t *);
187 extern bool_t		rfs4_dbe_is_invalid(rfs4_dbe_t *);
188 extern time_t		rfs4_dbe_get_timerele(rfs4_dbe_t *);
189 extern void		rfs4_dbe_hide(rfs4_dbe_t *);
190 extern void		rfs4_dbe_unhide(rfs4_dbe_t *);
191 #ifdef DEBUG
192 extern bool_t		rfs4_dbe_islocked(rfs4_dbe_t *);
193 #endif
194 extern void		rfs4_dbe_walk(rfs4_table_t *,
195 			void (*callout)(rfs4_entry_t, void *), void *);
196 
197 /*
198  * Minimal server stable storage.
199  *
200  * Currently the NFSv4 server will only save the client
201  * ID (the long version) so that it will be able to
202  * grant possible reclaim requests during the infamous
203  * grace_period.
204  */
205 
206 #define	RFS4_SS_DIRSIZE	64 * 1024
207 #define	NFS4_SS_VERSION 1
208 
209 /* handy pathname structure */
210 typedef struct ss_pn {
211 	char *leaf;
212 	char pn[MAXPATHLEN];
213 } rfs4_ss_pn_t;
214 
215 /*
216  * The server will build this link list on startup. It represents the
217  * clients that have had valid state on the server in a prior instance.
218  *
219  */
220 typedef struct rfs4_oldstate {
221 	struct rfs4_oldstate	*next;
222 	struct rfs4_oldstate	*prev;
223 	rfs4_ss_pn_t		*ss_pn;
224 	nfs_client_id4		cl_id4;
225 } rfs4_oldstate_t;
226 
227 /*
228  * This union is used to overlay the server's internal treatment of
229  * the protocols stateid4 datatype.  Therefore, "bits" must not exceed
230  * the size of stateid4 and more importantly should match the size of
231  * stateid4.  The chgseq field must the first entry since it overlays
232  * stateid4.seqid.
233  */
234 typedef union {
235 	stateid4 stateid;
236 	struct {
237 		uint32_t chgseq;	/* State changes / protocol's seqid */
238 		uint32_t boottime;	/* boot time  */
239 		uint32_t type:2;	/* stateid_type_t as define below */
240 		uint32_t clnodeid:8;	/* cluster server nodeid */
241 		uint32_t ident:22;	/* 2^22-1 openowner x fhs */
242 		pid_t	 pid;		/* pid of corresponding lock owner */
243 	} bits;
244 } stateid_t;
245 /*
246  * Note that the way the type field above is defined, this enum must
247  * not have more than 4 members.
248  */
249 typedef enum {OPENID, LOCKID, DELEGID} stateid_type_t;
250 
251 /*
252  * "wait" struct for use in the open open and lock owner state
253  * structures to provide serialization between server threads that are
254  * handling requests for the same open owner or lock stateid.  This
255  * way only one thread will be updating things like sequence ids,
256  * replay cache and stateid at a time.
257  */
258 typedef struct rfs4_state_wait {
259 	uint32_t		sw_active;
260 	uint32_t		sw_wait_count;
261 	kmutex_t		sw_cv_lock[1];
262 	kcondvar_t		sw_cv[1];
263 } rfs4_state_wait_t;
264 
265 extern void	rfs4_sw_enter(rfs4_state_wait_t *);
266 extern void	rfs4_sw_exit(rfs4_state_wait_t *);
267 
268 /*
269  * This enum and the following rfs4_cbinfo_t struct are used to
270  * maintain information about the callback path used from the server
271  * to client for operations like CB_GETATTR and CB_RECALL.  The
272  * rfs4_cbinfo_t struct is meant to be encompassed in the client
273  * struct and managed within that structure's locking scheme.
274  *
275  * The various states of the callback path are used by the server to
276  * determine if delegations should initially be provided to a client
277  * and then later on if connectivity has been lost and delegations
278  * should be revoked.
279  */
280 
281 /*
282  * CB_NOCHANGE - Special value used for interfaces within the delegation
283  *		code to signify that "no change" has occurred to the
284  *		callback path
285  * CB_UNINIT	- No callback info provided by the client
286  * CB_NONE	- Callback info provided but CB_NULL call
287  *		  has yet to be attempted
288  * CB_OK	- Callback path tested with CB_NULL with success
289  * CB_INPROG	- Callback path currently being tested with CB_NULL
290  * CB_FAILED	- Callback path was == CB_OK but has failed
291  *		  with timeout/rpc error
292  * CB_BAD	- Callback info provided but CB_NULL failed
293  */
294 typedef enum {
295 	CB_NOCHANGE = 0,
296 	CB_UNINIT = 1,
297 	CB_NONE = 2,
298 	CB_OK = 3,
299 	CB_INPROG = 4,
300 	CB_FAILED = 5,
301 	CB_BAD = 6
302 } rfs4_cbstate_t;
303 
304 #define	RFS4_CBCH_MAX	10	/* size callback client handle cache */
305 /*
306  * Callback info for a client.
307  * Client only provides: cb_client4 and cb_ident
308  * The rest of the information is used to track callback path status
309  * and usage.
310  *
311  * cb_state - used as comments for the rfs4_cbstate_t enum indicate
312  * cb_notified_of_cb_path_down - if the callback path was once CB_OK and
313  *	has hence CB_FAILED, the client needs to be notified via RENEW.
314  * cb_timefailed - current time when cb_state transitioned from
315  *	CB_OK -> CB_FAILED.  Meant for observability.  When did that happen?
316  * cb_chc_free/cb_chc - cache of client handles for the callback path
317  * cb_ident - SETCLIENTID provided callback_ident value
318  * callback - SETCLIENTID provided cb_client4 value
319  * cb_refcnt - current number of users of this structure's content
320  *	protected by cb_lock
321  * cb_badbehavior - how many times did a client do something we didn't like?
322  * cb_lock - lock for contents of cbinfo
323  * cb_cv - used to allow threads to wait on CB_NULL completion
324  * cb_nullcaller - is there a thread currently taking care of
325  *	new callback information?
326  * cb_cv_nullcaller - used by the thread doing CB_NULL to wait on
327  *	threads that may be using client handles of the current
328  *	client handle cache.
329  * newer - new callback info provided by a client and awaiting
330  *	CB_NULL testing and move to regular cbinfo.
331  */
332 typedef struct {
333 	rfs4_cbstate_t	cb_state;
334 	unsigned	cb_notified_of_cb_path_down:1;
335 	time_t		cb_timefailed;
336 	int		cb_chc_free;
337 	CLIENT		*cb_chc[RFS4_CBCH_MAX];
338 	uint32_t	cb_ident;
339 	cb_client4	cb_callback;
340 	uint32_t	cb_refcnt;
341 	uint32_t	cb_badbehavior;
342 	kmutex_t	cb_lock[1];
343 	kcondvar_t	cb_cv[1];
344 	bool_t		cb_nullcaller;
345 	kcondvar_t	cb_cv_nullcaller[1];
346 	struct {
347 		bool_t		cb_new;
348 		bool_t		cb_confirmed;
349 		uint32_t	cb_ident;
350 		cb_client4	cb_callback;
351 	} cb_newer;
352 } rfs4_cbinfo_t;
353 
354 /*
355  * A server instance. We can associate sets of clients - via a pointer in
356  * rfs4_client_t - with a given server instance, allowing us to treat clients
357  * in the set differently to clients in other sets.
358  *
359  * Currently used only for Sun Cluster HA-NFS support, to group clients
360  * on NFS resource failover so each set of clients gets its own dedicated
361  * grace period and distributed stable storage data.
362  */
363 typedef struct rfs4_servinst {
364 	int			dss_npaths;
365 	krwlock_t		rwlock;
366 	krwlock_t		oldstate_lock;
367 	time_t			start_time;
368 	time_t			grace_period;
369 	uint_t			nreclaim;	/* number reclaim clients  */
370 	rfs4_oldstate_t		*oldstate;
371 	struct rfs4_dss_path	**dss_paths;
372 	struct rfs4_servinst	*next;
373 	struct rfs4_servinst	*prev;
374 } rfs4_servinst_t;
375 
376 /*
377  * DSS: distributed stable storage
378  */
379 
380 typedef struct rfs4_dss_path {
381 	struct rfs4_dss_path	*next; /* for insque/remque */
382 	struct rfs4_dss_path	*prev; /* for insque/remque */
383 	char			*path;
384 	struct rfs4_servinst	*sip;
385 	unsigned		index; /* offset in servinst's array */
386 } rfs4_dss_path_t;
387 
388 /* array of paths passed-in from nfsd command-line; stored in nvlist */
389 extern char		**rfs4_dss_newpaths;
390 extern uint_t		rfs4_dss_numnewpaths;
391 
392 /* nvlists of all DSS paths: current, and before last warmstart */
393 extern nvlist_t *rfs4_dss_paths, *rfs4_dss_oldpaths;
394 
395 /*
396  * The server maintains a set of state on a per client basis that
397  * matches that of the protocol requirements.  A client's state is
398  * rooted with the rfs4_client_t struct of which there is one per
399  * client and is created when SETCLIENTID/SETCLIENTID_CONFIRM are
400  * received.  From there, the server then creates rfs4_openowner_t
401  * structs for each new open owner from that client and are initiated
402  * at OPEN/OPEN_CONFIRM (when the open owner is new to the server).
403  * At OPEN, at least two other structures are created, and potentially a
404  * third.  rfs4_state_t is created to track the association between an
405  * open owner and a particular file. An rfs4_file_t struct may be
406  * created (if the file is not already open) at OPEN as well.  The
407  * rfs4_file_t struct is the only one that is per server and not per
408  * client.  The rfs4_deleg_state_t struct is created in the
409  * instance that the server is going to provide a delegation for the
410  * file being OPENed.  Finally, the rfs4_lockowner_t is created at the
411  * first use of a lock owner at the server and is a result of the LOCK
412  * operation.  The rfs4_lo_state_t struct is then created to represent
413  * the relation between the lock owner and the file.
414  *
415  */
416 /*
417  * The following ascii art represents each of these data structs and
418  * their references to each other.  Note: "<-(x)->" represents the
419  * doubly link lists (list_t).
420  *
421  *                          ____________________
422  *                         |                    |
423  *                         |    rfs4_client_t   |
424  *                       ->|         (1)        |<-
425  *                      /  |____________________|  \
426  *                     /              ^             \
427  *                    /               |              \
428  *  ____________________    ____________________    ____________________
429  * |                    |  |                    |  |                    |
430  * |  rfs4_lockowner_t  |  |  rfs4_openowner_t  |  | rfs4_deleg_state_t |
431  * |                    |  |     (3)    <-(1)-> |  |            <-(2)-> |
432  * |____________________|  |____________________|  |____________________|
433  *           ^                        ^                       |
434  *           |                        |                       V
435  *  ____________________    ____________________    ____________________
436  * |                    |  |                    |  |                    |
437  * |  rfs4_lo_state_t   |->|    rfs4_state_t    |->|     rfs4_file_t    |
438  * |            <-(4)-> |  |     (4)    <-(3)-> |  |        (2)         |
439  * |____________________|  |____________________|  |____________________|
440  */
441 /*
442  * Each of these data types are kept in a separate rfs4_table_t and is
443  * actually encapsulated within a rfs4_dbe_t struct.  The various
444  * tables and their construction is done in nfs4_state.c but
445  * documented here to completeness.
446  *
447  * Table		Data struct stored	Indexed by
448  * -----		------------------	----------
449  * rfs4_client_tab	rfs4_client_t		nfs_client_id4
450  *						clientid4
451  *
452  * rfs4_openowner_tab	rfs4_openowner_t	open_owner4
453  *
454  * rfs4_state_tab	rfs4_state_t		open_owner4 | file
455  *						stateid
456  *
457  * rfs4_lo_state_tab	rfs4_lo_state_t		lockowner | stateid
458  *						lock_stateid
459  *
460  * rfs4_lockowner_tab	rfs4_lockowner_t	lockowner
461  *						pid
462  *
463  * rfs4_file_tab	rfs4_file_t		filehandle
464  *
465  * rfs4_deleg_state_tab	rfs4_deleg_state_t	clientid4 | file
466  *						deleg_stateid
467  */
468 
469 /*
470  * The client struct, it is the root of all state for a particular
471  * client.  The client is identified by the nfs_client_id4 via
472  * SETCLIENTID and the server returns the clientid4 as short hand reference
473  */
474 /*
475  * Client struct - as mentioned above it is the root of all state for
476  * a single client as identified by the client supplied nfs_client_id4
477  *
478  * dbe - encapsulation struct
479  * clientid - server assigned short hand reference to client
480  * nfs_client - client supplied identifier for itself
481  * confirm_verf - the value provided to the client for SETCLIENTID_CONFIRM
482  * need_confirm - does this client need to be SETCLIENTID_CONFIRMed?
483  *
484  * unlksys_completed - has an F_UNLKSYS been done for this client which
485  *		says that the use of cleanlocks() on individual files
486  *		is not required?
487  * can_reclaim - indicates if client is allowed to reclaim after server
488  *		start-up (client had previous state at server)
489  * ss_remove - indicates that the rfs4_client_destroy function should
490  *		clean up stable storage file.
491  * forced_expire - set if the sysadmin has used clear_locks for this client.
492  * no_referrals - set if the client is Solaris and pre-dates referrals
493  * deleg_revoked - how many delegations have been revoked for this client?
494  *
495  * cp_confirmed - this refers to a confirmed client struct that has
496  * the same nfs_client_id4 as this client struct.  When/if this client
497  * struct is confirmed via SETCLINETID_CONFIRM, the previously
498  * confirmed client struct will be "closed" and hence this reference.
499  *
500  * last_access - used to determine if the client has let its lease expire
501  * cbinfo - struct containing all callback related information
502  * cr_set - credentials used for the SETCLIENTID/SETCLIENTID_CONFIRM pair
503  * sysid - the lock manager sysid allocated for this client's file locks
504  * openownerlist - root of openowners list associated with this client
505  * ss_pn - Pathname to the stable storage file.
506  * cl_addr - Clients network address.
507  * server_instance - pointer to the currently associated server instance
508  */
509 typedef struct rfs4_client {
510 	rfs4_dbe_t		*rc_dbe;
511 	clientid4		rc_clientid;
512 	nfs_client_id4		rc_nfs_client;
513 	verifier4		rc_confirm_verf;
514 	unsigned		rc_need_confirm:1;
515 	unsigned		rc_unlksys_completed:1;
516 	unsigned		rc_can_reclaim:1;
517 	unsigned		rc_ss_remove:1;
518 	unsigned		rc_forced_expire:1;
519 	unsigned		rc_reclaim_completed:1;
520 	uint_t			rc_deleg_revoked;
521 	struct rfs4_client	*rc_cp_confirmed;
522 	time_t			rc_last_access;
523 	rfs4_cbinfo_t		rc_cbinfo;
524 	cred_set_t		rc_cr_set;
525 	sysid_t			rc_sysidt;
526 	list_t			rc_openownerlist;
527 	rfs4_ss_pn_t		*rc_ss_pn;
528 	struct sockaddr_storage rc_addr;
529 	rfs4_servinst_t		*rc_server_instance;
530 
531 	/* nfsv4.1 */
532 	rfs41_csr_t		rc_contrived;
533 	rfs41_sprot_t		rc_state_prot;
534 	list_t			rc_sessions;
535 	unsigned		rc_destroying:1;    /* flag: going to destroy */
536 } rfs4_client_t;
537 
538 /*
539  * ClntIP struct - holds the diagnosis about whether the client
540  * cannot support referrals.  Set to true for old Solaris clients.
541  */
542 
543 typedef struct rfs4_clntip {
544 	rfs4_dbe_t		*ri_dbe;
545 	struct sockaddr_storage ri_addr;
546 	unsigned		ri_no_referrals:1;
547 } rfs4_clntip_t;
548 
549 /*
550  * The openowner contains the client supplied open_owner4 as well as
551  * the matching sequence id and is used to track the client's usage of
552  * the open_owner4.  Note that a reply is saved here as well for
553  * processing of retransmissions.
554  *
555  * dbe - encapsulation struct
556  * client - reference to rfs4_client_t for this openowner
557  * owner - actual client supplied open_owner4
558  * need_confirm - does this openowner need to be OPEN_CONFIRMed
559  * postpone_confirm - set if error received on first use of open_owner
560  * state2confirm - what stateid4 should be used on the OPEN_CONFIRM
561  * open_seqid - what is the next open_seqid expected for this openowner
562  * oo_sw - used to serialize access to the open seqid/reply handling
563  * statelist - root of state struct list associated with this openowner
564  * node - node for client struct list of openowners
565  * reply_fh - open replay processing needs the filehandle so that it is
566  *	able to reset the current filehandle for appropriate compound
567  *	processing and reply.
568  * reply - last reply sent in relation to this openowner
569  */
570 typedef struct rfs4_openowner {
571 	rfs4_dbe_t		*ro_dbe;
572 	rfs4_client_t		*ro_client;
573 	open_owner4		ro_owner;
574 	unsigned		ro_need_confirm:1;
575 	unsigned		ro_postpone_confirm:1;
576 	seqid4			ro_open_seqid;
577 	rfs4_state_wait_t	ro_sw;
578 	list_t			ro_statelist;
579 	list_node_t		ro_node;
580 	nfs_fh4			ro_reply_fh;
581 	nfs_resop4		ro_reply;
582 } rfs4_openowner_t;
583 
584 /*
585  * This state struct represents the association between an openowner
586  * and a file that has been OPENed by that openowner.
587  *
588  * dbe - encapsulation struct
589  * stateid - server provided stateid
590  * owner - reference back to the openowner for this state
591  * finfo - reference to the open file for this state
592  * open_access - how did the openowner OPEN the file (access)
593  * open_deny - how did the openowner OPEN the file (deny)
594  * share_access - what share reservation is on the file (access)
595  * share_deny - what share reservation is on the file (deny)
596  * closed - has this file been closed?
597  * lostatelist - root of list of lo_state associated with this state/file
598  * node - node for state struct list of states
599  */
600 typedef struct rfs4_state {
601 	rfs4_dbe_t		*rs_dbe;
602 	stateid_t		rs_stateid;
603 	rfs4_openowner_t	*rs_owner;
604 	struct rfs4_file	*rs_finfo;
605 	uint32_t		rs_open_access;
606 	uint32_t		rs_open_deny;
607 	uint32_t		rs_share_access;
608 	uint32_t		rs_share_deny;
609 	unsigned		rs_closed:1;
610 	list_t			rs_lostatelist;
611 	list_node_t		rs_node;
612 } rfs4_state_t;
613 
614 /*
615  * Lockowner - track the lockowner and its related info
616  *
617  * dbe - encapsulation struct
618  * client - reference to the client
619  * owner - lockowner supplied by the client
620  * pid - local identifier used for file locking
621  */
622 typedef struct rfs4_lockowner {
623 	rfs4_dbe_t		*rl_dbe;
624 	rfs4_client_t		*rl_client;
625 	lock_owner4		rl_owner;
626 	pid_t			rl_pid;
627 } rfs4_lockowner_t;
628 
629 /*
630  * Lockowner_state associated with a state struct and lockowner
631  *
632  * dbe - encapsulation struct
633  * state - reference back to state struct for open file
634  * lockid - stateid for this lockowner/state
635  * locker - reference to lockowner
636  * seqid - sequence id for this lockowner/state
637  * skip_seqid_check - used on initialization of struct
638  * locks_cleaned - have all locks been released for this lockowner/file?
639  * lock_completed - successful LOCK with lockowner/file?
640  * ls_sw - used to serialize update seqid/reply/stateid handling
641  * node - node for state struct list of lo_states
642  * reply - last reply sent in relation to this lockowner/state
643  */
644 typedef struct rfs4_lo_state {
645 	rfs4_dbe_t		*rls_dbe;
646 	rfs4_state_t		*rls_state;
647 	stateid_t		rls_lockid;
648 	rfs4_lockowner_t	*rls_locker;
649 	seqid4			rls_seqid;
650 	unsigned		rls_skip_seqid_check:1;
651 	unsigned		rls_locks_cleaned:1;
652 	unsigned		rls_lock_completed:1;
653 	rfs4_state_wait_t	rls_sw;
654 	list_node_t		rls_node;
655 	nfs_resop4		rls_reply;
656 } rfs4_lo_state_t;
657 
658 /*
659  * Delegation state - per client
660  *
661  * dbe - encapsulation struct
662  * dtype - type of delegation (NONE, READ, WRITE)
663  * delegid - stateid for this delegation
664  * time_granted - time this delegation was assigned to client
665  * time_recalled - time when the server started recall process
666  * time_revoked - if revoked, time that the revoke occurred
667  * finfo - reference to the file associated with this delegation
668  * client - reference to client for which this delegation is associated
669  * node - list of delegations for the file (WRITE == 1, READ == )
670  */
671 typedef struct rfs4_deleg_state {
672 	rfs4_dbe_t		*rds_dbe;
673 	open_delegation_type4	rds_dtype;
674 	stateid_t		rds_delegid;
675 	time_t			rds_time_granted;
676 	time_t			rds_time_recalled;
677 	time_t			rds_time_revoked;
678 	struct rfs4_file	*rds_finfo;
679 	rfs4_client_t		*rds_client;
680 	list_node_t		rds_node;
681 } rfs4_deleg_state_t;
682 
683 /*
684  * Delegation info associated with the file
685  *
686  * dtype - type of delegation for file (NONE, READ, WRITE)
687  * time_returned - time that last delegation was returned for file
688  * time_recalled - time that recall sequence started
689  * time_lastgrant - time that last delegation was provided to a client
690  * time_lastwrite - time of last write to use the delegation stateid
691  * time_rm_delayed - time of last remove/rename which was DELAYed
692  * rdgrants - how many read delegations have been provided for this file
693  * wrgrants - how many write delegations provided (can only be one)
694  * recall_count - how many recall threads are outstanding
695  * recall_lock - lock to protect contents of this struct
696  * recall_cv - condition var for the "parent" thread to wait upon
697  * deleg_change_grant - value for change attribute at time of write grant
698  * deleg_change - most recent value of change obtained from client
699  * deleg_change_ts - time of last deleg_change update
700  * ever_recalled - has this particular delegation ever been recalled?
701  * dont_grant - file deletion is impending, don't grant a delegation
702  * conflicted_client - clientid of the client that caused a CB_RECALL
703  *	to occur. This is used for delegation policy (should a delegation
704  *	be granted shortly after it has been returned?)
705  */
706 typedef struct rfs4_dinfo {
707 	open_delegation_type4 rd_dtype;
708 	time_t		rd_time_returned;
709 	time_t		rd_time_recalled;
710 	time_t		rd_time_lastgrant;
711 	time_t		rd_time_lastwrite;
712 	time_t		rd_time_rm_delayed;
713 	uint32_t	rd_rdgrants;
714 	uint32_t	rd_wrgrants;
715 	int32_t		rd_recall_count;
716 	kmutex_t	rd_recall_lock[1];
717 	kcondvar_t	rd_recall_cv[1];
718 	bool_t		rd_ever_recalled;
719 	uint32_t	rd_hold_grant;
720 	clientid4	rd_conflicted_client;
721 } rfs4_dinfo_t;
722 
723 /*
724  * File
725  *
726  * dbe - encapsulation struct
727  * vp - vnode for the file that is open or has a delegation
728  * filehandle - the filehandle generated by the server for this file
729  * delegstatelist - root of delegation list for this file
730  * dinfo - see struct definition above
731  * share_deny - union of all deny modes on file
732  * share_access - union of all access modes on file
733  * access_read - count of read access
734  * access_write - count of write access
735  * deny_read - count of deny reads
736  * deny_write - count of deny writes
737  * file_rwlock - lock for serializing the removal of a file while
738  *	the state structures are active within the server
739  *
740  *	The only requirement for locking file_rwlock is that the
741  *	caller have a reference to the containing rfs4_file.  The dbe
742  *	lock may or may not be held for lock/unlock of file_rwlock.
743  *	As mentioned above, the file_rwlock is used for serialization
744  *	of file removal and more specifically reference to the held
745  *	vnode (e.g. vp).
746  */
747 typedef struct rfs4_file {
748 	rfs4_dbe_t	*rf_dbe;
749 	vnode_t		*rf_vp;
750 	nfs_fh4		rf_filehandle;
751 	list_t		rf_delegstatelist;
752 	rfs4_dinfo_t	rf_dinfo;
753 	uint32_t	rf_share_deny;
754 	uint32_t	rf_share_access;
755 	uint32_t	rf_access_read;
756 	uint32_t	rf_access_write;
757 	uint32_t	rf_deny_read;
758 	uint32_t	rf_deny_write;
759 	krwlock_t	rf_file_rwlock;
760 } rfs4_file_t;
761 
762 /*
763  * nfs4_deleg_policy is used to signify the server's global delegation
764  * policy.  The default is to NEVER delegate files and the
765  * administrator must configure the server to enable delegations.
766  *
767  * The disable/enable delegation functions are used to eliminate a
768  * race with exclusive creates.
769  */
770 typedef enum {
771 	SRV_NEVER_DELEGATE = 0,
772 	SRV_NORMAL_DELEGATE = 1
773 } srv_deleg_policy_t;
774 
775 extern void rfs4_disable_delegation(void), rfs4_enable_delegation(void);
776 
777 /*
778  * Request types for delegation. These correspond with
779  * open_delegation_type4 with the addition of a new value, DELEG_ANY,
780  * to reqequest any delegation.
781  */
782 typedef enum {
783 	DELEG_NONE = 0,		/* Corresponds to OPEN_DELEG_NONE */
784 	DELEG_READ = 1,		/* Corresponds to OPEN_DELEG_READ */
785 	DELEG_WRITE = 2,	/* Corresponds to OPEN_DELEG_WRITE */
786 	DELEG_ANY = -1		/* New value to request any delegation type */
787 } delegreq_t;
788 
789 #define	NFS4_DELEG4TYPE2REQTYPE(x) (delegreq_t)(x)
790 
791 /*
792  * Zone global variables of NFSv4 server
793  */
794 typedef struct nfs4_srv {
795 	/* Unique write verifier */
796 	verifier4	write4verf;
797 	/* Delegation lock */
798 	kmutex_t	deleg_lock;
799 	/* Used to serialize create/destroy of nfs4_server_state database */
800 	kmutex_t	state_lock;
801 	rfs4_database_t *nfs4_server_state;
802 	/* Used to manage access to server instance linked list */
803 	kmutex_t	servinst_lock;
804 	rfs4_servinst_t *nfs4_cur_servinst;
805 	/* Used to manage access to nfs4_deleg_policy */
806 	krwlock_t	deleg_policy_lock;
807 	srv_deleg_policy_t nfs4_deleg_policy;
808 	/* Allowed minors, nfs4 minors start from 0, which is always allowed */
809 	nfs4_minor_t	nfs4_minor_max;
810 	/* Set first time we see one */
811 	int		seen_first_compound;
812 	/*
813 	 * Circular double-linked list of paths for currently-served RGs.
814 	 * No locking required -- only changed on server start.
815 	 * Managed with insque/remque.
816 	 */
817 	rfs4_dss_path_t	*dss_pathlist;
818 	/* Duplicate request cache */
819 	struct rfs4_drc	*nfs4_drc;
820 	/* nfsv4 server start time */
821 	time_t rfs4_start_time;
822 	/* Used to serialize lookups of clientids */
823 	krwlock_t rfs4_findclient_lock;
824 
825 	/* NFSv4 server state client tables */
826 	/* table expiry times */
827 	time_t rfs4_client_cache_time;
828 	time_t rfs4_openowner_cache_time;
829 	time_t rfs4_state_cache_time;
830 	time_t rfs4_lo_state_cache_time;
831 	time_t rfs4_lockowner_cache_time;
832 	time_t rfs4_file_cache_time;
833 	time_t rfs4_deleg_state_cache_time;
834 	time_t rfs4_clntip_cache_time;
835 	/* tables and indexes */
836 	/* client table */
837 	rfs4_table_t *rfs4_client_tab;
838 	rfs4_index_t *rfs4_clientid_idx;
839 	rfs4_index_t *rfs4_nfsclnt_idx;
840 	/* client IP table */
841 	rfs4_table_t *rfs4_clntip_tab;
842 	rfs4_index_t *rfs4_clntip_idx;
843 	/* Open Owner table */
844 	rfs4_table_t *rfs4_openowner_tab;
845 	rfs4_index_t *rfs4_openowner_idx;
846 	/* Open State ID table */
847 	rfs4_table_t *rfs4_state_tab;
848 	rfs4_index_t *rfs4_state_idx;
849 	rfs4_index_t *rfs4_state_owner_file_idx;
850 	rfs4_index_t *rfs4_state_file_idx;
851 	/* Lock State ID table */
852 	rfs4_table_t *rfs4_lo_state_tab;
853 	rfs4_index_t *rfs4_lo_state_idx;
854 	rfs4_index_t *rfs4_lo_state_owner_idx;
855 	/* Lock owner table */
856 	rfs4_table_t *rfs4_lockowner_tab;
857 	rfs4_index_t *rfs4_lockowner_idx;
858 	rfs4_index_t *rfs4_lockowner_pid_idx;
859 	/* File table */
860 	rfs4_table_t *rfs4_file_tab;
861 	rfs4_index_t *rfs4_file_idx;
862 	/* Deleg State table */
863 	rfs4_table_t *rfs4_deleg_state_tab;
864 	rfs4_index_t *rfs4_deleg_idx;
865 	rfs4_index_t *rfs4_deleg_state_idx;
866 
867 	/* nfs4.x */
868 	rfs4_table_t	*rfs4_session_tab;
869 	rfs4_index_t	*rfs4_session_idx;
870 
871 	/* client stable storage */
872 	int rfs4_ss_enabled;
873 } nfs4_srv_t;
874 
875 /*
876  * max length of the NFSv4 server database name
877  */
878 #define	RFS4_MAX_MEM_CACHE_NAME 48
879 
880 /*
881  * global NFSv4 server kmem caches
882  * r_db_name - The name of the state database and the table that will use it
883  *             These tables are defined in nfs4_srv_t
884  * r_db_mem_cache - The kmem cache associated with the state database name
885  */
886 typedef struct rfs4_db_mem_cache {
887 	char		r_db_name[RFS4_MAX_MEM_CACHE_NAME];
888 	kmem_cache_t	*r_db_mem_cache;
889 } rfs4_db_mem_cache_t;
890 
891 #define	RFS4_DB_MEM_CACHE_NUM 9
892 
893 extern rfs4_db_mem_cache_t rfs4_db_mem_cache_table[RFS4_DB_MEM_CACHE_NUM];
894 
895 extern srv_deleg_policy_t nfs4_get_deleg_policy();
896 
897 extern void		rfs4_servinst_create(nfs4_srv_t *, int, int, char **);
898 extern void		rfs4_servinst_destroy_all(nfs4_srv_t *);
899 extern void		rfs4_servinst_assign(nfs4_srv_t *, rfs4_client_t *,
900 			    rfs4_servinst_t *);
901 extern rfs4_servinst_t	*rfs4_servinst(rfs4_client_t *);
902 extern int		rfs4_clnt_in_grace(rfs4_client_t *);
903 extern int		rfs4_servinst_in_grace(rfs4_servinst_t *);
904 extern int		rfs4_servinst_grace_new(rfs4_servinst_t *);
905 extern void		rfs4_grace_start(rfs4_servinst_t *);
906 extern void		rfs4_grace_start_new(nfs4_srv_t *);
907 extern void		rfs4_grace_reset_all(nfs4_srv_t *);
908 extern void		rfs4_dss_readstate(nfs4_srv_t *, int, char **);
909 
910 /*
911  * Various interfaces to manipulate the state structures introduced
912  * above
913  */
914 extern	void		rfs4_free_reply(nfs_resop4 *);
915 extern	void		rfs4_copy_reply(nfs_resop4 *, nfs_resop4 *);
916 
917 /* rfs4_client_t handling */
918 extern	rfs4_client_t	*rfs4_findclient(nfs_client_id4 *,
919 					bool_t *, rfs4_client_t *);
920 extern	rfs4_client_t	*rfs4_findclient_by_id(clientid4, bool_t);
921 extern	rfs4_client_t	*rfs4_findclient_by_addr(struct sockaddr *);
922 extern	void		rfs4_client_rele(rfs4_client_t *);
923 extern	void		rfs4_client_close(rfs4_client_t *);
924 extern	void		rfs4_client_state_remove(rfs4_client_t *);
925 extern	void		rfs4_client_scv_next(rfs4_client_t *);
926 extern	void		rfs4_update_lease(rfs4_client_t *);
927 extern	bool_t		rfs4_lease_expired(rfs4_client_t *);
928 extern	nfsstat4	rfs4_check_clientid(clientid4 *, int);
929 
930 /* rfs4_clntip_t handling */
931 extern	rfs4_clntip_t	*rfs4_find_clntip(struct sockaddr *, bool_t *);
932 extern	void		rfs4_invalidate_clntip(struct sockaddr *);
933 
934 /* rfs4_openowner_t handling */
935 extern	rfs4_openowner_t *rfs4_findopenowner(open_owner4 *, bool_t *, seqid4);
936 extern	void		rfs4_update_open_sequence(rfs4_openowner_t *);
937 extern	void		rfs4_update_open_resp(rfs4_openowner_t *,
938 					nfs_resop4 *, nfs_fh4 *);
939 extern	void		rfs4_openowner_rele(rfs4_openowner_t *);
940 extern	void		rfs4_free_opens(rfs4_openowner_t *, bool_t, bool_t);
941 
942 /* rfs4_lockowner_t handling */
943 extern	rfs4_lockowner_t *rfs4_findlockowner(lock_owner4 *, bool_t *);
944 extern	rfs4_lockowner_t *rfs4_findlockowner_by_pid(pid_t);
945 extern	void		rfs4_lockowner_rele(rfs4_lockowner_t *);
946 
947 /* rfs4_state_t handling */
948 extern	rfs4_state_t	*rfs4_findstate_by_owner_file(rfs4_openowner_t *,
949 					rfs4_file_t *, bool_t *);
950 extern	void		rfs4_state_rele(rfs4_state_t *);
951 extern	void		rfs4_state_close(rfs4_state_t *, bool_t,
952 					bool_t, cred_t *);
953 extern	void		rfs4_release_share_lock_state(rfs4_state_t *,
954 					cred_t *, bool_t);
955 extern	void		rfs4_close_all_state(rfs4_file_t *);
956 
957 /* rfs4_lo_state_t handling */
958 extern	rfs4_lo_state_t *rfs4_findlo_state_by_owner(rfs4_lockowner_t *,
959 						rfs4_state_t *, bool_t *);
960 extern	void		rfs4_lo_state_rele(rfs4_lo_state_t *, bool_t);
961 extern	void		rfs4_update_lock_sequence(rfs4_lo_state_t *);
962 extern	void		rfs4_update_lock_resp(rfs4_lo_state_t *,
963 					nfs_resop4 *);
964 
965 /* rfs4_file_t handling */
966 extern	rfs4_file_t	*rfs4_findfile(vnode_t *, nfs_fh4 *, bool_t *);
967 extern	rfs4_file_t	*rfs4_findfile_withlock(vnode_t *, nfs_fh4 *,
968 						bool_t *);
969 extern	void		rfs4_file_rele(rfs4_file_t *);
970 
971 /* General collection of "get state" functions */
972 extern	nfsstat4	rfs4_get_state(stateid4 *, rfs4_state_t **,
973 					rfs4_dbsearch_type_t);
974 extern	nfsstat4	rfs4_get_deleg_state(stateid4 *,
975 					rfs4_deleg_state_t **);
976 extern	nfsstat4	rfs4_get_lo_state(stateid4 *, rfs4_lo_state_t **,
977 					bool_t);
978 struct compound_state;
979 extern	nfsstat4	rfs4_check_stateid(int, vnode_t *, stateid4 *,
980 					bool_t, bool_t *, bool_t,
981 					caller_context_t *,
982 					struct compound_state *);
983 extern	int		rfs4_check_stateid_seqid(rfs4_state_t *, stateid4 *,
984 					const struct compound_state *);
985 extern	int		rfs4_check_lo_stateid_seqid(rfs4_lo_state_t *,
986 					stateid4 *,
987 					const struct compound_state *);
988 
989 /* return values for rfs4_check_stateid_seqid() */
990 #define	NFS4_CHECK_STATEID_OKAY	1
991 #define	NFS4_CHECK_STATEID_OLD	2
992 #define	NFS4_CHECK_STATEID_BAD	3
993 #define	NFS4_CHECK_STATEID_EXPIRED	4
994 #define	NFS4_CHECK_STATEID_REPLAY	5
995 #define	NFS4_CHECK_STATEID_CLOSED	6
996 #define	NFS4_CHECK_STATEID_UNCONFIRMED	7
997 
998 /* delay() time that server is willing to briefly wait for a delegreturn */
999 #define	NFS4_DELEGATION_CONFLICT_DELAY	(hz/10)
1000 
1001 /*
1002  * Interfaces for handling of callback's client handle cache and
1003  * callback interfaces themselves.
1004  */
1005 extern	void		rfs4_cbinfo_free(rfs4_cbinfo_t *);
1006 extern	void		rfs4_client_setcb(rfs4_client_t *, cb_client4 *,
1007 					uint32_t);
1008 extern	void		rfs4_deleg_cb_check(rfs4_client_t *);
1009 extern	nfsstat4	rfs4_vop_getattr(vnode_t *, vattr_t *, int, cred_t *);
1010 
1011 /* rfs4_deleg_state_t handling and other delegation interfaces */
1012 extern	rfs4_deleg_state_t *rfs4_finddeleg(rfs4_state_t *, bool_t *);
1013 extern	rfs4_deleg_state_t *rfs4_finddelegstate(stateid_t *);
1014 extern	bool_t		rfs4_check_recall(rfs4_state_t *, uint32_t);
1015 extern	void		rfs4_recall_deleg(rfs4_file_t *,
1016 				bool_t, rfs4_client_t *);
1017 extern	int		rfs4_get_deleg(rfs4_state_t *,  open_delegation_type4,
1018 			open_delegation_type4 (*policy)(rfs4_state_t *,
1019 				open_delegation_type4 dtype));
1020 extern	rfs4_deleg_state_t *rfs4_grant_delegation(delegreq_t, rfs4_state_t *,
1021 				int *);
1022 extern	void		rfs4_set_deleg_response(rfs4_deleg_state_t *,
1023 				open_delegation4 *, nfsace4 *, int);
1024 extern	void		rfs4_return_deleg(rfs4_deleg_state_t *, bool_t);
1025 extern	bool_t		rfs4_is_deleg(rfs4_state_t *);
1026 extern	void		rfs4_deleg_state_rele(rfs4_deleg_state_t *);
1027 extern	bool_t		rfs4_check_delegated_byfp(int, rfs4_file_t *,
1028 					bool_t, bool_t, bool_t, clientid4 *);
1029 extern	void		rfs4_clear_dont_grant(rfs4_file_t *);
1030 
1031 /*
1032  * nfs4 monitored operations.
1033  */
1034 extern int deleg_rd_open(femarg_t *, int, cred_t *, caller_context_t *);
1035 extern int deleg_wr_open(femarg_t *, int, cred_t *, caller_context_t *);
1036 extern int deleg_wr_read(femarg_t *, uio_t *, int, cred_t *,
1037 	    caller_context_t *);
1038 extern int deleg_rd_write(femarg_t *, uio_t *, int, cred_t *,
1039 	    caller_context_t *);
1040 extern int deleg_wr_write(femarg_t *, uio_t *, int, cred_t *,
1041 	    caller_context_t *);
1042 extern int deleg_rd_setattr(femarg_t *, vattr_t *, int, cred_t *,
1043 		caller_context_t *);
1044 extern int deleg_wr_setattr(femarg_t *, vattr_t *, int, cred_t *,
1045 		caller_context_t *);
1046 extern int deleg_rd_rwlock(femarg_t *, int, caller_context_t *);
1047 extern int deleg_wr_rwlock(femarg_t *, int, caller_context_t *);
1048 extern int deleg_rd_space(femarg_t *, int, flock64_t *, int, offset_t, cred_t *,
1049 		caller_context_t *);
1050 extern int deleg_wr_space(femarg_t *, int, flock64_t *, int, offset_t, cred_t *,
1051 		caller_context_t *);
1052 extern int deleg_rd_setsecattr(femarg_t *, vsecattr_t *, int, cred_t *,
1053 		caller_context_t *);
1054 extern int deleg_wr_setsecattr(femarg_t *, vsecattr_t *, int, cred_t *,
1055 		caller_context_t *);
1056 extern int deleg_rd_vnevent(femarg_t *, vnevent_t, vnode_t *, char *,
1057 		caller_context_t *);
1058 extern int deleg_wr_vnevent(femarg_t *, vnevent_t, vnode_t *, char *,
1059 		caller_context_t *);
1060 
1061 extern void rfs4_mon_hold(void *);
1062 extern void rfs4_mon_rele(void *);
1063 
1064 extern fem_t	*deleg_rdops;
1065 extern fem_t	*deleg_wrops;
1066 
1067 extern int rfs4_share(rfs4_state_t *, uint32_t, uint32_t);
1068 extern int rfs4_unshare(rfs4_state_t *);
1069 extern void rfs4_set_deleg_policy(nfs4_srv_t *, srv_deleg_policy_t);
1070 extern void rfs4_hold_deleg_policy(nfs4_srv_t *);
1071 extern void rfs4_rele_deleg_policy(nfs4_srv_t *);
1072 
1073 #ifdef DEBUG
1074 #define	NFS4_DEBUG(var, args) if (var) cmn_err args
1075 
1076 extern int rfs4_debug;
1077 extern int nfs4_client_attr_debug;
1078 extern int nfs4_client_state_debug;
1079 extern int nfs4_client_shadow_debug;
1080 extern int nfs4_client_lock_debug;
1081 extern int nfs4_client_lease_debug;
1082 extern int nfs4_seqid_sync;
1083 extern int nfs4_client_map_debug;
1084 extern int nfs4_client_inactive_debug;
1085 extern int nfs4_client_recov_debug;
1086 extern int nfs4_client_failover_debug;
1087 extern int nfs4_client_call_debug;
1088 extern int nfs4_client_foo_debug;
1089 extern int nfs4_client_zone_debug;
1090 extern int nfs4_lost_rqst_debug;
1091 extern int nfs4_open_stream_debug;
1092 extern int nfs4_client_open_dg;
1093 extern int nfs4_srvmnt_debug;
1094 extern int nfs4_utf8_debug;
1095 
1096 void rfs4_dbe_debug(rfs4_dbe_t *e);
1097 
1098 #ifdef NFS4_DEBUG_MUTEX
1099 void nfs4_debug_mutex_enter(kmutex_t *, char *, int);
1100 void nfs4_debug_mutex_exit(kmutex_t *, char *, int);
1101 
1102 #define	mutex_enter(m) nfs4_debug_mutex_enter((m), __FILE__, __LINE__)
1103 #define	mutex_exit(m) nfs4_debug_mutex_exit((m), __FILE__, __LINE__)
1104 #endif /* NFS4_DEBUG_MUTEX */
1105 
1106 #else  /* ! DEBUG */
1107 #define	NFS4_DEBUG(var, args)
1108 #endif /* DEBUG */
1109 
1110 /*
1111  * XXX - temporary for testing of volatile fh
1112  */
1113 
1114 #ifdef VOLATILE_FH_TEST
1115 
1116 struct nfs_fh4_fmt {
1117 	fhandle4_t	fh4_i;
1118 	uint32_t	fh4_flag;
1119 	uint32_t	fh4_volatile_id;
1120 };
1121 
1122 #else /* VOLATILE_FH_TEST */
1123 
1124 struct nfs_fh4_fmt {
1125 	fhandle4_t	fh4_i;
1126 	uint32_t	fh4_flag;
1127 };
1128 
1129 #endif /* VOLATILE_FH_TEST */
1130 
1131 #define	FH4_NAMEDATTR	1
1132 #define	FH4_ATTRDIR	2
1133 
1134 #define	fh4_fsid	fh4_i.fhx_fsid
1135 #define	fh4_len		fh4_i.fhx_len	/* fid length */
1136 #define	fh4_data	fh4_i.fhx_data	/* fid bytes */
1137 #define	fh4_xlen	fh4_i.fhx_xlen
1138 #define	fh4_xdata	fh4_i.fhx_xdata
1139 typedef struct nfs_fh4_fmt nfs_fh4_fmt_t;
1140 
1141 #define	fh4_to_fmt4(fh4p) ((nfs_fh4_fmt_t *)(fh4p)->nfs_fh4_val)
1142 #define	get_fh4_flag(fh4p, flag) ((fh4_to_fmt4(fh4p)->fh4_flag) & (flag))
1143 #define	set_fh4_flag(fh4p, flag) ((fh4_to_fmt4(fh4p)->fh4_flag) |= (flag))
1144 #define	clr_fh4_flag(fh4p, flag) ((fh4_to_fmt4(fh4p)->fh4_flag) &= ~(flag))
1145 
1146 #define	NFS_FH4_LEN	sizeof (nfs_fh4_fmt_t)
1147 
1148 /*
1149  * Copy fields from external (fhandle_t) to in-memory (nfs_fh4_fmt_t)
1150  * format to support export info checking.  It does not copy over
1151  * the complete filehandle, just the fsid, xlen and xdata.  It may
1152  * need to be changed to be used in other places.
1153  *
1154  * NOTE: The macro expects the space to be  pre-allocated for
1155  * the contents of nfs_fh4_fmt_t.
1156  */
1157 #define	FH_TO_FMT4(exifh, nfs_fmt) {				\
1158 	bzero((nfs_fmt), NFS_FH4_LEN);				\
1159 	(nfs_fmt)->fh4_fsid = (exifh)->fh_fsid;			\
1160 	(nfs_fmt)->fh4_xlen = (exifh)->fh_xlen;			\
1161 	bcopy((exifh)->fh_xdata, (nfs_fmt)->fh4_xdata,		\
1162 	    (exifh)->fh_xlen);					\
1163 }
1164 
1165 /*
1166  * A few definitions of repeatedly used constructs for nfsv4
1167  */
1168 #define	UTF8STRING_FREE(str)	{				\
1169 	kmem_free((str).utf8string_val,	(str).utf8string_len);	\
1170 	(str).utf8string_val = NULL;				\
1171 	(str).utf8string_len = 0;				\
1172 }
1173 
1174 /*
1175  * NFS4_VOLATILE_FH yields non-zero if the filesystem uses non-persistent
1176  * filehandles.
1177  */
1178 #define	NFS4_VOLATILE_FH(mi)					\
1179 	((mi)->mi_fh_expire_type &				\
1180 	(FH4_VOLATILE_ANY | FH4_VOL_MIGRATION | FH4_VOL_RENAME))
1181 
1182 /*
1183  * NFS_IS_DOTNAME checks if the name given represents a dot or dotdot entry
1184  */
1185 #define	NFS_IS_DOTNAME(name)					\
1186 	(((name)[0] == '.') &&					\
1187 	(((name)[1] == '\0') || (((name)[1] == '.') && ((name)[2] == '\0'))))
1188 
1189 /*
1190  * Define the number of bits in a bitmap word (uint32)
1191  */
1192 #define	NFS4_BITMAP4_BITSPERWORD	(sizeof (uint32_t) * 8)
1193 
1194 /*
1195  * Define the value for the access field of the compound_state structure
1196  * based on the result of nfsauth access checking.
1197  */
1198 #define	CS_ACCESS_OK		0x1
1199 #define	CS_ACCESS_DENIED	0x2
1200 #define	CS_ACCESS_LIMITED	0x4
1201 
1202 /*
1203  * compound state in nfsv4 server
1204  */
1205 struct compound_state {
1206 	struct exportinfo *exi;
1207 	struct exportinfo *saved_exi;	/* export struct for saved_vp */
1208 	cred_t		*basecr;	/* UNIX cred:  only RPC request */
1209 	caddr_t		principal;
1210 	int		nfsflavor;
1211 	cred_t		*cr;		/* UNIX cred: RPC request and */
1212 					/* target export */
1213 	bool_t		cont;
1214 	uint_t		access;		/* access perm on vp per request */
1215 	bool_t		deleg;		/* TRUE if current fh has */
1216 					/* write delegated */
1217 	vnode_t		*vp;		/* modified by PUTFH, and by ops that */
1218 					/* input to GETFH */
1219 	bool_t		mandlock;	/* Is mandatory locking in effect */
1220 					/* for vp */
1221 	vnode_t		*saved_vp;	/* modified by SAVEFH, copied to */
1222 					/* vp by RESTOREFH */
1223 	nfsstat4	*statusp;
1224 	nfs_fh4		fh;		/* ditto. valid only if vp != NULL */
1225 	nfs_fh4		saved_fh;	/* ditto. valid only if */
1226 					/*	saved_vp != NULL */
1227 	struct svc_req	*req;
1228 	char		fhbuf[NFS4_FHSIZE];
1229 
1230 	/* NFSv4.1 */
1231 	uint8_t		minorversion;	/* NFS4 minor version */
1232 	rfs4_session_t	*sp;		/* OP_SEQUENCE set it */
1233 	slotid4		slotno;
1234 	rfs4_slot_t	*slot;
1235 	rfs4_client_t	*client;
1236 	uint16_t	op_pos;
1237 	uint16_t	op_len;		/* number operations in compound req */
1238 #define	RFS4_DISPATCH_DONE	(1 << 0)
1239 	uint8_t		cs_flags;
1240 	bool_t		cachethis;
1241 	COMPOUND4res	*cmpresp;
1242 };
1243 
1244 typedef struct compound_state compound_state_t;
1245 
1246 static inline bool_t
rfs4_has_session(const compound_state_t * cs)1247 rfs4_has_session(const compound_state_t *cs)
1248 {
1249 	return (cs->slot != NULL);
1250 }
1251 
1252 /*
1253  * Conversion commands for nfsv4 server attr checking
1254  */
1255 enum nfs4_attr_cmd {
1256 	NFS4ATTR_SUPPORTED = 0,		/* check which attrs supported */
1257 	NFS4ATTR_GETIT = 1,		/* getattr - sys to fattr4 (r) */
1258 	NFS4ATTR_SETIT = 2,		/* setattr - fattr4 to sys (w) */
1259 	NFS4ATTR_VERIT = 3,		/* verify - fattr4 to sys (r) */
1260 	NFS4ATTR_FREEIT = 4		/* free any alloc'd space for attr */
1261 };
1262 
1263 typedef enum nfs4_attr_cmd nfs4_attr_cmd_t;
1264 
1265 struct nfs4_svgetit_arg {
1266 	nfs4_attr_cmd_t op;		/* getit or setit */
1267 	struct compound_state *cs;
1268 	struct statvfs64 *sbp;
1269 	uint_t		flag;		/* VOP_GETATTR/VOP_SETATTR flag */
1270 	uint_t		xattr;		/* object is xattr */
1271 	bool_t		rdattr_error_req; /* if readdir & client wants */
1272 						/* rdattr_error */
1273 	nfsstat4	rdattr_error;	/* used for per-entry status */
1274 					/* (if rdattr_err) */
1275 	bool_t		is_referral;	/* because sometimes we tell lies */
1276 	bool_t		mntdfid_set;
1277 
1278 	fattr4_mounted_on_fileid
1279 			mounted_on_fileid;
1280 					/* readdir op can always return	*/
1281 					/* d_ino from server fs dirent  */
1282 					/* for mounted_on_fileid attr.	*/
1283 					/* This field holds d_ino so	*/
1284 					/* srv attr conv code can avoid */
1285 					/* doing an untraverse.		*/
1286 	vattr_t		vap[1];
1287 };
1288 
1289 struct nfs4_ntov_map {
1290 	bitmap4		fbit;		/* FATTR4_XXX_MASKY */
1291 	uint_t		vbit;		/* AT_XXX */
1292 	bool_t		vfsstat;
1293 	bool_t		mandatory;	/* attribute mandatory to implement? */
1294 	uint_t		nval;
1295 	int		xdr_size;	/* Size of XDR'd attr */
1296 	xdrproc_t	xfunc;
1297 	int (*sv_getit)(nfs4_attr_cmd_t, struct nfs4_svgetit_arg *,
1298 		union nfs4_attr_u *);	/* subroutine for getting attr. */
1299 	char		*prtstr;	/* string attr for printing */
1300 };
1301 
1302 struct nfs4attr_to_vattr {
1303 	vnode_t		*vp;
1304 	vattr_t		*vap;
1305 	nfs_fh4		*fhp;
1306 	nfsstat4	rdattr_error;
1307 	uint32_t	flag;
1308 	fattr4_change	change;
1309 	fattr4_fsid	srv_fsid;
1310 	fattr4_mounted_on_fileid	mntd_fid;
1311 };
1312 
1313 typedef struct nfs4attr_to_vattr ntov4_t;
1314 
1315 /*
1316  * nfs4attr_to_vattr flags
1317  */
1318 #define	NTOV_FHP_VALID			0x01
1319 #define	NTOV_RDATTR_ERROR_VALID		0x02
1320 #define	NTOV_CHANGE_VALID		0x04
1321 #define	NTOV_SUPP_VALID			0x08
1322 #define	NTOV_SRV_FSID_VALID		0x10
1323 #define	NTOV_MOUNTED_ON_FILEID_VALID	0x20
1324 
1325 
1326 #define	FATTR4_MANDATTR_MASK (		\
1327 	FATTR4_SUPPORTED_ATTRS_MASK |	\
1328 	FATTR4_TYPE_MASK |		\
1329 	FATTR4_FH_EXPIRE_TYPE_MASK |	\
1330 	FATTR4_CHANGE_MASK |		\
1331 	FATTR4_SIZE_MASK |		\
1332 	FATTR4_LINK_SUPPORT_MASK |	\
1333 	FATTR4_SYMLINK_SUPPORT_MASK |	\
1334 	FATTR4_NAMED_ATTR_MASK |	\
1335 	FATTR4_FSID_MASK |		\
1336 	FATTR4_UNIQUE_HANDLES_MASK |	\
1337 	FATTR4_LEASE_TIME_MASK |	\
1338 	FATTR4_RDATTR_ERROR_MASK |	\
1339 	FATTR4_FILEHANDLE_MASK)
1340 
1341 
1342 struct nfs4attr_to_osattr {
1343 	void *attrconv_arg;
1344 	uint_t mask;
1345 };
1346 
1347 struct mntinfo4;
1348 
1349 /*
1350  * lkp4_attr_setup lists the different options for attributes when calling
1351  * nfs4lookup_setup - either no attributes (just lookups - e.g., secinfo),
1352  * one component only (normal component lookup), get attributes for the
1353  * last component (e.g., mount), attributes for each component (e.g.,
1354  * failovers later), just the filehandle for the last component (e.g.,
1355  * volatile filehandle recovery), or stuff that needs OPENATTR (e.g.
1356  * looking up a named attribute or it's hidden directory).
1357  */
1358 enum lkp4_attr_setup {
1359 	LKP4_NO_ATTRIBUTES = 0,		/* no attrs or filehandles */
1360 	LKP4_ALL_ATTRIBUTES = 3,	/* multi-comp: attrs for all comps */
1361 	LKP4_LAST_NAMED_ATTR = 5,	/* multi-comp: named attr & attrdir */
1362 	LKP4_LAST_ATTRDIR = 6,		/* multi-comp: just attrdir */
1363 	LKP4_ALL_ATTR_SECINFO = 7	/* multi-comp: attrs for all comp and */
1364 					/*	secinfo for last comp */
1365 };
1366 
1367 /*
1368  * lookup4_param a set of parameters to nfs4lookup_setup -
1369  * used to setup a path lookup compound request.
1370  */
1371 typedef struct lookup4_param {
1372 	enum lkp4_attr_setup l4_getattrs; /* (in) get attrs in the lookup? */
1373 	int		header_len;	/* (in) num ops before first lookup  */
1374 	int		trailer_len;	/* (in) num ops after last	*/
1375 					/*	Lookup/Getattr		*/
1376 	bitmap4		ga_bits;	/* (in) Which attributes for Getattr */
1377 	COMPOUND4args_clnt *argsp;	/* (in/out) args for compound struct */
1378 	COMPOUND4res_clnt  *resp;	/* (in/out) res for compound  struct */
1379 	int		arglen;		/* (out) argop buffer alloc'd length */
1380 	struct mntinfo4 *mi;
1381 } lookup4_param_t;
1382 
1383 
1384 #define	NFS4_FATTR4_FINISH	-1	/* fattr4 index indicating finish */
1385 
1386 typedef int (*nfs4attr_to_os_t)(int, union nfs4_attr_u *,
1387 		struct nfs4attr_to_osattr *);
1388 
1389 /*
1390  * The nfs4_error_t is the basic structure to return error values
1391  * from rfs4call.  It encapsulates the unix errno
1392  * value, the nfsstat4 value and the rpc status value into a single
1393  * structure.
1394  *
1395  * If error is set, then stat is ignored and rpc_status may be
1396  * set if the error occurred as the result of a CLNT_CALL.  If
1397  * stat is set, then rpc request succeeded, error and
1398  * rpc_status are set to 0 and stat contains the result of
1399  * operation, NFS4_OK or one of the NFS4ERR_* values.
1400  *
1401  * Functions which want to generate errors independently from
1402  * rfs4call should set error to the desired errno value and
1403  * set stat and rpc_status to 0.  nfs4_error_init() is a
1404  * convenient function to do this.
1405  */
1406 typedef struct {
1407 	int		error;
1408 	nfsstat4	stat;
1409 	enum clnt_stat	rpc_status;
1410 } nfs4_error_t;
1411 
1412 /*
1413  * Shared functions
1414  */
1415 extern void	rfs4_op_readdir(nfs_argop4 *, nfs_resop4 *,
1416 			struct svc_req *, struct compound_state *);
1417 extern void	nfs_fh4_copy(nfs_fh4 *, nfs_fh4 *);
1418 
1419 extern void	nfs4_fattr4_free(fattr4 *);
1420 
1421 extern int	nfs4lookup_setup(char *, lookup4_param_t *, int);
1422 extern void	nfs4_getattr_otw_norecovery(vnode_t *,
1423 			nfs4_ga_res_t *, nfs4_error_t *, cred_t *, int);
1424 extern int	nfs4_getattr_otw(vnode_t *, nfs4_ga_res_t *, cred_t *, int);
1425 extern int	nfs4cmpfh(const nfs_fh4 *, const nfs_fh4 *);
1426 extern int	nfs4cmpfhandle(nfs4_fhandle_t *, nfs4_fhandle_t *);
1427 extern int	nfs4getattr(vnode_t *, struct vattr *, cred_t *);
1428 extern int	nfs4_waitfor_purge_complete(vnode_t *);
1429 extern int	nfs4_validate_caches(vnode_t *, cred_t *);
1430 extern int	nfs4init(int, char *);
1431 extern void	nfs4fini(void);
1432 extern int	nfs4_vfsinit(void);
1433 extern void	nfs4_vfsfini(void);
1434 
1435 extern void	nfs4_vnops_init(void);
1436 extern void	nfs4_vnops_fini(void);
1437 extern void	nfs_idmap_init(void);
1438 extern void	nfs_idmap_flush(int);
1439 extern void	nfs_idmap_fini(void);
1440 extern int	nfs4_rnode_init(void);
1441 extern int	nfs4_rnode_fini(void);
1442 extern int	nfs4_shadow_init(void);
1443 extern int	nfs4_shadow_fini(void);
1444 extern int	nfs4_acache_init(void);
1445 extern int	nfs4_acache_fini(void);
1446 extern int	nfs4_subr_init(void);
1447 extern int	nfs4_subr_fini(void);
1448 extern void	nfs4_acl_init(void);
1449 extern void	nfs4_acl_free_cache(vsecattr_t *);
1450 
1451 extern int	geterrno4(nfsstat4);
1452 extern nfsstat4	puterrno4(int);
1453 extern int	nfs4_need_to_bump_seqid(COMPOUND4res_clnt *);
1454 extern int	nfs4tsize(void);
1455 extern int	checkauth4(struct compound_state *, struct svc_req *);
1456 extern nfsstat4 call_checkauth4(struct compound_state *, struct svc_req *);
1457 extern int	is_exported_sec(int, struct exportinfo *);
1458 extern void	nfs4_vmask_to_nmask(uint_t, bitmap4 *);
1459 extern void	nfs4_vmask_to_nmask_set(uint_t, bitmap4 *);
1460 extern int	nfs_idmap_str_uid(utf8string *u8s, uid_t *, bool_t);
1461 extern int	nfs_idmap_str_gid(utf8string *u8s, gid_t *, bool_t);
1462 extern int	nfs_idmap_uid_str(uid_t, utf8string *u8s, bool_t);
1463 extern int	nfs_idmap_gid_str(gid_t gid, utf8string *u8s, bool_t);
1464 extern int	nfs4_time_ntov(nfstime4 *, timestruc_t *);
1465 extern int	nfs4_time_vton(timestruc_t *, nfstime4 *);
1466 extern char	*utf8_to_str(utf8string *, uint_t *, char *);
1467 extern char	*utf8_to_fn(utf8string *, uint_t *, char *);
1468 extern utf8string *str_to_utf8(char *, utf8string *);
1469 extern utf8string *utf8_copy(utf8string *, utf8string *);
1470 extern int	utf8_compare(const utf8string *, const utf8string *);
1471 extern nfsstat4	utf8_dir_verify(utf8string *);
1472 extern char	*utf8_strchr(utf8string *, const char);
1473 extern int	ln_ace4_cmp(nfsace4 *, nfsace4 *, int);
1474 extern int	vs_aent_to_ace4(vsecattr_t *, vsecattr_t *, int, int);
1475 extern int	vs_ace4_to_aent(vsecattr_t *, vsecattr_t *, uid_t, gid_t,
1476     int, int);
1477 extern int	vs_ace4_to_acet(vsecattr_t *, vsecattr_t *, uid_t, gid_t,
1478     int);
1479 extern int	vs_acet_to_ace4(vsecattr_t *, vsecattr_t *, int);
1480 extern void	vs_acet_destroy(vsecattr_t *);
1481 extern void	vs_ace4_destroy(vsecattr_t *);
1482 extern void	vs_aent_destroy(vsecattr_t *);
1483 
1484 extern int	vn_find_nfs_record(vnode_t *, nvlist_t **, char **, char **);
1485 extern int	vn_is_nfs_reparse(vnode_t *, cred_t *);
1486 extern fs_locations4 *fetch_referral(vnode_t *, cred_t *);
1487 extern char	*build_symlink(vnode_t *, cred_t *, size_t *);
1488 
1489 extern int	stateid4_cmp(stateid4 *, stateid4 *);
1490 
1491 extern vtype_t	nf4_to_vt[];
1492 
1493 extern struct nfs4_ntov_map nfs4_ntov_map[];
1494 extern uint_t nfs4_ntov_map_size;
1495 
1496 extern struct vfsops	*nfs4_vfsops;
1497 extern struct vnodeops	*nfs4_vnodeops;
1498 extern const struct	fs_operation_def nfs4_vnodeops_template[];
1499 extern vnodeops_t	*nfs4_trigger_vnodeops;
1500 extern const struct	fs_operation_def nfs4_trigger_vnodeops_template[];
1501 
1502 extern uint_t nfs4_tsize(struct knetconfig *);
1503 extern uint_t rfs4_tsize(struct svc_req *);
1504 
1505 extern bool_t	xdr_inline_decode_nfs_fh4(uint32_t *, nfs_fh4_fmt_t *,
1506 			uint32_t);
1507 extern bool_t	xdr_inline_encode_nfs_fh4(uint32_t **, uint32_t *,
1508 			nfs_fh4_fmt_t *);
1509 
1510 #ifdef DEBUG
1511 extern int		rfs4_do_pre_op_attr;
1512 extern int		rfs4_do_post_op_attr;
1513 #endif
1514 
1515 extern stateid4 clnt_special0;
1516 extern stateid4 clnt_special1;
1517 #define	CLNT_ISSPECIAL(id) (stateid4_cmp(id, &clnt_special0) || \
1518 				stateid4_cmp(id, &clnt_special1))
1519 
1520 /* State's functions */
1521 extern void rfs4_ss_clid(nfs4_srv_t *nsrv4, rfs4_client_t *);
1522 extern void rfs4_ss_chkclid(nfs4_srv_t *nsrv4, rfs4_client_t *);
1523 
1524 /* Declarations for nfs4.x */
1525 nfsstat4 do_rfs4_op_secinfo(struct compound_state *, char *, SECINFO4res *);
1526 
1527 /*
1528  * The NFS Version 4 service procedures.
1529  */
1530 
1531 extern void	rfs4_do_server_start(int, int, nfs4_minor_t, int);
1532 extern void	rfs4_compound(COMPOUND4args *, COMPOUND4res *,
1533 			compound_state_t *, struct svc_req *, int *);
1534 extern void rfs4_init_compound_state(struct compound_state *);
1535 extern void rfs4_fini_compound_state(struct compound_state *);
1536 
1537 struct rpcdisp;
1538 extern int rfs4_dispatch(struct rpcdisp *, struct svc_req *, SVCXPRT *, char *);
1539 extern void	rfs4_compound_free(COMPOUND4res *);
1540 extern void	rfs4_compound_flagproc(COMPOUND4args *, int *);
1541 
1542 extern void	rfs4_srvrinit(void);
1543 extern void	rfs4_srvrfini(void);
1544 extern void	rfs4_srv_zone_init(nfs_globals_t *);
1545 extern void	rfs4_srv_zone_fini(nfs_globals_t *);
1546 extern void	rfs4_state_g_init(void);
1547 extern void	rfs4_state_zone_init(nfs4_srv_t *);
1548 extern void	rfs4_state_g_fini(void);
1549 extern void	rfs4_state_zone_fini(void);
1550 extern nfs4_srv_t *nfs4_get_srv(void);
1551 
1552 #endif
1553 #ifdef	__cplusplus
1554 }
1555 #endif
1556 
1557 #endif /* _NFS4_H */
1558