/*

 * 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 <nfs/nfs.h>

#include <nfs/export.h>

#include <sys/cmn_err.h>

/*

 * A version of VOP_FID that deals with a remote VOP_FID for nfs.

 * If vp is an nfs node, nfs4_fid() returns EREMOTE, nfs3_fid() and nfs_fid()

 * returns the filehandle of vp as its fid. When nfs uses fid to set the

 * exportinfo filehandle template, a remote nfs filehandle would be too big for

 * the fid of the exported directory. This routine remaps the value of the

 * attribute va_nodeid of vp to be the fid of vp, so that the fid can fit.

 *

 * We need this fid mainly for setting up NFSv4 server namespace where an

 * nfs filesystem is also part of it. Thus, need to be able to setup a pseudo

 * exportinfo for an nfs node.

 *

 * e.g. mount an ufs filesystem on an nfs filesystem, then share the ufs

 *      filesystem. (like exporting a local disk from a "diskless" client)

 */

int

vop_fid_pseudo(vnode_t *vp, fid_t *fidp)

{

	struct vattr va;

	int error;

	error = VOP_FID(vp, fidp);

	/*

	 * XXX nfs4_fid() does nothing and returns EREMOTE.

	 * XXX nfs3_fid()/nfs_fid() returns nfs filehandle as its fid

	 * which has a bigger length than local fid.

	 * NFS_FH4MAXDATA is the size of

	 * fhandle4_t.fh_xdata[NFS_FH4MAXDATA].

	 *

	 * Note: nfs[2,3,4]_fid() only gets called for diskless clients.

	 */

	if (error == EREMOTE ||

	    (error == 0 && fidp->fid_len > NFS_FH4MAXDATA)) {

		va.va_mask = AT_NODEID;

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

		if (error)

			return (error);

		fidp->fid_len = sizeof (va.va_nodeid);

		bcopy(&va.va_nodeid, fidp->fid_data, fidp->fid_len);

		return (0);

	}

	return (error);

}

/*

 * Get an nfsv4 vnode of the given fid from the visible list of an

 * nfs filesystem or get the exi_vp if it is the root node.

 */

int

nfs4_vget_pseudo(struct exportinfo *exi, vnode_t **vpp, fid_t *fidp)

{

	fid_t exp_fid;

	struct exp_visible *visp;

	int error;

	/* check if the given fid is in the visible list */

	for (visp = exi->exi_visible; visp; visp = visp->vis_next) {

		if (EQFID(fidp, &visp->vis_fid)) {

			VN_HOLD(visp->vis_vp);

			*vpp = visp->vis_vp;

			return (0);

		}

	}

	/* check if the given fid is the same as the exported node */

	bzero(&exp_fid, sizeof (exp_fid));

	exp_fid.fid_len = MAXFIDSZ;

	error = vop_fid_pseudo(exi->exi_vp, &exp_fid);

	if (error)

		return (error);

	if (EQFID(fidp, &exp_fid)) {

		VN_HOLD(exi->exi_vp);

		*vpp = exi->exi_vp;

		return (0);

	}

	return (ENOENT);

}

/*

 * Create a pseudo export entry

 *

 * This is an export entry that's created as the

 * side-effect of a "real" export.  As a part of

 * a real export, the pathname to the export is

 * checked to see if all the directory components

 * are accessible via an NFSv4 client, i.e. are

 * exported.  If tree_climb() finds an unexported

 * mountpoint along the path, then it calls this

 * function to export it.

 *

 * This pseudo export differs from a real export

 * in restriction on simple. read-only access,

 * and the addition of a "visible" list of directories.

 * A real export may have a visible list if it is a root of

 * a file system and at least one of its subtree resides in

 * a different file system is shared.

 *

 * A visible list is per file system. It resides in the exportinfo

 * for the pseudo node (VROOT) and it could reside in a real export

 * of a VROOT node.

 */

int

pseudo_exportfs(vnode_t *vp, struct exp_visible *vis_head,

					struct exportdata *exdata)

{

	struct exportinfo *exi;

	struct exportdata *kex;

	fid_t fid;

	fsid_t fsid;

	int error;

	char *pseudo;

	ASSERT(RW_WRITE_HELD(&exported_lock));

	/*

	 * Get the vfs id

	 */

	bzero(&fid, sizeof (fid));

	fid.fid_len = MAXFIDSZ;

	error = vop_fid_pseudo(vp, &fid);

	if (error) {

		/*

		 * If VOP_FID returns ENOSPC then the fid supplied

		 * is too small.  For now we simply return EREMOTE.

		 */

		if (error == ENOSPC)

			error = EREMOTE;

		return (error);

	}

	fsid = vp->v_vfsp->vfs_fsid;

	exi = kmem_zalloc(sizeof (*exi), KM_SLEEP);

	exi->exi_fsid = fsid;

	exi->exi_fid = fid;

	exi->exi_vp = vp;

	VN_HOLD(exi->exi_vp);

	exi->exi_visible = vis_head;

	exi->exi_count = 1;

	exi->exi_volatile_dev = (vfssw[vp->v_vfsp->vfs_fstype].vsw_flag &

				VSW_VOLATILEDEV) ? 1 : 0;

	mutex_init(&exi->exi_lock, NULL, MUTEX_DEFAULT, NULL);

	/*

	 * Build up the template fhandle

	 */

	exi->exi_fh.fh_fsid = fsid;

	ASSERT(exi->exi_fid.fid_len <= sizeof (exi->exi_fh.fh_xdata));

	exi->exi_fh.fh_xlen = exi->exi_fid.fid_len;

	bcopy(exi->exi_fid.fid_data, exi->exi_fh.fh_xdata,

	    exi->exi_fid.fid_len);

	exi->exi_fh.fh_len = sizeof (exi->exi_fh.fh_data);

	kex = &exi->exi_export;

	kex->ex_flags = EX_PSEUDO;

	/* Set up a generic pathname */

	pseudo = "(pseudo)";

	kex->ex_pathlen = strlen(pseudo);

	kex->ex_path = kmem_alloc(kex->ex_pathlen + 1, KM_SLEEP);

	(void) strcpy(kex->ex_path, pseudo);

	/* Transfer the secinfo data from exdata to this new pseudo node */

	if (exdata)

		srv_secinfo_exp2pseu(&exi->exi_export, exdata);

	/*

	 * Initialize auth cache lock

	 */

	rw_init(&exi->exi_cache_lock, NULL, RW_DEFAULT, NULL);

	/*

	 * Insert the new entry at the front of the export list

	 */

	export_link(exi);

	return (0);

}

/*

 * Free a list of visible directories

 */

void

free_visible(struct exp_visible *head)

{

	struct exp_visible *visp, *next;

	for (visp = head; visp; visp = next) {

		if (visp->vis_vp != NULL)

			VN_RELE(visp->vis_vp);

		next = visp->vis_next;

		kmem_free(visp, sizeof (*visp));

	}

}

/*

 * Add a list of visible directories to a pseudo exportfs.

 *

 * When we export a new directory we need to add a new

 * path segment through the pseudofs to reach the new

 * directory. This new path is reflected in a list of

 * directories added to the "visible" list.

 *

 * Here there are two lists of visible fids: one hanging off the

 * pseudo exportinfo, and the one we want to add.  It's possible

 * that the two lists share a common path segment

 * and have some common directories.  We need to combine

 * the lists so there's no duplicate entries. Where a common

 * path component is found, the vis_count field is bumped.

 *

 * When the addition is complete, the supplied list is freed.

 */

static void

more_visible(struct exportinfo *exi, struct exp_visible *vis_head)

{

	struct exp_visible *vp1, *vp2;

	struct exp_visible *tail, *new;

	int found;

	/*

	 * If exportinfo doesn't already have a visible

	 * list just assign the entire supplied list.

	 */

	if (exi->exi_visible == NULL) {

		exi->exi_visible = vis_head;

		return;

	}

	/*

	 * The outer loop traverses the supplied list.

	 */

	for (vp1 = vis_head; vp1; vp1 = vp1->vis_next) {

		/*

		 * Given an element from the list to be added,

		 * search the exportinfo visible list looking for a match.

		 * If a match is found, increment the reference count.

		 */

		found = 0;

		for (vp2 = exi->exi_visible; vp2; vp2 = vp2->vis_next) {

			tail = vp2;

			if (EQFID(&vp1->vis_fid, &vp2->vis_fid)) {

				found = 1;

				vp2->vis_count++;

				VN_RELE(vp1->vis_vp);

				vp1->vis_vp = NULL;

				/*

				 * If the visible struct we want to add

				 * (vp1) has vis_exported set to 1, then

				 * the matching visible struct we just found

				 * must also have it's vis_exported field

				 * set to 1.

				 *

				 * For example, if /export/home was shared

				 * (and a UFS mountpoint), then "export" and

				 * "home" would each have visible structs in

				 * the root pseudo exportinfo. The vis_exported

				 * for home would be 1, and vis_exported for

				 * export would be 0.  Now, if /export was

				 * also shared, more_visible would find the

				 * existing visible struct for export, and

				 * see that vis_exported was 0.  The code

				 * below will set it to 1.

				 *

				 * vp1 is from vis list passed in (vis_head)

				 * vp2 is from vis list on pseudo exportinfo

				 */

				if (vp1->vis_exported && !vp2->vis_exported)

					vp2->vis_exported = 1;

				break;

			}

		}

		/* If not found - add to the end of the list */

		if (! found) {

			new = kmem_zalloc(sizeof (*new), KM_SLEEP);

			*new = *vp1;

			tail->vis_next = new;

			new->vis_next = NULL;

			vp1->vis_vp = NULL;

		}

	}

	/*

	 * Throw away the path list. vis_vp pointers in vis_head list

	 * are either VN_RELEed or reassigned, and are set to NULL.

	 * There is no need to VN_RELE in free_visible for this vis_head.

	 */

	free_visible(vis_head);

}

/*

 * Remove a list of visible directories from the pseudo exportfs.

 *

 * When we unexport a directory, we have to remove path

 * components from the visible list in the pseudo exportfs

 * entry.  The supplied visible list contains the fids of the path

 * to the unexported directory.  The visible list of the export

 * is checked against this list any matching fids have their

 * reference count decremented.  If a reference count drops to

 * zero, then it means no paths now use this directory, so its

 * fid can be removed from the visible list.

 *

 * When the last path is removed, the visible list will be null.

 */

static void

less_visible(struct exportinfo *exi, struct exp_visible *vis_head)

{

	struct exp_visible *vp1, *vp2;

	struct exp_visible *prev, *next;

	/*

	 * The outer loop traverses the supplied list.

	 */

	for (vp1 = vis_head; vp1; vp1 = vp1->vis_next) {

		/*

		 * Given an element from the list to be removed,

		 * search the exportinfo list looking for a match.

		 * If a match is found, decrement the reference

		 * count and drop the element if the count drops

		 * to zero.

		 */

		for (vp2 = exi->exi_visible, prev = NULL; vp2; vp2 = next) {

			next = vp2->vis_next;

			if (EQFID(&vp1->vis_fid, &vp2->vis_fid)) {

				/*

				 * Decrement the ref count.

				 * Remove the entry if it's zero.

				 */

				if (--vp2->vis_count <= 0) {

					if (prev == NULL)

						exi->exi_visible = next;

					else

						prev->vis_next = next;

					VN_RELE(vp2->vis_vp);

					kmem_free(vp2, sizeof (*vp1));

				} else {

					/*

					 * If we're here, then the vp2 will

					 * remain in the vis list.  If the

					 * vis entry corresponds to the object

					 * being unshared, then vis_exported

					 * needs to be set to 0.

					 *

					 * vp1 is a node from caller's list

					 * vp2 is node from exportinfo's list

					 *

					 * Only 1 node in the caller's list

					 * will have vis_exported set to 1,

					 * and it corresponds to the obj being

					 * unshared.  It should always be the

					 * last element of the caller's list.

					 */

					if (vp1->vis_exported &&

					    vp2->vis_exported) {

						vp2->vis_exported = 0;

					}

				}

				break;

			}

			prev = vp2;

		}

	}

	free_visible(vis_head);

}

/*

 * This function checks the path to a new export to

 * check whether all the pathname components are

 * exported. It works by climbing the file tree one

 * component at a time via "..", crossing mountpoints

 * if necessary until an export entry is found, or the

 * system root is reached.

 *

 * If an unexported mountpoint is found, then

 * a new pseudo export is added and the pathname from

 * the mountpoint down to the export is added to the

 * visible list for the new pseudo export.  If an existing

 * pseudo export is found, then the pathname is added

 * to its visible list.

 *

 * Note that there's some tests for exportdir.

 * The exportinfo entry that's passed as a parameter

 * is that of the real export and exportdir is set

 * for this case.

 *

 * Here is an example of a possible setup:

 *

 * () - a new fs; fs mount point

 * EXPORT - a real exported node

 * PSEUDO - a pseudo node

 * vis - visible list

 * f# - security flavor#

 * (f#) - security flavor# propagated from its decendents

 * "" - covered vnode

 *

 *

 *                 /

 *                 |

 *                 (a) PSEUDO (f1,f2)

 *                 |   vis: b,b,"c","n"

 *                 |

 *                 b

 *        ---------|------------------

 *        |                          |

 *        (c) EXPORT,f1(f2)          (n) PSEUDO (f1,f2)

 *        |   vis: "e","d"           |   vis: m,m,,p,q,"o"

 *        |                          |

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

 *  |        |        |         |                  |

 *  (d)      (e)      f         m EXPORT,f1(f2)    p

 *  EXPORT   EXPORT             |                  |

 *  f1       f2                 |                  |

 *           |                  |                  |

 *           j                 (o) EXPORT,f2       q EXPORT f2

 *

 */

int

treeclimb_export(struct exportinfo *exip)

{

	vnode_t *dvp, *vp;

	fid_t fid;

	int error;

	int exportdir;

	struct exportinfo *exi = NULL;

	struct exp_visible *visp;

	struct exp_visible *vis_head = NULL;

	struct vattr va;

	ASSERT(RW_WRITE_HELD(&exported_lock));

	vp = exip->exi_vp;

	VN_HOLD(vp);

	exportdir = 1;

	for (;;) {

		bzero(&fid, sizeof (fid));

		fid.fid_len = MAXFIDSZ;

		error = vop_fid_pseudo(vp, &fid);

		if (error)

			break;

		if (! exportdir) {

			/*

			 * Check if this exportroot is a VROOT dir.  If so,

			 * then attach the pseudonodes.  If not, then

			 * continue .. traversal until we hit a VROOT

			 * export (pseudo or real).

			 */

			exi = checkexport4(&vp->v_vfsp->vfs_fsid, &fid, vp);

			if (exi != NULL && vp->v_flag & VROOT) {

				/*

				 * Found an export info

				 *

				 * Extend the list of visible

				 * directories whether it's a pseudo

				 * or a real export.

				 */

				more_visible(exi, vis_head);

				vis_head = NULL;

				break;	/* and climb no further */

			}

		}

		/*

		 * If at the root of the filesystem, need

		 * to traverse across the mountpoint

		 * and continue the climb on the mounted-on

		 * filesystem.

		 */

		if (vp->v_flag & VROOT) {

			if (! exportdir) {