1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6ea8dc4b6Seschrock * 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 /* 22ea8dc4b6Seschrock * 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> 341d452cf5Sahrens #include <sys/dsl_synctask.h> 35fa9e4066Sahrens #include <sys/dnode.h> 36fa9e4066Sahrens #include <sys/dbuf.h> 37*a2eea2e1Sahrens #include <sys/zvol.h> 38fa9e4066Sahrens #include <sys/dmu_tx.h> 39fa9e4066Sahrens #include <sys/zio_checksum.h> 40fa9e4066Sahrens #include <sys/zap.h> 41fa9e4066Sahrens #include <sys/zil.h> 42fa9e4066Sahrens #include <sys/dmu_impl.h> 43fa9e4066Sahrens 44fa9e4066Sahrens 45fa9e4066Sahrens spa_t * 46fa9e4066Sahrens dmu_objset_spa(objset_t *os) 47fa9e4066Sahrens { 48fa9e4066Sahrens return (os->os->os_spa); 49fa9e4066Sahrens } 50fa9e4066Sahrens 51fa9e4066Sahrens zilog_t * 52fa9e4066Sahrens dmu_objset_zil(objset_t *os) 53fa9e4066Sahrens { 54fa9e4066Sahrens return (os->os->os_zil); 55fa9e4066Sahrens } 56fa9e4066Sahrens 57fa9e4066Sahrens dsl_pool_t * 58fa9e4066Sahrens dmu_objset_pool(objset_t *os) 59fa9e4066Sahrens { 60fa9e4066Sahrens dsl_dataset_t *ds; 61fa9e4066Sahrens 62fa9e4066Sahrens if ((ds = os->os->os_dsl_dataset) != NULL && ds->ds_dir) 63fa9e4066Sahrens return (ds->ds_dir->dd_pool); 64fa9e4066Sahrens else 65fa9e4066Sahrens return (spa_get_dsl(os->os->os_spa)); 66fa9e4066Sahrens } 67fa9e4066Sahrens 68fa9e4066Sahrens dsl_dataset_t * 69fa9e4066Sahrens dmu_objset_ds(objset_t *os) 70fa9e4066Sahrens { 71fa9e4066Sahrens return (os->os->os_dsl_dataset); 72fa9e4066Sahrens } 73fa9e4066Sahrens 74fa9e4066Sahrens dmu_objset_type_t 75fa9e4066Sahrens dmu_objset_type(objset_t *os) 76fa9e4066Sahrens { 77fa9e4066Sahrens return (os->os->os_phys->os_type); 78fa9e4066Sahrens } 79fa9e4066Sahrens 80fa9e4066Sahrens void 81fa9e4066Sahrens dmu_objset_name(objset_t *os, char *buf) 82fa9e4066Sahrens { 83fa9e4066Sahrens dsl_dataset_name(os->os->os_dsl_dataset, buf); 84fa9e4066Sahrens } 85fa9e4066Sahrens 86fa9e4066Sahrens uint64_t 87fa9e4066Sahrens dmu_objset_id(objset_t *os) 88fa9e4066Sahrens { 89fa9e4066Sahrens dsl_dataset_t *ds = os->os->os_dsl_dataset; 90fa9e4066Sahrens 91fa9e4066Sahrens return (ds ? ds->ds_object : 0); 92fa9e4066Sahrens } 93fa9e4066Sahrens 94fa9e4066Sahrens static void 95fa9e4066Sahrens checksum_changed_cb(void *arg, uint64_t newval) 96fa9e4066Sahrens { 97fa9e4066Sahrens objset_impl_t *osi = arg; 98fa9e4066Sahrens 99fa9e4066Sahrens /* 100fa9e4066Sahrens * Inheritance should have been done by now. 101fa9e4066Sahrens */ 102fa9e4066Sahrens ASSERT(newval != ZIO_CHECKSUM_INHERIT); 103fa9e4066Sahrens 104fa9e4066Sahrens osi->os_checksum = zio_checksum_select(newval, ZIO_CHECKSUM_ON_VALUE); 105fa9e4066Sahrens } 106fa9e4066Sahrens 107fa9e4066Sahrens static void 108fa9e4066Sahrens compression_changed_cb(void *arg, uint64_t newval) 109fa9e4066Sahrens { 110fa9e4066Sahrens objset_impl_t *osi = arg; 111fa9e4066Sahrens 112fa9e4066Sahrens /* 113fa9e4066Sahrens * Inheritance and range checking should have been done by now. 114fa9e4066Sahrens */ 115fa9e4066Sahrens ASSERT(newval != ZIO_COMPRESS_INHERIT); 116fa9e4066Sahrens 117fa9e4066Sahrens osi->os_compress = zio_compress_select(newval, ZIO_COMPRESS_ON_VALUE); 118fa9e4066Sahrens } 119fa9e4066Sahrens 120fa9e4066Sahrens void 121fa9e4066Sahrens dmu_objset_byteswap(void *buf, size_t size) 122fa9e4066Sahrens { 123fa9e4066Sahrens objset_phys_t *osp = buf; 124fa9e4066Sahrens 125fa9e4066Sahrens ASSERT(size == sizeof (objset_phys_t)); 126fa9e4066Sahrens dnode_byteswap(&osp->os_meta_dnode); 127fa9e4066Sahrens byteswap_uint64_array(&osp->os_zil_header, sizeof (zil_header_t)); 128fa9e4066Sahrens osp->os_type = BSWAP_64(osp->os_type); 129fa9e4066Sahrens } 130fa9e4066Sahrens 131ea8dc4b6Seschrock int 132ea8dc4b6Seschrock dmu_objset_open_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp, 133ea8dc4b6Seschrock objset_impl_t **osip) 134fa9e4066Sahrens { 135fa9e4066Sahrens objset_impl_t *winner, *osi; 136fa9e4066Sahrens int i, err, checksum; 137fa9e4066Sahrens 138fa9e4066Sahrens osi = kmem_zalloc(sizeof (objset_impl_t), KM_SLEEP); 139fa9e4066Sahrens osi->os.os = osi; 140fa9e4066Sahrens osi->os_dsl_dataset = ds; 141fa9e4066Sahrens osi->os_spa = spa; 142fa9e4066Sahrens if (bp) 143fa9e4066Sahrens osi->os_rootbp = *bp; 144fa9e4066Sahrens osi->os_phys = zio_buf_alloc(sizeof (objset_phys_t)); 145fa9e4066Sahrens if (!BP_IS_HOLE(&osi->os_rootbp)) { 14613506d1eSmaybee uint32_t aflags = ARC_WAIT; 147ea8dc4b6Seschrock zbookmark_t zb; 148ea8dc4b6Seschrock zb.zb_objset = ds ? ds->ds_object : 0; 149ea8dc4b6Seschrock zb.zb_object = 0; 150ea8dc4b6Seschrock zb.zb_level = -1; 151ea8dc4b6Seschrock zb.zb_blkid = 0; 152ea8dc4b6Seschrock 153fa9e4066Sahrens dprintf_bp(&osi->os_rootbp, "reading %s", ""); 154ea8dc4b6Seschrock err = arc_read(NULL, spa, &osi->os_rootbp, 155fa9e4066Sahrens dmu_ot[DMU_OT_OBJSET].ot_byteswap, 156fa9e4066Sahrens arc_bcopy_func, osi->os_phys, 15713506d1eSmaybee ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_CANFAIL, &aflags, &zb); 158ea8dc4b6Seschrock if (err) { 159ea8dc4b6Seschrock zio_buf_free(osi->os_phys, sizeof (objset_phys_t)); 160ea8dc4b6Seschrock kmem_free(osi, sizeof (objset_impl_t)); 161ea8dc4b6Seschrock return (err); 162ea8dc4b6Seschrock } 163fa9e4066Sahrens } else { 164fa9e4066Sahrens bzero(osi->os_phys, sizeof (objset_phys_t)); 165fa9e4066Sahrens } 166fa9e4066Sahrens 167fa9e4066Sahrens /* 168fa9e4066Sahrens * Note: the changed_cb will be called once before the register 169fa9e4066Sahrens * func returns, thus changing the checksum/compression from the 17099653d4eSeschrock * default (fletcher2/off). Snapshots don't need to know, and 17199653d4eSeschrock * registering would complicate clone promotion. 172fa9e4066Sahrens */ 17399653d4eSeschrock if (ds && ds->ds_phys->ds_num_children == 0) { 174fa9e4066Sahrens err = dsl_prop_register(ds, "checksum", 175fa9e4066Sahrens checksum_changed_cb, osi); 176ea8dc4b6Seschrock if (err == 0) 177ea8dc4b6Seschrock err = dsl_prop_register(ds, "compression", 178ea8dc4b6Seschrock compression_changed_cb, osi); 179ea8dc4b6Seschrock if (err) { 180ea8dc4b6Seschrock zio_buf_free(osi->os_phys, sizeof (objset_phys_t)); 181ea8dc4b6Seschrock kmem_free(osi, sizeof (objset_impl_t)); 182ea8dc4b6Seschrock return (err); 183ea8dc4b6Seschrock } 18499653d4eSeschrock } else if (ds == NULL) { 185fa9e4066Sahrens /* It's the meta-objset. */ 186fa9e4066Sahrens osi->os_checksum = ZIO_CHECKSUM_FLETCHER_4; 187ea8dc4b6Seschrock osi->os_compress = ZIO_COMPRESS_LZJB; 188fa9e4066Sahrens } 189fa9e4066Sahrens 190ea8dc4b6Seschrock osi->os_zil = zil_alloc(&osi->os, &osi->os_phys->os_zil_header); 191ea8dc4b6Seschrock 192fa9e4066Sahrens /* 193fa9e4066Sahrens * Metadata always gets compressed and checksummed. 194fa9e4066Sahrens * If the data checksum is multi-bit correctable, and it's not 195fa9e4066Sahrens * a ZBT-style checksum, then it's suitable for metadata as well. 196fa9e4066Sahrens * Otherwise, the metadata checksum defaults to fletcher4. 197fa9e4066Sahrens */ 198fa9e4066Sahrens checksum = osi->os_checksum; 199fa9e4066Sahrens 200fa9e4066Sahrens if (zio_checksum_table[checksum].ci_correctable && 201fa9e4066Sahrens !zio_checksum_table[checksum].ci_zbt) 202fa9e4066Sahrens osi->os_md_checksum = checksum; 203fa9e4066Sahrens else 204fa9e4066Sahrens osi->os_md_checksum = ZIO_CHECKSUM_FLETCHER_4; 205ea8dc4b6Seschrock osi->os_md_compress = ZIO_COMPRESS_LZJB; 206fa9e4066Sahrens 207fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++) { 208fa9e4066Sahrens list_create(&osi->os_dirty_dnodes[i], sizeof (dnode_t), 209fa9e4066Sahrens offsetof(dnode_t, dn_dirty_link[i])); 210fa9e4066Sahrens list_create(&osi->os_free_dnodes[i], sizeof (dnode_t), 211fa9e4066Sahrens offsetof(dnode_t, dn_dirty_link[i])); 212fa9e4066Sahrens } 213fa9e4066Sahrens list_create(&osi->os_dnodes, sizeof (dnode_t), 214fa9e4066Sahrens offsetof(dnode_t, dn_link)); 215fa9e4066Sahrens list_create(&osi->os_downgraded_dbufs, sizeof (dmu_buf_impl_t), 216fa9e4066Sahrens offsetof(dmu_buf_impl_t, db_link)); 217fa9e4066Sahrens 2185ad82045Snd mutex_init(&osi->os_lock, NULL, MUTEX_DEFAULT, NULL); 2195ad82045Snd mutex_init(&osi->os_obj_lock, NULL, MUTEX_DEFAULT, NULL); 2205ad82045Snd 221fa9e4066Sahrens osi->os_meta_dnode = dnode_special_open(osi, 222fa9e4066Sahrens &osi->os_phys->os_meta_dnode, DMU_META_DNODE_OBJECT); 223fa9e4066Sahrens 224fa9e4066Sahrens if (ds != NULL) { 225fa9e4066Sahrens winner = dsl_dataset_set_user_ptr(ds, osi, dmu_objset_evict); 226fa9e4066Sahrens if (winner) { 227fa9e4066Sahrens dmu_objset_evict(ds, osi); 228fa9e4066Sahrens osi = winner; 229fa9e4066Sahrens } 230fa9e4066Sahrens } 231fa9e4066Sahrens 232ea8dc4b6Seschrock *osip = osi; 233ea8dc4b6Seschrock return (0); 234fa9e4066Sahrens } 235fa9e4066Sahrens 236fa9e4066Sahrens /* called from zpl */ 237fa9e4066Sahrens int 238fa9e4066Sahrens dmu_objset_open(const char *name, dmu_objset_type_t type, int mode, 239fa9e4066Sahrens objset_t **osp) 240fa9e4066Sahrens { 241fa9e4066Sahrens dsl_dataset_t *ds; 242fa9e4066Sahrens int err; 243fa9e4066Sahrens objset_t *os; 244fa9e4066Sahrens objset_impl_t *osi; 245fa9e4066Sahrens 246fa9e4066Sahrens os = kmem_alloc(sizeof (objset_t), KM_SLEEP); 247fa9e4066Sahrens err = dsl_dataset_open(name, mode, os, &ds); 248fa9e4066Sahrens if (err) { 249fa9e4066Sahrens kmem_free(os, sizeof (objset_t)); 250fa9e4066Sahrens return (err); 251fa9e4066Sahrens } 252fa9e4066Sahrens 253fa9e4066Sahrens osi = dsl_dataset_get_user_ptr(ds); 254fa9e4066Sahrens if (osi == NULL) { 255fa9e4066Sahrens blkptr_t bp; 256fa9e4066Sahrens 257fa9e4066Sahrens dsl_dataset_get_blkptr(ds, &bp); 258ea8dc4b6Seschrock err = dmu_objset_open_impl(dsl_dataset_get_spa(ds), 259ea8dc4b6Seschrock ds, &bp, &osi); 260ea8dc4b6Seschrock if (err) { 261ea8dc4b6Seschrock dsl_dataset_close(ds, mode, os); 262ea8dc4b6Seschrock kmem_free(os, sizeof (objset_t)); 263ea8dc4b6Seschrock return (err); 264ea8dc4b6Seschrock } 265fa9e4066Sahrens } 266fa9e4066Sahrens 267fa9e4066Sahrens os->os = osi; 268fa9e4066Sahrens os->os_mode = mode; 269fa9e4066Sahrens 270fa9e4066Sahrens if (type != DMU_OST_ANY && type != os->os->os_phys->os_type) { 271fa9e4066Sahrens dmu_objset_close(os); 272fa9e4066Sahrens return (EINVAL); 273fa9e4066Sahrens } 274fa9e4066Sahrens *osp = os; 275fa9e4066Sahrens return (0); 276fa9e4066Sahrens } 277fa9e4066Sahrens 278fa9e4066Sahrens void 279fa9e4066Sahrens dmu_objset_close(objset_t *os) 280fa9e4066Sahrens { 281fa9e4066Sahrens dsl_dataset_close(os->os->os_dsl_dataset, os->os_mode, os); 282fa9e4066Sahrens kmem_free(os, sizeof (objset_t)); 283fa9e4066Sahrens } 284fa9e4066Sahrens 285436b2950Sperrin int 286436b2950Sperrin dmu_objset_evict_dbufs(objset_t *os, int try) 287ea8dc4b6Seschrock { 288ea8dc4b6Seschrock objset_impl_t *osi = os->os; 289ea8dc4b6Seschrock dnode_t *dn; 290c543ec06Sahrens 291c543ec06Sahrens mutex_enter(&osi->os_lock); 292c543ec06Sahrens 293c543ec06Sahrens /* process the mdn last, since the other dnodes have holds on it */ 294c543ec06Sahrens list_remove(&osi->os_dnodes, osi->os_meta_dnode); 295c543ec06Sahrens list_insert_tail(&osi->os_dnodes, osi->os_meta_dnode); 296ea8dc4b6Seschrock 297ea8dc4b6Seschrock /* 298c543ec06Sahrens * Find the first dnode with holds. We have to do this dance 299c543ec06Sahrens * because dnode_add_ref() only works if you already have a 300c543ec06Sahrens * hold. If there are no holds then it has no dbufs so OK to 301c543ec06Sahrens * skip. 302ea8dc4b6Seschrock */ 303c543ec06Sahrens for (dn = list_head(&osi->os_dnodes); 304c543ec06Sahrens dn && refcount_is_zero(&dn->dn_holds); 305c543ec06Sahrens dn = list_next(&osi->os_dnodes, dn)) 306c543ec06Sahrens continue; 307c543ec06Sahrens if (dn) 308c543ec06Sahrens dnode_add_ref(dn, FTAG); 309c543ec06Sahrens 310c543ec06Sahrens while (dn) { 311c543ec06Sahrens dnode_t *next_dn = dn; 312c543ec06Sahrens 313c543ec06Sahrens do { 314c543ec06Sahrens next_dn = list_next(&osi->os_dnodes, next_dn); 315c543ec06Sahrens } while (next_dn && refcount_is_zero(&next_dn->dn_holds)); 316c543ec06Sahrens if (next_dn) 317c543ec06Sahrens dnode_add_ref(next_dn, FTAG); 318c543ec06Sahrens 319c543ec06Sahrens mutex_exit(&osi->os_lock); 320436b2950Sperrin if (dnode_evict_dbufs(dn, try)) { 321436b2950Sperrin dnode_rele(dn, FTAG); 322436b2950Sperrin if (next_dn) 323436b2950Sperrin dnode_rele(next_dn, FTAG); 324436b2950Sperrin return (1); 325436b2950Sperrin } 326c543ec06Sahrens dnode_rele(dn, FTAG); 327c543ec06Sahrens mutex_enter(&osi->os_lock); 328c543ec06Sahrens dn = next_dn; 329ea8dc4b6Seschrock } 330ea8dc4b6Seschrock mutex_exit(&osi->os_lock); 331436b2950Sperrin return (0); 332ea8dc4b6Seschrock } 333ea8dc4b6Seschrock 334fa9e4066Sahrens void 335fa9e4066Sahrens dmu_objset_evict(dsl_dataset_t *ds, void *arg) 336fa9e4066Sahrens { 337fa9e4066Sahrens objset_impl_t *osi = arg; 338ea8dc4b6Seschrock objset_t os; 33999653d4eSeschrock int i; 340fa9e4066Sahrens 341fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++) { 342fa9e4066Sahrens ASSERT(list_head(&osi->os_dirty_dnodes[i]) == NULL); 343fa9e4066Sahrens ASSERT(list_head(&osi->os_free_dnodes[i]) == NULL); 344fa9e4066Sahrens } 345fa9e4066Sahrens 34699653d4eSeschrock if (ds && ds->ds_phys->ds_num_children == 0) { 34799653d4eSeschrock VERIFY(0 == dsl_prop_unregister(ds, "checksum", 34899653d4eSeschrock checksum_changed_cb, osi)); 34999653d4eSeschrock VERIFY(0 == dsl_prop_unregister(ds, "compression", 35099653d4eSeschrock compression_changed_cb, osi)); 351fa9e4066Sahrens } 352fa9e4066Sahrens 353ea8dc4b6Seschrock /* 354ea8dc4b6Seschrock * We should need only a single pass over the dnode list, since 355ea8dc4b6Seschrock * nothing can be added to the list at this point. 356ea8dc4b6Seschrock */ 357ea8dc4b6Seschrock os.os = osi; 358436b2950Sperrin (void) dmu_objset_evict_dbufs(&os, 0); 359ea8dc4b6Seschrock 360fa9e4066Sahrens ASSERT3P(list_head(&osi->os_dnodes), ==, osi->os_meta_dnode); 361fa9e4066Sahrens ASSERT3P(list_tail(&osi->os_dnodes), ==, osi->os_meta_dnode); 362fa9e4066Sahrens ASSERT3P(list_head(&osi->os_meta_dnode->dn_dbufs), ==, NULL); 363fa9e4066Sahrens 364fa9e4066Sahrens dnode_special_close(osi->os_meta_dnode); 365fa9e4066Sahrens zil_free(osi->os_zil); 366fa9e4066Sahrens 367fa9e4066Sahrens zio_buf_free(osi->os_phys, sizeof (objset_phys_t)); 3685ad82045Snd mutex_destroy(&osi->os_lock); 3695ad82045Snd mutex_destroy(&osi->os_obj_lock); 370fa9e4066Sahrens kmem_free(osi, sizeof (objset_impl_t)); 371fa9e4066Sahrens } 372fa9e4066Sahrens 373fa9e4066Sahrens /* called from dsl for meta-objset */ 374fa9e4066Sahrens objset_impl_t * 375fa9e4066Sahrens dmu_objset_create_impl(spa_t *spa, dsl_dataset_t *ds, dmu_objset_type_t type, 376fa9e4066Sahrens dmu_tx_t *tx) 377fa9e4066Sahrens { 378fa9e4066Sahrens objset_impl_t *osi; 379fa9e4066Sahrens dnode_t *mdn; 380fa9e4066Sahrens 381fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 382ea8dc4b6Seschrock VERIFY(0 == dmu_objset_open_impl(spa, ds, NULL, &osi)); 383fa9e4066Sahrens mdn = osi->os_meta_dnode; 384fa9e4066Sahrens 385fa9e4066Sahrens dnode_allocate(mdn, DMU_OT_DNODE, 1 << DNODE_BLOCK_SHIFT, 386fa9e4066Sahrens DN_MAX_INDBLKSHIFT, DMU_OT_NONE, 0, tx); 387fa9e4066Sahrens 388fa9e4066Sahrens /* 389fa9e4066Sahrens * We don't want to have to increase the meta-dnode's nlevels 390fa9e4066Sahrens * later, because then we could do it in quescing context while 391fa9e4066Sahrens * we are also accessing it in open context. 392fa9e4066Sahrens * 393fa9e4066Sahrens * This precaution is not necessary for the MOS (ds == NULL), 394fa9e4066Sahrens * because the MOS is only updated in syncing context. 395fa9e4066Sahrens * This is most fortunate: the MOS is the only objset that 396fa9e4066Sahrens * needs to be synced multiple times as spa_sync() iterates 397fa9e4066Sahrens * to convergence, so minimizing its dn_nlevels matters. 398fa9e4066Sahrens */ 399ea8dc4b6Seschrock if (ds != NULL) { 400ea8dc4b6Seschrock int levels = 1; 401ea8dc4b6Seschrock 402ea8dc4b6Seschrock /* 403ea8dc4b6Seschrock * Determine the number of levels necessary for the meta-dnode 404ea8dc4b6Seschrock * to contain DN_MAX_OBJECT dnodes. 405ea8dc4b6Seschrock */ 406ea8dc4b6Seschrock while ((uint64_t)mdn->dn_nblkptr << (mdn->dn_datablkshift + 407ea8dc4b6Seschrock (levels - 1) * (mdn->dn_indblkshift - SPA_BLKPTRSHIFT)) < 408ea8dc4b6Seschrock DN_MAX_OBJECT * sizeof (dnode_phys_t)) 409ea8dc4b6Seschrock levels++; 410ea8dc4b6Seschrock 411fa9e4066Sahrens mdn->dn_next_nlevels[tx->tx_txg & TXG_MASK] = 412ea8dc4b6Seschrock mdn->dn_nlevels = levels; 413ea8dc4b6Seschrock } 414fa9e4066Sahrens 415fa9e4066Sahrens ASSERT(type != DMU_OST_NONE); 416fa9e4066Sahrens ASSERT(type != DMU_OST_ANY); 417fa9e4066Sahrens ASSERT(type < DMU_OST_NUMTYPES); 418fa9e4066Sahrens osi->os_phys->os_type = type; 419fa9e4066Sahrens 420fa9e4066Sahrens dsl_dataset_dirty(ds, tx); 421fa9e4066Sahrens 422fa9e4066Sahrens return (osi); 423fa9e4066Sahrens } 424fa9e4066Sahrens 425fa9e4066Sahrens struct oscarg { 426fa9e4066Sahrens void (*userfunc)(objset_t *os, void *arg, dmu_tx_t *tx); 427fa9e4066Sahrens void *userarg; 428fa9e4066Sahrens dsl_dataset_t *clone_parent; 429fa9e4066Sahrens const char *lastname; 430fa9e4066Sahrens dmu_objset_type_t type; 431fa9e4066Sahrens }; 432fa9e4066Sahrens 4331d452cf5Sahrens /* ARGSUSED */ 434fa9e4066Sahrens static int 4351d452cf5Sahrens dmu_objset_create_check(void *arg1, void *arg2, dmu_tx_t *tx) 436fa9e4066Sahrens { 4371d452cf5Sahrens dsl_dir_t *dd = arg1; 4381d452cf5Sahrens struct oscarg *oa = arg2; 4391d452cf5Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 440fa9e4066Sahrens int err; 4411d452cf5Sahrens uint64_t ddobj; 4421d452cf5Sahrens 4431d452cf5Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 4441d452cf5Sahrens oa->lastname, sizeof (uint64_t), 1, &ddobj); 4451d452cf5Sahrens if (err != ENOENT) 4461d452cf5Sahrens return (err ? err : EEXIST); 4471d452cf5Sahrens 4481d452cf5Sahrens if (oa->clone_parent != NULL) { 4491d452cf5Sahrens /* 4501d452cf5Sahrens * You can't clone across pools. 4511d452cf5Sahrens */ 4521d452cf5Sahrens if (oa->clone_parent->ds_dir->dd_pool != dd->dd_pool) 4531d452cf5Sahrens return (EXDEV); 4541d452cf5Sahrens 4551d452cf5Sahrens /* 4561d452cf5Sahrens * You can only clone snapshots, not the head datasets. 4571d452cf5Sahrens */ 4581d452cf5Sahrens if (oa->clone_parent->ds_phys->ds_num_children == 0) 4591d452cf5Sahrens return (EINVAL); 4601d452cf5Sahrens } 4611d452cf5Sahrens return (0); 4621d452cf5Sahrens } 4631d452cf5Sahrens 4641d452cf5Sahrens static void 4651d452cf5Sahrens dmu_objset_create_sync(void *arg1, void *arg2, dmu_tx_t *tx) 4661d452cf5Sahrens { 4671d452cf5Sahrens dsl_dir_t *dd = arg1; 4681d452cf5Sahrens struct oscarg *oa = arg2; 4691d452cf5Sahrens dsl_dataset_t *ds; 470fa9e4066Sahrens blkptr_t bp; 4711d452cf5Sahrens uint64_t dsobj; 472fa9e4066Sahrens 473fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 474fa9e4066Sahrens 4751d452cf5Sahrens dsobj = dsl_dataset_create_sync(dd, oa->lastname, 476fa9e4066Sahrens oa->clone_parent, tx); 477fa9e4066Sahrens 4781d452cf5Sahrens VERIFY(0 == dsl_dataset_open_obj(dd->dd_pool, dsobj, NULL, 479ea8dc4b6Seschrock DS_MODE_STANDARD | DS_MODE_READONLY, FTAG, &ds)); 480fa9e4066Sahrens dsl_dataset_get_blkptr(ds, &bp); 481fa9e4066Sahrens if (BP_IS_HOLE(&bp)) { 482fa9e4066Sahrens objset_impl_t *osi; 483fa9e4066Sahrens 484fa9e4066Sahrens /* This is an empty dmu_objset; not a clone. */ 485fa9e4066Sahrens osi = dmu_objset_create_impl(dsl_dataset_get_spa(ds), 486fa9e4066Sahrens ds, oa->type, tx); 487fa9e4066Sahrens 488fa9e4066Sahrens if (oa->userfunc) 489fa9e4066Sahrens oa->userfunc(&osi->os, oa->userarg, tx); 490fa9e4066Sahrens } 491fa9e4066Sahrens dsl_dataset_close(ds, DS_MODE_STANDARD | DS_MODE_READONLY, FTAG); 492fa9e4066Sahrens } 493fa9e4066Sahrens 494fa9e4066Sahrens int 495fa9e4066Sahrens dmu_objset_create(const char *name, dmu_objset_type_t type, 496fa9e4066Sahrens objset_t *clone_parent, 497fa9e4066Sahrens void (*func)(objset_t *os, void *arg, dmu_tx_t *tx), void *arg) 498fa9e4066Sahrens { 4991d452cf5Sahrens dsl_dir_t *pdd; 500fa9e4066Sahrens const char *tail; 501fa9e4066Sahrens int err = 0; 5021d452cf5Sahrens struct oscarg oa = { 0 }; 503fa9e4066Sahrens 5041d452cf5Sahrens ASSERT(strchr(name, '@') == NULL); 5051d452cf5Sahrens err = dsl_dir_open(name, FTAG, &pdd, &tail); 506ea8dc4b6Seschrock if (err) 507ea8dc4b6Seschrock return (err); 508fa9e4066Sahrens if (tail == NULL) { 5091d452cf5Sahrens dsl_dir_close(pdd, FTAG); 510fa9e4066Sahrens return (EEXIST); 511fa9e4066Sahrens } 512fa9e4066Sahrens 513fa9e4066Sahrens dprintf("name=%s\n", name); 514fa9e4066Sahrens 5151d452cf5Sahrens oa.userfunc = func; 5161d452cf5Sahrens oa.userarg = arg; 5171d452cf5Sahrens oa.lastname = tail; 5181d452cf5Sahrens oa.type = type; 5191d452cf5Sahrens if (clone_parent != NULL) { 520fa9e4066Sahrens /* 5211d452cf5Sahrens * You can't clone to a different type. 522fa9e4066Sahrens */ 5231d452cf5Sahrens if (clone_parent->os->os_phys->os_type != type) { 5241d452cf5Sahrens dsl_dir_close(pdd, FTAG); 5251d452cf5Sahrens return (EINVAL); 526fa9e4066Sahrens } 5271d452cf5Sahrens oa.clone_parent = clone_parent->os->os_dsl_dataset; 528fa9e4066Sahrens } 5291d452cf5Sahrens err = dsl_sync_task_do(pdd->dd_pool, dmu_objset_create_check, 5301d452cf5Sahrens dmu_objset_create_sync, pdd, &oa, 5); 5311d452cf5Sahrens dsl_dir_close(pdd, FTAG); 532fa9e4066Sahrens return (err); 533fa9e4066Sahrens } 534fa9e4066Sahrens 535fa9e4066Sahrens int 536fa9e4066Sahrens dmu_objset_destroy(const char *name) 537fa9e4066Sahrens { 538fa9e4066Sahrens objset_t *os; 539fa9e4066Sahrens int error; 540fa9e4066Sahrens 541fa9e4066Sahrens /* 542fa9e4066Sahrens * If it looks like we'll be able to destroy it, and there's 543fa9e4066Sahrens * an unplayed replay log sitting around, destroy the log. 544fa9e4066Sahrens * It would be nicer to do this in dsl_dataset_destroy_sync(), 545fa9e4066Sahrens * but the replay log objset is modified in open context. 546fa9e4066Sahrens */ 547fa9e4066Sahrens error = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_EXCLUSIVE, &os); 548fa9e4066Sahrens if (error == 0) { 549d80c45e0Sbonwick zil_destroy(dmu_objset_zil(os), B_FALSE); 550fa9e4066Sahrens dmu_objset_close(os); 551fa9e4066Sahrens } 552fa9e4066Sahrens 553fa9e4066Sahrens return (dsl_dataset_destroy(name)); 554fa9e4066Sahrens } 555fa9e4066Sahrens 556fa9e4066Sahrens int 557fa9e4066Sahrens dmu_objset_rollback(const char *name) 558fa9e4066Sahrens { 559fa9e4066Sahrens int err; 560fa9e4066Sahrens objset_t *os; 561fa9e4066Sahrens 5621d452cf5Sahrens err = dmu_objset_open(name, DMU_OST_ANY, 5631d452cf5Sahrens DS_MODE_EXCLUSIVE | DS_MODE_INCONSISTENT, &os); 564fa9e4066Sahrens if (err == 0) { 565fa9e4066Sahrens err = zil_suspend(dmu_objset_zil(os)); 566fa9e4066Sahrens if (err == 0) 567fa9e4066Sahrens zil_resume(dmu_objset_zil(os)); 568fa9e4066Sahrens if (err == 0) { 569fa9e4066Sahrens /* XXX uncache everything? */ 5701d452cf5Sahrens err = dsl_dataset_rollback(os->os->os_dsl_dataset); 571fa9e4066Sahrens } 5721d452cf5Sahrens dmu_objset_close(os); 573fa9e4066Sahrens } 574fa9e4066Sahrens return (err); 575fa9e4066Sahrens } 576fa9e4066Sahrens 5771d452cf5Sahrens struct snaparg { 5781d452cf5Sahrens dsl_sync_task_group_t *dstg; 5791d452cf5Sahrens char *snapname; 5801d452cf5Sahrens char failed[MAXPATHLEN]; 5811d452cf5Sahrens }; 5821d452cf5Sahrens 5831d452cf5Sahrens static int 5841d452cf5Sahrens dmu_objset_snapshot_one(char *name, void *arg) 5851d452cf5Sahrens { 5861d452cf5Sahrens struct snaparg *sn = arg; 5871d452cf5Sahrens objset_t *os; 5881d452cf5Sahrens int err; 5891d452cf5Sahrens 5901d452cf5Sahrens (void) strcpy(sn->failed, name); 5911d452cf5Sahrens 5921d452cf5Sahrens err = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_STANDARD, &os); 5931d452cf5Sahrens if (err != 0) 5941d452cf5Sahrens return (err); 5951d452cf5Sahrens 5961d452cf5Sahrens /* 5971d452cf5Sahrens * NB: we need to wait for all in-flight changes to get to disk, 5981d452cf5Sahrens * so that we snapshot those changes. zil_suspend does this as 5991d452cf5Sahrens * a side effect. 6001d452cf5Sahrens */ 6011d452cf5Sahrens err = zil_suspend(dmu_objset_zil(os)); 6021d452cf5Sahrens if (err == 0) { 6031d452cf5Sahrens dsl_sync_task_create(sn->dstg, dsl_dataset_snapshot_check, 6041d452cf5Sahrens dsl_dataset_snapshot_sync, os, sn->snapname, 3); 6051d452cf5Sahrens } 6061d452cf5Sahrens return (err); 6071d452cf5Sahrens } 6081d452cf5Sahrens 6091d452cf5Sahrens int 6101d452cf5Sahrens dmu_objset_snapshot(char *fsname, char *snapname, boolean_t recursive) 6111d452cf5Sahrens { 6121d452cf5Sahrens dsl_sync_task_t *dst; 6131d452cf5Sahrens struct snaparg sn = { 0 }; 6141d452cf5Sahrens char *cp; 6151d452cf5Sahrens spa_t *spa; 6161d452cf5Sahrens int err; 6171d452cf5Sahrens 6181d452cf5Sahrens (void) strcpy(sn.failed, fsname); 6191d452cf5Sahrens 6201d452cf5Sahrens cp = strchr(fsname, '/'); 6211d452cf5Sahrens if (cp) { 6221d452cf5Sahrens *cp = '\0'; 6231d452cf5Sahrens err = spa_open(fsname, &spa, FTAG); 6241d452cf5Sahrens *cp = '/'; 6251d452cf5Sahrens } else { 6261d452cf5Sahrens err = spa_open(fsname, &spa, FTAG); 6271d452cf5Sahrens } 6281d452cf5Sahrens if (err) 6291d452cf5Sahrens return (err); 6301d452cf5Sahrens 6311d452cf5Sahrens sn.dstg = dsl_sync_task_group_create(spa_get_dsl(spa)); 6321d452cf5Sahrens sn.snapname = snapname; 6331d452cf5Sahrens 6340b69c2f0Sahrens if (recursive) { 6350b69c2f0Sahrens err = dmu_objset_find(fsname, 6360b69c2f0Sahrens dmu_objset_snapshot_one, &sn, DS_FIND_CHILDREN); 6370b69c2f0Sahrens } else { 6381d452cf5Sahrens err = dmu_objset_snapshot_one(fsname, &sn); 6390b69c2f0Sahrens } 6401d452cf5Sahrens 6411d452cf5Sahrens if (err) 6421d452cf5Sahrens goto out; 6431d452cf5Sahrens 6441d452cf5Sahrens err = dsl_sync_task_group_wait(sn.dstg); 6451d452cf5Sahrens 6461d452cf5Sahrens for (dst = list_head(&sn.dstg->dstg_tasks); dst; 6471d452cf5Sahrens dst = list_next(&sn.dstg->dstg_tasks, dst)) { 6481d452cf5Sahrens objset_t *os = dst->dst_arg1; 6491d452cf5Sahrens if (dst->dst_err) 6501d452cf5Sahrens dmu_objset_name(os, sn.failed); 6511d452cf5Sahrens zil_resume(dmu_objset_zil(os)); 6521d452cf5Sahrens dmu_objset_close(os); 6531d452cf5Sahrens } 6541d452cf5Sahrens out: 6551d452cf5Sahrens if (err) 6561d452cf5Sahrens (void) strcpy(fsname, sn.failed); 6571d452cf5Sahrens dsl_sync_task_group_destroy(sn.dstg); 6581d452cf5Sahrens spa_close(spa, FTAG); 6591d452cf5Sahrens return (err); 6601d452cf5Sahrens } 6611d452cf5Sahrens 662fa9e4066Sahrens static void 663fa9e4066Sahrens dmu_objset_sync_dnodes(objset_impl_t *os, list_t *list, dmu_tx_t *tx) 664fa9e4066Sahrens { 665fa9e4066Sahrens dnode_t *dn = list_head(list); 666fa9e4066Sahrens int level, err; 667fa9e4066Sahrens 668fa9e4066Sahrens for (level = 0; dn = list_head(list); level++) { 669fa9e4066Sahrens zio_t *zio; 670fa9e4066Sahrens zio = zio_root(os->os_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED); 671fa9e4066Sahrens 672fa9e4066Sahrens ASSERT3U(level, <=, DN_MAX_LEVELS); 673fa9e4066Sahrens 674fa9e4066Sahrens while (dn) { 675fa9e4066Sahrens dnode_t *next = list_next(list, dn); 676fa9e4066Sahrens 677fa9e4066Sahrens list_remove(list, dn); 678fa9e4066Sahrens if (dnode_sync(dn, level, zio, tx) == 0) { 679fa9e4066Sahrens /* 680fa9e4066Sahrens * This dnode requires syncing at higher 681fa9e4066Sahrens * levels; put it back onto the list. 682fa9e4066Sahrens */ 683fa9e4066Sahrens if (next) 684fa9e4066Sahrens list_insert_before(list, next, dn); 685fa9e4066Sahrens else 686fa9e4066Sahrens list_insert_tail(list, dn); 687fa9e4066Sahrens } 688fa9e4066Sahrens dn = next; 689fa9e4066Sahrens } 690fa9e4066Sahrens err = zio_wait(zio); 691fa9e4066Sahrens ASSERT(err == 0); 692fa9e4066Sahrens } 693fa9e4066Sahrens } 694fa9e4066Sahrens 695fa9e4066Sahrens /* ARGSUSED */ 696fa9e4066Sahrens static void 697fa9e4066Sahrens killer(zio_t *zio, arc_buf_t *abuf, void *arg) 698fa9e4066Sahrens { 699fa9e4066Sahrens objset_impl_t *os = arg; 700fa9e4066Sahrens objset_phys_t *osphys = zio->io_data; 701fa9e4066Sahrens dnode_phys_t *dnp = &osphys->os_meta_dnode; 702fa9e4066Sahrens int i; 703fa9e4066Sahrens 704fa9e4066Sahrens ASSERT3U(zio->io_error, ==, 0); 705fa9e4066Sahrens 706fa9e4066Sahrens /* 707fa9e4066Sahrens * Update rootbp fill count. 708fa9e4066Sahrens */ 709fa9e4066Sahrens os->os_rootbp.blk_fill = 1; /* count the meta-dnode */ 710fa9e4066Sahrens for (i = 0; i < dnp->dn_nblkptr; i++) 711fa9e4066Sahrens os->os_rootbp.blk_fill += dnp->dn_blkptr[i].blk_fill; 712fa9e4066Sahrens 713fa9e4066Sahrens BP_SET_TYPE(zio->io_bp, DMU_OT_OBJSET); 714fa9e4066Sahrens BP_SET_LEVEL(zio->io_bp, 0); 715fa9e4066Sahrens 716fa9e4066Sahrens if (!DVA_EQUAL(BP_IDENTITY(zio->io_bp), 717fa9e4066Sahrens BP_IDENTITY(&zio->io_bp_orig))) { 718fa9e4066Sahrens dsl_dataset_block_kill(os->os_dsl_dataset, &zio->io_bp_orig, 719fa9e4066Sahrens os->os_synctx); 720fa9e4066Sahrens dsl_dataset_block_born(os->os_dsl_dataset, zio->io_bp, 721fa9e4066Sahrens os->os_synctx); 722fa9e4066Sahrens } 723fa9e4066Sahrens } 724fa9e4066Sahrens 725fa9e4066Sahrens /* called from dsl */ 726fa9e4066Sahrens void 727fa9e4066Sahrens dmu_objset_sync(objset_impl_t *os, dmu_tx_t *tx) 728fa9e4066Sahrens { 729fa9e4066Sahrens extern taskq_t *dbuf_tq; 730fa9e4066Sahrens int txgoff; 731fa9e4066Sahrens list_t *dirty_list; 732fa9e4066Sahrens int err; 733ea8dc4b6Seschrock zbookmark_t zb; 734fa9e4066Sahrens arc_buf_t *abuf = 735fa9e4066Sahrens arc_buf_alloc(os->os_spa, sizeof (objset_phys_t), FTAG); 736fa9e4066Sahrens 737fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 738fa9e4066Sahrens ASSERT(os->os_synctx == NULL); 739fa9e4066Sahrens /* XXX the write_done callback should really give us the tx... */ 740fa9e4066Sahrens os->os_synctx = tx; 741fa9e4066Sahrens 742fa9e4066Sahrens dprintf_ds(os->os_dsl_dataset, "txg=%llu\n", tx->tx_txg); 743fa9e4066Sahrens 744fa9e4066Sahrens txgoff = tx->tx_txg & TXG_MASK; 745fa9e4066Sahrens 746fa9e4066Sahrens dmu_objset_sync_dnodes(os, &os->os_free_dnodes[txgoff], tx); 747fa9e4066Sahrens dmu_objset_sync_dnodes(os, &os->os_dirty_dnodes[txgoff], tx); 748fa9e4066Sahrens 749fa9e4066Sahrens /* 750fa9e4066Sahrens * Free intent log blocks up to this tx. 751fa9e4066Sahrens */ 752fa9e4066Sahrens zil_sync(os->os_zil, tx); 753fa9e4066Sahrens 754fa9e4066Sahrens /* 755fa9e4066Sahrens * Sync meta-dnode 756fa9e4066Sahrens */ 757fa9e4066Sahrens dirty_list = &os->os_dirty_dnodes[txgoff]; 758fa9e4066Sahrens ASSERT(list_head(dirty_list) == NULL); 759fa9e4066Sahrens list_insert_tail(dirty_list, os->os_meta_dnode); 760fa9e4066Sahrens dmu_objset_sync_dnodes(os, dirty_list, tx); 761fa9e4066Sahrens 762fa9e4066Sahrens /* 763fa9e4066Sahrens * Sync the root block. 764fa9e4066Sahrens */ 765fa9e4066Sahrens bcopy(os->os_phys, abuf->b_data, sizeof (objset_phys_t)); 766ea8dc4b6Seschrock zb.zb_objset = os->os_dsl_dataset ? os->os_dsl_dataset->ds_object : 0; 767ea8dc4b6Seschrock zb.zb_object = 0; 768ea8dc4b6Seschrock zb.zb_level = -1; 769ea8dc4b6Seschrock zb.zb_blkid = 0; 770fa9e4066Sahrens err = arc_write(NULL, os->os_spa, os->os_md_checksum, 77144cd46caSbillm os->os_md_compress, 77244cd46caSbillm dmu_get_replication_level(os->os_spa, &zb, DMU_OT_OBJSET), 77344cd46caSbillm tx->tx_txg, &os->os_rootbp, abuf, killer, os, 774ea8dc4b6Seschrock ZIO_PRIORITY_ASYNC_WRITE, ZIO_FLAG_MUSTSUCCEED, ARC_WAIT, &zb); 775fa9e4066Sahrens ASSERT(err == 0); 776ea8dc4b6Seschrock VERIFY(arc_buf_remove_ref(abuf, FTAG) == 1); 777fa9e4066Sahrens 778fa9e4066Sahrens dsl_dataset_set_blkptr(os->os_dsl_dataset, &os->os_rootbp, tx); 779fa9e4066Sahrens 780fa9e4066Sahrens ASSERT3P(os->os_synctx, ==, tx); 781fa9e4066Sahrens taskq_wait(dbuf_tq); 782fa9e4066Sahrens os->os_synctx = NULL; 783fa9e4066Sahrens } 784fa9e4066Sahrens 785fa9e4066Sahrens void 786*a2eea2e1Sahrens dmu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp, 787*a2eea2e1Sahrens uint64_t *usedobjsp, uint64_t *availobjsp) 788fa9e4066Sahrens { 789*a2eea2e1Sahrens dsl_dataset_space(os->os->os_dsl_dataset, refdbytesp, availbytesp, 790*a2eea2e1Sahrens usedobjsp, availobjsp); 791*a2eea2e1Sahrens } 792*a2eea2e1Sahrens 793*a2eea2e1Sahrens uint64_t 794*a2eea2e1Sahrens dmu_objset_fsid_guid(objset_t *os) 795*a2eea2e1Sahrens { 796*a2eea2e1Sahrens return (dsl_dataset_fsid_guid(os->os->os_dsl_dataset)); 797*a2eea2e1Sahrens } 798*a2eea2e1Sahrens 799*a2eea2e1Sahrens void 800*a2eea2e1Sahrens dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat) 801*a2eea2e1Sahrens { 802*a2eea2e1Sahrens stat->dds_type = os->os->os_phys->os_type; 803*a2eea2e1Sahrens if (os->os->os_dsl_dataset) 804*a2eea2e1Sahrens dsl_dataset_fast_stat(os->os->os_dsl_dataset, stat); 805*a2eea2e1Sahrens } 806*a2eea2e1Sahrens 807*a2eea2e1Sahrens void 808*a2eea2e1Sahrens dmu_objset_stats(objset_t *os, nvlist_t *nv) 809*a2eea2e1Sahrens { 810*a2eea2e1Sahrens ASSERT(os->os->os_dsl_dataset || 811*a2eea2e1Sahrens os->os->os_phys->os_type == DMU_OST_META); 812*a2eea2e1Sahrens 813*a2eea2e1Sahrens if (os->os->os_dsl_dataset != NULL) 814*a2eea2e1Sahrens dsl_dataset_stats(os->os->os_dsl_dataset, nv); 815*a2eea2e1Sahrens 816*a2eea2e1Sahrens dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_TYPE, 817*a2eea2e1Sahrens os->os->os_phys->os_type); 818fa9e4066Sahrens } 819fa9e4066Sahrens 820fa9e4066Sahrens int 821fa9e4066Sahrens dmu_objset_is_snapshot(objset_t *os) 822fa9e4066Sahrens { 823fa9e4066Sahrens if (os->os->os_dsl_dataset != NULL) 824fa9e4066Sahrens return (dsl_dataset_is_snapshot(os->os->os_dsl_dataset)); 825fa9e4066Sahrens else 826fa9e4066Sahrens return (B_FALSE); 827fa9e4066Sahrens } 828fa9e4066Sahrens 829fa9e4066Sahrens int 830fa9e4066Sahrens dmu_snapshot_list_next(objset_t *os, int namelen, char *name, 83187e5029aSahrens uint64_t *idp, uint64_t *offp) 832fa9e4066Sahrens { 833fa9e4066Sahrens dsl_dataset_t *ds = os->os->os_dsl_dataset; 834fa9e4066Sahrens zap_cursor_t cursor; 835fa9e4066Sahrens zap_attribute_t attr; 836fa9e4066Sahrens 837fa9e4066Sahrens if (ds->ds_phys->ds_snapnames_zapobj == 0) 838fa9e4066Sahrens return (ENOENT); 839fa9e4066Sahrens 840fa9e4066Sahrens zap_cursor_init_serialized(&cursor, 841fa9e4066Sahrens ds->ds_dir->dd_pool->dp_meta_objset, 842fa9e4066Sahrens ds->ds_phys->ds_snapnames_zapobj, *offp); 843fa9e4066Sahrens 84487e5029aSahrens if (zap_cursor_retrieve(&cursor, &attr) != 0) { 84587e5029aSahrens zap_cursor_fini(&cursor); 84687e5029aSahrens return (ENOENT); 84787e5029aSahrens } 84887e5029aSahrens 84987e5029aSahrens if (strlen(attr.za_name) + 1 > namelen) { 85087e5029aSahrens zap_cursor_fini(&cursor); 85187e5029aSahrens return (ENAMETOOLONG); 85287e5029aSahrens } 85387e5029aSahrens 85487e5029aSahrens (void) strcpy(name, attr.za_name); 85587e5029aSahrens if (idp) 85687e5029aSahrens *idp = attr.za_first_integer; 85787e5029aSahrens zap_cursor_advance(&cursor); 85887e5029aSahrens *offp = zap_cursor_serialize(&cursor); 85987e5029aSahrens zap_cursor_fini(&cursor); 86087e5029aSahrens 86187e5029aSahrens return (0); 86287e5029aSahrens } 86387e5029aSahrens 86487e5029aSahrens int 86587e5029aSahrens dmu_dir_list_next(objset_t *os, int namelen, char *name, 86687e5029aSahrens uint64_t *idp, uint64_t *offp) 86787e5029aSahrens { 86887e5029aSahrens dsl_dir_t *dd = os->os->os_dsl_dataset->ds_dir; 86987e5029aSahrens zap_cursor_t cursor; 87087e5029aSahrens zap_attribute_t attr; 87187e5029aSahrens 87287e5029aSahrens /* there is no next dir on a snapshot! */ 87387e5029aSahrens if (os->os->os_dsl_dataset->ds_object != 87487e5029aSahrens dd->dd_phys->dd_head_dataset_obj) 875fa9e4066Sahrens return (ENOENT); 876fa9e4066Sahrens 87787e5029aSahrens zap_cursor_init_serialized(&cursor, 87887e5029aSahrens dd->dd_pool->dp_meta_objset, 87987e5029aSahrens dd->dd_phys->dd_child_dir_zapobj, *offp); 88087e5029aSahrens 88187e5029aSahrens if (zap_cursor_retrieve(&cursor, &attr) != 0) { 88287e5029aSahrens zap_cursor_fini(&cursor); 88387e5029aSahrens return (ENOENT); 88487e5029aSahrens } 88587e5029aSahrens 88687e5029aSahrens if (strlen(attr.za_name) + 1 > namelen) { 88787e5029aSahrens zap_cursor_fini(&cursor); 888fa9e4066Sahrens return (ENAMETOOLONG); 88987e5029aSahrens } 890fa9e4066Sahrens 891fa9e4066Sahrens (void) strcpy(name, attr.za_name); 89287e5029aSahrens if (idp) 89387e5029aSahrens *idp = attr.za_first_integer; 894fa9e4066Sahrens zap_cursor_advance(&cursor); 895fa9e4066Sahrens *offp = zap_cursor_serialize(&cursor); 89687e5029aSahrens zap_cursor_fini(&cursor); 897fa9e4066Sahrens 898fa9e4066Sahrens return (0); 899fa9e4066Sahrens } 900fa9e4066Sahrens 901fa9e4066Sahrens /* 902fa9e4066Sahrens * Find all objsets under name, and for each, call 'func(child_name, arg)'. 903fa9e4066Sahrens */ 9041d452cf5Sahrens int 9051d452cf5Sahrens dmu_objset_find(char *name, int func(char *, void *), void *arg, int flags) 906fa9e4066Sahrens { 907fa9e4066Sahrens dsl_dir_t *dd; 908fa9e4066Sahrens objset_t *os; 909fa9e4066Sahrens uint64_t snapobj; 910fa9e4066Sahrens zap_cursor_t zc; 911fa9e4066Sahrens zap_attribute_t attr; 912fa9e4066Sahrens char *child; 913ea8dc4b6Seschrock int do_self, err; 914fa9e4066Sahrens 915ea8dc4b6Seschrock err = dsl_dir_open(name, FTAG, &dd, NULL); 916ea8dc4b6Seschrock if (err) 9171d452cf5Sahrens return (err); 918fa9e4066Sahrens 9191d452cf5Sahrens /* NB: the $MOS dir doesn't have a head dataset */ 920fa9e4066Sahrens do_self = (dd->dd_phys->dd_head_dataset_obj != 0); 921fa9e4066Sahrens 922fa9e4066Sahrens /* 923fa9e4066Sahrens * Iterate over all children. 924fa9e4066Sahrens */ 9250b69c2f0Sahrens if (flags & DS_FIND_CHILDREN) { 9260b69c2f0Sahrens for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset, 9270b69c2f0Sahrens dd->dd_phys->dd_child_dir_zapobj); 9280b69c2f0Sahrens zap_cursor_retrieve(&zc, &attr) == 0; 9290b69c2f0Sahrens (void) zap_cursor_advance(&zc)) { 9300b69c2f0Sahrens ASSERT(attr.za_integer_length == sizeof (uint64_t)); 9310b69c2f0Sahrens ASSERT(attr.za_num_integers == 1); 932fa9e4066Sahrens 9330b69c2f0Sahrens /* 9340b69c2f0Sahrens * No separating '/' because parent's name ends in /. 9350b69c2f0Sahrens */ 9360b69c2f0Sahrens child = kmem_alloc(MAXPATHLEN, KM_SLEEP); 9370b69c2f0Sahrens /* XXX could probably just use name here */ 9380b69c2f0Sahrens dsl_dir_name(dd, child); 9390b69c2f0Sahrens (void) strcat(child, "/"); 9400b69c2f0Sahrens (void) strcat(child, attr.za_name); 9410b69c2f0Sahrens err = dmu_objset_find(child, func, arg, flags); 9420b69c2f0Sahrens kmem_free(child, MAXPATHLEN); 9430b69c2f0Sahrens if (err) 9440b69c2f0Sahrens break; 9450b69c2f0Sahrens } 9460b69c2f0Sahrens zap_cursor_fini(&zc); 9471d452cf5Sahrens 9480b69c2f0Sahrens if (err) { 9490b69c2f0Sahrens dsl_dir_close(dd, FTAG); 9500b69c2f0Sahrens return (err); 9510b69c2f0Sahrens } 952fa9e4066Sahrens } 953fa9e4066Sahrens 954fa9e4066Sahrens /* 955fa9e4066Sahrens * Iterate over all snapshots. 956fa9e4066Sahrens */ 957fa9e4066Sahrens if ((flags & DS_FIND_SNAPSHOTS) && 958fa9e4066Sahrens dmu_objset_open(name, DMU_OST_ANY, 959fa9e4066Sahrens DS_MODE_STANDARD | DS_MODE_READONLY, &os) == 0) { 960fa9e4066Sahrens 961fa9e4066Sahrens snapobj = os->os->os_dsl_dataset->ds_phys->ds_snapnames_zapobj; 962fa9e4066Sahrens dmu_objset_close(os); 963fa9e4066Sahrens 964fa9e4066Sahrens for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset, snapobj); 965fa9e4066Sahrens zap_cursor_retrieve(&zc, &attr) == 0; 966fa9e4066Sahrens (void) zap_cursor_advance(&zc)) { 967fa9e4066Sahrens ASSERT(attr.za_integer_length == sizeof (uint64_t)); 968fa9e4066Sahrens ASSERT(attr.za_num_integers == 1); 969fa9e4066Sahrens 970fa9e4066Sahrens child = kmem_alloc(MAXPATHLEN, KM_SLEEP); 971fa9e4066Sahrens /* XXX could probably just use name here */ 972fa9e4066Sahrens dsl_dir_name(dd, child); 973fa9e4066Sahrens (void) strcat(child, "@"); 974fa9e4066Sahrens (void) strcat(child, attr.za_name); 9751d452cf5Sahrens err = func(child, arg); 976fa9e4066Sahrens kmem_free(child, MAXPATHLEN); 9771d452cf5Sahrens if (err) 9781d452cf5Sahrens break; 979fa9e4066Sahrens } 98087e5029aSahrens zap_cursor_fini(&zc); 981fa9e4066Sahrens } 982fa9e4066Sahrens 983fa9e4066Sahrens dsl_dir_close(dd, FTAG); 984fa9e4066Sahrens 9851d452cf5Sahrens if (err) 9861d452cf5Sahrens return (err); 9871d452cf5Sahrens 988fa9e4066Sahrens /* 989fa9e4066Sahrens * Apply to self if appropriate. 990fa9e4066Sahrens */ 991fa9e4066Sahrens if (do_self) 9921d452cf5Sahrens err = func(name, arg); 9931d452cf5Sahrens return (err); 994fa9e4066Sahrens } 995