/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#ifndef _NFS4_H

#define	_NFS4_H

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>

#include <sys/vnode.h>

#include <sys/fem.h>

#include <rpc/rpc.h>

#include <nfs/nfs.h>

#ifdef _KERNEL

#include <nfs/nfs4_kprot.h>

#else

#include <rpcsvc/nfs4_prot.h>

#endif

#include <nfs/nfs4_attr.h>

#include <sys/acl.h>

#ifdef	__cplusplus

extern "C" {

#endif

#define	NFS4_MAX_UTF8STRING	65536

#define	NFS4_MAX_PATHNAME4	65536

#define	NFS4_MAX_SECOID4	65536

#ifdef _KERNEL

typedef struct nfs4_fhandle {

	int fh_len;

	char fh_buf[NFS4_FHSIZE];

} nfs4_fhandle_t;

#define	NFS4_MINORVERSION 0

#define	CB4_MINORVERSION 0

/*

 * Set the fattr4_change variable using a time struct. Note that change

 * is 64 bits, but timestruc_t is 128 bits in a 64-bit kernel.

 */

#define	NFS4_SET_FATTR4_CHANGE(change, ts)			\

{							\

	change = (ts).tv_sec;				\

	change <<= 32;					\

	change |= (uint32_t)((ts).tv_nsec);		\

}

/*

 * Server lease period.  Value is in seconds;  Also used for grace period

 */

extern time_t rfs4_lease_time;

/*

 * This set of typedefs and interfaces represent the core or base set

 * of functionality that backs the NFSv4 server's state related data

 * structures.  Since the NFSv4 server needs inter-RPC state to be

 * available that is unrelated to the filesystem (in other words,

 * soft-state), this functionality is needed to maintain that and is

 * written to be somewhat flexible to adapt to the various types of

 * data structures contained within the server.

 *

 * The basic structure at this level is that the server maintains a

 * global "database" which consists of a set of tables.  Each table

 * contains a set of like data structures.  Each table is indexed by

 * at least one hash function and in most cases two hashes.  Each

 * table's characteristics is set when it is created at run-time via

 * rfs4_table_create().  All table creation and related functions are

 * located in nfs4_state.c.  The generic database functionality is

 * located in nfs4_db.c.

 */

typedef struct rfs4_dbe rfs4_dbe_t;		/* basic opaque db entry */

typedef struct rfs4_table rfs4_table_t;		/* basic table type */

typedef struct rfs4_index rfs4_index_t;		/* index */

typedef struct rfs4_database rfs4_database_t;	/* and database */

typedef struct {		/* opaque entry type for later use */

	rfs4_dbe_t *dbe;

} *rfs4_entry_t;

extern rfs4_table_t *rfs4_client_tab;

/* database, table, index creation entry points */

extern rfs4_database_t *rfs4_database_create(uint32_t);

extern void		rfs4_database_shutdown(rfs4_database_t *);

extern void		rfs4_database_destroy(rfs4_database_t *);

extern void		rfs4_database_destroy(rfs4_database_t *);

extern rfs4_table_t	*rfs4_table_create(rfs4_database_t *, char *,

				time_t, uint32_t,

				bool_t (*create)(rfs4_entry_t, void *),

				void (*destroy)(rfs4_entry_t),

				bool_t (*expiry)(rfs4_entry_t),

				uint32_t, uint32_t, uint32_t, id_t);

extern void		rfs4_table_destroy(rfs4_database_t *, rfs4_table_t *);

extern rfs4_index_t	*rfs4_index_create(rfs4_table_t *, char *,

				uint32_t (*hash)(void *),

				bool_t (compare)(rfs4_entry_t, void *),

				void *(*mkkey)(rfs4_entry_t), bool_t);

extern void		rfs4_index_destroy(rfs4_index_t *);

/* Type used to direct rfs4_dbsearch() in what types of records to inspect */

typedef enum {RFS4_DBS_VALID, RFS4_DBS_INVALID} rfs4_dbsearch_type_t;

/* search and db entry manipulation entry points */

extern rfs4_entry_t	rfs4_dbsearch(rfs4_index_t *, void *,

				bool_t *, void *, rfs4_dbsearch_type_t);

extern void		rfs4_dbe_lock(rfs4_dbe_t *);

extern void		rfs4_dbe_unlock(rfs4_dbe_t *);

extern clock_t		rfs4_dbe_twait(rfs4_dbe_t *, clock_t);

extern void		rfs4_dbe_cv_broadcast(rfs4_dbe_t *);

extern void		rfs4_dbe_hold(rfs4_dbe_t *);

extern void		rfs4_dbe_hold_nolock(rfs4_dbe_t *);

extern void		rfs4_dbe_rele_nolock(rfs4_dbe_t *);

extern void		rfs4_dbe_rele(rfs4_dbe_t *);

extern uint32_t	rfs4_dbe_refcnt(rfs4_dbe_t *);

extern id_t		rfs4_dbe_getid(rfs4_dbe_t *);

extern void		rfs4_dbe_invalidate(rfs4_dbe_t *);

extern bool_t		rfs4_dbe_is_invalid(rfs4_dbe_t *);

extern time_t		rfs4_dbe_get_timerele(rfs4_dbe_t *);

extern void		rfs4_dbe_hide(rfs4_dbe_t *);

extern void		rfs4_dbe_unhide(rfs4_dbe_t *);

#ifdef DEBUG

extern bool_t		rfs4_dbe_islocked(rfs4_dbe_t *);

#endif

extern void		rfs4_dbe_walk(rfs4_table_t *,

			void (*callout)(rfs4_entry_t, void *), void *);

/*

 * Minimal server stable storage.

 *

 * Currently the NFSv4 server will only save the client

 * ID (the long version) so that it will be able to

 * grant possible reclaim requests during the infamous

 * grace_period.

 */

#define	RFS4_SS_DIRSIZE	64 * 1024

#define	NFS4_SS_VERSION 1

/* handy pathname structure */

typedef struct ss_pn {

	char *leaf;

	char pn[MAXPATHLEN];

} rfs4_ss_pn_t;

/*

 * The server will build this link list on startup. It represents the

 * clients that have had valid state on the server in a prior instance.

 *

 */

typedef struct rfs4_oldstate {

	struct rfs4_oldstate 	*next;

	struct rfs4_oldstate 	*prev;

	rfs4_ss_pn_t		*ss_pn;

	nfs_client_id4		cl_id4;

} rfs4_oldstate_t;

/*

 * This union is used to overlay the server's internal treatment of

 * the protocols stateid4 datatype.  Therefore, "bits" must not exceed

 * the size of stateid4 and more importantly should match the size of

 * stateid4.  The chgseq field must the first entry since it overlays

 * stateid4.seqid.

 */

typedef union {

	stateid4 stateid;

	struct {

		uint32_t chgseq;	/* State changes / protocol's seqid */

		uint32_t boottime;	/* boot time  */

		uint32_t type:2;	/* stateid_type_t as define below */

		uint32_t clnodeid:8;	/* cluster server nodeid */

		uint32_t ident:22;	/* 2^22-1 openowner x fhs */

		pid_t	 pid;		/* pid of corresponding lock owner */

	} bits;

} stateid_t;

/*

 * Note that the way the type field above is defined, this enum must

 * not have more than 4 members.

 */

typedef enum {OPENID, LOCKID, DELEGID} stateid_type_t;

/*

 * Set of RPC credentials used for a particular operation.

 * Used for operations like SETCLIENTID_CONFIRM where the

 * credentials needs to match those used at SETCLIENTID.

 */

typedef void *cred_set_t;		/* For now XXX */

/*

 * "wait" struct for use in the open open and lock owner state

 * structures to provide serialization between server threads that are

 * handling requests for the same open owner or lock stateid.  This

 * way only one thread will be updating things like sequence ids,

 * replay cache and stateid at a time.

 */

typedef struct rfs4_state_wait {

	uint32_t		sw_active;

	uint32_t		sw_wait_count;

	kmutex_t		sw_cv_lock[1];

	kcondvar_t		sw_cv[1];

} rfs4_state_wait_t;

extern void	rfs4_sw_enter(rfs4_state_wait_t *);

extern void	rfs4_sw_exit(rfs4_state_wait_t *);

/*

 * This enum and the following rfs4_cbinfo_t struct are used to

 * maintain information about the callback path used from the server

 * to client for operations like CB_GETATTR and CB_RECALL.  The

 * rfs4_cbinfo_t struct is meant to be encompassed in the client

 * struct and managed within that structure's locking scheme.

 *

 * The various states of the callback path are used by the server to

 * determine if delegations should initially be provided to a client

 * and then later on if connectivity has been lost and delegations

 * should be revoked.

 */

/*

 * CB_NOCHANGE - Special value used for interfaces within the delegation

 *		code to signify that "no change" has occurred to the

 *		callback path

 * CB_UNINIT	- No callback info provided by the client

 * CB_NONE	- Callback info provided but CB_NULL call

 *		  has yet to be attempted

 * CB_OK	- Callback path tested with CB_NULL with success

 * CB_INPROG	- Callback path currently being tested with CB_NULL

 * CB_FAILED	- Callback path was == CB_OK but has failed

 *		  with timeout/rpc error

 * CB_BAD	- Callback info provided but CB_NULL failed

 */

typedef enum {

	CB_NOCHANGE = 0,

	CB_UNINIT = 1,

	CB_NONE = 2,

	CB_OK = 3,

	CB_INPROG = 4,

	CB_FAILED = 5,

	CB_BAD = 6

} rfs4_cbstate_t;

#define	RFS4_CBCH_MAX	10	/* size callback client handle cache */

/*

 * Callback info for a client.

 * Client only provides: cb_client4 and cb_ident

 * The rest of the information is used to track callback path status

 * and usage.

 *

 * cb_state - used as comments for the rfs4_cbstate_t enum indicate

 * cb_notified_of_cb_path_down - if the callback path was once CB_OK and

 *	has hence CB_FAILED, the client needs to be notified via RENEW.

 * cb_timefailed - current time when cb_state transitioned from

 *	CB_OK -> CB_FAILED.  Meant for observability.  When did that happen?

 * cb_chc_free/cb_chc - cache of client handles for the callback path

 * cb_ident - SETCLIENTID provided callback_ident value

 * callback - SETCLIENTID provided cb_client4 value

 * cb_refcnt - current number of users of this structure's content

 *	protected by cb_lock

 * cb_badbehavior - how many times did a client do something we didn't like?

 * cb_lock - lock for contents of cbinfo

 * cb_cv - used to allow threads to wait on CB_NULL completion

 * cb_nullcaller - is there a thread currently taking care of

 *	new callback information?

 * cb_cv_nullcaller - used by the thread doing CB_NULL to wait on

 *	threads that may be using client handles of the current

 *	client handle cache.

 * newer - new callback info provided by a client and awaiting

 *	CB_NULL testing and move to regular cbinfo.

 */

typedef struct {

	rfs4_cbstate_t	cb_state;

	unsigned	cb_notified_of_cb_path_down:1;

	time_t		cb_timefailed;

	int		cb_chc_free;

	CLIENT		*cb_chc[RFS4_CBCH_MAX];

	uint32_t	cb_ident;

	cb_client4	cb_callback;

	uint32_t	cb_refcnt;

	uint32_t	cb_badbehavior;

	kmutex_t	cb_lock[1];

	kcondvar_t	cb_cv[1];

	bool_t		cb_nullcaller;

	kcondvar_t	cb_cv_nullcaller[1];

	struct {

		bool_t		cb_new;

		bool_t		cb_confirmed;

		uint32_t	cb_ident;

		cb_client4	cb_callback;

	} cb_newer;

} rfs4_cbinfo_t;

/*

 * A server instance. We can associate sets of clients - via a pointer in

 * rfs4_client_t - with a given server instance, allowing us to treat clients

 * in the set differently to clients in other sets.

 *

 * Currently used only for Sun Cluster HA-NFS support, to group clients

 * on NFS resource failover so each set of clients gets its own dedicated

 * grace period.

 */

typedef struct rfs4_servinst {

	krwlock_t		rwlock;

	time_t			start_time;

	time_t			grace_period;

	struct rfs4_servinst	*next;

	struct rfs4_servinst	*prev;

} rfs4_servinst_t;

/*

 * List declarations (suitable for insque/remque) used to link the

 * various datastructs listed below.

 */

typedef struct rfs4_state_list {

	struct rfs4_state_list *next;

	struct rfs4_state_list *prev;

	struct rfs4_state *sp;

} rfs4_state_list_t;

typedef struct rfs4_lo_state_list {

	struct rfs4_lo_state_list *next;

	struct rfs4_lo_state_list *prev;

	struct rfs4_lo_state *lsp;

} rfs4_lo_state_list_t;

typedef struct rfs4_openowner_list {

	struct rfs4_openowner_list *next;

	struct rfs4_openowner_list *prev;

	struct rfs4_openowner *oop;

} rfs4_openowner_list_t;

typedef struct rfs4_deleg_list {

	struct rfs4_deleg_list *next;

	struct rfs4_deleg_list *prev;

	struct rfs4_deleg_state *dsp;

} rfs4_deleg_list_t;

/*

 * The server maintains a set of state on a per client basis that

 * matches that of the protocol requirements.  A client's state is

 * rooted with the rfs4_client_t struct of which there is one per

 * client and is created when SETCLIENTID/SETCLIENTID_CONFIRM are

 * received.  From there, the server then creates rfs4_openowner_t

 * structs for each new open owner from that client and are initiated

 * at OPEN/OPEN_CONFIRM (when the open owner is new to the server).

 * At OPEN, at least two other structures are created, and potentially a

 * third.  rfs4_state_t is created to track the association between an

 * open owner and a particular file. An rfs4_file_t struct may be

 * created (if the file is not already open) at OPEN as well.  The

 * rfs4_file_t struct is the only one that is per server and not per

 * client.  The rfs4_deleg_state_t struct is created in the

 * instance that the server is going to provide a delegation for the

 * file being OPENed.  Finally, the rfs4_lockowner_t is created at the

 * first use of a lock owner at the server and is a result of the LOCK

 * operation.  The rfs4_lo_state_t struct is then created to represent

 * the relation between the lock owner and the file.

 *

 */

/*

 * The following ascii art represents each of these data structs and

 * their references to each other.  Note: "<-(x)->" represents the

 * doubly link lists defined above.

 *

 *                          ____________________

 *                         |                    |

 *                         |    rfs4_client_t   |

 *                       ->|         (1),(2)    |<-

 *                      /  |____________________|  \

 *                     /              ^             \

 *                    /               |              \

 *  ____________________    ____________________    ____________________

 * |                    |  |                    |  |                    |

 * |  rfs4_lockowner_t  |  |  rfs4_openowner_t  |  | rfs4_deleg_state_t |

 * |                    |  |     (3)    <-(1)-> |  |            <-(2)-> |

 * |____________________|  |____________________|  |____________________|

 *           ^                        ^                       |

 *           |                        |                       V

 *  ____________________    ____________________    ____________________

 * |                    |  |                    |  |                    |

 * |  rfs4_lo_state_t   |->|    rfs4_state_t    |->|     rfs4_file_t    |

 * |            <-(4)-> |  |     (4)    <-(3)-> |  |                    |

 * |____________________|  |____________________|  |____________________|

 */

/*

 * Each of these data types are kept in a separate rfs4_table_t and is

 * actually encapsulated within a rfs4_dbe_t struct.  The various

 * tables and their construction is done in nfs4_state.c but

 * documented here to completeness.

 *

 * Table		Data struct stored	Indexed by

 * -----		------------------	----------

 * rfs4_client_tab	rfs4_client_t		nfs_client_id4

 *						clientid4

 *

 * rfs4_openowner_tab	rfs4_openowner_t	open_owner4

 *

 * rfs4_state_tab	rfs4_state_t		open_owner4 | file

 *						stateid

 *

 * rfs4_lo_state_tab	rfs4_lo_state_t		lockowner | stateid

 *						lock_stateid

 *

 * rfs4_lockowner_tab	rfs4_lockowner_t	lockowner

 *						pid

 *

 * rfs4_file_tab	rfs4_file_t		filehandle

 *

 * rfs4_deleg_state_tab	rfs4_deleg_state_t	clientid4 | file

 *						deleg_stateid

 */

/*

 * The client struct, it is the root of all state for a particular

 * client.  The client is identified by the nfs_client_id4 via

 * SETCLIENTID and the server returns the clientid4 as short hand reference

 */

/*

 * Client struct - as mentioned above it is the root of all state for

 * a single client as identified by the client supplied nfs_client_id4

 *

 * dbe - encapsulation struct

 * clientid - server assigned short hand reference to client

 * nfs_client - client supplied identifier for itself

 * confirm_verf - the value provided to the client for SETCLIENTID_CONFIRM

 * need_confirm - does this client need to be SETCLIENTID_CONFIRMed?

 *

 * unlksys_completed - has an F_UNLKSYS been done for this client which

 *		says that the use of cleanlocks() on individual files

 *		is not required?

 * can_reclaim - indicates if client is allowed to reclaim after server

 * 		start-up (client had previous state at server)

 * ss_remove - indicates that the rfs4_client_destroy function should

 * 		clean up stable storage file.

 * forced_expire - set if the sysadmin has used clear_locks for this client.

 * deleg_revoked - how many delegations have been revoked for this client?

 *

 * cp_confirmed - this refers to a confirmed client struct that has

 * the same nfs_client_id4 as this client struct.  When/if this client

 * struct is confirmed via SETCLINETID_CONFIRM, the previously

 * confirmed client struct will be "closed" and hence this reference.

 *

 * last_access - used to determine if the client has let its lease expire

 * cbinfo - struct containing all callback related information

 * cr_set - credentials used for the SETCLIENTID/SETCLIENTID_CONFIRM pair

 * sysid - the lock manager sysid allocated for this client's file locks

 * openownerlist - root of openowners list associated with this client

 * clientdeleglist - root of delegations list provided to this client

 * ss_pn - Pathname to the stable storage file.

 * cl_addr - Clients network address.

 * server_instance - pointer to the currently associated server instance

 */

typedef struct rfs4_client {

	rfs4_dbe_t		*dbe;

	clientid4		clientid;

	nfs_client_id4		nfs_client;

	verifier4		confirm_verf;

	unsigned		need_confirm:1;

	unsigned		unlksys_completed:1;

	unsigned		can_reclaim:1;

	unsigned 		ss_remove:1;

	unsigned		forced_expire:1;

	uint_t			deleg_revoked;

	struct rfs4_client	*cp_confirmed;

	time_t			last_access;

	rfs4_cbinfo_t		cbinfo;

	cred_set_t		cr_set;

	sysid_t			sysidt;

	rfs4_openowner_list_t	openownerlist;

	rfs4_deleg_list_t	clientdeleglist;

	rfs4_ss_pn_t		*ss_pn;

	struct sockaddr_storage cl_addr;

	rfs4_servinst_t		*server_instance;

} rfs4_client_t;

/*

 * The openowner contains the client supplied open_owner4 as well as

 * the matching sequence id and is used to track the client's usage of

 * the open_owner4.  Note that a reply is saved here as well for

 * processing of retransmissions.

 *

 * dbe - encapsulation struct

 * client - reference to rfs4_client_t for this openowner

 * owner - actual client supplied open_owner4

 * need_confirm - does this openowner need to be OPEN_CONFIRMed

 * postpone_confirm - set if error received on first use of open_owner

 * state2confirm - what stateid4 should be used on the OPEN_CONFIRM

 * open_seqid - what is the next open_seqid expected for this openowner

 * oo_sw - used to serialize access to the open seqid/reply handling

 * cr_set - credential used for the OPEN

 * ownerstateids - root of state struct list associated with this openowner

 * openownerlist - list of openowners for a client struct

 * reply_fh - open replay processing needs the filehandle so that it is

 *	able to reset the current filehandle for appropriate compound

 *	processing and reply.

 * reply - last reply sent in relation to this openowner

 */

typedef struct rfs4_openowner {

	rfs4_dbe_t		*dbe;

	rfs4_client_t		*client;

	open_owner4		owner;

	unsigned		need_confirm:1;