/*

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

 * Use is subject to license terms.

 */

#include <sys/dmu.h>

#include <sys/dmu_objset.h>

#include <sys/dmu_tx.h>

#include <sys/dsl_dataset.h>

#include <sys/dsl_dir.h>

#include <sys/dsl_prop.h>

#include <sys/dsl_synctask.h>

#include <sys/dsl_deleg.h>

#include <sys/spa.h>

#include <sys/metaslab.h>

#include <sys/zap.h>

#include <sys/zio.h>

#include <sys/arc.h>

#include <sys/sunddi.h>

#include "zfs_namecheck.h"

static uint64_t dsl_dir_space_towrite(dsl_dir_t *dd);

static void dsl_dir_set_reservation_sync(void *arg1, void *arg2,

    cred_t *cr, dmu_tx_t *tx);

/* ARGSUSED */

static void

dsl_dir_evict(dmu_buf_t *db, void *arg)

{

	dsl_dir_t *dd = arg;

	dsl_pool_t *dp = dd->dd_pool;

	int t;

	for (t = 0; t < TXG_SIZE; t++) {

		ASSERT(!txg_list_member(&dp->dp_dirty_dirs, dd, t));

		ASSERT(dd->dd_tempreserved[t] == 0);

		ASSERT(dd->dd_space_towrite[t] == 0);

	}

	if (dd->dd_parent)

		dsl_dir_close(dd->dd_parent, dd);

	spa_close(dd->dd_pool->dp_spa, dd);

	/*

	 * The props callback list should be empty since they hold the

	 * dir open.

	 */

	list_destroy(&dd->dd_prop_cbs);

	mutex_destroy(&dd->dd_lock);

	kmem_free(dd, sizeof (dsl_dir_t));

}

int

dsl_dir_open_obj(dsl_pool_t *dp, uint64_t ddobj,

    const char *tail, void *tag, dsl_dir_t **ddp)

{

	dmu_buf_t *dbuf;

	dsl_dir_t *dd;

	int err;

	ASSERT(RW_LOCK_HELD(&dp->dp_config_rwlock) ||

	    dsl_pool_sync_context(dp));

	err = dmu_bonus_hold(dp->dp_meta_objset, ddobj, tag, &dbuf);

	if (err)

		return (err);

	dd = dmu_buf_get_user(dbuf);

#ifdef ZFS_DEBUG

	{

		dmu_object_info_t doi;

		dmu_object_info_from_db(dbuf, &doi);

		ASSERT3U(doi.doi_type, ==, DMU_OT_DSL_DIR);

		ASSERT3U(doi.doi_bonus_size, >=, sizeof (dsl_dir_phys_t));

	}

#endif

	if (dd == NULL) {

		dsl_dir_t *winner;

		dd = kmem_zalloc(sizeof (dsl_dir_t), KM_SLEEP);

		dd->dd_object = ddobj;

		dd->dd_dbuf = dbuf;

		dd->dd_pool = dp;

		dd->dd_phys = dbuf->db_data;

		mutex_init(&dd->dd_lock, NULL, MUTEX_DEFAULT, NULL);

		list_create(&dd->dd_prop_cbs, sizeof (dsl_prop_cb_record_t),

		    offsetof(dsl_prop_cb_record_t, cbr_node));

		dsl_dir_snap_cmtime_update(dd);

		if (dd->dd_phys->dd_parent_obj) {

			err = dsl_dir_open_obj(dp, dd->dd_phys->dd_parent_obj,

			    NULL, dd, &dd->dd_parent);

			if (err)

				goto errout;

			if (tail) {

#ifdef ZFS_DEBUG

				uint64_t foundobj;

				err = zap_lookup(dp->dp_meta_objset,

				    dd->dd_parent->dd_phys->dd_child_dir_zapobj,

				    tail, sizeof (foundobj), 1, &foundobj);

				ASSERT(err || foundobj == ddobj);

#endif

				(void) strcpy(dd->dd_myname, tail);

			} else {

				err = zap_value_search(dp->dp_meta_objset,

				    dd->dd_parent->dd_phys->dd_child_dir_zapobj,

				    ddobj, 0, dd->dd_myname);

			}

			if (err)

				goto errout;

		} else {

			(void) strcpy(dd->dd_myname, spa_name(dp->dp_spa));

		}

		winner = dmu_buf_set_user_ie(dbuf, dd, &dd->dd_phys,

		    dsl_dir_evict);

		if (winner) {

			if (dd->dd_parent)

				dsl_dir_close(dd->dd_parent, dd);

			mutex_destroy(&dd->dd_lock);

			kmem_free(dd, sizeof (dsl_dir_t));

			dd = winner;

		} else {

			spa_open_ref(dp->dp_spa, dd);

		}

	}

	/*

	 * The dsl_dir_t has both open-to-close and instantiate-to-evict

	 * holds on the spa.  We need the open-to-close holds because

	 * otherwise the spa_refcnt wouldn't change when we open a

	 * dir which the spa also has open, so we could incorrectly

	 * think it was OK to unload/export/destroy the pool.  We need

	 * the instantiate-to-evict hold because the dsl_dir_t has a

	 * pointer to the dd_pool, which has a pointer to the spa_t.

	 */

	spa_open_ref(dp->dp_spa, tag);

	ASSERT3P(dd->dd_pool, ==, dp);

	ASSERT3U(dd->dd_object, ==, ddobj);

	ASSERT3P(dd->dd_dbuf, ==, dbuf);

	*ddp = dd;

	return (0);

errout:

	if (dd->dd_parent)

		dsl_dir_close(dd->dd_parent, dd);

	mutex_destroy(&dd->dd_lock);

	kmem_free(dd, sizeof (dsl_dir_t));

	dmu_buf_rele(dbuf, tag);

	return (err);

}

void

dsl_dir_close(dsl_dir_t *dd, void *tag)

{

	dprintf_dd(dd, "%s\n", "");

	spa_close(dd->dd_pool->dp_spa, tag);

	dmu_buf_rele(dd->dd_dbuf, tag);

}

/* buf must be long enough (MAXNAMELEN + strlen(MOS_DIR_NAME) + 1 should do) */

void

dsl_dir_name(dsl_dir_t *dd, char *buf)

{

	if (dd->dd_parent) {

		dsl_dir_name(dd->dd_parent, buf);

		(void) strcat(buf, "/");

	} else {

		buf[0] = '\0';

	}

	if (!MUTEX_HELD(&dd->dd_lock)) {

		/*

		 * recursive mutex so that we can use

		 * dprintf_dd() with dd_lock held

		 */

		mutex_enter(&dd->dd_lock);

		(void) strcat(buf, dd->dd_myname);

		mutex_exit(&dd->dd_lock);

	} else {

		(void) strcat(buf, dd->dd_myname);

	}

}

/* Calculate name legnth, avoiding all the strcat calls of dsl_dir_name */

int

dsl_dir_namelen(dsl_dir_t *dd)

{

	int result = 0;

	if (dd->dd_parent) {

		/* parent's name + 1 for the "/" */

		result = dsl_dir_namelen(dd->dd_parent) + 1;

	}

	if (!MUTEX_HELD(&dd->dd_lock)) {

		/* see dsl_dir_name */

		mutex_enter(&dd->dd_lock);

		result += strlen(dd->dd_myname);

		mutex_exit(&dd->dd_lock);

	} else {

		result += strlen(dd->dd_myname);

	}

	return (result);

}

static int

getcomponent(const char *path, char *component, const char **nextp)

{

	char *p;

	if ((path == NULL) || (path[0] == '\0'))

		return (ENOENT);

	/* This would be a good place to reserve some namespace... */

	p = strpbrk(path, "/@");

	if (p && (p[1] == '/' || p[1] == '@')) {

		/* two separators in a row */

		return (EINVAL);

	}

	if (p == NULL || p == path) {

		/*

		 * if the first thing is an @ or /, it had better be an

		 * @ and it had better not have any more ats or slashes,

		 * and it had better have something after the @.

		 */

		if (p != NULL &&

		    (p[0] != '@' || strpbrk(path+1, "/@") || p[1] == '\0'))

			return (EINVAL);

		if (strlen(path) >= MAXNAMELEN)

			return (ENAMETOOLONG);

		(void) strcpy(component, path);

		p = NULL;

	} else if (p[0] == '/') {

		if (p-path >= MAXNAMELEN)

			return (ENAMETOOLONG);

		(void) strncpy(component, path, p - path);

		component[p-path] = '\0';

		p++;

	} else if (p[0] == '@') {

		/*

		 * if the next separator is an @, there better not be

		 * any more slashes.

		 */

		if (strchr(path, '/'))

			return (EINVAL);

		if (p-path >= MAXNAMELEN)

			return (ENAMETOOLONG);

		(void) strncpy(component, path, p - path);

		component[p-path] = '\0';

	} else {

		ASSERT(!"invalid p");

	}

	*nextp = p;

	return (0);

}

/*

 * same as dsl_open_dir, ignore the first component of name and use the

 * spa instead

 */

int

dsl_dir_open_spa(spa_t *spa, const char *name, void *tag,

    dsl_dir_t **ddp, const char **tailp)

{

	char buf[MAXNAMELEN];

	const char *next, *nextnext = NULL;

	int err;

	dsl_dir_t *dd;

	dsl_pool_t *dp;

	uint64_t ddobj;

	int openedspa = FALSE;

	dprintf("%s\n", name);

	err = getcomponent(name, buf, &next);

	if (err)

		return (err);

	if (spa == NULL) {

		err = spa_open(buf, &spa, FTAG);

		if (err) {

			dprintf("spa_open(%s) failed\n", buf);

			return (err);

		}

		openedspa = TRUE;

		/* XXX this assertion belongs in spa_open */

		ASSERT(!dsl_pool_sync_context(spa_get_dsl(spa)));

	}

	dp = spa_get_dsl(spa);

	rw_enter(&dp->dp_config_rwlock, RW_READER);

	err = dsl_dir_open_obj(dp, dp->dp_root_dir_obj, NULL, tag, &dd);

	if (err) {

		rw_exit(&dp->dp_config_rwlock);

		if (openedspa)

			spa_close(spa, FTAG);

		return (err);

	}

	while (next != NULL) {

		dsl_dir_t *child_ds;

		err = getcomponent(next, buf, &nextnext);

		if (err)

			break;

		ASSERT(next[0] != '\0');

		if (next[0] == '@')

			break;

		dprintf("looking up %s in obj%lld\n",

		    buf, dd->dd_phys->dd_child_dir_zapobj);

		err = zap_lookup(dp->dp_meta_objset,

		    dd->dd_phys->dd_child_dir_zapobj,

		    buf, sizeof (ddobj), 1, &ddobj);

		if (err) {

			if (err == ENOENT)

				err = 0;

			break;

		}

		err = dsl_dir_open_obj(dp, ddobj, buf, tag, &child_ds);

		if (err)

			break;

		dsl_dir_close(dd, tag);

		dd = child_ds;

		next = nextnext;

	}

	rw_exit(&dp->dp_config_rwlock);

	if (err) {

		dsl_dir_close(dd, tag);

		if (openedspa)

			spa_close(spa, FTAG);

		return (err);

	}

	/*

	 * It's an error if there's more than one component left, or

	 * tailp==NULL and there's any component left.

	 */

	if (next != NULL &&

	    (tailp == NULL || (nextnext && nextnext[0] != '\0'))) {

		/* bad path name */

		dsl_dir_close(dd, tag);

		dprintf("next=%p (%s) tail=%p\n", next, next?next:"", tailp);

		err = ENOENT;

	}

	if (tailp)

		*tailp = next;

	if (openedspa)

		spa_close(spa, FTAG);

	*ddp = dd;

	return (err);

}

/*

 * Return the dsl_dir_t, and possibly the last component which couldn't

 * be found in *tail.  Return NULL if the path is bogus, or if

 * tail==NULL and we couldn't parse the whole name.  (*tail)[0] == '@'

 * means that the last component is a snapshot.

 */

int

dsl_dir_open(const char *name, void *tag, dsl_dir_t **ddp, const char **tailp)

{

	return (dsl_dir_open_spa(NULL, name, tag, ddp, tailp));

}

uint64_t

dsl_dir_create_sync(dsl_pool_t *dp, dsl_dir_t *pds, const char *name,

    dmu_tx_t *tx)

{

	objset_t *mos = dp->dp_meta_objset;

	uint64_t ddobj;

	dsl_dir_phys_t *dsphys;

	dmu_buf_t *dbuf;

	ddobj = dmu_object_alloc(mos, DMU_OT_DSL_DIR, 0,

	    DMU_OT_DSL_DIR, sizeof (dsl_dir_phys_t), tx);

	if (pds) {

		VERIFY(0 == zap_add(mos, pds->dd_phys->dd_child_dir_zapobj,

		    name, sizeof (uint64_t), 1, &ddobj, tx));

	} else {

		/* it's the root dir */

		VERIFY(0 == zap_add(mos, DMU_POOL_DIRECTORY_OBJECT,

		    DMU_POOL_ROOT_DATASET, sizeof (uint64_t), 1, &ddobj, tx));

	}

	VERIFY(0 == dmu_bonus_hold(mos, ddobj, FTAG, &dbuf));

	dmu_buf_will_dirty(dbuf, tx);

	dsphys = dbuf->db_data;

	dsphys->dd_creation_time = gethrestime_sec();

	if (pds)

		dsphys->dd_parent_obj = pds->dd_object;

	dsphys->dd_props_zapobj = zap_create(mos,

	    DMU_OT_DSL_PROPS, DMU_OT_NONE, 0, tx);

	dsphys->dd_child_dir_zapobj = zap_create(mos,

	    DMU_OT_DSL_DIR_CHILD_MAP, DMU_OT_NONE, 0, tx);

	if (spa_version(dp->dp_spa) >= SPA_VERSION_USED_BREAKDOWN)

		dsphys->dd_flags |= DD_FLAG_USED_BREAKDOWN;

	dmu_buf_rele(dbuf, FTAG);

	return (ddobj);

}

/* ARGSUSED */

int

dsl_dir_destroy_check(void *arg1, void *arg2, dmu_tx_t *tx)

{

	dsl_dir_t *dd = arg1;

	dsl_pool_t *dp = dd->dd_pool;

	objset_t *mos = dp->dp_meta_objset;

	int err;

	uint64_t count;

	/*

	 * There should be exactly two holds, both from

	 * dsl_dataset_destroy: one on the dd directory, and one on its

	 * head ds.  Otherwise, someone is trying to lookup something

	 * inside this dir while we want to destroy it.  The

	 * config_rwlock ensures that nobody else opens it after we

	 * check.

	 */

	if (dmu_buf_refcount(dd->dd_dbuf) > 2)

		return (EBUSY);

	err = zap_count(mos, dd->dd_phys->dd_child_dir_zapobj, &count);

	if (err)

		return (err);

	if (count != 0)

		return (EEXIST);

	return (0);

}

void

dsl_dir_destroy_sync(void *arg1, void *tag, cred_t *cr, dmu_tx_t *tx)

{

	dsl_dir_t *dd = arg1;

	objset_t *mos = dd->dd_pool->dp_meta_objset;

	uint64_t val, obj;

	dd_used_t t;

	ASSERT(RW_WRITE_HELD(&dd->dd_pool->dp_config_rwlock));

	ASSERT(dd->dd_phys->dd_head_dataset_obj == 0);

	/* Remove our reservation. */

	val = 0;

	dsl_dir_set_reservation_sync(dd, &val, cr, tx);

	ASSERT3U(dd->dd_phys->dd_used_bytes, ==, 0);

	ASSERT3U(dd->dd_phys->dd_reserved, ==, 0);

	for (t = 0; t < DD_USED_NUM; t++)

		ASSERT3U(dd->dd_phys->dd_used_breakdown[t], ==, 0);

	VERIFY(0 == zap_destroy(mos, dd->dd_phys->dd_child_dir_zapobj, tx));

	VERIFY(0 == zap_destroy(mos, dd->dd_phys->dd_props_zapobj, tx));

	VERIFY(0 == dsl_deleg_destroy(mos, dd->dd_phys->dd_deleg_zapobj, tx));

	VERIFY(0 == zap_remove(mos,

	    dd->dd_parent->dd_phys->dd_child_dir_zapobj, dd->dd_myname, tx));

	obj = dd->dd_object;

	dsl_dir_close(dd, tag);

	VERIFY(0 == dmu_object_free(mos, obj, tx));

}

boolean_t

dsl_dir_is_clone(dsl_dir_t *dd)

{

	return (dd->dd_phys->dd_origin_obj &&

	    (dd->dd_pool->dp_origin_snap == NULL ||

	    dd->dd_phys->dd_origin_obj !=

	    dd->dd_pool->dp_origin_snap->ds_object));

}

void

dsl_dir_stats(dsl_dir_t *dd, nvlist_t *nv)

{

	mutex_enter(&dd->dd_lock);

	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USED,

	    dd->dd_phys->dd_used_bytes);

	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_QUOTA, dd->dd_phys->dd_quota);

	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_RESERVATION,

	    dd->dd_phys->dd_reserved);

	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_COMPRESSRATIO,