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