/*

 * CDDL HEADER START

 *

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

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * 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.

 */

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

#include <sys/systm.h>

#include <sys/kmem.h>

#include <sys/cmn_err.h>

#include <sys/atomic.h>

#include <sys/clconf.h>

#include <sys/cladm.h>

#include <sys/flock.h>

#include <nfs/export.h>

#include <nfs/nfs.h>

#include <nfs/nfs4.h>

#include <nfs/nfssys.h>

#include <nfs/lm.h>

#include <sys/pathname.h>

#include <sys/nvpair.h>

extern time_t rfs4_start_time;

stateid4 special0 = {

	0,

	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }

};

stateid4 special1 = {

	0xffffffff,

	{

		(char)0xff, (char)0xff, (char)0xff, (char)0xff,

		(char)0xff, (char)0xff, (char)0xff, (char)0xff,

		(char)0xff, (char)0xff, (char)0xff, (char)0xff

	}

};

#define	ISSPECIAL(id)  (stateid4_cmp(id, &special0) || \

			stateid4_cmp(id, &special1))

/* For embedding the cluster nodeid into our clientid */

#define	CLUSTER_NODEID_SHIFT	24

#define	CLUSTER_MAX_NODEID	255

#ifdef DEBUG

int rfs4_debug;

#endif

static uint32_t rfs4_database_debug = 0x00;

static void rfs4_ss_clid_write(rfs4_client_t *cp, char *leaf);

static void rfs4_ss_clid_write_one(rfs4_client_t *cp, char *dir, char *leaf);

static void rfs4_dss_clear_oldstate(rfs4_servinst_t *sip);

static void rfs4_ss_chkclid_sip(rfs4_client_t *cp, rfs4_servinst_t *sip);

/*

 * Couple of simple init/destroy functions for a general waiter

 */

void

rfs4_sw_init(rfs4_state_wait_t *swp)

{

	mutex_init(swp->sw_cv_lock, NULL, MUTEX_DEFAULT, NULL);

	cv_init(swp->sw_cv, NULL, CV_DEFAULT, NULL);

	swp->sw_active = FALSE;

	swp->sw_wait_count = 0;

}

void

rfs4_sw_destroy(rfs4_state_wait_t *swp)

{

	mutex_destroy(swp->sw_cv_lock);

	cv_destroy(swp->sw_cv);

}

void

rfs4_sw_enter(rfs4_state_wait_t *swp)

{

	mutex_enter(swp->sw_cv_lock);

	while (swp->sw_active) {

		swp->sw_wait_count++;

		cv_wait(swp->sw_cv, swp->sw_cv_lock);

		swp->sw_wait_count--;

	}

	ASSERT(swp->sw_active == FALSE);

	swp->sw_active = TRUE;

	mutex_exit(swp->sw_cv_lock);

}

void

rfs4_sw_exit(rfs4_state_wait_t *swp)

{

	mutex_enter(swp->sw_cv_lock);

	ASSERT(swp->sw_active == TRUE);

	swp->sw_active = FALSE;

	if (swp->sw_wait_count != 0)

		cv_broadcast(swp->sw_cv);

	mutex_exit(swp->sw_cv_lock);

}

/*

 * CPR callback id -- not related to v4 callbacks

 */

static callb_id_t cpr_id = 0;

static void

deep_lock_copy(LOCK4res *dres, LOCK4res *sres)

{

	lock_owner4 *slo = &sres->LOCK4res_u.denied.owner;

	lock_owner4 *dlo = &dres->LOCK4res_u.denied.owner;

	if (sres->status == NFS4ERR_DENIED) {

		dlo->owner_val = kmem_alloc(slo->owner_len, KM_SLEEP);

		bcopy(slo->owner_val, dlo->owner_val, slo->owner_len);

	}

}

static void

deep_lock_free(LOCK4res *res)

{

	lock_owner4 *lo = &res->LOCK4res_u.denied.owner;

	if (res->status == NFS4ERR_DENIED)

		kmem_free(lo->owner_val, lo->owner_len);

}

static void

deep_open_copy(OPEN4res *dres, OPEN4res *sres)

{

	nfsace4 *sacep, *dacep;

	if (sres->status != NFS4_OK) {

		return;

	}

	dres->attrset = sres->attrset;

	switch (sres->delegation.delegation_type) {

	case OPEN_DELEGATE_NONE:

		return;

	case OPEN_DELEGATE_READ:

		sacep = &sres->delegation.open_delegation4_u.read.permissions;

		dacep = &dres->delegation.open_delegation4_u.read.permissions;

		break;

	case OPEN_DELEGATE_WRITE:

		sacep = &sres->delegation.open_delegation4_u.write.permissions;

		dacep = &dres->delegation.open_delegation4_u.write.permissions;

		break;

	}

	dacep->who.utf8string_val =

		kmem_alloc(sacep->who.utf8string_len, KM_SLEEP);

	bcopy(sacep->who.utf8string_val, dacep->who.utf8string_val,

	    sacep->who.utf8string_len);

}

static void

deep_open_free(OPEN4res *res)

{

	nfsace4 *acep;

	if (res->status != NFS4_OK)

		return;

	switch (res->delegation.delegation_type) {

	case OPEN_DELEGATE_NONE:

		return;

	case OPEN_DELEGATE_READ:

		acep = &res->delegation.open_delegation4_u.read.permissions;

		break;

	case OPEN_DELEGATE_WRITE:

		acep = &res->delegation.open_delegation4_u.write.permissions;

		break;

	}

	if (acep->who.utf8string_val) {

		kmem_free(acep->who.utf8string_val, acep->who.utf8string_len);

		acep->who.utf8string_val = NULL;

	}

}

void

rfs4_free_reply(nfs_resop4 *rp)

{

	switch (rp->resop) {

	case OP_LOCK:

		deep_lock_free(&rp->nfs_resop4_u.oplock);

		break;

	case OP_OPEN:

		deep_open_free(&rp->nfs_resop4_u.opopen);

	default:

		break;

	}

}

void

rfs4_copy_reply(nfs_resop4 *dst, nfs_resop4 *src)

{

	*dst = *src;

	/* Handle responses that need deep copy */

	switch (src->resop) {

	case OP_LOCK:

		deep_lock_copy(&dst->nfs_resop4_u.oplock,

			    &src->nfs_resop4_u.oplock);

		break;

	case OP_OPEN:

		deep_open_copy(&dst->nfs_resop4_u.opopen,

			    &src->nfs_resop4_u.opopen);

		break;

	default:

		break;

	};

}

/*

 * This is the implementation of the underlying state engine. The

 * public interface to this engine is described by

 * nfs4_state.h. Callers to the engine should hold no state engine

 * locks when they call in to it. If the protocol needs to lock data

 * structures it should do so after acquiring all references to them

 * first and then follow the following lock order:

 *

 *	client > openowner > state > lo_state > lockowner > file.

 *

 * Internally we only allow a thread to hold one hash bucket lock at a

 * time and the lock is higher in the lock order (must be acquired

 * first) than the data structure that is on that hash list.

 *

 * If a new reference was acquired by the caller, that reference needs

 * to be released after releasing all acquired locks with the

 * corresponding rfs4_*_rele routine.

 */

/*

 * This code is some what prototypical for now. Its purpose currently is to

 * implement the interfaces sufficiently to finish the higher protocol

 * elements. This will be replaced by a dynamically resizeable tables

 * backed by kmem_cache allocator. However synchronization is handled

 * correctly (I hope) and will not change by much.  The mutexes for

 * the hash buckets that can be used to create new instances of data

 * structures  might be good candidates to evolve into reader writer

 * locks. If it has to do a creation, it would be holding the

 * mutex across a kmem_alloc with KM_SLEEP specified.

 */

#ifdef DEBUG

#define	TABSIZE 17

#else

#define	TABSIZE 2047

#endif

#define	ADDRHASH(key) ((unsigned long)(key) >> 3)

/* Used to serialize create/destroy of rfs4_server_state database */

kmutex_t	rfs4_state_lock;

static rfs4_database_t *rfs4_server_state = NULL;

/* Used to serialize lookups of clientids */

static	krwlock_t	rfs4_findclient_lock;

/*

 * For now this "table" is exposed so that the CPR callback

 * function can tromp through it..

 */

rfs4_table_t *rfs4_client_tab;

static rfs4_index_t *rfs4_clientid_idx;

static rfs4_index_t *rfs4_nfsclnt_idx;

static rfs4_table_t *rfs4_openowner_tab;

static rfs4_index_t *rfs4_openowner_idx;

static rfs4_table_t *rfs4_state_tab;

static rfs4_index_t *rfs4_state_idx;

static rfs4_index_t *rfs4_state_owner_file_idx;

static rfs4_index_t *rfs4_state_file_idx;

static rfs4_table_t *rfs4_lo_state_tab;

static rfs4_index_t *rfs4_lo_state_idx;

static rfs4_index_t *rfs4_lo_state_owner_idx;

static rfs4_table_t *rfs4_lockowner_tab;

static rfs4_index_t *rfs4_lockowner_idx;

static rfs4_index_t *rfs4_lockowner_pid_idx;

static rfs4_table_t *rfs4_file_tab;

static rfs4_index_t *rfs4_file_idx;

static rfs4_table_t *rfs4_deleg_state_tab;

static rfs4_index_t *rfs4_deleg_idx;

static rfs4_index_t *rfs4_deleg_state_idx;

#define	MAXTABSZ 1024*1024

/* The values below are rfs4_lease_time units */

#ifdef DEBUG

#define	CLIENT_CACHE_TIME 1

#define	OPENOWNER_CACHE_TIME 1

#define	STATE_CACHE_TIME 1

#define	LO_STATE_CACHE_TIME 1

#define	LOCKOWNER_CACHE_TIME 1

#define	FILE_CACHE_TIME 3

#define	DELEG_STATE_CACHE_TIME 1

#else

#define	CLIENT_CACHE_TIME 10

#define	OPENOWNER_CACHE_TIME 5

#define	STATE_CACHE_TIME 1

#define	LO_STATE_CACHE_TIME 1

#define	LOCKOWNER_CACHE_TIME 3

#define	FILE_CACHE_TIME 40

#define	DELEG_STATE_CACHE_TIME 1

#endif

static time_t rfs4_client_cache_time = 0;

static time_t rfs4_openowner_cache_time = 0;

static time_t rfs4_state_cache_time = 0;

static time_t rfs4_lo_state_cache_time = 0;

static time_t rfs4_lockowner_cache_time = 0;

static time_t rfs4_file_cache_time = 0;

static time_t rfs4_deleg_state_cache_time = 0;

static bool_t rfs4_client_create(rfs4_entry_t, void *);

static void rfs4_dss_remove_cpleaf(rfs4_client_t *);

static void rfs4_dss_remove_leaf(rfs4_servinst_t *, char *, char *);

static void rfs4_client_destroy(rfs4_entry_t);

static bool_t rfs4_client_expiry(rfs4_entry_t);

static uint32_t clientid_hash(void *);

static bool_t clientid_compare(rfs4_entry_t, void *);

static void *clientid_mkkey(rfs4_entry_t);

static uint32_t nfsclnt_hash(void *);

static bool_t nfsclnt_compare(rfs4_entry_t, void *);

static void *nfsclnt_mkkey(rfs4_entry_t);

static bool_t rfs4_openowner_create(rfs4_entry_t, void *);

static void rfs4_openowner_destroy(rfs4_entry_t);

static bool_t rfs4_openowner_expiry(rfs4_entry_t);

static uint32_t openowner_hash(void *);

static bool_t openowner_compare(rfs4_entry_t, void *);

static void *openowner_mkkey(rfs4_entry_t);

static bool_t rfs4_state_create(rfs4_entry_t, void *);

static void rfs4_state_destroy(rfs4_entry_t);

static bool_t rfs4_state_expiry(rfs4_entry_t);

static uint32_t state_hash(void *);

static bool_t state_compare(rfs4_entry_t, void *);

static void *state_mkkey(rfs4_entry_t);

static uint32_t state_owner_file_hash(void *);

static bool_t state_owner_file_compare(rfs4_entry_t, void *);

static void *state_owner_file_mkkey(rfs4_entry_t);

static uint32_t state_file_hash(void *);

static bool_t state_file_compare(rfs4_entry_t, void *);

static void *state_file_mkkey(rfs4_entry_t);

static bool_t rfs4_lo_state_create(rfs4_entry_t, void *);

static void rfs4_lo_state_destroy(rfs4_entry_t);

static bool_t rfs4_lo_state_expiry(rfs4_entry_t);

static uint32_t lo_state_hash(void *);

static bool_t lo_state_compare(rfs4_entry_t, void *);

static void *lo_state_mkkey(rfs4_entry_t);

static uint32_t lo_state_lo_hash(void *);

static bool_t lo_state_lo_compare(rfs4_entry_t, void *);

static void *lo_state_lo_mkkey(rfs4_entry_t);

static bool_t rfs4_lockowner_create(rfs4_entry_t, void *);

static void rfs4_lockowner_destroy(rfs4_entry_t);

static bool_t rfs4_lockowner_expiry(rfs4_entry_t);

static uint32_t lockowner_hash(void *);

static bool_t lockowner_compare(rfs4_entry_t, void *);

static void *lockowner_mkkey(rfs4_entry_t);

static uint32_t pid_hash(void *);

static bool_t pid_compare(rfs4_entry_t, void *);

static void *pid_mkkey(rfs4_entry_t);

static bool_t rfs4_file_create(rfs4_entry_t, void *);

static void rfs4_file_destroy(rfs4_entry_t);

static uint32_t file_hash(void *);

static bool_t file_compare(rfs4_entry_t, void *);

static void *file_mkkey(rfs4_entry_t);

static bool_t rfs4_deleg_state_create(rfs4_entry_t, void *);

static void rfs4_deleg_state_destroy(rfs4_entry_t);

static bool_t rfs4_deleg_state_expiry(rfs4_entry_t);

static uint32_t deleg_hash(void *);

static bool_t deleg_compare(rfs4_entry_t, void *);

static void *deleg_mkkey(rfs4_entry_t);

static uint32_t deleg_state_hash(void *);

static bool_t deleg_state_compare(rfs4_entry_t, void *);

static void *deleg_state_mkkey(rfs4_entry_t);

static void rfs4_state_rele_nounlock(rfs4_state_t *);

static int rfs4_ss_enabled = 0;

extern void (*rfs4_client_clrst)(struct nfs4clrst_args *);

void

rfs4_ss_pnfree(rfs4_ss_pn_t *ss_pn)

{

	kmem_free(ss_pn, sizeof (rfs4_ss_pn_t));

}

static rfs4_ss_pn_t *

rfs4_ss_pnalloc(char *dir, char *leaf)

{

	rfs4_ss_pn_t *ss_pn;

	int 	dir_len, leaf_len;

	/*

	 * validate we have a resonable path

	 * (account for the '/' and trailing null)

	 */

	if ((dir_len = strlen(dir)) > MAXPATHLEN ||

		(leaf_len = strlen(leaf)) > MAXNAMELEN ||

		(dir_len + leaf_len + 2) > MAXPATHLEN) {

		return (NULL);

	}

	ss_pn = kmem_alloc(sizeof (rfs4_ss_pn_t), KM_SLEEP);

	(void) snprintf(ss_pn->pn, MAXPATHLEN, "%s/%s", dir, leaf);

	/* Handy pointer to just the leaf name */

	ss_pn->leaf = ss_pn->pn + dir_len + 1;

	return (ss_pn);

}

/*

 * Move the "leaf" filename from "sdir" directory

 * to the "ddir" directory. Return the pathname of

 * the destination unless the rename fails in which

 * case we need to return the source pathname.

 */

static rfs4_ss_pn_t *

rfs4_ss_movestate(char *sdir, char *ddir, char *leaf)

{

	rfs4_ss_pn_t *src, *dst;

	if ((src = rfs4_ss_pnalloc(sdir, leaf)) == NULL)

		return (NULL);

	if ((dst = rfs4_ss_pnalloc(ddir, leaf)) == NULL) {

		rfs4_ss_pnfree(src);

		return (NULL);

	}

	/*

	 * If the rename fails we shall return the src

	 * pathname and free the dst. Otherwise we need

	 * to free the src and return the dst pathanme.

	 */

	if (vn_rename(src->pn, dst->pn, UIO_SYSSPACE)) {

		rfs4_ss_pnfree(dst);

		return (src);

	}

	rfs4_ss_pnfree(src);

	return (dst);

}

static rfs4_oldstate_t *

rfs4_ss_getstate(vnode_t *dvp, rfs4_ss_pn_t *ss_pn)

{

	struct uio uio;

	struct iovec iov[3];

	rfs4_oldstate_t *cl_ss = NULL;

	vnode_t *vp;

	vattr_t va;

	uint_t id_len;

	int err, kill_file, file_vers;

	if (ss_pn == NULL)

		return (NULL);

	/*

	 * open the state file.

	 */

	if (vn_open(ss_pn->pn, UIO_SYSSPACE, FREAD, 0, &vp, 0, 0) != 0) {

		return (NULL);

	}

	if (vp->v_type != VREG) {

		(void) VOP_CLOSE(vp, FREAD, 1, (offset_t)0, CRED());

		VN_RELE(vp);

		return (NULL);

	}

	err = VOP_ACCESS(vp, VREAD, 0, CRED());

	if (err) {

		/*

		 * We don't have read access? better get the heck out.

		 */

		(void) VOP_CLOSE(vp, FREAD, 1, (offset_t)0, CRED());

		VN_RELE(vp);

		return (NULL);

	}

	(void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, NULL);

	/*

	 * get the file size to do some basic validation

	 */

	va.va_mask = AT_SIZE;

	err = VOP_GETATTR(vp, &va, 0, CRED());

	kill_file = (va.va_size == 0 || va.va_size <

		(NFS4_VERIFIER_SIZE + sizeof (uint_t)+1));

	if (err || kill_file) {

		VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);

		(void) VOP_CLOSE(vp, FREAD, 1, (offset_t)0, CRED());

		VN_RELE(vp);

		if (kill_file) {

			(void) VOP_REMOVE(dvp, ss_pn->leaf, CRED());

		}

		return (NULL);

	}