1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5*ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6*ea8dc4b6Seschrock * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 21fa9e4066Sahrens /* 22*ea8dc4b6Seschrock * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27fa9e4066Sahrens 28fa9e4066Sahrens #include <sys/zfs_context.h> 29fa9e4066Sahrens #include <sys/dmu_objset.h> 30fa9e4066Sahrens #include <sys/dsl_dir.h> 31fa9e4066Sahrens #include <sys/dsl_dataset.h> 32fa9e4066Sahrens #include <sys/dsl_prop.h> 33fa9e4066Sahrens #include <sys/dsl_pool.h> 34fa9e4066Sahrens #include <sys/dnode.h> 35fa9e4066Sahrens #include <sys/dbuf.h> 36fa9e4066Sahrens #include <sys/dmu_tx.h> 37fa9e4066Sahrens #include <sys/zio_checksum.h> 38fa9e4066Sahrens #include <sys/zap.h> 39fa9e4066Sahrens #include <sys/zil.h> 40fa9e4066Sahrens #include <sys/dmu_impl.h> 41fa9e4066Sahrens 42fa9e4066Sahrens 43fa9e4066Sahrens spa_t * 44fa9e4066Sahrens dmu_objset_spa(objset_t *os) 45fa9e4066Sahrens { 46fa9e4066Sahrens return (os->os->os_spa); 47fa9e4066Sahrens } 48fa9e4066Sahrens 49fa9e4066Sahrens zilog_t * 50fa9e4066Sahrens dmu_objset_zil(objset_t *os) 51fa9e4066Sahrens { 52fa9e4066Sahrens return (os->os->os_zil); 53fa9e4066Sahrens } 54fa9e4066Sahrens 55fa9e4066Sahrens dsl_pool_t * 56fa9e4066Sahrens dmu_objset_pool(objset_t *os) 57fa9e4066Sahrens { 58fa9e4066Sahrens dsl_dataset_t *ds; 59fa9e4066Sahrens 60fa9e4066Sahrens if ((ds = os->os->os_dsl_dataset) != NULL && ds->ds_dir) 61fa9e4066Sahrens return (ds->ds_dir->dd_pool); 62fa9e4066Sahrens else 63fa9e4066Sahrens return (spa_get_dsl(os->os->os_spa)); 64fa9e4066Sahrens } 65fa9e4066Sahrens 66fa9e4066Sahrens dsl_dataset_t * 67fa9e4066Sahrens dmu_objset_ds(objset_t *os) 68fa9e4066Sahrens { 69fa9e4066Sahrens return (os->os->os_dsl_dataset); 70fa9e4066Sahrens } 71fa9e4066Sahrens 72fa9e4066Sahrens dmu_objset_type_t 73fa9e4066Sahrens dmu_objset_type(objset_t *os) 74fa9e4066Sahrens { 75fa9e4066Sahrens return (os->os->os_phys->os_type); 76fa9e4066Sahrens } 77fa9e4066Sahrens 78fa9e4066Sahrens void 79fa9e4066Sahrens dmu_objset_name(objset_t *os, char *buf) 80fa9e4066Sahrens { 81fa9e4066Sahrens dsl_dataset_name(os->os->os_dsl_dataset, buf); 82fa9e4066Sahrens } 83fa9e4066Sahrens 84fa9e4066Sahrens uint64_t 85fa9e4066Sahrens dmu_objset_id(objset_t *os) 86fa9e4066Sahrens { 87fa9e4066Sahrens dsl_dataset_t *ds = os->os->os_dsl_dataset; 88fa9e4066Sahrens 89fa9e4066Sahrens return (ds ? ds->ds_object : 0); 90fa9e4066Sahrens } 91fa9e4066Sahrens 92fa9e4066Sahrens static void 93fa9e4066Sahrens checksum_changed_cb(void *arg, uint64_t newval) 94fa9e4066Sahrens { 95fa9e4066Sahrens objset_impl_t *osi = arg; 96fa9e4066Sahrens 97fa9e4066Sahrens /* 98fa9e4066Sahrens * Inheritance should have been done by now. 99fa9e4066Sahrens */ 100fa9e4066Sahrens ASSERT(newval != ZIO_CHECKSUM_INHERIT); 101fa9e4066Sahrens 102fa9e4066Sahrens osi->os_checksum = zio_checksum_select(newval, ZIO_CHECKSUM_ON_VALUE); 103fa9e4066Sahrens } 104fa9e4066Sahrens 105fa9e4066Sahrens static void 106fa9e4066Sahrens compression_changed_cb(void *arg, uint64_t newval) 107fa9e4066Sahrens { 108fa9e4066Sahrens objset_impl_t *osi = arg; 109fa9e4066Sahrens 110fa9e4066Sahrens /* 111fa9e4066Sahrens * Inheritance and range checking should have been done by now. 112fa9e4066Sahrens */ 113fa9e4066Sahrens ASSERT(newval != ZIO_COMPRESS_INHERIT); 114fa9e4066Sahrens 115fa9e4066Sahrens osi->os_compress = zio_compress_select(newval, ZIO_COMPRESS_ON_VALUE); 116fa9e4066Sahrens } 117fa9e4066Sahrens 118fa9e4066Sahrens void 119fa9e4066Sahrens dmu_objset_byteswap(void *buf, size_t size) 120fa9e4066Sahrens { 121fa9e4066Sahrens objset_phys_t *osp = buf; 122fa9e4066Sahrens 123fa9e4066Sahrens ASSERT(size == sizeof (objset_phys_t)); 124fa9e4066Sahrens dnode_byteswap(&osp->os_meta_dnode); 125fa9e4066Sahrens byteswap_uint64_array(&osp->os_zil_header, sizeof (zil_header_t)); 126fa9e4066Sahrens osp->os_type = BSWAP_64(osp->os_type); 127fa9e4066Sahrens } 128fa9e4066Sahrens 129*ea8dc4b6Seschrock int 130*ea8dc4b6Seschrock dmu_objset_open_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp, 131*ea8dc4b6Seschrock objset_impl_t **osip) 132fa9e4066Sahrens { 133fa9e4066Sahrens objset_impl_t *winner, *osi; 134fa9e4066Sahrens int i, err, checksum; 135fa9e4066Sahrens 136fa9e4066Sahrens osi = kmem_zalloc(sizeof (objset_impl_t), KM_SLEEP); 137fa9e4066Sahrens osi->os.os = osi; 138fa9e4066Sahrens osi->os_dsl_dataset = ds; 139fa9e4066Sahrens osi->os_spa = spa; 140fa9e4066Sahrens if (bp) 141fa9e4066Sahrens osi->os_rootbp = *bp; 142fa9e4066Sahrens osi->os_phys = zio_buf_alloc(sizeof (objset_phys_t)); 143fa9e4066Sahrens if (!BP_IS_HOLE(&osi->os_rootbp)) { 144*ea8dc4b6Seschrock zbookmark_t zb; 145*ea8dc4b6Seschrock zb.zb_objset = ds ? ds->ds_object : 0; 146*ea8dc4b6Seschrock zb.zb_object = 0; 147*ea8dc4b6Seschrock zb.zb_level = -1; 148*ea8dc4b6Seschrock zb.zb_blkid = 0; 149*ea8dc4b6Seschrock 150fa9e4066Sahrens dprintf_bp(&osi->os_rootbp, "reading %s", ""); 151*ea8dc4b6Seschrock err = arc_read(NULL, spa, &osi->os_rootbp, 152fa9e4066Sahrens dmu_ot[DMU_OT_OBJSET].ot_byteswap, 153fa9e4066Sahrens arc_bcopy_func, osi->os_phys, 154*ea8dc4b6Seschrock ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_CANFAIL, ARC_WAIT, &zb); 155*ea8dc4b6Seschrock if (err) { 156*ea8dc4b6Seschrock zio_buf_free(osi->os_phys, sizeof (objset_phys_t)); 157*ea8dc4b6Seschrock kmem_free(osi, sizeof (objset_impl_t)); 158*ea8dc4b6Seschrock return (err); 159*ea8dc4b6Seschrock } 160fa9e4066Sahrens } else { 161fa9e4066Sahrens bzero(osi->os_phys, sizeof (objset_phys_t)); 162fa9e4066Sahrens } 163fa9e4066Sahrens 164fa9e4066Sahrens /* 165fa9e4066Sahrens * Note: the changed_cb will be called once before the register 166fa9e4066Sahrens * func returns, thus changing the checksum/compression from the 167fa9e4066Sahrens * default (fletcher2/off). 168fa9e4066Sahrens */ 169fa9e4066Sahrens if (ds) { 170fa9e4066Sahrens err = dsl_prop_register(ds, "checksum", 171fa9e4066Sahrens checksum_changed_cb, osi); 172*ea8dc4b6Seschrock if (err == 0) 173*ea8dc4b6Seschrock err = dsl_prop_register(ds, "compression", 174*ea8dc4b6Seschrock compression_changed_cb, osi); 175*ea8dc4b6Seschrock if (err) { 176*ea8dc4b6Seschrock zio_buf_free(osi->os_phys, sizeof (objset_phys_t)); 177*ea8dc4b6Seschrock kmem_free(osi, sizeof (objset_impl_t)); 178*ea8dc4b6Seschrock return (err); 179*ea8dc4b6Seschrock } 180fa9e4066Sahrens } else { 181fa9e4066Sahrens /* It's the meta-objset. */ 182fa9e4066Sahrens osi->os_checksum = ZIO_CHECKSUM_FLETCHER_4; 183*ea8dc4b6Seschrock osi->os_compress = ZIO_COMPRESS_LZJB; 184fa9e4066Sahrens } 185fa9e4066Sahrens 186*ea8dc4b6Seschrock osi->os_zil = zil_alloc(&osi->os, &osi->os_phys->os_zil_header); 187*ea8dc4b6Seschrock 188fa9e4066Sahrens /* 189fa9e4066Sahrens * Metadata always gets compressed and checksummed. 190fa9e4066Sahrens * If the data checksum is multi-bit correctable, and it's not 191fa9e4066Sahrens * a ZBT-style checksum, then it's suitable for metadata as well. 192fa9e4066Sahrens * Otherwise, the metadata checksum defaults to fletcher4. 193fa9e4066Sahrens */ 194fa9e4066Sahrens checksum = osi->os_checksum; 195fa9e4066Sahrens 196fa9e4066Sahrens if (zio_checksum_table[checksum].ci_correctable && 197fa9e4066Sahrens !zio_checksum_table[checksum].ci_zbt) 198fa9e4066Sahrens osi->os_md_checksum = checksum; 199fa9e4066Sahrens else 200fa9e4066Sahrens osi->os_md_checksum = ZIO_CHECKSUM_FLETCHER_4; 201*ea8dc4b6Seschrock osi->os_md_compress = ZIO_COMPRESS_LZJB; 202fa9e4066Sahrens 203fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++) { 204fa9e4066Sahrens list_create(&osi->os_dirty_dnodes[i], sizeof (dnode_t), 205fa9e4066Sahrens offsetof(dnode_t, dn_dirty_link[i])); 206fa9e4066Sahrens list_create(&osi->os_free_dnodes[i], sizeof (dnode_t), 207fa9e4066Sahrens offsetof(dnode_t, dn_dirty_link[i])); 208fa9e4066Sahrens } 209fa9e4066Sahrens list_create(&osi->os_dnodes, sizeof (dnode_t), 210fa9e4066Sahrens offsetof(dnode_t, dn_link)); 211fa9e4066Sahrens list_create(&osi->os_downgraded_dbufs, sizeof (dmu_buf_impl_t), 212fa9e4066Sahrens offsetof(dmu_buf_impl_t, db_link)); 213fa9e4066Sahrens 214fa9e4066Sahrens osi->os_meta_dnode = dnode_special_open(osi, 215fa9e4066Sahrens &osi->os_phys->os_meta_dnode, DMU_META_DNODE_OBJECT); 216fa9e4066Sahrens 217fa9e4066Sahrens if (ds != NULL) { 218fa9e4066Sahrens winner = dsl_dataset_set_user_ptr(ds, osi, dmu_objset_evict); 219fa9e4066Sahrens if (winner) { 220fa9e4066Sahrens dmu_objset_evict(ds, osi); 221fa9e4066Sahrens osi = winner; 222fa9e4066Sahrens } 223fa9e4066Sahrens } 224fa9e4066Sahrens 225*ea8dc4b6Seschrock *osip = osi; 226*ea8dc4b6Seschrock return (0); 227fa9e4066Sahrens } 228fa9e4066Sahrens 229fa9e4066Sahrens /* called from zpl */ 230fa9e4066Sahrens int 231fa9e4066Sahrens dmu_objset_open(const char *name, dmu_objset_type_t type, int mode, 232fa9e4066Sahrens objset_t **osp) 233fa9e4066Sahrens { 234fa9e4066Sahrens dsl_dataset_t *ds; 235fa9e4066Sahrens int err; 236fa9e4066Sahrens objset_t *os; 237fa9e4066Sahrens objset_impl_t *osi; 238fa9e4066Sahrens 239fa9e4066Sahrens os = kmem_alloc(sizeof (objset_t), KM_SLEEP); 240fa9e4066Sahrens err = dsl_dataset_open(name, mode, os, &ds); 241fa9e4066Sahrens if (err) { 242fa9e4066Sahrens kmem_free(os, sizeof (objset_t)); 243fa9e4066Sahrens return (err); 244fa9e4066Sahrens } 245fa9e4066Sahrens 246fa9e4066Sahrens osi = dsl_dataset_get_user_ptr(ds); 247fa9e4066Sahrens if (osi == NULL) { 248fa9e4066Sahrens blkptr_t bp; 249fa9e4066Sahrens 250fa9e4066Sahrens dsl_dataset_get_blkptr(ds, &bp); 251*ea8dc4b6Seschrock err = dmu_objset_open_impl(dsl_dataset_get_spa(ds), 252*ea8dc4b6Seschrock ds, &bp, &osi); 253*ea8dc4b6Seschrock if (err) { 254*ea8dc4b6Seschrock dsl_dataset_close(ds, mode, os); 255*ea8dc4b6Seschrock kmem_free(os, sizeof (objset_t)); 256*ea8dc4b6Seschrock return (err); 257*ea8dc4b6Seschrock } 258fa9e4066Sahrens } 259fa9e4066Sahrens 260fa9e4066Sahrens os->os = osi; 261fa9e4066Sahrens os->os_mode = mode; 262fa9e4066Sahrens 263fa9e4066Sahrens if (type != DMU_OST_ANY && type != os->os->os_phys->os_type) { 264fa9e4066Sahrens dmu_objset_close(os); 265fa9e4066Sahrens return (EINVAL); 266fa9e4066Sahrens } 267fa9e4066Sahrens *osp = os; 268fa9e4066Sahrens return (0); 269fa9e4066Sahrens } 270fa9e4066Sahrens 271fa9e4066Sahrens void 272fa9e4066Sahrens dmu_objset_close(objset_t *os) 273fa9e4066Sahrens { 274fa9e4066Sahrens dsl_dataset_close(os->os->os_dsl_dataset, os->os_mode, os); 275fa9e4066Sahrens kmem_free(os, sizeof (objset_t)); 276fa9e4066Sahrens } 277fa9e4066Sahrens 278*ea8dc4b6Seschrock void 279*ea8dc4b6Seschrock dmu_objset_evict_dbufs(objset_t *os) 280*ea8dc4b6Seschrock { 281*ea8dc4b6Seschrock objset_impl_t *osi = os->os; 282*ea8dc4b6Seschrock dnode_t *mdn = osi->os_meta_dnode; 283*ea8dc4b6Seschrock dnode_t *dn; 284*ea8dc4b6Seschrock int allzero = B_TRUE; 285*ea8dc4b6Seschrock 286*ea8dc4b6Seschrock /* 287*ea8dc4b6Seschrock * Each time we process an entry on the list, we first move it 288*ea8dc4b6Seschrock * to the tail so that we don't process it over and over again. 289*ea8dc4b6Seschrock * We use the meta-dnode as a marker: if we make a complete pass 290*ea8dc4b6Seschrock * over the list without finding any work to do, we're done. 291*ea8dc4b6Seschrock * This ensures that we complete in linear time rather than 292*ea8dc4b6Seschrock * quadratic time, as described in detail in bug 1182169. 293*ea8dc4b6Seschrock */ 294*ea8dc4b6Seschrock mutex_enter(&osi->os_lock); 295*ea8dc4b6Seschrock list_remove(&osi->os_dnodes, mdn); 296*ea8dc4b6Seschrock list_insert_tail(&osi->os_dnodes, mdn); 297*ea8dc4b6Seschrock while ((dn = list_head(&osi->os_dnodes)) != NULL) { 298*ea8dc4b6Seschrock list_remove(&osi->os_dnodes, dn); 299*ea8dc4b6Seschrock list_insert_tail(&osi->os_dnodes, dn); 300*ea8dc4b6Seschrock if (dn == mdn) { 301*ea8dc4b6Seschrock if (allzero) 302*ea8dc4b6Seschrock break; 303*ea8dc4b6Seschrock allzero = B_TRUE; 304*ea8dc4b6Seschrock continue; 305*ea8dc4b6Seschrock } 306*ea8dc4b6Seschrock if (!refcount_is_zero(&dn->dn_holds)) { 307*ea8dc4b6Seschrock allzero = B_FALSE; 308*ea8dc4b6Seschrock dnode_add_ref(dn, FTAG); 309*ea8dc4b6Seschrock mutex_exit(&osi->os_lock); 310*ea8dc4b6Seschrock dnode_evict_dbufs(dn); 311*ea8dc4b6Seschrock dnode_rele(dn, FTAG); 312*ea8dc4b6Seschrock mutex_enter(&osi->os_lock); 313*ea8dc4b6Seschrock } 314*ea8dc4b6Seschrock } 315*ea8dc4b6Seschrock mutex_exit(&osi->os_lock); 316*ea8dc4b6Seschrock dnode_evict_dbufs(mdn); 317*ea8dc4b6Seschrock } 318*ea8dc4b6Seschrock 319fa9e4066Sahrens void 320fa9e4066Sahrens dmu_objset_evict(dsl_dataset_t *ds, void *arg) 321fa9e4066Sahrens { 322fa9e4066Sahrens objset_impl_t *osi = arg; 323*ea8dc4b6Seschrock objset_t os; 324fa9e4066Sahrens int err, i; 325fa9e4066Sahrens 326fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++) { 327fa9e4066Sahrens ASSERT(list_head(&osi->os_dirty_dnodes[i]) == NULL); 328fa9e4066Sahrens ASSERT(list_head(&osi->os_free_dnodes[i]) == NULL); 329fa9e4066Sahrens } 330fa9e4066Sahrens 331fa9e4066Sahrens if (ds) { 332fa9e4066Sahrens err = dsl_prop_unregister(ds, "checksum", 333fa9e4066Sahrens checksum_changed_cb, osi); 334fa9e4066Sahrens ASSERT(err == 0); 335fa9e4066Sahrens 336fa9e4066Sahrens err = dsl_prop_unregister(ds, "compression", 337fa9e4066Sahrens compression_changed_cb, osi); 338fa9e4066Sahrens ASSERT(err == 0); 339fa9e4066Sahrens } 340fa9e4066Sahrens 341*ea8dc4b6Seschrock /* 342*ea8dc4b6Seschrock * We should need only a single pass over the dnode list, since 343*ea8dc4b6Seschrock * nothing can be added to the list at this point. 344*ea8dc4b6Seschrock */ 345*ea8dc4b6Seschrock os.os = osi; 346*ea8dc4b6Seschrock dmu_objset_evict_dbufs(&os); 347*ea8dc4b6Seschrock 348fa9e4066Sahrens ASSERT3P(list_head(&osi->os_dnodes), ==, osi->os_meta_dnode); 349fa9e4066Sahrens ASSERT3P(list_tail(&osi->os_dnodes), ==, osi->os_meta_dnode); 350fa9e4066Sahrens ASSERT3P(list_head(&osi->os_meta_dnode->dn_dbufs), ==, NULL); 351fa9e4066Sahrens 352fa9e4066Sahrens dnode_special_close(osi->os_meta_dnode); 353fa9e4066Sahrens zil_free(osi->os_zil); 354fa9e4066Sahrens 355fa9e4066Sahrens zio_buf_free(osi->os_phys, sizeof (objset_phys_t)); 356fa9e4066Sahrens kmem_free(osi, sizeof (objset_impl_t)); 357fa9e4066Sahrens } 358fa9e4066Sahrens 359fa9e4066Sahrens /* called from dsl for meta-objset */ 360fa9e4066Sahrens objset_impl_t * 361fa9e4066Sahrens dmu_objset_create_impl(spa_t *spa, dsl_dataset_t *ds, dmu_objset_type_t type, 362fa9e4066Sahrens dmu_tx_t *tx) 363fa9e4066Sahrens { 364fa9e4066Sahrens objset_impl_t *osi; 365fa9e4066Sahrens dnode_t *mdn; 366fa9e4066Sahrens 367fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 368*ea8dc4b6Seschrock VERIFY(0 == dmu_objset_open_impl(spa, ds, NULL, &osi)); 369fa9e4066Sahrens mdn = osi->os_meta_dnode; 370fa9e4066Sahrens 371fa9e4066Sahrens dnode_allocate(mdn, DMU_OT_DNODE, 1 << DNODE_BLOCK_SHIFT, 372fa9e4066Sahrens DN_MAX_INDBLKSHIFT, DMU_OT_NONE, 0, tx); 373fa9e4066Sahrens 374fa9e4066Sahrens /* 375fa9e4066Sahrens * We don't want to have to increase the meta-dnode's nlevels 376fa9e4066Sahrens * later, because then we could do it in quescing context while 377fa9e4066Sahrens * we are also accessing it in open context. 378fa9e4066Sahrens * 379fa9e4066Sahrens * This precaution is not necessary for the MOS (ds == NULL), 380fa9e4066Sahrens * because the MOS is only updated in syncing context. 381fa9e4066Sahrens * This is most fortunate: the MOS is the only objset that 382fa9e4066Sahrens * needs to be synced multiple times as spa_sync() iterates 383fa9e4066Sahrens * to convergence, so minimizing its dn_nlevels matters. 384fa9e4066Sahrens */ 385*ea8dc4b6Seschrock if (ds != NULL) { 386*ea8dc4b6Seschrock int levels = 1; 387*ea8dc4b6Seschrock 388*ea8dc4b6Seschrock /* 389*ea8dc4b6Seschrock * Determine the number of levels necessary for the meta-dnode 390*ea8dc4b6Seschrock * to contain DN_MAX_OBJECT dnodes. 391*ea8dc4b6Seschrock */ 392*ea8dc4b6Seschrock while ((uint64_t)mdn->dn_nblkptr << (mdn->dn_datablkshift + 393*ea8dc4b6Seschrock (levels - 1) * (mdn->dn_indblkshift - SPA_BLKPTRSHIFT)) < 394*ea8dc4b6Seschrock DN_MAX_OBJECT * sizeof (dnode_phys_t)) 395*ea8dc4b6Seschrock levels++; 396*ea8dc4b6Seschrock 397fa9e4066Sahrens mdn->dn_next_nlevels[tx->tx_txg & TXG_MASK] = 398*ea8dc4b6Seschrock mdn->dn_nlevels = levels; 399*ea8dc4b6Seschrock } 400fa9e4066Sahrens 401fa9e4066Sahrens ASSERT(type != DMU_OST_NONE); 402fa9e4066Sahrens ASSERT(type != DMU_OST_ANY); 403fa9e4066Sahrens ASSERT(type < DMU_OST_NUMTYPES); 404fa9e4066Sahrens osi->os_phys->os_type = type; 405fa9e4066Sahrens 406fa9e4066Sahrens dsl_dataset_dirty(ds, tx); 407fa9e4066Sahrens 408fa9e4066Sahrens return (osi); 409fa9e4066Sahrens } 410fa9e4066Sahrens 411fa9e4066Sahrens struct oscarg { 412fa9e4066Sahrens void (*userfunc)(objset_t *os, void *arg, dmu_tx_t *tx); 413fa9e4066Sahrens void *userarg; 414fa9e4066Sahrens dsl_dataset_t *clone_parent; 415fa9e4066Sahrens const char *fullname; 416fa9e4066Sahrens const char *lastname; 417fa9e4066Sahrens dmu_objset_type_t type; 418fa9e4066Sahrens }; 419fa9e4066Sahrens 420fa9e4066Sahrens static int 421fa9e4066Sahrens dmu_objset_create_sync(dsl_dir_t *dd, void *arg, dmu_tx_t *tx) 422fa9e4066Sahrens { 423fa9e4066Sahrens struct oscarg *oa = arg; 424fa9e4066Sahrens dsl_dataset_t *ds; 425fa9e4066Sahrens int err; 426fa9e4066Sahrens blkptr_t bp; 427fa9e4066Sahrens 428fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 429fa9e4066Sahrens 430fa9e4066Sahrens err = dsl_dataset_create_sync(dd, oa->fullname, oa->lastname, 431fa9e4066Sahrens oa->clone_parent, tx); 432fa9e4066Sahrens dprintf_dd(dd, "fn=%s ln=%s err=%d\n", 433fa9e4066Sahrens oa->fullname, oa->lastname, err); 434fa9e4066Sahrens if (err) 435fa9e4066Sahrens return (err); 436fa9e4066Sahrens 437*ea8dc4b6Seschrock VERIFY(0 == dsl_dataset_open_spa(dd->dd_pool->dp_spa, oa->fullname, 438*ea8dc4b6Seschrock DS_MODE_STANDARD | DS_MODE_READONLY, FTAG, &ds)); 439fa9e4066Sahrens dsl_dataset_get_blkptr(ds, &bp); 440fa9e4066Sahrens if (BP_IS_HOLE(&bp)) { 441fa9e4066Sahrens objset_impl_t *osi; 442fa9e4066Sahrens 443fa9e4066Sahrens /* This is an empty dmu_objset; not a clone. */ 444fa9e4066Sahrens osi = dmu_objset_create_impl(dsl_dataset_get_spa(ds), 445fa9e4066Sahrens ds, oa->type, tx); 446fa9e4066Sahrens 447fa9e4066Sahrens if (oa->userfunc) 448fa9e4066Sahrens oa->userfunc(&osi->os, oa->userarg, tx); 449fa9e4066Sahrens } 450fa9e4066Sahrens dsl_dataset_close(ds, DS_MODE_STANDARD | DS_MODE_READONLY, FTAG); 451fa9e4066Sahrens 452fa9e4066Sahrens return (0); 453fa9e4066Sahrens } 454fa9e4066Sahrens 455fa9e4066Sahrens int 456fa9e4066Sahrens dmu_objset_create(const char *name, dmu_objset_type_t type, 457fa9e4066Sahrens objset_t *clone_parent, 458fa9e4066Sahrens void (*func)(objset_t *os, void *arg, dmu_tx_t *tx), void *arg) 459fa9e4066Sahrens { 460fa9e4066Sahrens dsl_dir_t *pds; 461fa9e4066Sahrens const char *tail; 462fa9e4066Sahrens int err = 0; 463fa9e4066Sahrens 464*ea8dc4b6Seschrock err = dsl_dir_open(name, FTAG, &pds, &tail); 465*ea8dc4b6Seschrock if (err) 466*ea8dc4b6Seschrock return (err); 467fa9e4066Sahrens if (tail == NULL) { 468fa9e4066Sahrens dsl_dir_close(pds, FTAG); 469fa9e4066Sahrens return (EEXIST); 470fa9e4066Sahrens } 471fa9e4066Sahrens 472fa9e4066Sahrens dprintf("name=%s\n", name); 473fa9e4066Sahrens 474fa9e4066Sahrens if (tail[0] == '@') { 475fa9e4066Sahrens /* 476fa9e4066Sahrens * If we're creating a snapshot, make sure everything 477fa9e4066Sahrens * they might want is on disk. XXX Sketchy to know 478fa9e4066Sahrens * about snapshots here, better to put in DSL. 479fa9e4066Sahrens */ 480fa9e4066Sahrens objset_t *os; 481fa9e4066Sahrens size_t plen = strchr(name, '@') - name + 1; 482fa9e4066Sahrens char *pbuf = kmem_alloc(plen, KM_SLEEP); 483fa9e4066Sahrens bcopy(name, pbuf, plen - 1); 484fa9e4066Sahrens pbuf[plen - 1] = '\0'; 485fa9e4066Sahrens 486fa9e4066Sahrens err = dmu_objset_open(pbuf, DMU_OST_ANY, DS_MODE_STANDARD, &os); 487fa9e4066Sahrens if (err == 0) { 488fa9e4066Sahrens err = zil_suspend(dmu_objset_zil(os)); 489fa9e4066Sahrens if (err == 0) { 490fa9e4066Sahrens err = dsl_dir_sync_task(pds, 491fa9e4066Sahrens dsl_dataset_snapshot_sync, 492fa9e4066Sahrens (void*)(tail+1), 16*1024); 493fa9e4066Sahrens zil_resume(dmu_objset_zil(os)); 494fa9e4066Sahrens } 495fa9e4066Sahrens dmu_objset_close(os); 496fa9e4066Sahrens } 497fa9e4066Sahrens kmem_free(pbuf, plen); 498fa9e4066Sahrens } else { 499fa9e4066Sahrens struct oscarg oa = { 0 }; 500fa9e4066Sahrens oa.userfunc = func; 501fa9e4066Sahrens oa.userarg = arg; 502fa9e4066Sahrens oa.fullname = name; 503fa9e4066Sahrens oa.lastname = tail; 504fa9e4066Sahrens oa.type = type; 505fa9e4066Sahrens if (clone_parent != NULL) { 506fa9e4066Sahrens /* 507fa9e4066Sahrens * You can't clone to a different type. 508fa9e4066Sahrens */ 509fa9e4066Sahrens if (clone_parent->os->os_phys->os_type != type) { 510fa9e4066Sahrens dsl_dir_close(pds, FTAG); 511fa9e4066Sahrens return (EINVAL); 512fa9e4066Sahrens } 513fa9e4066Sahrens oa.clone_parent = clone_parent->os->os_dsl_dataset; 514fa9e4066Sahrens } 515fa9e4066Sahrens err = dsl_dir_sync_task(pds, dmu_objset_create_sync, &oa, 516fa9e4066Sahrens 256*1024); 517fa9e4066Sahrens } 518fa9e4066Sahrens dsl_dir_close(pds, FTAG); 519fa9e4066Sahrens return (err); 520fa9e4066Sahrens } 521fa9e4066Sahrens 522fa9e4066Sahrens int 523fa9e4066Sahrens dmu_objset_destroy(const char *name) 524fa9e4066Sahrens { 525fa9e4066Sahrens objset_t *os; 526fa9e4066Sahrens int error; 527fa9e4066Sahrens 528fa9e4066Sahrens /* 529fa9e4066Sahrens * If it looks like we'll be able to destroy it, and there's 530fa9e4066Sahrens * an unplayed replay log sitting around, destroy the log. 531fa9e4066Sahrens * It would be nicer to do this in dsl_dataset_destroy_sync(), 532fa9e4066Sahrens * but the replay log objset is modified in open context. 533fa9e4066Sahrens */ 534fa9e4066Sahrens error = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_EXCLUSIVE, &os); 535fa9e4066Sahrens if (error == 0) { 536fa9e4066Sahrens zil_destroy(dmu_objset_zil(os)); 537fa9e4066Sahrens dmu_objset_close(os); 538fa9e4066Sahrens } 539fa9e4066Sahrens 540fa9e4066Sahrens /* XXX uncache everything? */ 541fa9e4066Sahrens return (dsl_dataset_destroy(name)); 542fa9e4066Sahrens } 543fa9e4066Sahrens 544fa9e4066Sahrens int 545fa9e4066Sahrens dmu_objset_rollback(const char *name) 546fa9e4066Sahrens { 547fa9e4066Sahrens int err; 548fa9e4066Sahrens objset_t *os; 549fa9e4066Sahrens 550fa9e4066Sahrens err = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_EXCLUSIVE, &os); 551fa9e4066Sahrens if (err == 0) { 552fa9e4066Sahrens err = zil_suspend(dmu_objset_zil(os)); 553fa9e4066Sahrens if (err == 0) 554fa9e4066Sahrens zil_resume(dmu_objset_zil(os)); 555fa9e4066Sahrens dmu_objset_close(os); 556fa9e4066Sahrens if (err == 0) { 557fa9e4066Sahrens /* XXX uncache everything? */ 558fa9e4066Sahrens err = dsl_dataset_rollback(name); 559fa9e4066Sahrens } 560fa9e4066Sahrens } 561fa9e4066Sahrens return (err); 562fa9e4066Sahrens } 563fa9e4066Sahrens 564fa9e4066Sahrens static void 565fa9e4066Sahrens dmu_objset_sync_dnodes(objset_impl_t *os, list_t *list, dmu_tx_t *tx) 566fa9e4066Sahrens { 567fa9e4066Sahrens dnode_t *dn = list_head(list); 568fa9e4066Sahrens int level, err; 569fa9e4066Sahrens 570fa9e4066Sahrens for (level = 0; dn = list_head(list); level++) { 571fa9e4066Sahrens zio_t *zio; 572fa9e4066Sahrens zio = zio_root(os->os_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED); 573fa9e4066Sahrens 574fa9e4066Sahrens ASSERT3U(level, <=, DN_MAX_LEVELS); 575fa9e4066Sahrens 576fa9e4066Sahrens while (dn) { 577fa9e4066Sahrens dnode_t *next = list_next(list, dn); 578fa9e4066Sahrens 579fa9e4066Sahrens list_remove(list, dn); 580fa9e4066Sahrens if (dnode_sync(dn, level, zio, tx) == 0) { 581fa9e4066Sahrens /* 582fa9e4066Sahrens * This dnode requires syncing at higher 583fa9e4066Sahrens * levels; put it back onto the list. 584fa9e4066Sahrens */ 585fa9e4066Sahrens if (next) 586fa9e4066Sahrens list_insert_before(list, next, dn); 587fa9e4066Sahrens else 588fa9e4066Sahrens list_insert_tail(list, dn); 589fa9e4066Sahrens } 590fa9e4066Sahrens dn = next; 591fa9e4066Sahrens } 592fa9e4066Sahrens err = zio_wait(zio); 593fa9e4066Sahrens ASSERT(err == 0); 594fa9e4066Sahrens } 595fa9e4066Sahrens } 596fa9e4066Sahrens 597fa9e4066Sahrens /* ARGSUSED */ 598fa9e4066Sahrens static void 599fa9e4066Sahrens killer(zio_t *zio, arc_buf_t *abuf, void *arg) 600fa9e4066Sahrens { 601fa9e4066Sahrens objset_impl_t *os = arg; 602fa9e4066Sahrens objset_phys_t *osphys = zio->io_data; 603fa9e4066Sahrens dnode_phys_t *dnp = &osphys->os_meta_dnode; 604fa9e4066Sahrens int i; 605fa9e4066Sahrens 606fa9e4066Sahrens ASSERT3U(zio->io_error, ==, 0); 607fa9e4066Sahrens 608fa9e4066Sahrens /* 609fa9e4066Sahrens * Update rootbp fill count. 610fa9e4066Sahrens */ 611fa9e4066Sahrens os->os_rootbp.blk_fill = 1; /* count the meta-dnode */ 612fa9e4066Sahrens for (i = 0; i < dnp->dn_nblkptr; i++) 613fa9e4066Sahrens os->os_rootbp.blk_fill += dnp->dn_blkptr[i].blk_fill; 614fa9e4066Sahrens 615fa9e4066Sahrens BP_SET_TYPE(zio->io_bp, DMU_OT_OBJSET); 616fa9e4066Sahrens BP_SET_LEVEL(zio->io_bp, 0); 617fa9e4066Sahrens 618fa9e4066Sahrens if (!DVA_EQUAL(BP_IDENTITY(zio->io_bp), 619fa9e4066Sahrens BP_IDENTITY(&zio->io_bp_orig))) { 620fa9e4066Sahrens dsl_dataset_block_kill(os->os_dsl_dataset, &zio->io_bp_orig, 621fa9e4066Sahrens os->os_synctx); 622fa9e4066Sahrens dsl_dataset_block_born(os->os_dsl_dataset, zio->io_bp, 623fa9e4066Sahrens os->os_synctx); 624fa9e4066Sahrens } 625fa9e4066Sahrens } 626fa9e4066Sahrens 627fa9e4066Sahrens 628fa9e4066Sahrens /* called from dsl */ 629fa9e4066Sahrens void 630fa9e4066Sahrens dmu_objset_sync(objset_impl_t *os, dmu_tx_t *tx) 631fa9e4066Sahrens { 632fa9e4066Sahrens extern taskq_t *dbuf_tq; 633fa9e4066Sahrens int txgoff; 634fa9e4066Sahrens list_t *dirty_list; 635fa9e4066Sahrens int err; 636*ea8dc4b6Seschrock zbookmark_t zb; 637fa9e4066Sahrens arc_buf_t *abuf = 638fa9e4066Sahrens arc_buf_alloc(os->os_spa, sizeof (objset_phys_t), FTAG); 639fa9e4066Sahrens 640fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 641fa9e4066Sahrens ASSERT(os->os_synctx == NULL); 642fa9e4066Sahrens /* XXX the write_done callback should really give us the tx... */ 643fa9e4066Sahrens os->os_synctx = tx; 644fa9e4066Sahrens 645fa9e4066Sahrens dprintf_ds(os->os_dsl_dataset, "txg=%llu\n", tx->tx_txg); 646fa9e4066Sahrens 647fa9e4066Sahrens txgoff = tx->tx_txg & TXG_MASK; 648fa9e4066Sahrens 649fa9e4066Sahrens dmu_objset_sync_dnodes(os, &os->os_free_dnodes[txgoff], tx); 650fa9e4066Sahrens dmu_objset_sync_dnodes(os, &os->os_dirty_dnodes[txgoff], tx); 651fa9e4066Sahrens 652fa9e4066Sahrens /* 653fa9e4066Sahrens * Free intent log blocks up to this tx. 654fa9e4066Sahrens */ 655fa9e4066Sahrens zil_sync(os->os_zil, tx); 656fa9e4066Sahrens 657fa9e4066Sahrens /* 658fa9e4066Sahrens * Sync meta-dnode 659fa9e4066Sahrens */ 660fa9e4066Sahrens dirty_list = &os->os_dirty_dnodes[txgoff]; 661fa9e4066Sahrens ASSERT(list_head(dirty_list) == NULL); 662fa9e4066Sahrens list_insert_tail(dirty_list, os->os_meta_dnode); 663fa9e4066Sahrens dmu_objset_sync_dnodes(os, dirty_list, tx); 664fa9e4066Sahrens 665fa9e4066Sahrens /* 666fa9e4066Sahrens * Sync the root block. 667fa9e4066Sahrens */ 668fa9e4066Sahrens bcopy(os->os_phys, abuf->b_data, sizeof (objset_phys_t)); 669*ea8dc4b6Seschrock zb.zb_objset = os->os_dsl_dataset ? os->os_dsl_dataset->ds_object : 0; 670*ea8dc4b6Seschrock zb.zb_object = 0; 671*ea8dc4b6Seschrock zb.zb_level = -1; 672*ea8dc4b6Seschrock zb.zb_blkid = 0; 673fa9e4066Sahrens err = arc_write(NULL, os->os_spa, os->os_md_checksum, 674fa9e4066Sahrens os->os_md_compress, tx->tx_txg, &os->os_rootbp, abuf, killer, os, 675*ea8dc4b6Seschrock ZIO_PRIORITY_ASYNC_WRITE, ZIO_FLAG_MUSTSUCCEED, ARC_WAIT, &zb); 676fa9e4066Sahrens ASSERT(err == 0); 677*ea8dc4b6Seschrock VERIFY(arc_buf_remove_ref(abuf, FTAG) == 1); 678fa9e4066Sahrens 679fa9e4066Sahrens dsl_dataset_set_blkptr(os->os_dsl_dataset, &os->os_rootbp, tx); 680fa9e4066Sahrens 681fa9e4066Sahrens ASSERT3P(os->os_synctx, ==, tx); 682fa9e4066Sahrens taskq_wait(dbuf_tq); 683fa9e4066Sahrens os->os_synctx = NULL; 684fa9e4066Sahrens } 685fa9e4066Sahrens 686fa9e4066Sahrens void 687fa9e4066Sahrens dmu_objset_stats(objset_t *os, dmu_objset_stats_t *dds) 688fa9e4066Sahrens { 689fa9e4066Sahrens if (os->os->os_dsl_dataset != NULL) { 690fa9e4066Sahrens dsl_dataset_stats(os->os->os_dsl_dataset, dds); 691fa9e4066Sahrens } else { 692fa9e4066Sahrens ASSERT(os->os->os_phys->os_type == DMU_OST_META); 693fa9e4066Sahrens bzero(dds, sizeof (*dds)); 694fa9e4066Sahrens } 695fa9e4066Sahrens dds->dds_type = os->os->os_phys->os_type; 696fa9e4066Sahrens } 697fa9e4066Sahrens 698fa9e4066Sahrens int 699fa9e4066Sahrens dmu_objset_is_snapshot(objset_t *os) 700fa9e4066Sahrens { 701fa9e4066Sahrens if (os->os->os_dsl_dataset != NULL) 702fa9e4066Sahrens return (dsl_dataset_is_snapshot(os->os->os_dsl_dataset)); 703fa9e4066Sahrens else 704fa9e4066Sahrens return (B_FALSE); 705fa9e4066Sahrens } 706fa9e4066Sahrens 707fa9e4066Sahrens int 708fa9e4066Sahrens dmu_snapshot_list_next(objset_t *os, int namelen, char *name, 70987e5029aSahrens uint64_t *idp, uint64_t *offp) 710fa9e4066Sahrens { 711fa9e4066Sahrens dsl_dataset_t *ds = os->os->os_dsl_dataset; 712fa9e4066Sahrens zap_cursor_t cursor; 713fa9e4066Sahrens zap_attribute_t attr; 714fa9e4066Sahrens 715fa9e4066Sahrens if (ds->ds_phys->ds_snapnames_zapobj == 0) 716fa9e4066Sahrens return (ENOENT); 717fa9e4066Sahrens 718fa9e4066Sahrens zap_cursor_init_serialized(&cursor, 719fa9e4066Sahrens ds->ds_dir->dd_pool->dp_meta_objset, 720fa9e4066Sahrens ds->ds_phys->ds_snapnames_zapobj, *offp); 721fa9e4066Sahrens 72287e5029aSahrens if (zap_cursor_retrieve(&cursor, &attr) != 0) { 72387e5029aSahrens zap_cursor_fini(&cursor); 72487e5029aSahrens return (ENOENT); 72587e5029aSahrens } 72687e5029aSahrens 72787e5029aSahrens if (strlen(attr.za_name) + 1 > namelen) { 72887e5029aSahrens zap_cursor_fini(&cursor); 72987e5029aSahrens return (ENAMETOOLONG); 73087e5029aSahrens } 73187e5029aSahrens 73287e5029aSahrens (void) strcpy(name, attr.za_name); 73387e5029aSahrens if (idp) 73487e5029aSahrens *idp = attr.za_first_integer; 73587e5029aSahrens zap_cursor_advance(&cursor); 73687e5029aSahrens *offp = zap_cursor_serialize(&cursor); 73787e5029aSahrens zap_cursor_fini(&cursor); 73887e5029aSahrens 73987e5029aSahrens return (0); 74087e5029aSahrens } 74187e5029aSahrens 74287e5029aSahrens int 74387e5029aSahrens dmu_dir_list_next(objset_t *os, int namelen, char *name, 74487e5029aSahrens uint64_t *idp, uint64_t *offp) 74587e5029aSahrens { 74687e5029aSahrens dsl_dir_t *dd = os->os->os_dsl_dataset->ds_dir; 74787e5029aSahrens zap_cursor_t cursor; 74887e5029aSahrens zap_attribute_t attr; 74987e5029aSahrens 75087e5029aSahrens if (dd->dd_phys->dd_child_dir_zapobj == 0) 75187e5029aSahrens return (ENOENT); 75287e5029aSahrens 75387e5029aSahrens /* there is no next dir on a snapshot! */ 75487e5029aSahrens if (os->os->os_dsl_dataset->ds_object != 75587e5029aSahrens dd->dd_phys->dd_head_dataset_obj) 756fa9e4066Sahrens return (ENOENT); 757fa9e4066Sahrens 75887e5029aSahrens zap_cursor_init_serialized(&cursor, 75987e5029aSahrens dd->dd_pool->dp_meta_objset, 76087e5029aSahrens dd->dd_phys->dd_child_dir_zapobj, *offp); 76187e5029aSahrens 76287e5029aSahrens if (zap_cursor_retrieve(&cursor, &attr) != 0) { 76387e5029aSahrens zap_cursor_fini(&cursor); 76487e5029aSahrens return (ENOENT); 76587e5029aSahrens } 76687e5029aSahrens 76787e5029aSahrens if (strlen(attr.za_name) + 1 > namelen) { 76887e5029aSahrens zap_cursor_fini(&cursor); 769fa9e4066Sahrens return (ENAMETOOLONG); 77087e5029aSahrens } 771fa9e4066Sahrens 772fa9e4066Sahrens (void) strcpy(name, attr.za_name); 77387e5029aSahrens if (idp) 77487e5029aSahrens *idp = attr.za_first_integer; 775fa9e4066Sahrens zap_cursor_advance(&cursor); 776fa9e4066Sahrens *offp = zap_cursor_serialize(&cursor); 77787e5029aSahrens zap_cursor_fini(&cursor); 778fa9e4066Sahrens 779fa9e4066Sahrens return (0); 780fa9e4066Sahrens } 781fa9e4066Sahrens 782fa9e4066Sahrens /* 783fa9e4066Sahrens * Find all objsets under name, and for each, call 'func(child_name, arg)'. 784fa9e4066Sahrens */ 785fa9e4066Sahrens void 786fa9e4066Sahrens dmu_objset_find(char *name, void func(char *, void *), void *arg, int flags) 787fa9e4066Sahrens { 788fa9e4066Sahrens dsl_dir_t *dd; 789fa9e4066Sahrens objset_t *os; 790fa9e4066Sahrens uint64_t snapobj; 791fa9e4066Sahrens zap_cursor_t zc; 792fa9e4066Sahrens zap_attribute_t attr; 793fa9e4066Sahrens char *child; 794*ea8dc4b6Seschrock int do_self, err; 795fa9e4066Sahrens 796*ea8dc4b6Seschrock err = dsl_dir_open(name, FTAG, &dd, NULL); 797*ea8dc4b6Seschrock if (err) 798fa9e4066Sahrens return; 799fa9e4066Sahrens 800fa9e4066Sahrens do_self = (dd->dd_phys->dd_head_dataset_obj != 0); 801fa9e4066Sahrens 802fa9e4066Sahrens /* 803fa9e4066Sahrens * Iterate over all children. 804fa9e4066Sahrens */ 805fa9e4066Sahrens if (dd->dd_phys->dd_child_dir_zapobj != 0) { 806fa9e4066Sahrens for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset, 807fa9e4066Sahrens dd->dd_phys->dd_child_dir_zapobj); 808fa9e4066Sahrens zap_cursor_retrieve(&zc, &attr) == 0; 809fa9e4066Sahrens (void) zap_cursor_advance(&zc)) { 810fa9e4066Sahrens ASSERT(attr.za_integer_length == sizeof (uint64_t)); 811fa9e4066Sahrens ASSERT(attr.za_num_integers == 1); 812fa9e4066Sahrens 813fa9e4066Sahrens /* 814fa9e4066Sahrens * No separating '/' because parent's name ends in /. 815fa9e4066Sahrens */ 816fa9e4066Sahrens child = kmem_alloc(MAXPATHLEN, KM_SLEEP); 817fa9e4066Sahrens /* XXX could probably just use name here */ 818fa9e4066Sahrens dsl_dir_name(dd, child); 819fa9e4066Sahrens (void) strcat(child, "/"); 820fa9e4066Sahrens (void) strcat(child, attr.za_name); 821fa9e4066Sahrens dmu_objset_find(child, func, arg, flags); 822fa9e4066Sahrens kmem_free(child, MAXPATHLEN); 823fa9e4066Sahrens } 82487e5029aSahrens zap_cursor_fini(&zc); 825fa9e4066Sahrens } 826fa9e4066Sahrens 827fa9e4066Sahrens /* 828fa9e4066Sahrens * Iterate over all snapshots. 829fa9e4066Sahrens */ 830fa9e4066Sahrens if ((flags & DS_FIND_SNAPSHOTS) && 831fa9e4066Sahrens dmu_objset_open(name, DMU_OST_ANY, 832fa9e4066Sahrens DS_MODE_STANDARD | DS_MODE_READONLY, &os) == 0) { 833fa9e4066Sahrens 834fa9e4066Sahrens snapobj = os->os->os_dsl_dataset->ds_phys->ds_snapnames_zapobj; 835fa9e4066Sahrens dmu_objset_close(os); 836fa9e4066Sahrens 837fa9e4066Sahrens for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset, snapobj); 838fa9e4066Sahrens zap_cursor_retrieve(&zc, &attr) == 0; 839fa9e4066Sahrens (void) zap_cursor_advance(&zc)) { 840fa9e4066Sahrens ASSERT(attr.za_integer_length == sizeof (uint64_t)); 841fa9e4066Sahrens ASSERT(attr.za_num_integers == 1); 842fa9e4066Sahrens 843fa9e4066Sahrens child = kmem_alloc(MAXPATHLEN, KM_SLEEP); 844fa9e4066Sahrens /* XXX could probably just use name here */ 845fa9e4066Sahrens dsl_dir_name(dd, child); 846fa9e4066Sahrens (void) strcat(child, "@"); 847fa9e4066Sahrens (void) strcat(child, attr.za_name); 848fa9e4066Sahrens func(child, arg); 849fa9e4066Sahrens kmem_free(child, MAXPATHLEN); 850fa9e4066Sahrens } 85187e5029aSahrens zap_cursor_fini(&zc); 852fa9e4066Sahrens } 853fa9e4066Sahrens 854fa9e4066Sahrens dsl_dir_close(dd, FTAG); 855fa9e4066Sahrens 856fa9e4066Sahrens /* 857fa9e4066Sahrens * Apply to self if appropriate. 858fa9e4066Sahrens */ 859fa9e4066Sahrens if (do_self) 860fa9e4066Sahrens func(name, arg); 861fa9e4066Sahrens } 862