/*

 * 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 (c) 1983,1984,1985,1986,1987,1988,1989  AT&T.

 *	All rights reserved.

 *	Use is subject to license terms.

 */

#include <sys/param.h>

#include <sys/types.h>

#include <sys/systm.h>

#include <sys/cred.h>

#include <sys/proc.h>

#include <sys/user.h>

#include <sys/buf.h>

#include <sys/vfs.h>

#include <sys/vnode.h>

#include <sys/pathname.h>

#include <sys/uio.h>

#include <sys/file.h>

#include <sys/stat.h>

#include <sys/errno.h>

#include <sys/socket.h>

#include <sys/sysmacros.h>

#include <sys/siginfo.h>

#include <sys/tiuser.h>

#include <sys/statvfs.h>

#include <sys/stream.h>

#include <sys/strsubr.h>

#include <sys/stropts.h>

#include <sys/timod.h>

#include <sys/t_kuser.h>

#include <sys/kmem.h>

#include <sys/kstat.h>

#include <sys/dirent.h>

#include <sys/cmn_err.h>

#include <sys/debug.h>

#include <sys/unistd.h>

#include <sys/vtrace.h>

#include <sys/mode.h>

#include <sys/acl.h>

#include <sys/sdt.h>

#include <rpc/types.h>

#include <rpc/auth.h>

#include <rpc/auth_unix.h>

#include <rpc/auth_des.h>

#include <rpc/svc.h>

#include <rpc/xdr.h>

#include <rpc/rpc_rdma.h>

#include <nfs/nfs.h>

#include <nfs/export.h>

#include <nfs/nfssys.h>

#include <nfs/nfs_clnt.h>

#include <nfs/nfs_acl.h>

#include <nfs/nfs_log.h>

#include <nfs/nfs_cmd.h>

#include <nfs/lm.h>

#include <nfs/nfs_dispatch.h>

#include <nfs/nfs4_drc.h>

#include <sys/modctl.h>

#include <sys/cladm.h>

#include <sys/clconf.h>

#include <sys/tsol/label.h>

#define	MAXHOST 32

const char *kinet_ntop6(uchar_t *, char *, size_t);

/*

 * Module linkage information.

 */

static struct modlmisc modlmisc = {

	&mod_miscops, "NFS server module"

};

static struct modlinkage modlinkage = {

	MODREV_1, (void *)&modlmisc, NULL

};

char _depends_on[] = "misc/klmmod";

kmem_cache_t *nfs_xuio_cache;

int nfs_loaned_buffers = 0;

int

_init(void)

{

	int status;

	if ((status = nfs_srvinit()) != 0) {

		cmn_err(CE_WARN, "_init: nfs_srvinit failed");

		return (status);

	}

	status = mod_install((struct modlinkage *)&modlinkage);

	if (status != 0) {

		/*

		 * Could not load module, cleanup previous

		 * initialization work.

		 */

		nfs_srvfini();

	}

	/*

	 * Initialise some placeholders for nfssys() calls. These have

	 * to be declared by the nfs module, since that handles nfssys()

	 * calls - also used by NFS clients - but are provided by this

	 * nfssrv module. These also then serve as confirmation to the

	 * relevant code in nfs that nfssrv has been loaded, as they're

	 * initially NULL.

	 */

	nfs_srv_quiesce_func = nfs_srv_quiesce_all;

	nfs_srv_dss_func = rfs4_dss_setpaths;

	/* setup DSS paths here; must be done before initial server startup */

	rfs4_dss_paths = rfs4_dss_oldpaths = NULL;

	/* initialize the copy reduction caches */

	nfs_xuio_cache = kmem_cache_create("nfs_xuio_cache",

	    sizeof (nfs_xuio_t), 0, NULL, NULL, NULL, NULL, NULL, 0);

	return (status);

}

int

_fini()

{

	return (EBUSY);

}

int

_info(struct modinfo *modinfop)

{

	return (mod_info(&modlinkage, modinfop));

}

/*

 * PUBLICFH_CHECK() checks if the dispatch routine supports

 * RPC_PUBLICFH_OK, if the filesystem is exported public, and if the

 * incoming request is using the public filehandle. The check duplicates

 * the exportmatch() call done in checkexport(), and we should consider

 * modifying those routines to avoid the duplication. For now, we optimize

 * by calling exportmatch() only after checking that the dispatch routine

 * supports RPC_PUBLICFH_OK, and if the filesystem is explicitly exported

 * public (i.e., not the placeholder).

 */

#define	PUBLICFH_CHECK(disp, exi, fsid, xfid) \

		((disp->dis_flags & RPC_PUBLICFH_OK) && \

		((exi->exi_export.ex_flags & EX_PUBLIC) || \

		(exi == exi_public && exportmatch(exi_root, \

		fsid, xfid))))

static void	nfs_srv_shutdown_all(int);

static void	rfs4_server_start(int);

static void	nullfree(void);

static void	rfs_dispatch(struct svc_req *, SVCXPRT *);

static void	acl_dispatch(struct svc_req *, SVCXPRT *);

static void	common_dispatch(struct svc_req *, SVCXPRT *,

		rpcvers_t, rpcvers_t, char *,

		struct rpc_disptable *);

static void	hanfsv4_failover(void);

static	int	checkauth(struct exportinfo *, struct svc_req *, cred_t *, int,

			bool_t);

static char	*client_name(struct svc_req *req);

static char	*client_addr(struct svc_req *req, char *buf);

extern	int	sec_svc_getcred(struct svc_req *, cred_t *cr, char **, int *);

extern	bool_t	sec_svc_inrootlist(int, caddr_t, int, caddr_t *);

#define	NFSLOG_COPY_NETBUF(exi, xprt, nb)	{		\

	(nb)->maxlen = (xprt)->xp_rtaddr.maxlen;		\

	(nb)->len = (xprt)->xp_rtaddr.len;			\

	(nb)->buf = kmem_alloc((nb)->len, KM_SLEEP);		\

	bcopy((xprt)->xp_rtaddr.buf, (nb)->buf, (nb)->len);	\

	}

/*

 * Public Filehandle common nfs routines

 */

static int	MCLpath(char **);

static void	URLparse(char *);

/*

 * NFS callout table.

 * This table is used by svc_getreq() to dispatch a request with

 * a given prog/vers pair to an appropriate service provider

 * dispatch routine.

 *

 * NOTE: ordering is relied upon below when resetting the version min/max

 * for NFS_PROGRAM.  Careful, if this is ever changed.

 */

static SVC_CALLOUT __nfs_sc_clts[] = {

	{ NFS_PROGRAM,	   NFS_VERSMIN,	    NFS_VERSMAX,	rfs_dispatch },

	{ NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX,	acl_dispatch }

};

static SVC_CALLOUT_TABLE nfs_sct_clts = {

	sizeof (__nfs_sc_clts) / sizeof (__nfs_sc_clts[0]), FALSE,

	__nfs_sc_clts

};

static SVC_CALLOUT __nfs_sc_cots[] = {

	{ NFS_PROGRAM,	   NFS_VERSMIN,	    NFS_VERSMAX,	rfs_dispatch },

	{ NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX,	acl_dispatch }

};

static SVC_CALLOUT_TABLE nfs_sct_cots = {

	sizeof (__nfs_sc_cots) / sizeof (__nfs_sc_cots[0]), FALSE, __nfs_sc_cots

};

static SVC_CALLOUT __nfs_sc_rdma[] = {

	{ NFS_PROGRAM,	   NFS_VERSMIN,	    NFS_VERSMAX,	rfs_dispatch },

	{ NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX,	acl_dispatch }

};

static SVC_CALLOUT_TABLE nfs_sct_rdma = {

	sizeof (__nfs_sc_rdma) / sizeof (__nfs_sc_rdma[0]), FALSE, __nfs_sc_rdma

};

rpcvers_t nfs_versmin = NFS_VERSMIN_DEFAULT;

rpcvers_t nfs_versmax = NFS_VERSMAX_DEFAULT;

/*

 * Used to track the state of the server so that initialization

 * can be done properly.

 */

typedef enum {

	NFS_SERVER_STOPPED,	/* server state destroyed */

	NFS_SERVER_STOPPING,	/* server state being destroyed */

	NFS_SERVER_RUNNING,

	NFS_SERVER_QUIESCED,	/* server state preserved */

	NFS_SERVER_OFFLINE	/* server pool offline */

} nfs_server_running_t;

static nfs_server_running_t nfs_server_upordown;

static kmutex_t nfs_server_upordown_lock;

static	kcondvar_t nfs_server_upordown_cv;

/*

 * DSS: distributed stable storage

 * lists of all DSS paths: current, and before last warmstart

 */

nvlist_t *rfs4_dss_paths, *rfs4_dss_oldpaths;

int rfs4_dispatch(struct rpcdisp *, struct svc_req *, SVCXPRT *, char *);

bool_t rfs4_minorvers_mismatch(struct svc_req *, SVCXPRT *, void *);

/*

 * RDMA wait variables.

 */

static kcondvar_t rdma_wait_cv;

static kmutex_t rdma_wait_mutex;

/*

 * Will be called at the point the server pool is being unregistered

 * from the pool list. From that point onwards, the pool is waiting

 * to be drained and as such the server state is stale and pertains

 * to the old instantiation of the NFS server pool.

 */

void

nfs_srv_offline(void)

{

	mutex_enter(&nfs_server_upordown_lock);

	if (nfs_server_upordown == NFS_SERVER_RUNNING) {

		nfs_server_upordown = NFS_SERVER_OFFLINE;

	}

	mutex_exit(&nfs_server_upordown_lock);

}

/*

 * Will be called at the point the server pool is being destroyed so

 * all transports have been closed and no service threads are in

 * existence.

 *

 * If we quiesce the server, we're shutting it down without destroying the

 * server state. This allows it to warm start subsequently.

 */

void

nfs_srv_stop_all(void)

{

	int quiesce = 0;

	nfs_srv_shutdown_all(quiesce);

}

/*

 * This alternative shutdown routine can be requested via nfssys()

 */

void

nfs_srv_quiesce_all(void)

{

	int quiesce = 1;

	nfs_srv_shutdown_all(quiesce);

}

static void

nfs_srv_shutdown_all(int quiesce) {

	mutex_enter(&nfs_server_upordown_lock);

	if (quiesce) {

		if (nfs_server_upordown == NFS_SERVER_RUNNING ||

			nfs_server_upordown == NFS_SERVER_OFFLINE) {

			nfs_server_upordown = NFS_SERVER_QUIESCED;

			cv_signal(&nfs_server_upordown_cv);

			/* reset DSS state, for subsequent warm restart */

			rfs4_dss_numnewpaths = 0;

			rfs4_dss_newpaths = NULL;

			cmn_err(CE_NOTE, "nfs_server: server is now quiesced; "

			    "NFSv4 state has been preserved");

		}

	} else {

		if (nfs_server_upordown == NFS_SERVER_OFFLINE) {

			nfs_server_upordown = NFS_SERVER_STOPPING;

			mutex_exit(&nfs_server_upordown_lock);

			rfs4_state_fini();

			rfs4_fini_drc(nfs4_drc);

			mutex_enter(&nfs_server_upordown_lock);

			nfs_server_upordown = NFS_SERVER_STOPPED;

			cv_signal(&nfs_server_upordown_cv);

		}

	}

	mutex_exit(&nfs_server_upordown_lock);

}

static int

nfs_srv_set_sc_versions(struct file *fp, SVC_CALLOUT_TABLE **sctpp,

			rpcvers_t versmin, rpcvers_t versmax)

{

	struct strioctl strioc;

	struct T_info_ack tinfo;

	int		error, retval;

	/*

	 * Find out what type of transport this is.

	 */

	strioc.ic_cmd = TI_GETINFO;

	strioc.ic_timout = -1;

	strioc.ic_len = sizeof (tinfo);

	strioc.ic_dp = (char *)&tinfo;

	tinfo.PRIM_type = T_INFO_REQ;

	error = strioctl(fp->f_vnode, I_STR, (intptr_t)&strioc, 0, K_TO_K,

	    CRED(), &retval);

	if (error || retval)

		return (error);

	/*

	 * Based on our query of the transport type...

	 *

	 * Reset the min/max versions based on the caller's request

	 * NOTE: This assumes that NFS_PROGRAM is first in the array!!

	 * And the second entry is the NFS_ACL_PROGRAM.

	 */

	switch (tinfo.SERV_type) {

	case T_CLTS:

		if (versmax == NFS_V4)

			return (EINVAL);

		__nfs_sc_clts[0].sc_versmin = versmin;

		__nfs_sc_clts[0].sc_versmax = versmax;

		__nfs_sc_clts[1].sc_versmin = versmin;

		__nfs_sc_clts[1].sc_versmax = versmax;

		*sctpp = &nfs_sct_clts;

		break;

	case T_COTS:

	case T_COTS_ORD:

		__nfs_sc_cots[0].sc_versmin = versmin;

		__nfs_sc_cots[0].sc_versmax = versmax;

		/* For the NFS_ACL program, check the max version */

		if (versmax > NFS_ACL_VERSMAX)

			versmax = NFS_ACL_VERSMAX;

		__nfs_sc_cots[1].sc_versmin = versmin;

		__nfs_sc_cots[1].sc_versmax = versmax;

		*sctpp = &nfs_sct_cots;

		break;

	default:

		error = EINVAL;

	}

	return (error);

}

/*

 * NFS Server system call.

 * Does all of the work of running a NFS server.

 * uap->fd is the fd of an open transport provider

 */

int

nfs_svc(struct nfs_svc_args *arg, model_t model)

{

	file_t *fp;

	SVCMASTERXPRT *xprt;

	int error;

	int readsize;

	char buf[KNC_STRSIZE];

	size_t len;

	STRUCT_HANDLE(nfs_svc_args, uap);

	struct netbuf addrmask;

	SVC_CALLOUT_TABLE *sctp = NULL;

#ifdef lint

	model = model;		/* STRUCT macros don't always refer to it */

#endif

	STRUCT_SET_HANDLE(uap, model, arg);

	/* Check privileges in nfssys() */

	if ((fp = getf(STRUCT_FGET(uap, fd))) == NULL)

		return (EBADF);

	/*

	 * Set read buffer size to rsize

	 * and add room for RPC headers.

	 */

	readsize = nfs3tsize() + (RPC_MAXDATASIZE - NFS_MAXDATA);

	if (readsize < RPC_MAXDATASIZE)

		readsize = RPC_MAXDATASIZE;

	error = copyinstr((const char *)STRUCT_FGETP(uap, netid), buf,

	    KNC_STRSIZE, &len);

	if (error) {

		releasef(STRUCT_FGET(uap, fd));

		return (error);

	}

	addrmask.len = STRUCT_FGET(uap, addrmask.len);

	addrmask.maxlen = STRUCT_FGET(uap, addrmask.maxlen);

	addrmask.buf = kmem_alloc(addrmask.maxlen, KM_SLEEP);

	error = copyin(STRUCT_FGETP(uap, addrmask.buf), addrmask.buf,

	    addrmask.len);

	if (error) {

		releasef(STRUCT_FGET(uap, fd));

		kmem_free(addrmask.buf, addrmask.maxlen);

		return (error);

	}

	nfs_versmin = STRUCT_FGET(uap, versmin);

	nfs_versmax = STRUCT_FGET(uap, versmax);

	/* Double check the vers min/max ranges */

	if ((nfs_versmin > nfs_versmax) ||

	    (nfs_versmin < NFS_VERSMIN) ||

	    (nfs_versmax > NFS_VERSMAX)) {

		nfs_versmin = NFS_VERSMIN_DEFAULT;

		nfs_versmax = NFS_VERSMAX_DEFAULT;

	}

	if (error =

	    nfs_srv_set_sc_versions(fp, &sctp, nfs_versmin, nfs_versmax)) {

		releasef(STRUCT_FGET(uap, fd));

		kmem_free(addrmask.buf, addrmask.maxlen);

		return (error);

	}

	/* Initialize nfsv4 server */

	if (nfs_versmax == (rpcvers_t)NFS_V4)

		rfs4_server_start(STRUCT_FGET(uap, delegation));

	/* Create a transport handle. */

	error = svc_tli_kcreate(fp, readsize, buf, &addrmask, &xprt,

	    sctp, NULL, NFS_SVCPOOL_ID, TRUE);

	if (error)

		kmem_free(addrmask.buf, addrmask.maxlen);

	releasef(STRUCT_FGET(uap, fd));

	/* HA-NFSv4: save the cluster nodeid */

	if (cluster_bootflags & CLUSTER_BOOTED)

		lm_global_nlmid = clconf_get_nodeid();

	return (error);

}

static void

rfs4_server_start(int nfs4_srv_delegation)

{

	/*

	 * Determine if the server has previously been "started" and

	 * if not, do the per instance initialization

	 */

	mutex_enter(&nfs_server_upordown_lock);

	if (nfs_server_upordown != NFS_SERVER_RUNNING) {

		/* Do we need to stop and wait on the previous server? */

		while (nfs_server_upordown == NFS_SERVER_STOPPING ||

		    nfs_server_upordown == NFS_SERVER_OFFLINE)

			cv_wait(&nfs_server_upordown_cv,

			    &nfs_server_upordown_lock);

		if (nfs_server_upordown != NFS_SERVER_RUNNING) {

			(void) svc_pool_control(NFS_SVCPOOL_ID,

			    SVCPSET_UNREGISTER_PROC, (void *)&nfs_srv_offline);

			(void) svc_pool_control(NFS_SVCPOOL_ID,

			    SVCPSET_SHUTDOWN_PROC, (void *)&nfs_srv_stop_all);

			/* is this an nfsd warm start? */