/*

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

#include <sys/dmu_tx.h>

#include <sys/dsl_dataset.h>

#include <sys/dsl_dir.h>

#include <sys/dsl_prop.h>

#include <sys/spa.h>

#include <sys/zap.h>

#include <sys/zio.h>

#include <sys/arc.h>

#include "zfs_namecheck.h"

static uint64_t dsl_dir_space_accounted(dsl_dir_t *dd);

static uint64_t dsl_dir_estimated_space(dsl_dir_t *dd);

static int dsl_dir_set_reservation_sync(dsl_dir_t *dd,

    void *arg, dmu_tx_t *tx);

static uint64_t dsl_dir_space_available(dsl_dir_t *dd,

    dsl_dir_t *ancestor, int64_t delta, int ondiskonly);

/* 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);

	}

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

	ASSERT(dd->dd_sync_txg == 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);

	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);

	}

#endif

	/* XXX assert bonus buffer size is correct */

	if (dd == NULL) {

		dsl_dir_t *winner;

		int err;

		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;

		dd->dd_used_bytes = dd->dd_phys->dd_used_bytes;

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

		    offsetof(dsl_prop_cb_record_t, cbr_node));

		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) {

				kmem_free(dd, sizeof (dsl_dir_t));

				dmu_buf_rele(dbuf, tag);

				return (err);

			}

			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, dd->dd_myname);

			}

			if (err) {

				dsl_dir_close(dd->dd_parent, dd);

				kmem_free(dd, sizeof (dsl_dir_t));

				dmu_buf_rele(dbuf, tag);

				return (err);

			}

		} 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);

			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);

}

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 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);

	}

}

int

dsl_dir_is_private(dsl_dir_t *dd)

{

	int rv = FALSE;

	if (dd->dd_parent && dsl_dir_is_private(dd->dd_parent))

		rv = TRUE;

	if (dataset_name_hidden(dd->dd_myname))

		rv = TRUE;

	return (rv);

}

static int

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

{

	char *p;

	if (path == NULL)

		return (NULL);

	/* 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);

	if (name == NULL)

		return (ENOENT);

	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;

		if (dd->dd_phys->dd_child_dir_zapobj == 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));

}

int

dsl_dir_create_sync(dsl_dir_t *pds, const char *name, dmu_tx_t *tx)

{

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

	uint64_t ddobj;

	dsl_dir_phys_t *dsphys;

	dmu_buf_t *dbuf;

	int err;

	ASSERT(dmu_tx_is_syncing(tx));

	if (pds->dd_phys->dd_child_dir_zapobj == 0) {

		dmu_buf_will_dirty(pds->dd_dbuf, tx);

		pds->dd_phys->dd_child_dir_zapobj = zap_create(mos,

		    DMU_OT_DSL_DIR_CHILD_MAP, DMU_OT_NONE, 0, tx);

	}

	rw_enter(&pds->dd_pool->dp_config_rwlock, RW_WRITER);

	err = zap_lookup(mos, pds->dd_phys->dd_child_dir_zapobj,

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

	if (err != ENOENT) {

		rw_exit(&pds->dd_pool->dp_config_rwlock);

		return (err ? err : EEXIST);

	}

	ddobj = dmu_object_alloc(mos, DMU_OT_DSL_DIR, 0,

	    DMU_OT_DSL_DIR, sizeof (dsl_dir_phys_t), tx);

	err = zap_add(mos, pds->dd_phys->dd_child_dir_zapobj,

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

	ASSERT3U(err, ==, 0);

	dprintf("dataset_create: zap_add %s->%lld to %lld returned %d\n",

	    name, ddobj, pds->dd_phys->dd_child_dir_zapobj, err);

	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();

	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);

	dmu_buf_rele(dbuf, FTAG);

	rw_exit(&pds->dd_pool->dp_config_rwlock);

	return (0);

}

int

dsl_dir_destroy_sync(dsl_dir_t *pds, void *arg, dmu_tx_t *tx)

{

	const char *name = arg;

	dsl_dir_t *dd = NULL;

	dsl_pool_t *dp = pds->dd_pool;

	objset_t *mos = dp->dp_meta_objset;

	uint64_t val, obj, child_zapobj, props_zapobj;

	int t, err;

	rw_enter(&dp->dp_config_rwlock, RW_WRITER);

	err = zap_lookup(mos, pds->dd_phys->dd_child_dir_zapobj, name,

	    8, 1, &obj);

	if (err)

		goto out;

	err = dsl_dir_open_obj(dp, obj, name, FTAG, &dd);

	if (err)

		goto out;

	ASSERT3U(dd->dd_phys->dd_parent_obj, ==, pds->dd_object);

	if (dmu_buf_refcount(dd->dd_dbuf) > 1) {

		err = EBUSY;

		goto out;

	}

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

		/*

		 * if they were dirty, they'd also be open.

		 * dp_config_rwlock ensures that it stays that way.

		 */

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

	}

	child_zapobj = dd->dd_phys->dd_child_dir_zapobj;

	props_zapobj = dd->dd_phys->dd_props_zapobj;

	if (child_zapobj != 0) {

		uint64_t count;

		err = EEXIST;

		(void) zap_count(mos, child_zapobj, &count);

		if (count != 0)

			goto out;

	}

	if (dd->dd_phys->dd_head_dataset_obj != 0) {

		err = dsl_dataset_destroy_sync(dd, NULL, tx);

		if (err)

			goto out;

	}

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

	/* The point of no (unsuccessful) return */

	/* Make sure parent's used gets updated */

	val = 0;

	err = dsl_dir_set_reservation_sync(dd, &val, tx);

	ASSERT(err == 0);

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

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

	dsl_dir_close(dd, FTAG);

	dd = NULL;

	err = dmu_object_free(mos, obj, tx);

	ASSERT(err == 0);

	if (child_zapobj)

		err = zap_destroy(mos, child_zapobj, tx);

	ASSERT(err == 0);

	if (props_zapobj)

		err = zap_destroy(mos, props_zapobj, tx);

	ASSERT(err == 0);

	err = zap_remove(mos, pds->dd_phys->dd_child_dir_zapobj, name, tx);

	ASSERT(err == 0);

out:

	rw_exit(&dp->dp_config_rwlock);

	if (dd)

		dsl_dir_close(dd, FTAG);

	return (err);