/*

 * 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 2007 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

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

#include <sys/types.h>

#include <sys/param.h>

#include <sys/time.h>

#include <sys/systm.h>

#include <sys/sysmacros.h>

#include <sys/resource.h>

#include <sys/vfs.h>

#include <sys/vnode.h>

#include <sys/file.h>

#include <sys/mode.h>

#include <sys/kmem.h>

#include <sys/uio.h>

#include <sys/pathname.h>

#include <sys/cmn_err.h>

#include <sys/errno.h>

#include <sys/stat.h>

#include <sys/unistd.h>

#include <sys/random.h>

#include <sys/policy.h>

#include <sys/zfs_dir.h>

#include <sys/zfs_acl.h>

#include <sys/fs/zfs.h>

#include "fs/fs_subr.h"

#include <sys/zap.h>

#include <sys/dmu.h>

#include <sys/atomic.h>

#include <sys/zfs_ctldir.h>

#include <sys/dnlc.h>

/*

 * Lock a directory entry.  A dirlock on <dzp, name> protects that name

 * in dzp's directory zap object.  As long as you hold a dirlock, you can

 * assume two things: (1) dzp cannot be reaped, and (2) no other thread

 * can change the zap entry for (i.e. link or unlink) this name.

 *

 * Input arguments:

 *	dzp	- znode for directory

 *	name	- name of entry to lock

 *	flag	- ZNEW: if the entry already exists, fail with EEXIST.

 *		  ZEXISTS: if the entry does not exist, fail with ENOENT.

 *		  ZSHARED: allow concurrent access with other ZSHARED callers.

 *		  ZXATTR: we want dzp's xattr directory

 *

 * Output arguments:

 *	zpp	- pointer to the znode for the entry (NULL if there isn't one)

 *	dlpp	- pointer to the dirlock for this entry (NULL on error)

 *

 * Return value: 0 on success or errno on failure.

 *

 * NOTE: Always checks for, and rejects, '.' and '..'.

 */

int

zfs_dirent_lock(zfs_dirlock_t **dlpp, znode_t *dzp, char *name, znode_t **zpp,

{

	zfsvfs_t	*zfsvfs = dzp->z_zfsvfs;

	zfs_dirlock_t	*dl;

	uint64_t	zoid;

	*zpp = NULL;

	*dlpp = NULL;

	/*

	 * Verify that we are not trying to lock '.', '..', or '.zfs'

	 */

	if (name[0] == '.' &&

	    (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')) ||

	    zfs_has_ctldir(dzp) && strcmp(name, ZFS_CTLDIR_NAME) == 0)

		return (EEXIST);

	/*

	 * Wait until there are no locks on this name.

	 */

	rw_enter(&dzp->z_name_lock, RW_READER);

	mutex_enter(&dzp->z_lock);

	for (;;) {

		if (dzp->z_unlinked) {

			mutex_exit(&dzp->z_lock);

			rw_exit(&dzp->z_name_lock);

			return (ENOENT);

		}

				break;

		if (dl == NULL)	{

			/*

			 * Allocate a new dirlock and add it to the list.

			 */

			dl = kmem_alloc(sizeof (zfs_dirlock_t), KM_SLEEP);

			cv_init(&dl->dl_cv, NULL, CV_DEFAULT, NULL);

			dl->dl_name = name;

			dl->dl_sharecnt = 0;

			dl->dl_namesize = 0;

			dl->dl_dzp = dzp;

			dl->dl_next = dzp->z_dirlocks;

			dzp->z_dirlocks = dl;

			break;

		}

		if ((flag & ZSHARED) && dl->dl_sharecnt != 0)

			break;

		cv_wait(&dl->dl_cv, &dzp->z_lock);

	}

	if ((flag & ZSHARED) && ++dl->dl_sharecnt > 1 && dl->dl_namesize == 0) {

		/*

		 * We're the second shared reference to dl.  Make a copy of

		 * dl_name in case the first thread goes away before we do.

		 * Note that we initialize the new name before storing its

		 * pointer into dl_name, because the first thread may load

		 * dl->dl_name at any time.  He'll either see the old value,

		 * which is his, or the new shared copy; either is OK.

		 */

		dl->dl_namesize = strlen(dl->dl_name) + 1;

		name = kmem_alloc(dl->dl_namesize, KM_SLEEP);

		bcopy(dl->dl_name, name, dl->dl_namesize);

		dl->dl_name = name;

	}

	mutex_exit(&dzp->z_lock);

	/*

	 * We have a dirlock on the name.  (Note that it is the dirlock,

	 * not the dzp's z_lock, that protects the name in the zap object.)

	 * See if there's an object by this name; if so, put a hold on it.

	 */

	if (flag & ZXATTR) {

		zoid = dzp->z_phys->zp_xattr;

		error = (zoid == 0 ? ENOENT : 0);

	} else {

		if (vp == DNLC_NO_VNODE) {

			VN_RELE(vp);

			error = ENOENT;

		} else if (vp) {

			if (flag & ZNEW) {

				zfs_dirent_unlock(dl);

				VN_RELE(vp);

				return (EEXIST);

			}

			*dlpp = dl;

			*zpp = VTOZ(vp);

			return (0);

		} else {

		}

	}

	if (error) {

		if (error != ENOENT || (flag & ZEXISTS)) {

			zfs_dirent_unlock(dl);

			return (error);

		}

	} else {

		if (flag & ZNEW) {

			zfs_dirent_unlock(dl);

			return (EEXIST);

		}

		error = zfs_zget(zfsvfs, zoid, zpp);

		if (error) {

			zfs_dirent_unlock(dl);

			return (error);

		}

			dnlc_update(ZTOV(dzp), name, ZTOV(*zpp));

	}

	*dlpp = dl;

	return (0);

}

/*

 * Unlock this directory entry and wake anyone who was waiting for it.

 */

void

zfs_dirent_unlock(zfs_dirlock_t *dl)

{

	znode_t *dzp = dl->dl_dzp;

	zfs_dirlock_t **prev_dl, *cur_dl;

	mutex_enter(&dzp->z_lock);

	rw_exit(&dzp->z_name_lock);

	if (dl->dl_sharecnt > 1) {

		dl->dl_sharecnt--;

		mutex_exit(&dzp->z_lock);

		return;

	}

	prev_dl = &dzp->z_dirlocks;

	while ((cur_dl = *prev_dl) != dl)

		prev_dl = &cur_dl->dl_next;

	*prev_dl = dl->dl_next;

	cv_broadcast(&dl->dl_cv);

	mutex_exit(&dzp->z_lock);

	if (dl->dl_namesize != 0)

		kmem_free(dl->dl_name, dl->dl_namesize);

	cv_destroy(&dl->dl_cv);

	kmem_free(dl, sizeof (*dl));

}

/*

 * Look up an entry in a directory.

 *

 * NOTE: '.' and '..' are handled as special cases because

 *	no directory entries are actually stored for them.  If this is

 *	the root of a filesystem, then '.zfs' is also treated as a

 *	special pseudo-directory.

 */

int

{

	zfs_dirlock_t *dl;

	znode_t *zp;

	int error = 0;

	if (name[0] == 0 || (name[0] == '.' && name[1] == 0)) {

		*vpp = ZTOV(dzp);

		VN_HOLD(*vpp);

	} else if (name[0] == '.' && name[1] == '.' && name[2] == 0) {

		zfsvfs_t *zfsvfs = dzp->z_zfsvfs;

		/*

		 * If we are a snapshot mounted under .zfs, return

		 * the vp for the snapshot directory.

		 */

		if (dzp->z_phys->zp_parent == dzp->z_id &&

		    zfsvfs->z_parent != zfsvfs) {

			error = zfsctl_root_lookup(zfsvfs->z_parent->z_ctldir,

			return (error);

		}

		rw_enter(&dzp->z_parent_lock, RW_READER);

		error = zfs_zget(zfsvfs, dzp->z_phys->zp_parent, &zp);

		if (error == 0)

			*vpp = ZTOV(zp);

		rw_exit(&dzp->z_parent_lock);

	} else if (zfs_has_ctldir(dzp) && strcmp(name, ZFS_CTLDIR_NAME) == 0) {

		*vpp = zfsctl_root(dzp);

	} else {

		if (error == 0) {

			*vpp = ZTOV(zp);

			zfs_dirent_unlock(dl);

			dzp->z_zn_prefetch = B_TRUE; /* enable prefetching */

		}

	}

	return (error);

}

static char *

zfs_unlinked_hexname(char namebuf[17], uint64_t x)

{

	char *name = &namebuf[16];

	const char digits[16] = "0123456789abcdef";

	*name = '\0';

	do {

		*--name = digits[x & 0xf];

		x >>= 4;

	} while (x != 0);

	return (name);

}

/*

 * unlinked Set (formerly known as the "delete queue") Error Handling

 *

 * When dealing with the unlinked set, we dmu_tx_hold_zap(), but we

 * don't specify the name of the entry that we will be manipulating.  We

 * also fib and say that we won't be adding any new entries to the

 * unlinked set, even though we might (this is to lower the minimum file

 * size that can be deleted in a full filesystem).  So on the small

 * chance that the nlink list is using a fat zap (ie. has more than

 * 2000 entries), we *may* not pre-read a block that's needed.

 * Therefore it is remotely possible for some of the assertions

 * regarding the unlinked set below to fail due to i/o error.  On a

 * nondebug system, this will result in the space being leaked.

 */

void

zfs_unlinked_add(znode_t *zp, dmu_tx_t *tx)

{

	zfsvfs_t *zfsvfs = zp->z_zfsvfs;

	char obj_name[17];

	int error;

	ASSERT(zp->z_unlinked);

	ASSERT3U(zp->z_phys->zp_links, ==, 0);

	error = zap_add(zfsvfs->z_os, zfsvfs->z_unlinkedobj,

	    zfs_unlinked_hexname(obj_name, zp->z_id), 8, 1, &zp->z_id, tx);

	ASSERT3U(error, ==, 0);

}

/*

 * Clean up any znodes that had no links when we either crashed or

 * (force) umounted the file system.

 */

void

zfs_unlinked_drain(zfsvfs_t *zfsvfs)

{

	zap_cursor_t	zc;

	zap_attribute_t zap;

	dmu_object_info_t doi;

	znode_t		*zp;

	int		error;

	/*

	 * Interate over the contents of the unlinked set.

	 */

	for (zap_cursor_init(&zc, zfsvfs->z_os, zfsvfs->z_unlinkedobj);

	    zap_cursor_retrieve(&zc, &zap) == 0;

	    zap_cursor_advance(&zc)) {

		/*

		 * See what kind of object we have in list

		 */

		error = dmu_object_info(zfsvfs->z_os,

		    zap.za_first_integer, &doi);

		if (error != 0)

			continue;

		ASSERT((doi.doi_type == DMU_OT_PLAIN_FILE_CONTENTS) ||

		    (doi.doi_type == DMU_OT_DIRECTORY_CONTENTS));

		/*

		 * We need to re-mark these list entries for deletion,

		 * so we pull them back into core and set zp->z_unlinked.

		 */

		error = zfs_zget(zfsvfs, zap.za_first_integer, &zp);

		/*

		 * We may pick up znodes that are already marked for deletion.

		 * This could happen during the purge of an extended attribute

		 * directory.  All we need to do is skip over them, since they

		 * are already in the system marked z_unlinked.

		 */

		if (error != 0)

			continue;

		zp->z_unlinked = B_TRUE;

		VN_RELE(ZTOV(zp));

	}

	zap_cursor_fini(&zc);

}

/*

 * Delete the entire contents of a directory.  Return a count

 * of the number of entries that could not be deleted.