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
52extern "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
60struct 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
71typedef 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 */
93extern 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
114typedef struct rfs4_dbe rfs4_dbe_t;		/* basic opaque db entry */
115typedef struct rfs4_table rfs4_table_t;		/* basic table type */
116typedef struct rfs4_index rfs4_index_t;		/* index */
117typedef struct rfs4_database rfs4_database_t;	/* and database */
118
119typedef 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 */
130extern kmem_cache_t *rfs4_client_mem_cache;
131extern kmem_cache_t *rfs4_clntIP_mem_cache;
132extern kmem_cache_t *rfs4_openown_mem_cache;
133extern kmem_cache_t *rfs4_openstID_mem_cache;
134extern kmem_cache_t *rfs4_lockstID_mem_cache;
135extern kmem_cache_t *rfs4_lockown_mem_cache;
136extern kmem_cache_t *rfs4_file_mem_cache;
137extern kmem_cache_t *rfs4_delegstID_mem_cache;
138
139/* database, table, index creation entry points */
140extern rfs4_database_t *rfs4_database_create(uint32_t);
141extern void		rfs4_database_shutdown(rfs4_database_t *);
142extern void		rfs4_database_destroy(rfs4_database_t *);
143
144extern void		rfs4_database_destroy(rfs4_database_t *);
145
146extern kmem_cache_t	*nfs4_init_mem_cache(char *, uint32_t, uint32_t,
147				uint32_t);
148extern 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);
154extern void		rfs4_table_destroy(rfs4_database_t *, rfs4_table_t *);
155extern 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);
159extern void		rfs4_index_destroy(rfs4_index_t *);
160
161/* Type used to direct rfs4_dbsearch() in what types of records to inspect */
162typedef enum {RFS4_DBS_VALID, RFS4_DBS_INVALID} rfs4_dbsearch_type_t;
163/* search and db entry manipulation entry points */
164extern rfs4_entry_t	rfs4_dbsearch(rfs4_index_t *, void *,
165				bool_t *, void *, rfs4_dbsearch_type_t);
166extern void		rfs4_dbe_lock(rfs4_dbe_t *);
167extern void		rfs4_dbe_unlock(rfs4_dbe_t *);
168extern clock_t		rfs4_dbe_twait(rfs4_dbe_t *, clock_t);
169extern void		rfs4_dbe_cv_broadcast(rfs4_dbe_t *);
170extern void		rfs4_dbe_hold(rfs4_dbe_t *);
171extern void		rfs4_dbe_hold_nolock(rfs4_dbe_t *);
172extern void		rfs4_dbe_rele_nolock(rfs4_dbe_t *);
173extern void		rfs4_dbe_rele(rfs4_dbe_t *);
174extern uint32_t	rfs4_dbe_refcnt(rfs4_dbe_t *);
175extern id_t		rfs4_dbe_getid(rfs4_dbe_t *);
176extern void		rfs4_dbe_invalidate(rfs4_dbe_t *);
177extern bool_t		rfs4_dbe_is_invalid(rfs4_dbe_t *);
178extern time_t		rfs4_dbe_get_timerele(rfs4_dbe_t *);
179extern void		rfs4_dbe_hide(rfs4_dbe_t *);
180extern void		rfs4_dbe_unhide(rfs4_dbe_t *);
181#ifdef DEBUG
182extern bool_t		rfs4_dbe_islocked(rfs4_dbe_t *);
183#endif
184extern 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 */
200typedef 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 */
210typedef 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 */
224typedef 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 */
239typedef 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 */
247typedef 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 */
256typedef 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
263extern void	rfs4_sw_enter(rfs4_state_wait_t *);
264extern 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 */
292typedef 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 */
330typedef 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 */
361typedef 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
377typedef 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 */
386char		**rfs4_dss_newpaths;
387uint_t		rfs4_dss_numnewpaths;
388
389/* nvlists of all DSS paths: current, and before last warmstart */
390nvlist_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 */
506typedef 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
533typedef 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 */
561typedef 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 */
592typedef 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 */
614typedef 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 */
636typedef 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 */
663typedef 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 */
698typedef 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 */
739typedef 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 */
762typedef enum {
763	SRV_NEVER_DELEGATE = 0,
764	SRV_NORMAL_DELEGATE = 1
765} srv_deleg_policy_t;
766
767extern 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 */
774typedef 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 */
786typedef 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 */
872typedef 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
879rfs4_db_mem_cache_t rfs4_db_mem_cache_table[RFS4_DB_MEM_CACHE_NUM];
880
881
882extern srv_deleg_policy_t nfs4_get_deleg_policy();
883
884extern void		rfs4_servinst_create(nfs4_srv_t *, int, int, char **);
885extern void		rfs4_servinst_destroy_all(nfs4_srv_t *);
886extern void		rfs4_servinst_assign(nfs4_srv_t *, rfs4_client_t *,
887			    rfs4_servinst_t *);
888extern rfs4_servinst_t	*rfs4_servinst(rfs4_client_t *);
889extern int		rfs4_clnt_in_grace(rfs4_client_t *);
890extern int		rfs4_servinst_in_grace(rfs4_servinst_t *);
891extern int		rfs4_servinst_grace_new(rfs4_servinst_t *);
892extern void		rfs4_grace_start(rfs4_servinst_t *);
893extern void		rfs4_grace_start_new(nfs4_srv_t *);
894extern void		rfs4_grace_reset_all(nfs4_srv_t *);
895extern void		rfs4_ss_oldstate(rfs4_oldstate_t *, char *, char *);
896extern void		rfs4_dss_readstate(nfs4_srv_t *, int, char **);
897
898/*
899 * Various interfaces to manipulate the state structures introduced
900 * above
901 */
902extern	void		rfs4_free_reply(nfs_resop4 *);
903extern	void		rfs4_copy_reply(nfs_resop4 *, nfs_resop4 *);
904
905/* rfs4_client_t handling */
906extern	rfs4_client_t	*rfs4_findclient(nfs_client_id4 *,
907					bool_t *, rfs4_client_t *);
908extern	rfs4_client_t	*rfs4_findclient_by_id(clientid4, bool_t);
909extern	rfs4_client_t	*rfs4_findclient_by_addr(struct sockaddr *);
910extern	void		rfs4_client_rele(rfs4_client_t *);
911extern	void		rfs4_client_close(rfs4_client_t *);
912extern	void		rfs4_client_state_remove(rfs4_client_t *);
913extern	void		rfs4_client_scv_next(rfs4_client_t *);
914extern	void		rfs4_update_lease(rfs4_client_t *);
915extern	bool_t		rfs4_lease_expired(rfs4_client_t *);
916extern	nfsstat4	rfs4_check_clientid(clientid4 *, int);
917
918/* rfs4_clntip_t handling */
919extern	rfs4_clntip_t	*rfs4_find_clntip(struct sockaddr *, bool_t *);
920extern	void		rfs4_invalidate_clntip(struct sockaddr *);
921
922/* rfs4_openowner_t handling */
923extern	rfs4_openowner_t *rfs4_findopenowner(open_owner4 *, bool_t *, seqid4);
924extern	void		rfs4_update_open_sequence(rfs4_openowner_t *);
925extern	void		rfs4_update_open_resp(rfs4_openowner_t *,
926					nfs_resop4 *, nfs_fh4 *);
927extern	void		rfs4_openowner_rele(rfs4_openowner_t *);
928extern	void		rfs4_free_opens(rfs4_openowner_t *, bool_t, bool_t);
929
930/* rfs4_lockowner_t handling */
931extern	rfs4_lockowner_t *rfs4_findlockowner(lock_owner4 *, bool_t *);
932extern	rfs4_lockowner_t *rfs4_findlockowner_by_pid(pid_t);
933extern	void		rfs4_lockowner_rele(rfs4_lockowner_t *);
934
935/* rfs4_state_t handling */
936extern	rfs4_state_t	*rfs4_findstate_by_owner_file(rfs4_openowner_t *,
937					rfs4_file_t *, bool_t *);
938extern	void		rfs4_state_rele(rfs4_state_t *);
939extern	void		rfs4_state_close(rfs4_state_t *, bool_t,
940					bool_t, cred_t *);
941extern	void		rfs4_release_share_lock_state(rfs4_state_t *,
942					cred_t *, bool_t);
943extern	void		rfs4_close_all_state(rfs4_file_t *);
944
945/* rfs4_lo_state_t handling */
946extern	rfs4_lo_state_t *rfs4_findlo_state_by_owner(rfs4_lockowner_t *,
947						rfs4_state_t *, bool_t *);
948extern	void		rfs4_lo_state_rele(rfs4_lo_state_t *, bool_t);
949extern	void		rfs4_update_lock_sequence(rfs4_lo_state_t *);
950extern	void		rfs4_update_lock_resp(rfs4_lo_state_t *,
951					nfs_resop4 *);
952
953/* rfs4_file_t handling */
954extern	rfs4_file_t	*rfs4_findfile(vnode_t *, nfs_fh4 *, bool_t *);
955extern	rfs4_file_t	*rfs4_findfile_withlock(vnode_t *, nfs_fh4 *,
956						bool_t *);
957extern	void		rfs4_file_rele(rfs4_file_t *);
958
959/* General collection of "get state" functions */
960extern	nfsstat4	rfs4_get_state(stateid4 *, rfs4_state_t **,
961					rfs4_dbsearch_type_t);
962extern	nfsstat4	rfs4_get_deleg_state(stateid4 *,
963					rfs4_deleg_state_t **);
964extern	nfsstat4	rfs4_get_lo_state(stateid4 *, rfs4_lo_state_t **,
965					bool_t);
966extern	nfsstat4	rfs4_check_stateid(int, vnode_t *, stateid4 *,
967					bool_t, bool_t *, bool_t,
968					caller_context_t *);
969extern	int		rfs4_check_stateid_seqid(rfs4_state_t *, stateid4 *);
970extern	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 */
989extern	void		rfs4_cbinfo_free(rfs4_cbinfo_t *);
990extern	void		rfs4_client_setcb(rfs4_client_t *, cb_client4 *,
991					uint32_t);
992extern	void		rfs4_deleg_cb_check(rfs4_client_t *);
993extern	nfsstat4	rfs4_vop_getattr(vnode_t *, vattr_t *, int, cred_t *);
994
995/* rfs4_deleg_state_t handling and other delegation interfaces */
996extern	rfs4_deleg_state_t *rfs4_finddeleg(rfs4_state_t *, bool_t *);
997extern	rfs4_deleg_state_t *rfs4_finddelegstate(stateid_t *);
998extern	bool_t		rfs4_check_recall(rfs4_state_t *, uint32_t);
999extern	void		rfs4_recall_deleg(rfs4_file_t *,
1000				bool_t, rfs4_client_t *);
1001extern	int		rfs4_get_deleg(rfs4_state_t *,  open_delegation_type4,
1002			open_delegation_type4 (*policy)(rfs4_state_t *,
1003				open_delegation_type4 dtype));
1004extern	rfs4_deleg_state_t *rfs4_grant_delegation(delegreq_t, rfs4_state_t *,
1005				int *);
1006extern	void		rfs4_set_deleg_response(rfs4_deleg_state_t *,
1007				open_delegation4 *, nfsace4 *, int);
1008extern	void		rfs4_return_deleg(rfs4_deleg_state_t *, bool_t);
1009extern	bool_t		rfs4_is_deleg(rfs4_state_t *);
1010extern	void		rfs4_deleg_state_rele(rfs4_deleg_state_t *);
1011extern	bool_t		rfs4_check_delegated_byfp(int, rfs4_file_t *,
1012					bool_t, bool_t, bool_t, clientid4 *);
1013extern	void		rfs4_clear_dont_grant(rfs4_file_t *);
1014
1015/*
1016 * nfs4 monitored operations.
1017 */
1018extern int deleg_rd_open(femarg_t *, int, cred_t *, caller_context_t *);
1019extern int deleg_wr_open(femarg_t *, int, cred_t *, caller_context_t *);
1020extern int deleg_wr_read(femarg_t *, uio_t *, int, cred_t *,
1021	    caller_context_t *);
1022extern int deleg_rd_write(femarg_t *, uio_t *, int, cred_t *,
1023	    caller_context_t *);
1024extern int deleg_wr_write(femarg_t *, uio_t *, int, cred_t *,
1025	    caller_context_t *);
1026extern int deleg_rd_setattr(femarg_t *, vattr_t *, int, cred_t *,
1027		caller_context_t *);
1028extern int deleg_wr_setattr(femarg_t *, vattr_t *, int, cred_t *,
1029		caller_context_t *);
1030extern int deleg_rd_rwlock(femarg_t *, int, caller_context_t *);
1031extern int deleg_wr_rwlock(femarg_t *, int, caller_context_t *);
1032extern int deleg_rd_space(femarg_t *, int, flock64_t *, int, offset_t, cred_t *,
1033		caller_context_t *);
1034extern int deleg_wr_space(femarg_t *, int, flock64_t *, int, offset_t, cred_t *,
1035		caller_context_t *);
1036extern int deleg_rd_setsecattr(femarg_t *, vsecattr_t *, int, cred_t *,
1037		caller_context_t *);
1038extern int deleg_wr_setsecattr(femarg_t *, vsecattr_t *, int, cred_t *,
1039		caller_context_t *);
1040extern int deleg_rd_vnevent(femarg_t *, vnevent_t, vnode_t *, char *,
1041		caller_context_t *);
1042extern int deleg_wr_vnevent(femarg_t *, vnevent_t, vnode_t *, char *,
1043		caller_context_t *);
1044
1045extern void rfs4_mon_hold(void *);
1046extern void rfs4_mon_rele(void *);
1047
1048extern fem_t	*deleg_rdops;
1049extern fem_t	*deleg_wrops;
1050
1051extern int rfs4_share(rfs4_state_t *, uint32_t, uint32_t);
1052extern int rfs4_unshare(rfs4_state_t *);
1053extern void rfs4_set_deleg_policy(nfs4_srv_t *, srv_deleg_policy_t);
1054extern void rfs4_hold_deleg_policy(nfs4_srv_t *);
1055extern void rfs4_rele_deleg_policy(nfs4_srv_t *);
1056
1057#ifdef DEBUG
1058#define	NFS4_DEBUG(var, args) if (var) cmn_err args
1059
1060extern int rfs4_debug;
1061extern int nfs4_client_attr_debug;
1062extern int nfs4_client_state_debug;
1063extern int nfs4_client_shadow_debug;
1064extern int nfs4_client_lock_debug;
1065extern int nfs4_client_lease_debug;
1066extern int nfs4_seqid_sync;
1067extern int nfs4_client_map_debug;
1068extern int nfs4_client_inactive_debug;
1069extern int nfs4_client_recov_debug;
1070extern int nfs4_client_failover_debug;
1071extern int nfs4_client_call_debug;
1072extern int nfs4_client_foo_debug;
1073extern int nfs4_client_zone_debug;
1074extern int nfs4_lost_rqst_debug;
1075extern int nfs4_open_stream_debug;
1076extern int nfs4_client_open_dg;
1077extern int nfs4_srvmnt_debug;
1078extern int nfs4_utf8_debug;
1079
1080void rfs4_dbe_debug(rfs4_dbe_t *e);
1081
1082#ifdef NFS4_DEBUG_MUTEX
1083void nfs4_debug_mutex_enter(kmutex_t *, char *, int);
1084void 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
1100struct 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
1108struct 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
1123typedef 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 */
1189struct 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 */
1218enum 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
1226typedef enum nfs4_attr_cmd nfs4_attr_cmd_t;
1227
1228struct 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
1251struct 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
1264struct 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
1275typedef 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
1304struct nfs4attr_to_osattr {
1305	void *attrconv_arg;
1306	uint_t mask;
1307};
1308
1309struct 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 */
1320enum 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 */
1333typedef 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
1348typedef 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 */
1368typedef struct {
1369	int		error;
1370	nfsstat4	stat;
1371	enum clnt_stat	rpc_status;
1372} nfs4_error_t;
1373
1374/*
1375 * Shared functions
1376 */
1377extern void	rfs4_op_readdir(nfs_argop4 *, nfs_resop4 *,
1378			struct svc_req *, struct compound_state *);
1379extern void	nfs_fh4_copy(nfs_fh4 *, nfs_fh4 *);
1380
1381extern void	nfs4_fattr4_free(fattr4 *);
1382
1383extern int	nfs4lookup_setup(char *, lookup4_param_t *, int);
1384extern void	nfs4_getattr_otw_norecovery(vnode_t *,
1385			nfs4_ga_res_t *, nfs4_error_t *, cred_t *, int);
1386extern int	nfs4_getattr_otw(vnode_t *, nfs4_ga_res_t *, cred_t *, int);
1387extern int	nfs4cmpfh(const nfs_fh4 *, const nfs_fh4 *);
1388extern int	nfs4cmpfhandle(nfs4_fhandle_t *, nfs4_fhandle_t *);
1389extern int	nfs4getattr(vnode_t *, struct vattr *, cred_t *);
1390extern int	nfs4_waitfor_purge_complete(vnode_t *);
1391extern int	nfs4_validate_caches(vnode_t *, cred_t *);
1392extern int	nfs4init(int, char *);
1393extern void	nfs4fini(void);
1394extern int	nfs4_vfsinit(void);
1395extern void	nfs4_vfsfini(void);
1396
1397extern void	nfs4_vnops_init(void);
1398extern void	nfs4_vnops_fini(void);
1399extern void	nfs_idmap_init(void);
1400extern void	nfs_idmap_flush(int);
1401extern void	nfs_idmap_fini(void);
1402extern int	nfs4_rnode_init(void);
1403extern int	nfs4_rnode_fini(void);
1404extern int	nfs4_shadow_init(void);
1405extern int	nfs4_shadow_fini(void);
1406extern int	nfs4_acache_init(void);
1407extern int	nfs4_acache_fini(void);
1408extern int	nfs4_subr_init(void);
1409extern int	nfs4_subr_fini(void);
1410extern void	nfs4_acl_init(void);
1411extern void	nfs4_acl_free_cache(vsecattr_t *);
1412
1413extern int	geterrno4(nfsstat4);
1414extern nfsstat4	puterrno4(int);
1415extern int	nfs4_need_to_bump_seqid(COMPOUND4res_clnt *);
1416extern int	nfs4tsize(void);
1417extern int	checkauth4(struct compound_state *, struct svc_req *);
1418extern nfsstat4 call_checkauth4(struct compound_state *, struct svc_req *);
1419extern int	is_exported_sec(int, struct exportinfo *);
1420extern void	nfs4_vmask_to_nmask(uint_t, bitmap4 *);
1421extern void	nfs4_vmask_to_nmask_set(uint_t, bitmap4 *);
1422extern int	nfs_idmap_str_uid(utf8string *u8s, uid_t *, bool_t);
1423extern int	nfs_idmap_str_gid(utf8string *u8s, gid_t *, bool_t);
1424extern int	nfs_idmap_uid_str(uid_t, utf8string *u8s, bool_t);
1425extern int	nfs_idmap_gid_str(gid_t gid, utf8string *u8s, bool_t);
1426extern int	nfs4_time_ntov(nfstime4 *, timestruc_t *);
1427extern int	nfs4_time_vton(timestruc_t *, nfstime4 *);
1428extern char	*utf8_to_str(utf8string *, uint_t *, char *);
1429extern char	*utf8_to_fn(utf8string *, uint_t *, char *);
1430extern utf8string *str_to_utf8(char *, utf8string *);
1431extern utf8string *utf8_copy(utf8string *, utf8string *);
1432extern int	utf8_compare(const utf8string *, const utf8string *);
1433extern nfsstat4	utf8_dir_verify(utf8string *);
1434extern char	*utf8_strchr(utf8string *, const char);
1435extern int	ln_ace4_cmp(nfsace4 *, nfsace4 *, int);
1436extern int	vs_aent_to_ace4(vsecattr_t *, vsecattr_t *, int, int);
1437extern int	vs_ace4_to_aent(vsecattr_t *, vsecattr_t *, uid_t, gid_t,
1438    int, int);
1439extern int	vs_ace4_to_acet(vsecattr_t *, vsecattr_t *, uid_t, gid_t,
1440    int);
1441extern int	vs_acet_to_ace4(vsecattr_t *, vsecattr_t *, int);
1442extern void	vs_acet_destroy(vsecattr_t *);
1443extern void	vs_ace4_destroy(vsecattr_t *);
1444extern void	vs_aent_destroy(vsecattr_t *);
1445
1446extern int	vn_find_nfs_record(vnode_t *, nvlist_t **, char **, char **);
1447extern int	vn_is_nfs_reparse(vnode_t *, cred_t *);
1448extern fs_locations4 *fetch_referral(vnode_t *, cred_t *);
1449extern char	*build_symlink(vnode_t *, cred_t *, size_t *);
1450
1451extern int	stateid4_cmp(stateid4 *, stateid4 *);
1452
1453extern vtype_t	nf4_to_vt[];
1454
1455extern struct nfs4_ntov_map nfs4_ntov_map[];
1456extern uint_t nfs4_ntov_map_size;
1457
1458extern struct vfsops	*nfs4_vfsops;
1459extern struct vnodeops	*nfs4_vnodeops;
1460extern const struct	fs_operation_def nfs4_vnodeops_template[];
1461extern vnodeops_t	*nfs4_trigger_vnodeops;
1462extern const struct	fs_operation_def nfs4_trigger_vnodeops_template[];
1463
1464extern uint_t nfs4_tsize(struct knetconfig *);
1465extern uint_t rfs4_tsize(struct svc_req *);
1466
1467extern bool_t	xdr_inline_decode_nfs_fh4(uint32_t *, nfs_fh4_fmt_t *,
1468			uint32_t);
1469extern bool_t	xdr_inline_encode_nfs_fh4(uint32_t **, uint32_t *,
1470			nfs_fh4_fmt_t *);
1471
1472#ifdef DEBUG
1473extern int		rfs4_do_pre_op_attr;
1474extern int		rfs4_do_post_op_attr;
1475#endif
1476
1477extern stateid4 clnt_special0;
1478extern 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
1486extern void	rfs4_do_server_start(int, int, int);
1487extern void	rfs4_compound(COMPOUND4args *, COMPOUND4res *,
1488			struct exportinfo *, struct svc_req *, cred_t *, int *);
1489extern void	rfs4_compound_free(COMPOUND4res *);
1490extern void	rfs4_compound_flagproc(COMPOUND4args *, int *);
1491
1492extern void	rfs4_srvrinit(void);
1493extern void	rfs4_srvrfini(void);
1494extern void	rfs4_srv_zone_init(nfs_globals_t *);
1495extern void	rfs4_srv_zone_fini(nfs_globals_t *);
1496extern void	rfs4_state_g_init(void);
1497extern void	rfs4_state_zone_init(nfs4_srv_t *);
1498extern void	rfs4_state_g_fini(void);
1499extern void	rfs4_state_zone_fini(void);
1500extern nfs4_srv_t *nfs4_get_srv(void);
1501
1502#endif
1503#ifdef	__cplusplus
1504}
1505#endif
1506
1507#endif /* _NFS4_H */
1508