/*

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

 */

/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */

/* All Rights Reserved */

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

#include <sys/param.h>

#include <sys/types.h>

#include <sys/systm.h>

#include <sys/cred.h>

#include <sys/vfs.h>

#include <sys/vnode.h>

#include <sys/pathname.h>

#include <sys/sysmacros.h>

#include <sys/kmem.h>

#include <sys/kstat.h>

#include <sys/mkdev.h>

#include <sys/mount.h>

#include <sys/statvfs.h>

#include <sys/errno.h>

#include <sys/debug.h>

#include <sys/cmn_err.h>

#include <sys/utsname.h>

#include <sys/bootconf.h>

#include <sys/modctl.h>

#include <sys/acl.h>

#include <sys/flock.h>

#include <sys/kstr.h>

#include <sys/stropts.h>

#include <sys/strsubr.h>

#include <sys/atomic.h>

#include <sys/disp.h>

#include <sys/policy.h>

#include <sys/list.h>

#include <sys/zone.h>

#include <rpc/types.h>

#include <rpc/auth.h>

#include <rpc/rpcsec_gss.h>

#include <rpc/clnt.h>

#include <rpc/xdr.h>

#include <nfs/nfs.h>

#include <nfs/nfs_clnt.h>

#include <nfs/mount.h>

#include <nfs/nfs_acl.h>

#include <fs/fs_subr.h>

#include <nfs/nfs4.h>

#include <nfs/rnode4.h>

#include <nfs/nfs4_clnt.h>

#include <nfs/nfssys.h>

#ifdef	DEBUG

/*

 * These are "special" state IDs and file handles that

 * match any delegation state ID or file handled.  This

 * is for testing purposes only.

 */

stateid4 nfs4_deleg_any = { 0x7FFFFFF0 };

char nfs4_deleg_fh[] = "\0377\0376\0375\0374";

nfs_fh4 nfs4_deleg_anyfh = { sizeof (nfs4_deleg_fh)-1, nfs4_deleg_fh };

int nfs4_deleg_accept_phony = OPEN_DELEGATE_NONE;

nfsace4 nfs4_deleg_ace_phony;

nfs_space_limit4 nfs4_deleg_space_phony = { NFS_LIMIT_SIZE, 8192 };

nfs_space_limit4 nfs4_deleg_space_phony2 = { NFS_LIMIT_BLOCKS, 0 };

nfs_modified_limit4 nfs4_deleg_space_phonyl = { 8, 512 };

changeid4 nfs4_deleg_change_phony = 0x7eeeeeee76666660LL;

int nfs4_use_phony_limit;

int nfs4_use_phony_recall;

int nfs4_phony_recall_v;

nfsstat4 cb4_getattr_fail = NFS4_OK;

nfsstat4 cb4_recall_fail = NFS4_OK;

int nfs4_callback_debug;

int nfs4_recall_debug;

int nfs4_drat_debug;

#endif

#define	CB_NOTE(x)	NFS4_DEBUG(nfs4_callback_debug, (CE_NOTE, x))

#define	CB_WARN(x)	NFS4_DEBUG(nfs4_callback_debug, (CE_WARN, x))

#define	CB_WARN1(x, y)	NFS4_DEBUG(nfs4_callback_debug, (CE_WARN, x, y))

enum nfs4_delegreturn_policy nfs4_delegreturn_policy = INACTIVE;

static zone_key_t nfs4_callback_zone_key;

/*

 * NFS4_MAPSIZE is the number of bytes we are willing to consume

 * for the block allocation map when the server grants a NFS_LIMIT_BLOCK

 * style delegation.

 */

#define	NFS4_MAPSIZE	8192

#define	NFS4_MAPWORDS	NFS4_MAPSIZE/sizeof (uint_t)

#define	NbPW		(NBBY*sizeof (uint_t))

static int nfs4_num_prognums = 1024;

static SVC_CALLOUT_TABLE nfs4_cb_sct;

struct nfs4_dnode {

	list_node_t	linkage;

	rnode4_t	*rnodep;

	int		flags;		/* Flags for nfs4delegreturn_impl() */

};

static const struct nfs4_callback_stats nfs4_callback_stats_tmpl = {

	{ "delegations",	KSTAT_DATA_UINT64 },

	{ "cb_getattr",		KSTAT_DATA_UINT64 },

	{ "cb_recall",		KSTAT_DATA_UINT64 },

	{ "cb_null",		KSTAT_DATA_UINT64 },

	{ "cb_dispatch",	KSTAT_DATA_UINT64 },

	{ "delegaccept_r",	KSTAT_DATA_UINT64 },

	{ "delegaccept_rw",	KSTAT_DATA_UINT64 },

	{ "delegreturn",	KSTAT_DATA_UINT64 },

	{ "callbacks",		KSTAT_DATA_UINT64 },

	{ "claim_cur",		KSTAT_DATA_UINT64 },

	{ "claim_cur_ok",	KSTAT_DATA_UINT64 },

	{ "recall_trunc",	KSTAT_DATA_UINT64 },

	{ "recall_failed",	KSTAT_DATA_UINT64 },

	{ "return_limit_write",	KSTAT_DATA_UINT64 },

	{ "return_limit_addmap", KSTAT_DATA_UINT64 },

	{ "deleg_recover",	KSTAT_DATA_UINT64 },

	{ "cb_illegal",		KSTAT_DATA_UINT64 }

};

struct nfs4_cb_port {

	list_node_t		linkage; /* linkage into per-zone port list */

	char			netid[KNC_STRSIZE];

	char			uaddr[KNC_STRSIZE];

	char			protofmly[KNC_STRSIZE];

	char			proto[KNC_STRSIZE];

};

static int cb_getattr_bytes;

struct cb_recall_pass {

	rnode4_t	*rp;

	int		flags;		/* Flags for nfs4delegreturn_impl() */

	bool_t		truncate;

};

static nfs4_open_stream_t *get_next_deleg_stream(rnode4_t *, int);

static void nfs4delegreturn_thread(struct cb_recall_pass *);

static int deleg_reopen(vnode_t *, bool_t *, struct nfs4_callback_globals *,

    int);

static void nfs4_dlistadd(rnode4_t *, struct nfs4_callback_globals *, int);

static void nfs4_dlistclean_impl(struct nfs4_callback_globals *, int);

static int nfs4delegreturn_impl(rnode4_t *, int,

    struct nfs4_callback_globals *);

static void nfs4delegreturn_cleanup_impl(rnode4_t *, nfs4_server_t *,

    struct nfs4_callback_globals *);

static void

cb_getattr(nfs_cb_argop4 *argop, nfs_cb_resop4 *resop, struct svc_req *req,

	struct compound_state *cs, struct nfs4_callback_globals *ncg)

{

	CB_GETATTR4args *args = &argop->nfs_cb_argop4_u.opcbgetattr;

	CB_GETATTR4res *resp = &resop->nfs_cb_resop4_u.opcbgetattr;

	rnode4_t *rp;

	vnode_t *vp;

	bool_t found = FALSE;

	struct nfs4_server *sp;

	struct fattr4 *fap;

	rpc_inline_t *fdata;

	long mapcnt;

	fattr4_change change;

	fattr4_size size;

	uint_t rflag;

	ncg->nfs4_callback_stats.cb_getattr.value.ui64++;

#ifdef DEBUG

	/*

	 * error injection hook: set cb_getattr_fail global to

	 * NFS4 pcol error to be returned

	 */

	if (cb4_getattr_fail != NFS4_OK) {

		*cs->statusp = resp->status = cb4_getattr_fail;

		return;

	}

#endif

	resp->obj_attributes.attrmask = 0;

	mutex_enter(&ncg->nfs4_cb_lock);

	sp = ncg->nfs4prog2server[req->rq_prog - NFS4_CALLBACK];

	mutex_exit(&ncg->nfs4_cb_lock);

	if (nfs4_server_vlock(sp, 0) == FALSE) {

		CB_WARN("cb_getattr: cannot find server\n");

		*cs->statusp = resp->status = NFS4ERR_BADHANDLE;

		return;

	}

	/*

	 * In cb_compound, callback_ident was validated against rq_prog,

	 * but we couldn't verify that it was set to the value we provided

	 * at setclientid time (because we didn't have server struct yet).

	 * Now we have the server struct, but don't have callback_ident

	 * handy.  So, validate server struct program number against req

	 * RPC's prog number.  At this point, we know the RPC prog num

	 * is valid (else we wouldn't be here); however, we don't know

	 * that it was the prog number we supplied to this server at

	 * setclientid time.  If the prog numbers aren't equivalent, then

	 * log the problem and fail the request because either cbserv

	 * and/or cbclient are confused.  This will probably never happen.

	 */

	if (sp->s_program != req->rq_prog) {

#ifdef DEBUG

		zcmn_err(getzoneid(), CE_WARN,

		    "cb_getattr: wrong server program number srv=%d req=%d\n",

		    sp->s_program, req->rq_prog);

#else

		zcmn_err(getzoneid(), CE_WARN,

		    "cb_getattr: wrong server program number\n");

#endif

		mutex_exit(&sp->s_lock);

		nfs4_server_rele(sp);

		*cs->statusp = resp->status = NFS4ERR_BADHANDLE;

		return;

	}

	/*

	 * Search the delegation list for a matching file handle;

	 * mutex on sp prevents the list from changing.

	 */

	rp = list_head(&sp->s_deleg_list);

	for (; rp != NULL; rp = list_next(&sp->s_deleg_list, rp)) {

		nfs4_fhandle_t fhandle;

		sfh4_copyval(rp->r_fh, &fhandle);

		if ((fhandle.fh_len == args->fh.nfs_fh4_len &&

		    bcmp(fhandle.fh_buf, args->fh.nfs_fh4_val,

		    fhandle.fh_len) == 0)) {

			found = TRUE;

			break;

		}

#ifdef	DEBUG

		if (nfs4_deleg_anyfh.nfs_fh4_len == args->fh.nfs_fh4_len &&

		    bcmp(nfs4_deleg_anyfh.nfs_fh4_val, args->fh.nfs_fh4_val,

		    args->fh.nfs_fh4_len) == 0) {

			found = TRUE;

			break;

		}

#endif

	}

	/*

	 * VN_HOLD the vnode before releasing s_lock to guarantee

	 * we have a valid vnode reference.

	 */

	if (found == TRUE) {

		vp = RTOV4(rp);

		VN_HOLD(vp);

	}

	mutex_exit(&sp->s_lock);

	nfs4_server_rele(sp);

	if (found == FALSE) {

		CB_WARN("cb_getattr: bad fhandle\n");

		*cs->statusp = resp->status = NFS4ERR_BADHANDLE;

		return;

	}

	/*

	 * Figure out which attributes the server wants.  We only

	 * offer FATTR4_CHANGE & FATTR4_SIZE; ignore the rest.

	 */

	fdata = kmem_alloc(cb_getattr_bytes, KM_SLEEP);

	/*

	 * Don't actually need to create XDR to encode these

	 * simple data structures.

	 * xdrmem_create(&xdr, fdata, cb_getattr_bytes, XDR_ENCODE);

	 */

	fap = &resp->obj_attributes;

	fap->attrmask = 0;

	/* attrlist4_len starts at 0 and increases as attrs are processed */

	fap->attrlist4 = (char *)fdata;

	fap->attrlist4_len = 0;

	/* don't supply attrs if request was zero */

	if (args->attr_request != 0) {

		if (args->attr_request & FATTR4_CHANGE_MASK) {

			/*

			 * If the file is mmapped, then increment the change

			 * attribute and return it.  This will guarantee that

			 * the server will perceive that the file has changed

			 * if there is any chance that the client application

			 * has changed it.  Otherwise, just return the change

			 * attribute as it has been updated by nfs4write_deleg.

			 */

			mutex_enter(&rp->r_statelock);

			mapcnt = rp->r_mapcnt;

			rflag = rp->r_flags;

			mutex_exit(&rp->r_statelock);

			mutex_enter(&rp->r_statev4_lock);

			/*

			 * If object mapped, then always return new change.

			 * Otherwise, return change if object has dirty

			 * pages.  If object doesn't have any dirty pages,

			 * then all changes have been pushed to server, so

			 * reset change to grant change.

			 */

			if (mapcnt)

				rp->r_deleg_change++;

			else if (! (rflag & R4DIRTY))

				rp->r_deleg_change = rp->r_deleg_change_grant;

			change = rp->r_deleg_change;

			mutex_exit(&rp->r_statev4_lock);

			/*

			 * Use inline XDR code directly, we know that we

			 * going to a memory buffer and it has enough

			 * space so it cannot fail.

			 */

			IXDR_PUT_U_HYPER(fdata, change);

			fap->attrlist4_len += 2 * BYTES_PER_XDR_UNIT;

			fap->attrmask |= FATTR4_CHANGE_MASK;

		}

		if (args->attr_request & FATTR4_SIZE_MASK) {

			/*

			 * Use an atomic add of 0 to fetch a consistent view

			 * of r_size; this avoids having to take rw_lock

			 * which could cause a deadlock.

			 */

			size = atomic_add_64_nv((uint64_t *)&rp->r_size, 0);

			/*

			 * Use inline XDR code directly, we know that we

			 * going to a memory buffer and it has enough

			 * space so it cannot fail.

			 */

			IXDR_PUT_U_HYPER(fdata, size);

			fap->attrlist4_len += 2 * BYTES_PER_XDR_UNIT;

			fap->attrmask |= FATTR4_SIZE_MASK;

		}

	}

	VN_RELE(vp);

	*cs->statusp = resp->status = NFS4_OK;

}

static void

cb_getattr_free(nfs_cb_resop4 *resop)

{

	if (resop->nfs_cb_resop4_u.opcbgetattr.obj_attributes.attrlist4)

		kmem_free(resop->nfs_cb_resop4_u.opcbgetattr.

			obj_attributes.attrlist4,

			cb_getattr_bytes);

}

static void

cb_recall(nfs_cb_argop4 *argop, nfs_cb_resop4 *resop, struct svc_req *req,

	struct compound_state *cs, struct nfs4_callback_globals *ncg)

{

	CB_RECALL4args * args = &argop->nfs_cb_argop4_u.opcbrecall;

	CB_RECALL4res *resp = &resop->nfs_cb_resop4_u.opcbrecall;

	rnode4_t *rp;

	vnode_t *vp;

	struct nfs4_server *sp;

	bool_t found = FALSE;

	ncg->nfs4_callback_stats.cb_recall.value.ui64++;

	ASSERT(req->rq_prog >= NFS4_CALLBACK);

	ASSERT(req->rq_prog < NFS4_CALLBACK+nfs4_num_prognums);

#ifdef DEBUG

	/*

	 * error injection hook: set cb_recall_fail global to

	 * NFS4 pcol error to be returned

	 */

	if (cb4_recall_fail != NFS4_OK) {

		*cs->statusp = resp->status = cb4_recall_fail;

		return;

	}

#endif

	mutex_enter(&ncg->nfs4_cb_lock);

	sp = ncg->nfs4prog2server[req->rq_prog - NFS4_CALLBACK];

	mutex_exit(&ncg->nfs4_cb_lock);

	if (nfs4_server_vlock(sp, 0) == FALSE) {

		CB_WARN("cb_recall: cannot find server\n");

		*cs->statusp = resp->status = NFS4ERR_BADHANDLE;

		return;

	}

	/*

	 * Search the delegation list for a matching file handle

	 * AND stateid; mutex on sp prevents the list from changing.

	 */

	rp = list_head(&sp->s_deleg_list);

	for (; rp != NULL; rp = list_next(&sp->s_deleg_list, rp)) {

		mutex_enter(&rp->r_statev4_lock);

		/* check both state id and file handle! */

		if ((bcmp(&rp->r_deleg_stateid, &args->stateid,

		    sizeof (stateid4)) == 0)) {

			nfs4_fhandle_t fhandle;

			sfh4_copyval(rp->r_fh, &fhandle);

			if ((fhandle.fh_len == args->fh.nfs_fh4_len &&

			    bcmp(fhandle.fh_buf, args->fh.nfs_fh4_val,

			    fhandle.fh_len) == 0)) {

				found = TRUE;

				break;

			} else {

#ifdef	DEBUG

				CB_WARN("cb_recall: stateid OK, bad fh");

#endif

			}

		}

#ifdef	DEBUG

		if (bcmp(&args->stateid, &nfs4_deleg_any,

		    sizeof (stateid4)) == 0) {

			found = TRUE;

			break;

		}

#endif

		mutex_exit(&rp->r_statev4_lock);

	}

	/*

	 * VN_HOLD the vnode before releasing s_lock to guarantee

	 * we have a valid vnode reference.  The async thread will

	 * release the hold when it's done.

	 */

	if (found == TRUE) {

		mutex_exit(&rp->r_statev4_lock);

		vp = RTOV4(rp);

		VN_HOLD(vp);

	}

	mutex_exit(&sp->s_lock);

	nfs4_server_rele(sp);

	if (found == FALSE) {

		CB_WARN("cb_recall: bad stateid\n");

		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;

		return;

	}

	/* Fire up a thread to do the delegreturn */

	nfs4delegreturn_async(rp, NFS4_DR_RECALL|NFS4_DR_REOPEN,

					args->truncate);

	*cs->statusp = resp->status = 0;

}

/* ARGSUSED */

static void

cb_recall_free(nfs_cb_resop4 *resop)

{

	/* nothing to do here, cb_recall doesn't kmem_alloc */

}

/*

 * This function handles the CB_NULL proc call from an NFSv4 Server.

 *

 * We take note that the server has sent a CB_NULL for later processing

 * in the recovery logic. It is noted so we may pause slightly after the

 * setclientid and before reopening files. The pause is to allow the

 * NFSv4 Server time to receive the CB_NULL reply and adjust any of

 * its internal structures such that it has the opportunity to grant

 * delegations to reopened files.

 *

 */

/* ARGSUSED */

static void

cb_null(CB_COMPOUND4args *args, CB_COMPOUND4res *resp, struct svc_req *req,

    struct nfs4_callback_globals *ncg)

{

	struct nfs4_server *sp;

	ncg->nfs4_callback_stats.cb_null.value.ui64++;