/*

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

#include <sys/zfs_context.h>

#include <sys/dmu_objset.h>

#include <sys/dsl_dir.h>

#include <sys/dsl_dataset.h>

#include <sys/dsl_prop.h>

#include <sys/dsl_pool.h>

#include <sys/dsl_synctask.h>

#include <sys/dsl_deleg.h>

#include <sys/dnode.h>

#include <sys/dbuf.h>

#include <sys/zvol.h>

#include <sys/dmu_tx.h>

#include <sys/zio_checksum.h>

#include <sys/zap.h>

#include <sys/zil.h>

#include <sys/dmu_impl.h>

#include <sys/zfs_ioctl.h>

spa_t *

dmu_objset_spa(objset_t *os)

{

	return (os->os_spa);

}

zilog_t *

dmu_objset_zil(objset_t *os)

{

	return (os->os_zil);

}

dsl_pool_t *

dmu_objset_pool(objset_t *os)

{

	dsl_dataset_t *ds;

	if ((ds = os->os_dsl_dataset) != NULL && ds->ds_dir)

		return (ds->ds_dir->dd_pool);

	else

		return (spa_get_dsl(os->os_spa));

}

dsl_dataset_t *

dmu_objset_ds(objset_t *os)

{

	return (os->os_dsl_dataset);

}

dmu_objset_type_t

dmu_objset_type(objset_t *os)

{

	return (os->os_phys->os_type);

}

void

dmu_objset_name(objset_t *os, char *buf)

{

	dsl_dataset_name(os->os_dsl_dataset, buf);

}

uint64_t

dmu_objset_id(objset_t *os)

{

	dsl_dataset_t *ds = os->os_dsl_dataset;

	return (ds ? ds->ds_object : 0);

}

static void

checksum_changed_cb(void *arg, uint64_t newval)

{

	objset_t *os = arg;

	/*

	 * Inheritance should have been done by now.

	 */

	ASSERT(newval != ZIO_CHECKSUM_INHERIT);

	os->os_checksum = zio_checksum_select(newval, ZIO_CHECKSUM_ON_VALUE);

}

static void

compression_changed_cb(void *arg, uint64_t newval)

{

	objset_t *os = arg;

	/*

	 * Inheritance and range checking should have been done by now.

	 */

	ASSERT(newval != ZIO_COMPRESS_INHERIT);

	os->os_compress = zio_compress_select(newval, ZIO_COMPRESS_ON_VALUE);

}

static void

copies_changed_cb(void *arg, uint64_t newval)

{

	objset_t *os = arg;

	/*

	 * Inheritance and range checking should have been done by now.

	 */

	ASSERT(newval > 0);

	ASSERT(newval <= spa_max_replication(os->os_spa));

	os->os_copies = newval;

}

static void

primary_cache_changed_cb(void *arg, uint64_t newval)

{

	objset_t *os = arg;

	/*

	 * Inheritance and range checking should have been done by now.

	 */

	ASSERT(newval == ZFS_CACHE_ALL || newval == ZFS_CACHE_NONE ||

	    newval == ZFS_CACHE_METADATA);

	os->os_primary_cache = newval;

}

static void

secondary_cache_changed_cb(void *arg, uint64_t newval)

{

	objset_t *os = arg;

	/*

	 * Inheritance and range checking should have been done by now.

	 */

	ASSERT(newval == ZFS_CACHE_ALL || newval == ZFS_CACHE_NONE ||

	    newval == ZFS_CACHE_METADATA);

	os->os_secondary_cache = newval;

}

void

dmu_objset_byteswap(void *buf, size_t size)

{

	objset_phys_t *osp = buf;

	ASSERT(size == OBJSET_OLD_PHYS_SIZE || size == sizeof (objset_phys_t));

	dnode_byteswap(&osp->os_meta_dnode);

	byteswap_uint64_array(&osp->os_zil_header, sizeof (zil_header_t));

	osp->os_type = BSWAP_64(osp->os_type);

	osp->os_flags = BSWAP_64(osp->os_flags);

	if (size == sizeof (objset_phys_t)) {

		dnode_byteswap(&osp->os_userused_dnode);

		dnode_byteswap(&osp->os_groupused_dnode);

	}

}

int

dmu_objset_open_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp,

    objset_t **osp)

{

	objset_t *os;

	int i, err;

	ASSERT(ds == NULL || MUTEX_HELD(&ds->ds_opening_lock));

	os = kmem_zalloc(sizeof (objset_t), KM_SLEEP);

	os->os_dsl_dataset = ds;

	os->os_spa = spa;

	os->os_rootbp = bp;

	if (!BP_IS_HOLE(os->os_rootbp)) {

		uint32_t aflags = ARC_WAIT;

		zbookmark_t zb;

		zb.zb_objset = ds ? ds->ds_object : 0;

		zb.zb_object = 0;

		zb.zb_level = -1;

		zb.zb_blkid = 0;

		if (DMU_OS_IS_L2CACHEABLE(os))

			aflags |= ARC_L2CACHE;

		dprintf_bp(os->os_rootbp, "reading %s", "");

		/*

		 * NB: when bprewrite scrub can change the bp,

		 * and this is called from dmu_objset_open_ds_os, the bp

		 * could change, and we'll need a lock.

		 */

		err = arc_read_nolock(NULL, spa, os->os_rootbp,

		    arc_getbuf_func, &os->os_phys_buf,

		    ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_CANFAIL, &aflags, &zb);

		if (err) {

			kmem_free(os, sizeof (objset_t));

			/* convert checksum errors into IO errors */

			if (err == ECKSUM)

				err = EIO;

			return (err);

		}

		/* Increase the blocksize if we are permitted. */

		if (spa_version(spa) >= SPA_VERSION_USERSPACE &&

		    arc_buf_size(os->os_phys_buf) < sizeof (objset_phys_t)) {

			arc_buf_t *buf = arc_buf_alloc(spa,

			    sizeof (objset_phys_t), &os->os_phys_buf,

			    ARC_BUFC_METADATA);

			bzero(buf->b_data, sizeof (objset_phys_t));

			bcopy(os->os_phys_buf->b_data, buf->b_data,

			    arc_buf_size(os->os_phys_buf));

			(void) arc_buf_remove_ref(os->os_phys_buf,

			    &os->os_phys_buf);

			os->os_phys_buf = buf;

		}

		os->os_phys = os->os_phys_buf->b_data;

		os->os_flags = os->os_phys->os_flags;

	} else {

		int size = spa_version(spa) >= SPA_VERSION_USERSPACE ?

		    sizeof (objset_phys_t) : OBJSET_OLD_PHYS_SIZE;

		os->os_phys_buf = arc_buf_alloc(spa, size,

		    &os->os_phys_buf, ARC_BUFC_METADATA);

		os->os_phys = os->os_phys_buf->b_data;

		bzero(os->os_phys, size);

	}

	/*

	 * Note: the changed_cb will be called once before the register

	 * func returns, thus changing the checksum/compression from the

	 * default (fletcher2/off).  Snapshots don't need to know about

	 * checksum/compression/copies.

	 */

	if (ds) {

		err = dsl_prop_register(ds, "primarycache",

		    primary_cache_changed_cb, os);

		if (err == 0)

			err = dsl_prop_register(ds, "secondarycache",

			    secondary_cache_changed_cb, os);

		if (!dsl_dataset_is_snapshot(ds)) {

			if (err == 0)

				err = dsl_prop_register(ds, "checksum",

				    checksum_changed_cb, os);

			if (err == 0)

				err = dsl_prop_register(ds, "compression",

				    compression_changed_cb, os);

			if (err == 0)

				err = dsl_prop_register(ds, "copies",

				    copies_changed_cb, os);

		}

		if (err) {

			VERIFY(arc_buf_remove_ref(os->os_phys_buf,

			    &os->os_phys_buf) == 1);

			kmem_free(os, sizeof (objset_t));

			return (err);

		}

	} else if (ds == NULL) {

		/* It's the meta-objset. */

		os->os_checksum = ZIO_CHECKSUM_FLETCHER_4;

		os->os_compress = ZIO_COMPRESS_LZJB;

		os->os_copies = spa_max_replication(spa);

		os->os_primary_cache = ZFS_CACHE_ALL;

		os->os_secondary_cache = ZFS_CACHE_ALL;

	}

	os->os_zil_header = os->os_phys->os_zil_header;

	os->os_zil = zil_alloc(os, &os->os_zil_header);

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

		list_create(&os->os_dirty_dnodes[i], sizeof (dnode_t),

		    offsetof(dnode_t, dn_dirty_link[i]));

		list_create(&os->os_free_dnodes[i], sizeof (dnode_t),

		    offsetof(dnode_t, dn_dirty_link[i]));

	}

	list_create(&os->os_dnodes, sizeof (dnode_t),

	    offsetof(dnode_t, dn_link));

	list_create(&os->os_downgraded_dbufs, sizeof (dmu_buf_impl_t),

	    offsetof(dmu_buf_impl_t, db_link));

	mutex_init(&os->os_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&os->os_obj_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&os->os_user_ptr_lock, NULL, MUTEX_DEFAULT, NULL);

	os->os_meta_dnode = dnode_special_open(os,

	    &os->os_phys->os_meta_dnode, DMU_META_DNODE_OBJECT);

	if (arc_buf_size(os->os_phys_buf) >= sizeof (objset_phys_t)) {

		os->os_userused_dnode = dnode_special_open(os,

		    &os->os_phys->os_userused_dnode, DMU_USERUSED_OBJECT);

		os->os_groupused_dnode = dnode_special_open(os,

		    &os->os_phys->os_groupused_dnode, DMU_GROUPUSED_OBJECT);

	}

	/*

	 * We should be the only thread trying to do this because we

	 * have ds_opening_lock

	 */

	if (ds) {

		mutex_enter(&ds->ds_lock);

		ASSERT(ds->ds_objset == NULL);

		ds->ds_objset = os;

		mutex_exit(&ds->ds_lock);

	}

	*osp = os;

	return (0);

}

int

dmu_objset_from_ds(dsl_dataset_t *ds, objset_t **osp)

{

	int err = 0;

	mutex_enter(&ds->ds_opening_lock);

	*osp = ds->ds_objset;

	if (*osp == NULL) {

		err = dmu_objset_open_impl(dsl_dataset_get_spa(ds),

		    ds, &ds->ds_phys->ds_bp, osp);

	}

	mutex_exit(&ds->ds_opening_lock);

	return (err);

}

/* called from zpl */

int

dmu_objset_hold(const char *name, void *tag, objset_t **osp)

{

	dsl_dataset_t *ds;

	int err;

	err = dsl_dataset_hold(name, tag, &ds);

	if (err)

		return (err);

	err = dmu_objset_from_ds(ds, osp);

	if (err)

		dsl_dataset_rele(ds, tag);

	return (err);

}

/* called from zpl */

int

dmu_objset_own(const char *name, dmu_objset_type_t type,

    boolean_t readonly, void *tag, objset_t **osp)

{

	dsl_dataset_t *ds;

	int err;

	err = dsl_dataset_own(name, B_FALSE, tag, &ds);

	if (err)

		return (err);

	err = dmu_objset_from_ds(ds, osp);

	if (err) {

		dsl_dataset_disown(ds, tag);

	} else if ((type != DMU_OST_ANY && type != (*osp)->os_phys->os_type) ||

	    (!readonly && dsl_dataset_is_snapshot(ds))) {

		dmu_objset_disown(*osp, tag);

		return (EINVAL);

	}

	return (err);

}

void

dmu_objset_rele(objset_t *os, void *tag)

{

	dsl_dataset_rele(os->os_dsl_dataset, tag);

}

void

dmu_objset_disown(objset_t *os, void *tag)

{

	dsl_dataset_disown(os->os_dsl_dataset, tag);

}

int

dmu_objset_evict_dbufs(objset_t *os)

{

	dnode_t *dn;

	mutex_enter(&os->os_lock);

	/* process the mdn last, since the other dnodes have holds on it */

	list_remove(&os->os_dnodes, os->os_meta_dnode);

	list_insert_tail(&os->os_dnodes, os->os_meta_dnode);

	/*

	 * Find the first dnode with holds.  We have to do this dance

	 * because dnode_add_ref() only works if you already have a

	 * hold.  If there are no holds then it has no dbufs so OK to

	 * skip.

	 */

	for (dn = list_head(&os->os_dnodes);

	    dn && !dnode_add_ref(dn, FTAG);

	    dn = list_next(&os->os_dnodes, dn))

		continue;

	while (dn) {

		dnode_t *next_dn = dn;

		do {

			next_dn = list_next(&os->os_dnodes, next_dn);

		} while (next_dn && !dnode_add_ref(next_dn, FTAG));

		mutex_exit(&os->os_lock);

		dnode_evict_dbufs(dn);

		dnode_rele(dn, FTAG);

		mutex_enter(&os->os_lock);

		dn = next_dn;

	}

	mutex_exit(&os->os_lock);

	return (list_head(&os->os_dnodes) != os->os_meta_dnode);

}

void

dmu_objset_evict(objset_t *os)

{

	dsl_dataset_t *ds = os->os_dsl_dataset;

	int i;

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

		ASSERT(list_head(&os->os_dirty_dnodes[i]) == NULL);

		ASSERT(list_head(&os->os_free_dnodes[i]) == NULL);

	}

	if (ds) {

		if (!dsl_dataset_is_snapshot(ds)) {

			VERIFY(0 == dsl_prop_unregister(ds, "checksum",

			    checksum_changed_cb, os));

			VERIFY(0 == dsl_prop_unregister(ds, "compression",

			    compression_changed_cb, os));

			VERIFY(0 == dsl_prop_unregister(ds, "copies",

			    copies_changed_cb, os));

		}

		VERIFY(0 == dsl_prop_unregister(ds, "primarycache",

		    primary_cache_changed_cb, os));

		VERIFY(0 == dsl_prop_unregister(ds, "secondarycache",

		    secondary_cache_changed_cb, os));

	}

	/*

	 * We should need only a single pass over the dnode list, since

	 * nothing can be added to the list at this point.

	 */

	(void) dmu_objset_evict_dbufs(os);

	dnode_special_close(os->os_meta_dnode);

	if (os->os_userused_dnode) {

		dnode_special_close(os->os_userused_dnode);

		dnode_special_close(os->os_groupused_dnode);

	}

	zil_free(os->os_zil);