dmu_objset.c revision 40feaa914945406e86e193599d115ea71a171d18
0N/A/*
0N/A * CDDL HEADER START
0N/A *
0N/A * The contents of this file are subject to the terms of the
0N/A * Common Development and Distribution License (the "License").
0N/A * You may not use this file except in compliance with the License.
0N/A *
0N/A * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
0N/A * or http://www.opensolaris.org/os/licensing.
0N/A * See the License for the specific language governing permissions
0N/A * and limitations under the License.
0N/A *
0N/A * When distributing Covered Code, include this CDDL HEADER in each
0N/A * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
0N/A * If applicable, add the following below this CDDL HEADER, with the
0N/A * fields enclosed by brackets "[]" replaced with your own identifying
0N/A * information: Portions Copyright [yyyy] [name of copyright owner]
0N/A *
873N/A * CDDL HEADER END
0N/A */
0N/A/*
0N/A * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
0N/A * Use is subject to license terms.
0N/A */
5136N/A
0N/A#pragma ident "%Z%%M% %I% %E% SMI"
0N/A
3853N/A#include <sys/cred.h>
0N/A#include <sys/zfs_context.h>
0N/A#include <sys/dmu_objset.h>
3853N/A#include <sys/dsl_dir.h>
3853N/A#include <sys/dsl_dataset.h>
3853N/A#include <sys/dsl_prop.h>
3853N/A#include <sys/dsl_pool.h>
3853N/A#include <sys/dsl_synctask.h>
3853N/A#include <sys/dsl_deleg.h>
3853N/A#include <sys/dnode.h>
0N/A#include <sys/dbuf.h>
0N/A#include <sys/zvol.h>
0N/A#include <sys/dmu_tx.h>
1638N/A#include <sys/zio_checksum.h>
0N/A#include <sys/zap.h>
0N/A#include <sys/zil.h>
0N/A#include <sys/dmu_impl.h>
0N/A#include <sys/zfs_ioctl.h>
3853N/A
1615N/A
1615N/Aspa_t *
1638N/Admu_objset_spa(objset_t *os)
1787N/A{
1638N/A return (os->os->os_spa);
1638N/A}
0N/A
0N/Azilog_t *
3853N/Admu_objset_zil(objset_t *os)
0N/A{
0N/A return (os->os->os_zil);
0N/A}
0N/A
5136N/Adsl_pool_t *
1638N/Admu_objset_pool(objset_t *os)
0N/A{
0N/A dsl_dataset_t *ds;
4134N/A
0N/A if ((ds = os->os->os_dsl_dataset) != NULL && ds->ds_dir)
0N/A return (ds->ds_dir->dd_pool);
0N/A else
0N/A return (spa_get_dsl(os->os->os_spa));
0N/A}
0N/A
0N/Adsl_dataset_t *
338N/Admu_objset_ds(objset_t *os)
1638N/A{
1638N/A return (os->os->os_dsl_dataset);
1638N/A}
0N/A
1400N/Admu_objset_type_t
1400N/Admu_objset_type(objset_t *os)
1400N/A{
1400N/A return (os->os->os_phys->os_type);
1400N/A}
1638N/A
1638N/Avoid
1638N/Admu_objset_name(objset_t *os, char *buf)
1638N/A{
1638N/A dsl_dataset_name(os->os->os_dsl_dataset, buf);
1638N/A}
1638N/A
1638N/Auint64_t
0N/Admu_objset_id(objset_t *os)
1638N/A{
1638N/A dsl_dataset_t *ds = os->os->os_dsl_dataset;
1638N/A
1638N/A return (ds ? ds->ds_object : 0);
1638N/A}
1638N/A
3853N/Astatic void
1638N/Achecksum_changed_cb(void *arg, uint64_t newval)
1638N/A{
3853N/A objset_impl_t *osi = arg;
1638N/A
1638N/A /*
3853N/A * Inheritance should have been done by now.
0N/A */
0N/A ASSERT(newval != ZIO_CHECKSUM_INHERIT);
0N/A
0N/A osi->os_checksum = zio_checksum_select(newval, ZIO_CHECKSUM_ON_VALUE);
0N/A}
0N/A
0N/Astatic void
1638N/Acompression_changed_cb(void *arg, uint64_t newval)
0N/A{
0N/A objset_impl_t *osi = arg;
0N/A
0N/A /*
0N/A * Inheritance and range checking should have been done by now.
0N/A */
0N/A ASSERT(newval != ZIO_COMPRESS_INHERIT);
0N/A
0N/A osi->os_compress = zio_compress_select(newval, ZIO_COMPRESS_ON_VALUE);
338N/A}
0N/A
338N/Astatic void
353N/Acopies_changed_cb(void *arg, uint64_t newval)
1638N/A{
338N/A objset_impl_t *osi = arg;
338N/A
1638N/A /*
1638N/A * Inheritance and range checking should have been done by now.
1638N/A */
1638N/A ASSERT(newval > 0);
1638N/A ASSERT(newval <= spa_max_replication(osi->os_spa));
1615N/A
338N/A osi->os_copies = newval;
338N/A}
338N/A
338N/Avoid
338N/Admu_objset_byteswap(void *buf, size_t size)
338N/A{
338N/A objset_phys_t *osp = buf;
338N/A
338N/A ASSERT(size == sizeof (objset_phys_t));
338N/A dnode_byteswap(&osp->os_meta_dnode);
338N/A byteswap_uint64_array(&osp->os_zil_header, sizeof (zil_header_t));
2086N/A osp->os_type = BSWAP_64(osp->os_type);
2086N/A}
2086N/A
338N/Aint
338N/Admu_objset_open_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp,
1638N/A objset_impl_t **osip)
1638N/A{
1638N/A objset_impl_t *winner, *osi;
1638N/A int i, err, checksum;
1638N/A
2414N/A osi = kmem_zalloc(sizeof (objset_impl_t), KM_SLEEP);
2624N/A osi->os.os = osi;
2624N/A osi->os_dsl_dataset = ds;
1638N/A osi->os_spa = spa;
1638N/A osi->os_rootbp = bp;
1638N/A if (!BP_IS_HOLE(osi->os_rootbp)) {
3853N/A uint32_t aflags = ARC_WAIT;
1638N/A zbookmark_t zb;
1638N/A zb.zb_objset = ds ? ds->ds_object : 0;
1638N/A zb.zb_object = 0;
1638N/A zb.zb_level = -1;
1638N/A zb.zb_blkid = 0;
1638N/A
1638N/A dprintf_bp(osi->os_rootbp, "reading %s", "");
1638N/A err = arc_read(NULL, spa, osi->os_rootbp,
1638N/A dmu_ot[DMU_OT_OBJSET].ot_byteswap,
1638N/A arc_getbuf_func, &osi->os_phys_buf,
1638N/A ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_CANFAIL, &aflags, &zb);
1638N/A if (err) {
1638N/A kmem_free(osi, sizeof (objset_impl_t));
2086N/A return (err);
2086N/A }
2086N/A osi->os_phys = osi->os_phys_buf->b_data;
1638N/A arc_release(osi->os_phys_buf, &osi->os_phys_buf);
1638N/A } else {
1638N/A osi->os_phys_buf = arc_buf_alloc(spa, sizeof (objset_phys_t),
1638N/A &osi->os_phys_buf, ARC_BUFC_METADATA);
1638N/A osi->os_phys = osi->os_phys_buf->b_data;
1638N/A bzero(osi->os_phys, sizeof (objset_phys_t));
2414N/A }
1638N/A
2414N/A /*
1638N/A * Note: the changed_cb will be called once before the register
1638N/A * func returns, thus changing the checksum/compression from the
2414N/A * default (fletcher2/off). Snapshots don't need to know, and
1638N/A * registering would complicate clone promotion.
1638N/A */
2086N/A if (ds && ds->ds_phys->ds_num_children == 0) {
2414N/A err = dsl_prop_register(ds, "checksum",
2414N/A checksum_changed_cb, osi);
2414N/A if (err == 0)
2414N/A err = dsl_prop_register(ds, "compression",
2414N/A compression_changed_cb, osi);
2414N/A if (err == 0)
2414N/A err = dsl_prop_register(ds, "copies",
2414N/A copies_changed_cb, osi);
2414N/A if (err) {
2086N/A VERIFY(arc_buf_remove_ref(osi->os_phys_buf,
1638N/A &osi->os_phys_buf) == 1);
1638N/A kmem_free(osi, sizeof (objset_impl_t));
1638N/A return (err);
1638N/A }
1638N/A } else if (ds == NULL) {
1638N/A /* It's the meta-objset. */
1638N/A osi->os_checksum = ZIO_CHECKSUM_FLETCHER_4;
1638N/A osi->os_compress = ZIO_COMPRESS_LZJB;
2414N/A osi->os_copies = spa_max_replication(spa);
2624N/A }
2624N/A
1638N/A osi->os_zil = zil_alloc(&osi->os, &osi->os_phys->os_zil_header);
1638N/A
1638N/A /*
3853N/A * Metadata always gets compressed and checksummed.
1638N/A * If the data checksum is multi-bit correctable, and it's not
1638N/A * a ZBT-style checksum, then it's suitable for metadata as well.
1638N/A * Otherwise, the metadata checksum defaults to fletcher4.
1638N/A */
1638N/A checksum = osi->os_checksum;
1638N/A
1638N/A if (zio_checksum_table[checksum].ci_correctable &&
1638N/A !zio_checksum_table[checksum].ci_zbt)
1638N/A osi->os_md_checksum = checksum;
1638N/A else
1638N/A osi->os_md_checksum = ZIO_CHECKSUM_FLETCHER_4;
1638N/A osi->os_md_compress = ZIO_COMPRESS_LZJB;
1638N/A
2086N/A for (i = 0; i < TXG_SIZE; i++) {
2086N/A list_create(&osi->os_dirty_dnodes[i], sizeof (dnode_t),
2086N/A offsetof(dnode_t, dn_dirty_link[i]));
1638N/A list_create(&osi->os_free_dnodes[i], sizeof (dnode_t),
1638N/A offsetof(dnode_t, dn_dirty_link[i]));
1638N/A }
1638N/A list_create(&osi->os_dnodes, sizeof (dnode_t),
1638N/A offsetof(dnode_t, dn_link));
1638N/A list_create(&osi->os_downgraded_dbufs, sizeof (dmu_buf_impl_t),
2414N/A offsetof(dmu_buf_impl_t, db_link));
1638N/A
2414N/A mutex_init(&osi->os_lock, NULL, MUTEX_DEFAULT, NULL);
1638N/A mutex_init(&osi->os_obj_lock, NULL, MUTEX_DEFAULT, NULL);
1638N/A
2414N/A osi->os_meta_dnode = dnode_special_open(osi,
1638N/A &osi->os_phys->os_meta_dnode, DMU_META_DNODE_OBJECT);
1638N/A
2086N/A if (ds != NULL) {
2414N/A winner = dsl_dataset_set_user_ptr(ds, osi, dmu_objset_evict);
2414N/A if (winner) {
2086N/A dmu_objset_evict(ds, osi);
1638N/A osi = winner;
1638N/A }
1638N/A }
1638N/A
1638N/A *osip = osi;
1638N/A return (0);
1638N/A}
1638N/A
1638N/A/* called from zpl */
1638N/Aint
1638N/Admu_objset_open(const char *name, dmu_objset_type_t type, int mode,
1638N/A objset_t **osp)
1638N/A{
1638N/A dsl_dataset_t *ds;
1638N/A int err;
1638N/A objset_t *os;
1638N/A objset_impl_t *osi;
1638N/A
1638N/A os = kmem_alloc(sizeof (objset_t), KM_SLEEP);
1638N/A err = dsl_dataset_open(name, mode, os, &ds);
1638N/A if (err) {
1638N/A kmem_free(os, sizeof (objset_t));
1638N/A return (err);
1638N/A }
1638N/A
1638N/A osi = dsl_dataset_get_user_ptr(ds);
1638N/A if (osi == NULL) {
1638N/A err = dmu_objset_open_impl(dsl_dataset_get_spa(ds),
1638N/A ds, &ds->ds_phys->ds_bp, &osi);
1638N/A if (err) {
1638N/A dsl_dataset_close(ds, mode, os);
1638N/A kmem_free(os, sizeof (objset_t));
1638N/A return (err);
1638N/A }
3853N/A }
3853N/A
1638N/A os->os = osi;
1638N/A os->os_mode = mode;
3853N/A
1638N/A if (type != DMU_OST_ANY && type != os->os->os_phys->os_type) {
3853N/A dmu_objset_close(os);
1638N/A return (EINVAL);
1638N/A }
1638N/A *osp = os;
1638N/A return (0);
1638N/A}
1638N/A
1638N/Avoid
1638N/Admu_objset_close(objset_t *os)
1638N/A{
1638N/A dsl_dataset_close(os->os->os_dsl_dataset, os->os_mode, os);
1638N/A kmem_free(os, sizeof (objset_t));
1638N/A}
1638N/A
1638N/Aint
1638N/Admu_objset_evict_dbufs(objset_t *os, int try)
1638N/A{
1638N/A objset_impl_t *osi = os->os;
1638N/A dnode_t *dn;
1638N/A
1638N/A mutex_enter(&osi->os_lock);
1638N/A
1638N/A /* process the mdn last, since the other dnodes have holds on it */
1638N/A list_remove(&osi->os_dnodes, osi->os_meta_dnode);
1638N/A list_insert_tail(&osi->os_dnodes, osi->os_meta_dnode);
1638N/A
338N/A /*
338N/A * Find the first dnode with holds. We have to do this dance
338N/A * because dnode_add_ref() only works if you already have a
338N/A * hold. If there are no holds then it has no dbufs so OK to
338N/A * skip.
338N/A */
338N/A for (dn = list_head(&osi->os_dnodes);
338N/A dn && refcount_is_zero(&dn->dn_holds);
3352N/A dn = list_next(&osi->os_dnodes, dn))
3352N/A continue;
0N/A if (dn)
5136N/A dnode_add_ref(dn, FTAG);
5136N/A
5136N/A while (dn) {
5136N/A dnode_t *next_dn = dn;
5136N/A
5136N/A do {
5136N/A next_dn = list_next(&osi->os_dnodes, next_dn);
5136N/A } while (next_dn && refcount_is_zero(&next_dn->dn_holds));
5136N/A if (next_dn)
5136N/A dnode_add_ref(next_dn, FTAG);
5136N/A
5136N/A mutex_exit(&osi->os_lock);
5136N/A if (dnode_evict_dbufs(dn, try)) {
5136N/A dnode_rele(dn, FTAG);
5136N/A if (next_dn)
5136N/A dnode_rele(next_dn, FTAG);
5136N/A return (1);
5136N/A }
5136N/A dnode_rele(dn, FTAG);
5136N/A mutex_enter(&osi->os_lock);
5136N/A dn = next_dn;
1638N/A }
3853N/A mutex_exit(&osi->os_lock);
1638N/A return (0);
1638N/A}
1638N/A
1638N/Avoid
1638N/Admu_objset_evict(dsl_dataset_t *ds, void *arg)
1638N/A{
1638N/A objset_impl_t *osi = arg;
1638N/A objset_t os;
3853N/A int i;
1638N/A
1638N/A for (i = 0; i < TXG_SIZE; i++) {
1638N/A ASSERT(list_head(&osi->os_dirty_dnodes[i]) == NULL);
1638N/A ASSERT(list_head(&osi->os_free_dnodes[i]) == NULL);
1638N/A }
1638N/A
1638N/A if (ds && ds->ds_phys->ds_num_children == 0) {
2086N/A VERIFY(0 == dsl_prop_unregister(ds, "checksum",
2086N/A checksum_changed_cb, osi));
2086N/A VERIFY(0 == dsl_prop_unregister(ds, "compression",
1638N/A compression_changed_cb, osi));
1638N/A VERIFY(0 == dsl_prop_unregister(ds, "copies",
1638N/A copies_changed_cb, osi));
1638N/A }
1638N/A
2086N/A /*
2086N/A * We should need only a single pass over the dnode list, since
2086N/A * nothing can be added to the list at this point.
1638N/A */
1638N/A os.os = osi;
1638N/A (void) dmu_objset_evict_dbufs(&os, 0);
1638N/A
1638N/A ASSERT3P(list_head(&osi->os_dnodes), ==, osi->os_meta_dnode);
1638N/A ASSERT3P(list_tail(&osi->os_dnodes), ==, osi->os_meta_dnode);
1638N/A ASSERT3P(list_head(&osi->os_meta_dnode->dn_dbufs), ==, NULL);
3853N/A
1638N/A dnode_special_close(osi->os_meta_dnode);
1638N/A zil_free(osi->os_zil);
1638N/A
1638N/A VERIFY(arc_buf_remove_ref(osi->os_phys_buf, &osi->os_phys_buf) == 1);
1638N/A mutex_destroy(&osi->os_lock);
3352N/A mutex_destroy(&osi->os_obj_lock);
1638N/A kmem_free(osi, sizeof (objset_impl_t));
1638N/A}
1638N/A
1638N/A/* called from dsl for meta-objset */
3853N/Aobjset_impl_t *
3853N/Admu_objset_create_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp,
1638N/A dmu_objset_type_t type, dmu_tx_t *tx)
3853N/A{
1638N/A objset_impl_t *osi;
1638N/A dnode_t *mdn;
1638N/A
1638N/A ASSERT(dmu_tx_is_syncing(tx));
1638N/A VERIFY(0 == dmu_objset_open_impl(spa, ds, bp, &osi));
3853N/A mdn = osi->os_meta_dnode;
1638N/A
1638N/A dnode_allocate(mdn, DMU_OT_DNODE, 1 << DNODE_BLOCK_SHIFT,
1638N/A DN_MAX_INDBLKSHIFT, DMU_OT_NONE, 0, tx);
3853N/A
1638N/A /*
3853N/A * We don't want to have to increase the meta-dnode's nlevels
4134N/A * later, because then we could do it in quescing context while
3853N/A * we are also accessing it in open context.
1638N/A *
1638N/A * This precaution is not necessary for the MOS (ds == NULL),
1638N/A * because the MOS is only updated in syncing context.
1638N/A * This is most fortunate: the MOS is the only objset that
1638N/A * needs to be synced multiple times as spa_sync() iterates
1638N/A * to convergence, so minimizing its dn_nlevels matters.
1638N/A */
1638N/A if (ds != NULL) {
1638N/A int levels = 1;
2086N/A
3853N/A /*
3853N/A * Determine the number of levels necessary for the meta-dnode
3853N/A * to contain DN_MAX_OBJECT dnodes.
3853N/A */
2086N/A while ((uint64_t)mdn->dn_nblkptr << (mdn->dn_datablkshift +
3853N/A (levels - 1) * (mdn->dn_indblkshift - SPA_BLKPTRSHIFT)) <
1638N/A DN_MAX_OBJECT * sizeof (dnode_phys_t))
1638N/A levels++;
1638N/A
3853N/A mdn->dn_next_nlevels[tx->tx_txg & TXG_MASK] =
3853N/A mdn->dn_nlevels = levels;
3853N/A }
3853N/A
1638N/A ASSERT(type != DMU_OST_NONE);
1638N/A ASSERT(type != DMU_OST_ANY);
1638N/A ASSERT(type < DMU_OST_NUMTYPES);
3853N/A osi->os_phys->os_type = type;
1638N/A
1638N/A dsl_dataset_dirty(ds, tx);
1638N/A
3853N/A return (osi);
1638N/A}
3853N/A
4134N/Astruct oscarg {
3853N/A void (*userfunc)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx);
1638N/A void *userarg;
1638N/A dsl_dataset_t *clone_parent;
1638N/A const char *lastname;
1638N/A dmu_objset_type_t type;
1638N/A};
1638N/A
1638N/A/*ARGSUSED*/
1638N/Astatic int
1638N/Admu_objset_create_check(void *arg1, void *arg2, dmu_tx_t *tx)
2086N/A{
3853N/A dsl_dir_t *dd = arg1;
3853N/A struct oscarg *oa = arg2;
3853N/A objset_t *mos = dd->dd_pool->dp_meta_objset;
3853N/A int err;
2086N/A uint64_t ddobj;
3853N/A
1638N/A err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj,
1638N/A oa->lastname, sizeof (uint64_t), 1, &ddobj);
1638N/A if (err != ENOENT)
3853N/A return (err ? err : EEXIST);
3853N/A
3853N/A if (oa->clone_parent != NULL) {
3853N/A /*
1638N/A * You can't clone across pools.
1638N/A */
1638N/A if (oa->clone_parent->ds_dir->dd_pool != dd->dd_pool)
3853N/A return (EXDEV);
1638N/A
3853N/A /*
1638N/A * You can only clone snapshots, not the head datasets.
1638N/A */
1638N/A if (oa->clone_parent->ds_phys->ds_num_children == 0)
3352N/A return (EINVAL);
1638N/A }
1638N/A
1638N/A return (0);
1638N/A}
1638N/A
0N/Astatic void
0N/Admu_objset_create_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
0N/A{
1638N/A dsl_dir_t *dd = arg1;
0N/A struct oscarg *oa = arg2;
1638N/A dsl_dataset_t *ds;
0N/A blkptr_t *bp;
0N/A uint64_t dsobj;
0N/A
0N/A ASSERT(dmu_tx_is_syncing(tx));
0N/A
0N/A dsobj = dsl_dataset_create_sync(dd, oa->lastname,
0N/A oa->clone_parent, tx);
3853N/A
3853N/A VERIFY(0 == dsl_dataset_open_obj(dd->dd_pool, dsobj, NULL,
0N/A DS_MODE_STANDARD | DS_MODE_READONLY, FTAG, &ds));
3853N/A bp = dsl_dataset_get_blkptr(ds);
0N/A if (BP_IS_HOLE(bp)) {
0N/A objset_impl_t *osi;
3853N/A
0N/A /* This is an empty dmu_objset; not a clone. */
0N/A osi = dmu_objset_create_impl(dsl_dataset_get_spa(ds),
0N/A ds, bp, oa->type, tx);
3853N/A
0N/A if (oa->userfunc)
3853N/A oa->userfunc(&osi->os, oa->userarg, cr, tx);
4134N/A }
0N/A
0N/A /*
0N/A * Create create time permission if any?
0N/A */
868N/A dsl_deleg_set_create_perms(ds->ds_dir, tx, cr);
868N/A
1400N/A spa_history_internal_log(LOG_DS_CREATE, dd->dd_pool->dp_spa,
868N/A tx, cr, "dataset = %llu", dsobj);
0N/A
3853N/A dsl_dataset_close(ds, DS_MODE_STANDARD | DS_MODE_READONLY, FTAG);
3853N/A}
2086N/A
2086N/Aint
3853N/Admu_objset_create(const char *name, dmu_objset_type_t type,
0N/A objset_t *clone_parent,
0N/A void (*func)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx), void *arg)
0N/A{
3853N/A dsl_dir_t *pdd;
3853N/A const char *tail;
3853N/A int err = 0;
3853N/A struct oscarg oa = { 0 };
0N/A
0N/A ASSERT(strchr(name, '@') == NULL);
3853N/A err = dsl_dir_open(name, FTAG, &pdd, &tail);
0N/A if (err)
3853N/A return (err);
0N/A if (tail == NULL) {
0N/A dsl_dir_close(pdd, FTAG);
0N/A return (EEXIST);
0N/A }
0N/A
0N/A dprintf("name=%s\n", name);
0N/A
0N/A oa.userfunc = func;
1638N/A oa.userarg = arg;
0N/A oa.lastname = tail;
1638N/A oa.type = type;
0N/A
0N/A if (clone_parent != NULL) {
0N/A /*
0N/A * You can't clone to a different type.
0N/A */
0N/A if (clone_parent->os->os_phys->os_type != type) {
0N/A dsl_dir_close(pdd, FTAG);
3853N/A return (EINVAL);
3853N/A }
0N/A oa.clone_parent = clone_parent->os->os_dsl_dataset;
3853N/A }
0N/A err = dsl_sync_task_do(pdd->dd_pool, dmu_objset_create_check,
0N/A dmu_objset_create_sync, pdd, &oa, 5);
3853N/A dsl_dir_close(pdd, FTAG);
0N/A return (err);
0N/A}
0N/A
3853N/Aint
0N/Admu_objset_destroy(const char *name)
3853N/A{
4134N/A objset_t *os;
0N/A int error;
0N/A
0N/A /*
0N/A * If it looks like we'll be able to destroy it, and there's
868N/A * an unplayed replay log sitting around, destroy the log.
868N/A * It would be nicer to do this in dsl_dataset_destroy_sync(),
1400N/A * but the replay log objset is modified in open context.
868N/A */
0N/A error = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_EXCLUSIVE, &os);
3853N/A if (error == 0) {
3853N/A zil_destroy(dmu_objset_zil(os), B_FALSE);
2086N/A dmu_objset_close(os);
2086N/A }
3853N/A
0N/A return (dsl_dataset_destroy(name));
0N/A}
0N/A
3853N/Aint
3853N/Admu_objset_rollback(const char *name)
3853N/A{
3853N/A int err;
0N/A objset_t *os;
0N/A
3853N/A err = dmu_objset_open(name, DMU_OST_ANY,
0N/A DS_MODE_EXCLUSIVE | DS_MODE_INCONSISTENT, &os);
3853N/A if (err == 0) {
0N/A err = zil_suspend(dmu_objset_zil(os));
0N/A if (err == 0)
0N/A zil_resume(dmu_objset_zil(os));
0N/A if (err == 0) {
0N/A /* XXX uncache everything? */
3352N/A err = dsl_dataset_rollback(os->os->os_dsl_dataset);
0N/A }
1615N/A dmu_objset_close(os);
1615N/A }
1615N/A return (err);
1615N/A}
1615N/A
1615N/Astruct snaparg {
1787N/A dsl_sync_task_group_t *dstg;
1787N/A char *snapname;
2086N/A char failed[MAXPATHLEN];
1787N/A boolean_t checkperms;
1787N/A};
1787N/A
1787N/Astatic int
1787N/Admu_objset_snapshot_one(char *name, void *arg)
1787N/A{
1787N/A struct snaparg *sn = arg;
1787N/A objset_t *os;
1787N/A dmu_objset_stats_t stat;
1787N/A int err;
1787N/A
1638N/A (void) strcpy(sn->failed, name);
1638N/A
2086N/A /*
1615N/A * Check permissions only when requested. This only applies when
1615N/A * doing a recursive snapshot. The permission checks for the starting
1615N/A * dataset have already been performed in zfs_secpolicy_snapshot()
1615N/A */
1615N/A if (sn->checkperms == B_TRUE &&
1615N/A (err = zfs_secpolicy_snapshot_perms(name, CRED())))
1615N/A return (err);
1615N/A
1615N/A err = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_STANDARD, &os);
1615N/A if (err != 0)
1615N/A return (err);
1615N/A
1615N/A /*
1615N/A * If the objset is in an inconsistent state, return busy.
2086N/A */
2086N/A dmu_objset_fast_stat(os, &stat);
1615N/A if (stat.dds_inconsistent) {
1615N/A dmu_objset_close(os);
1615N/A return (EBUSY);
1615N/A }
1615N/A
1638N/A /*
1638N/A * NB: we need to wait for all in-flight changes to get to disk,
1638N/A * so that we snapshot those changes. zil_suspend does this as
2414N/A * a side effect.
2624N/A */
2624N/A err = zil_suspend(dmu_objset_zil(os));
1638N/A if (err == 0) {
3853N/A dsl_sync_task_create(sn->dstg, dsl_dataset_snapshot_check,
3853N/A dsl_dataset_snapshot_sync, os, sn->snapname, 3);
1638N/A } else {
1638N/A dmu_objset_close(os);
1638N/A }
1638N/A
1638N/A return (err);
2086N/A}
2086N/A
1638N/Aint
1638N/Admu_objset_snapshot(char *fsname, char *snapname, boolean_t recursive)
1638N/A{
1638N/A dsl_sync_task_t *dst;
1638N/A struct snaparg sn = { 0 };
1638N/A spa_t *spa;
3853N/A int err;
2414N/A
1638N/A (void) strcpy(sn.failed, fsname);
2414N/A
1638N/A err = spa_open(fsname, &spa, FTAG);
1638N/A if (err)
2414N/A return (err);
1638N/A
1638N/A sn.dstg = dsl_sync_task_group_create(spa_get_dsl(spa));
2414N/A sn.snapname = snapname;
2414N/A
2414N/A if (recursive) {
2414N/A sn.checkperms = B_TRUE;
2414N/A err = dmu_objset_find(fsname,
2414N/A dmu_objset_snapshot_one, &sn, DS_FIND_CHILDREN);
2414N/A } else {
2414N/A sn.checkperms = B_FALSE;
2414N/A err = dmu_objset_snapshot_one(fsname, &sn);
2414N/A }
2414N/A
1638N/A if (err)
1638N/A goto out;
1638N/A
1638N/A err = dsl_sync_task_group_wait(sn.dstg);
1638N/A
1638N/A for (dst = list_head(&sn.dstg->dstg_tasks); dst;
1638N/A dst = list_next(&sn.dstg->dstg_tasks, dst)) {
1638N/A objset_t *os = dst->dst_arg1;
1638N/A if (dst->dst_err)
1638N/A dmu_objset_name(os, sn.failed);
2414N/A zil_resume(dmu_objset_zil(os));
2624N/A dmu_objset_close(os);
2624N/A }
1638N/Aout:
3853N/A if (err)
3853N/A (void) strcpy(fsname, sn.failed);
1638N/A dsl_sync_task_group_destroy(sn.dstg);
1638N/A spa_close(spa, FTAG);
1638N/A return (err);
1638N/A}
1638N/A
2086N/Astatic void
2086N/Admu_objset_sync_dnodes(list_t *list, dmu_tx_t *tx)
1638N/A{
1638N/A dnode_t *dn;
1638N/A
1638N/A while (dn = list_head(list)) {
1638N/A ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT);
1638N/A ASSERT(dn->dn_dbuf->db_data_pending);
3853N/A /*
2414N/A * Initialize dn_zio outside dnode_sync()
1638N/A * to accomodate meta-dnode
2414N/A */
1638N/A dn->dn_zio = dn->dn_dbuf->db_data_pending->dr_zio;
1638N/A ASSERT(dn->dn_zio);
2414N/A
1638N/A ASSERT3U(dn->dn_nlevels, <=, DN_MAX_LEVELS);
1638N/A list_remove(list, dn);
2086N/A dnode_sync(dn, tx);
2414N/A }
1638N/A}
1638N/A
1638N/A/* ARGSUSED */
1638N/Astatic void
1638N/Aready(zio_t *zio, arc_buf_t *abuf, void *arg)
1638N/A{
1638N/A objset_impl_t *os = arg;
1638N/A blkptr_t *bp = os->os_rootbp;
1615N/A dnode_phys_t *dnp = &os->os_phys->os_meta_dnode;
1615N/A int i;
1615N/A
1615N/A /*
1615N/A * Update rootbp fill count.
1615N/A */
1615N/A bp->blk_fill = 1; /* count the meta-dnode */
1615N/A for (i = 0; i < dnp->dn_nblkptr; i++)
1638N/A bp->blk_fill += dnp->dn_blkptr[i].blk_fill;
1638N/A}
1615N/A
1638N/A/* ARGSUSED */
1638N/Astatic void
2086N/Akiller(zio_t *zio, arc_buf_t *abuf, void *arg)
1638N/A{
1638N/A objset_impl_t *os = arg;
1638N/A
1638N/A ASSERT3U(zio->io_error, ==, 0);
1638N/A
3853N/A BP_SET_TYPE(zio->io_bp, DMU_OT_OBJSET);
2414N/A BP_SET_LEVEL(zio->io_bp, 0);
2624N/A
2624N/A if (!DVA_EQUAL(BP_IDENTITY(zio->io_bp),
1638N/A BP_IDENTITY(&zio->io_bp_orig))) {
1638N/A if (zio->io_bp_orig.blk_birth == os->os_synctx->tx_txg)
1638N/A dsl_dataset_block_kill(os->os_dsl_dataset,
3853N/A &zio->io_bp_orig, NULL, os->os_synctx);
1638N/A dsl_dataset_block_born(os->os_dsl_dataset, zio->io_bp,
1638N/A os->os_synctx);
1638N/A }
1638N/A arc_release(os->os_phys_buf, &os->os_phys_buf);
1638N/A}
1638N/A
1638N/A/* called from dsl */
1638N/Avoid
1638N/Admu_objset_sync(objset_impl_t *os, zio_t *pio, dmu_tx_t *tx)
1638N/A{
1638N/A int txgoff;
1638N/A zbookmark_t zb;
1638N/A zio_t *zio;
1638N/A list_t *list;
1638N/A dbuf_dirty_record_t *dr;
2086N/A int zio_flags;
2086N/A
1638N/A dprintf_ds(os->os_dsl_dataset, "txg=%llu\n", tx->tx_txg);
1638N/A
1638N/A ASSERT(dmu_tx_is_syncing(tx));
1638N/A /* XXX the write_done callback should really give us the tx... */
1638N/A os->os_synctx = tx;
2414N/A
1638N/A if (os->os_dsl_dataset == NULL) {
2414N/A /*
1638N/A * This is the MOS. If we have upgraded,
1638N/A * spa_max_replication() could change, so reset
2414N/A * os_copies here.
1638N/A */
1638N/A os->os_copies = spa_max_replication(os->os_spa);
1638N/A }
1638N/A
2414N/A /*
2414N/A * Create the root block IO
2414N/A */
2414N/A zb.zb_objset = os->os_dsl_dataset ? os->os_dsl_dataset->ds_object : 0;
2414N/A zb.zb_object = 0;
2414N/A zb.zb_level = -1;
2414N/A zb.zb_blkid = 0;
2414N/A zio_flags = ZIO_FLAG_MUSTSUCCEED;
2414N/A if (dmu_ot[DMU_OT_OBJSET].ot_metadata || zb.zb_level != 0)
2414N/A zio_flags |= ZIO_FLAG_METADATA;
2414N/A if (BP_IS_OLDER(os->os_rootbp, tx->tx_txg))
1638N/A dsl_dataset_block_kill(os->os_dsl_dataset,
1638N/A os->os_rootbp, pio, tx);
1638N/A zio = arc_write(pio, os->os_spa, os->os_md_checksum,
1638N/A os->os_md_compress,
1638N/A dmu_get_replication_level(os, &zb, DMU_OT_OBJSET),
1638N/A tx->tx_txg, os->os_rootbp, os->os_phys_buf, ready, killer, os,
1638N/A ZIO_PRIORITY_ASYNC_WRITE, zio_flags, &zb);
1638N/A
3853N/A /*
2414N/A * Sync meta-dnode - the parent IO for the sync is the root block
2624N/A */
2624N/A os->os_meta_dnode->dn_zio = zio;
1638N/A dnode_sync(os->os_meta_dnode, tx);
1638N/A
1638N/A txgoff = tx->tx_txg & TXG_MASK;
3853N/A
1638N/A dmu_objset_sync_dnodes(&os->os_free_dnodes[txgoff], tx);
1638N/A dmu_objset_sync_dnodes(&os->os_dirty_dnodes[txgoff], tx);
1638N/A
1638N/A list = &os->os_meta_dnode->dn_dirty_records[txgoff];
1638N/A while (dr = list_head(list)) {
1638N/A ASSERT(dr->dr_dbuf->db_level == 0);
1638N/A list_remove(list, dr);
1638N/A if (dr->dr_zio)
1638N/A zio_nowait(dr->dr_zio);
1638N/A }
1638N/A /*
1638N/A * Free intent log blocks up to this tx.
1638N/A */
1638N/A zil_sync(os->os_zil, tx);
2086N/A zio_nowait(zio);
2086N/A}
1638N/A
1638N/Avoid
1638N/Admu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp,
1638N/A uint64_t *usedobjsp, uint64_t *availobjsp)
1638N/A{
2414N/A dsl_dataset_space(os->os->os_dsl_dataset, refdbytesp, availbytesp,
1638N/A usedobjsp, availobjsp);
2414N/A}
1638N/A
1638N/Auint64_t
2414N/Admu_objset_fsid_guid(objset_t *os)
1638N/A{
1638N/A return (dsl_dataset_fsid_guid(os->os->os_dsl_dataset));
1638N/A}
1638N/A
2086N/Avoid
2414N/Admu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat)
1638N/A{
1638N/A stat->dds_type = os->os->os_phys->os_type;
1638N/A if (os->os->os_dsl_dataset)
1638N/A dsl_dataset_fast_stat(os->os->os_dsl_dataset, stat);
1638N/A}
1787N/A
1787N/Avoid
1787N/Admu_objset_stats(objset_t *os, nvlist_t *nv)
1787N/A{
1787N/A ASSERT(os->os->os_dsl_dataset ||
1787N/A os->os->os_phys->os_type == DMU_OST_META);
1638N/A
1615N/A if (os->os->os_dsl_dataset != NULL)
0N/A dsl_dataset_stats(os->os->os_dsl_dataset, nv);
0N/A
dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_TYPE,
os->os->os_phys->os_type);
}
int
dmu_objset_is_snapshot(objset_t *os)
{
if (os->os->os_dsl_dataset != NULL)
return (dsl_dataset_is_snapshot(os->os->os_dsl_dataset));
else
return (B_FALSE);
}
int
dmu_snapshot_list_next(objset_t *os, int namelen, char *name,
uint64_t *idp, uint64_t *offp)
{
dsl_dataset_t *ds = os->os->os_dsl_dataset;
zap_cursor_t cursor;
zap_attribute_t attr;
if (ds->ds_phys->ds_snapnames_zapobj == 0)
return (ENOENT);
zap_cursor_init_serialized(&cursor,
ds->ds_dir->dd_pool->dp_meta_objset,
ds->ds_phys->ds_snapnames_zapobj, *offp);
if (zap_cursor_retrieve(&cursor, &attr) != 0) {
zap_cursor_fini(&cursor);
return (ENOENT);
}
if (strlen(attr.za_name) + 1 > namelen) {
zap_cursor_fini(&cursor);
return (ENAMETOOLONG);
}
(void) strcpy(name, attr.za_name);
if (idp)
*idp = attr.za_first_integer;
zap_cursor_advance(&cursor);
*offp = zap_cursor_serialize(&cursor);
zap_cursor_fini(&cursor);
return (0);
}
int
dmu_dir_list_next(objset_t *os, int namelen, char *name,
uint64_t *idp, uint64_t *offp)
{
dsl_dir_t *dd = os->os->os_dsl_dataset->ds_dir;
zap_cursor_t cursor;
zap_attribute_t attr;
/* there is no next dir on a snapshot! */
if (os->os->os_dsl_dataset->ds_object !=
dd->dd_phys->dd_head_dataset_obj)
return (ENOENT);
zap_cursor_init_serialized(&cursor,
dd->dd_pool->dp_meta_objset,
dd->dd_phys->dd_child_dir_zapobj, *offp);
if (zap_cursor_retrieve(&cursor, &attr) != 0) {
zap_cursor_fini(&cursor);
return (ENOENT);
}
if (strlen(attr.za_name) + 1 > namelen) {
zap_cursor_fini(&cursor);
return (ENAMETOOLONG);
}
(void) strcpy(name, attr.za_name);
if (idp)
*idp = attr.za_first_integer;
zap_cursor_advance(&cursor);
*offp = zap_cursor_serialize(&cursor);
zap_cursor_fini(&cursor);
return (0);
}
/*
* Find all objsets under name, and for each, call 'func(child_name, arg)'.
*/
int
dmu_objset_find(char *name, int func(char *, void *), void *arg, int flags)
{
dsl_dir_t *dd;
objset_t *os;
uint64_t snapobj;
zap_cursor_t zc;
zap_attribute_t *attr;
char *child;
int do_self, err;
err = dsl_dir_open(name, FTAG, &dd, NULL);
if (err)
return (err);
/* NB: the $MOS dir doesn't have a head dataset */
do_self = (dd->dd_phys->dd_head_dataset_obj != 0);
attr = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP);
/*
* Iterate over all children.
*/
if (flags & DS_FIND_CHILDREN) {
for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset,
dd->dd_phys->dd_child_dir_zapobj);
zap_cursor_retrieve(&zc, attr) == 0;
(void) zap_cursor_advance(&zc)) {
ASSERT(attr->za_integer_length == sizeof (uint64_t));
ASSERT(attr->za_num_integers == 1);
/*
* No separating '/' because parent's name ends in /.
*/
child = kmem_alloc(MAXPATHLEN, KM_SLEEP);
/* XXX could probably just use name here */
dsl_dir_name(dd, child);
(void) strcat(child, "/");
(void) strcat(child, attr->za_name);
err = dmu_objset_find(child, func, arg, flags);
kmem_free(child, MAXPATHLEN);
if (err)
break;
}
zap_cursor_fini(&zc);
if (err) {
dsl_dir_close(dd, FTAG);
kmem_free(attr, sizeof (zap_attribute_t));
return (err);
}
}
/*
* Iterate over all snapshots.
*/
if ((flags & DS_FIND_SNAPSHOTS) &&
dmu_objset_open(name, DMU_OST_ANY,
DS_MODE_STANDARD | DS_MODE_READONLY, &os) == 0) {
snapobj = os->os->os_dsl_dataset->ds_phys->ds_snapnames_zapobj;
dmu_objset_close(os);
for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset, snapobj);
zap_cursor_retrieve(&zc, attr) == 0;
(void) zap_cursor_advance(&zc)) {
ASSERT(attr->za_integer_length == sizeof (uint64_t));
ASSERT(attr->za_num_integers == 1);
child = kmem_alloc(MAXPATHLEN, KM_SLEEP);
/* XXX could probably just use name here */
dsl_dir_name(dd, child);
(void) strcat(child, "@");
(void) strcat(child, attr->za_name);
err = func(child, arg);
kmem_free(child, MAXPATHLEN);
if (err)
break;
}
zap_cursor_fini(&zc);
}
dsl_dir_close(dd, FTAG);
kmem_free(attr, sizeof (zap_attribute_t));
if (err)
return (err);
/*
* Apply to self if appropriate.
*/
if (do_self)
err = func(name, arg);
return (err);
}