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