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 /* 22c717a561Smaybee * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27fa9e4066Sahrens 28*ecd6cf80Smarks #include <sys/cred.h> 29fa9e4066Sahrens #include <sys/zfs_context.h> 30fa9e4066Sahrens #include <sys/dmu_objset.h> 31fa9e4066Sahrens #include <sys/dsl_dir.h> 32fa9e4066Sahrens #include <sys/dsl_dataset.h> 33fa9e4066Sahrens #include <sys/dsl_prop.h> 34fa9e4066Sahrens #include <sys/dsl_pool.h> 351d452cf5Sahrens #include <sys/dsl_synctask.h> 36*ecd6cf80Smarks #include <sys/dsl_deleg.h> 37fa9e4066Sahrens #include <sys/dnode.h> 38fa9e4066Sahrens #include <sys/dbuf.h> 39a2eea2e1Sahrens #include <sys/zvol.h> 40fa9e4066Sahrens #include <sys/dmu_tx.h> 41fa9e4066Sahrens #include <sys/zio_checksum.h> 42fa9e4066Sahrens #include <sys/zap.h> 43fa9e4066Sahrens #include <sys/zil.h> 44fa9e4066Sahrens #include <sys/dmu_impl.h> 45*ecd6cf80Smarks #include <sys/zfs_ioctl.h> 46fa9e4066Sahrens 47fa9e4066Sahrens 48fa9e4066Sahrens spa_t * 49fa9e4066Sahrens dmu_objset_spa(objset_t *os) 50fa9e4066Sahrens { 51fa9e4066Sahrens return (os->os->os_spa); 52fa9e4066Sahrens } 53fa9e4066Sahrens 54fa9e4066Sahrens zilog_t * 55fa9e4066Sahrens dmu_objset_zil(objset_t *os) 56fa9e4066Sahrens { 57fa9e4066Sahrens return (os->os->os_zil); 58fa9e4066Sahrens } 59fa9e4066Sahrens 60fa9e4066Sahrens dsl_pool_t * 61fa9e4066Sahrens dmu_objset_pool(objset_t *os) 62fa9e4066Sahrens { 63fa9e4066Sahrens dsl_dataset_t *ds; 64fa9e4066Sahrens 65fa9e4066Sahrens if ((ds = os->os->os_dsl_dataset) != NULL && ds->ds_dir) 66fa9e4066Sahrens return (ds->ds_dir->dd_pool); 67fa9e4066Sahrens else 68fa9e4066Sahrens return (spa_get_dsl(os->os->os_spa)); 69fa9e4066Sahrens } 70fa9e4066Sahrens 71fa9e4066Sahrens dsl_dataset_t * 72fa9e4066Sahrens dmu_objset_ds(objset_t *os) 73fa9e4066Sahrens { 74fa9e4066Sahrens return (os->os->os_dsl_dataset); 75fa9e4066Sahrens } 76fa9e4066Sahrens 77fa9e4066Sahrens dmu_objset_type_t 78fa9e4066Sahrens dmu_objset_type(objset_t *os) 79fa9e4066Sahrens { 80fa9e4066Sahrens return (os->os->os_phys->os_type); 81fa9e4066Sahrens } 82fa9e4066Sahrens 83fa9e4066Sahrens void 84fa9e4066Sahrens dmu_objset_name(objset_t *os, char *buf) 85fa9e4066Sahrens { 86fa9e4066Sahrens dsl_dataset_name(os->os->os_dsl_dataset, buf); 87fa9e4066Sahrens } 88fa9e4066Sahrens 89fa9e4066Sahrens uint64_t 90fa9e4066Sahrens dmu_objset_id(objset_t *os) 91fa9e4066Sahrens { 92fa9e4066Sahrens dsl_dataset_t *ds = os->os->os_dsl_dataset; 93fa9e4066Sahrens 94fa9e4066Sahrens return (ds ? ds->ds_object : 0); 95fa9e4066Sahrens } 96fa9e4066Sahrens 97fa9e4066Sahrens static void 98fa9e4066Sahrens checksum_changed_cb(void *arg, uint64_t newval) 99fa9e4066Sahrens { 100fa9e4066Sahrens objset_impl_t *osi = arg; 101fa9e4066Sahrens 102fa9e4066Sahrens /* 103fa9e4066Sahrens * Inheritance should have been done by now. 104fa9e4066Sahrens */ 105fa9e4066Sahrens ASSERT(newval != ZIO_CHECKSUM_INHERIT); 106fa9e4066Sahrens 107fa9e4066Sahrens osi->os_checksum = zio_checksum_select(newval, ZIO_CHECKSUM_ON_VALUE); 108fa9e4066Sahrens } 109fa9e4066Sahrens 110fa9e4066Sahrens static void 111fa9e4066Sahrens compression_changed_cb(void *arg, uint64_t newval) 112fa9e4066Sahrens { 113fa9e4066Sahrens objset_impl_t *osi = arg; 114fa9e4066Sahrens 115fa9e4066Sahrens /* 116fa9e4066Sahrens * Inheritance and range checking should have been done by now. 117fa9e4066Sahrens */ 118fa9e4066Sahrens ASSERT(newval != ZIO_COMPRESS_INHERIT); 119fa9e4066Sahrens 120fa9e4066Sahrens osi->os_compress = zio_compress_select(newval, ZIO_COMPRESS_ON_VALUE); 121fa9e4066Sahrens } 122fa9e4066Sahrens 123d0ad202dSahrens static void 124d0ad202dSahrens copies_changed_cb(void *arg, uint64_t newval) 125d0ad202dSahrens { 126d0ad202dSahrens objset_impl_t *osi = arg; 127d0ad202dSahrens 128d0ad202dSahrens /* 129d0ad202dSahrens * Inheritance and range checking should have been done by now. 130d0ad202dSahrens */ 131d0ad202dSahrens ASSERT(newval > 0); 132d0ad202dSahrens ASSERT(newval <= spa_max_replication(osi->os_spa)); 133d0ad202dSahrens 134d0ad202dSahrens osi->os_copies = newval; 135d0ad202dSahrens } 136d0ad202dSahrens 137fa9e4066Sahrens void 138fa9e4066Sahrens dmu_objset_byteswap(void *buf, size_t size) 139fa9e4066Sahrens { 140fa9e4066Sahrens objset_phys_t *osp = buf; 141fa9e4066Sahrens 142fa9e4066Sahrens ASSERT(size == sizeof (objset_phys_t)); 143fa9e4066Sahrens dnode_byteswap(&osp->os_meta_dnode); 144fa9e4066Sahrens byteswap_uint64_array(&osp->os_zil_header, sizeof (zil_header_t)); 145fa9e4066Sahrens osp->os_type = BSWAP_64(osp->os_type); 146fa9e4066Sahrens } 147fa9e4066Sahrens 148ea8dc4b6Seschrock int 149ea8dc4b6Seschrock dmu_objset_open_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp, 150ea8dc4b6Seschrock objset_impl_t **osip) 151fa9e4066Sahrens { 152fa9e4066Sahrens objset_impl_t *winner, *osi; 153fa9e4066Sahrens int i, err, checksum; 154fa9e4066Sahrens 155fa9e4066Sahrens osi = kmem_zalloc(sizeof (objset_impl_t), KM_SLEEP); 156fa9e4066Sahrens osi->os.os = osi; 157fa9e4066Sahrens osi->os_dsl_dataset = ds; 158fa9e4066Sahrens osi->os_spa = spa; 159c717a561Smaybee osi->os_rootbp = bp; 160c717a561Smaybee if (!BP_IS_HOLE(osi->os_rootbp)) { 16113506d1eSmaybee uint32_t aflags = ARC_WAIT; 162ea8dc4b6Seschrock zbookmark_t zb; 163ea8dc4b6Seschrock zb.zb_objset = ds ? ds->ds_object : 0; 164ea8dc4b6Seschrock zb.zb_object = 0; 165ea8dc4b6Seschrock zb.zb_level = -1; 166ea8dc4b6Seschrock zb.zb_blkid = 0; 167ea8dc4b6Seschrock 168c717a561Smaybee dprintf_bp(osi->os_rootbp, "reading %s", ""); 169c717a561Smaybee err = arc_read(NULL, spa, osi->os_rootbp, 170fa9e4066Sahrens dmu_ot[DMU_OT_OBJSET].ot_byteswap, 171c717a561Smaybee arc_getbuf_func, &osi->os_phys_buf, 17213506d1eSmaybee ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_CANFAIL, &aflags, &zb); 173ea8dc4b6Seschrock if (err) { 174ea8dc4b6Seschrock kmem_free(osi, sizeof (objset_impl_t)); 175ea8dc4b6Seschrock return (err); 176ea8dc4b6Seschrock } 177c717a561Smaybee osi->os_phys = osi->os_phys_buf->b_data; 178c717a561Smaybee arc_release(osi->os_phys_buf, &osi->os_phys_buf); 179fa9e4066Sahrens } else { 180c717a561Smaybee osi->os_phys_buf = arc_buf_alloc(spa, sizeof (objset_phys_t), 181c717a561Smaybee &osi->os_phys_buf, ARC_BUFC_METADATA); 182c717a561Smaybee osi->os_phys = osi->os_phys_buf->b_data; 183fa9e4066Sahrens bzero(osi->os_phys, sizeof (objset_phys_t)); 184fa9e4066Sahrens } 185fa9e4066Sahrens 186fa9e4066Sahrens /* 187fa9e4066Sahrens * Note: the changed_cb will be called once before the register 188fa9e4066Sahrens * func returns, thus changing the checksum/compression from the 18999653d4eSeschrock * default (fletcher2/off). Snapshots don't need to know, and 19099653d4eSeschrock * registering would complicate clone promotion. 191fa9e4066Sahrens */ 19299653d4eSeschrock if (ds && ds->ds_phys->ds_num_children == 0) { 193fa9e4066Sahrens err = dsl_prop_register(ds, "checksum", 194fa9e4066Sahrens checksum_changed_cb, osi); 195ea8dc4b6Seschrock if (err == 0) 196ea8dc4b6Seschrock err = dsl_prop_register(ds, "compression", 197ea8dc4b6Seschrock compression_changed_cb, osi); 198d0ad202dSahrens if (err == 0) 199d0ad202dSahrens err = dsl_prop_register(ds, "copies", 200d0ad202dSahrens copies_changed_cb, osi); 201ea8dc4b6Seschrock if (err) { 202c717a561Smaybee VERIFY(arc_buf_remove_ref(osi->os_phys_buf, 203c717a561Smaybee &osi->os_phys_buf) == 1); 204ea8dc4b6Seschrock kmem_free(osi, sizeof (objset_impl_t)); 205ea8dc4b6Seschrock return (err); 206ea8dc4b6Seschrock } 20799653d4eSeschrock } else if (ds == NULL) { 208fa9e4066Sahrens /* It's the meta-objset. */ 209fa9e4066Sahrens osi->os_checksum = ZIO_CHECKSUM_FLETCHER_4; 210ea8dc4b6Seschrock osi->os_compress = ZIO_COMPRESS_LZJB; 211d0ad202dSahrens osi->os_copies = spa_max_replication(spa); 212fa9e4066Sahrens } 213fa9e4066Sahrens 214ea8dc4b6Seschrock osi->os_zil = zil_alloc(&osi->os, &osi->os_phys->os_zil_header); 215ea8dc4b6Seschrock 216fa9e4066Sahrens /* 217fa9e4066Sahrens * Metadata always gets compressed and checksummed. 218fa9e4066Sahrens * If the data checksum is multi-bit correctable, and it's not 219fa9e4066Sahrens * a ZBT-style checksum, then it's suitable for metadata as well. 220fa9e4066Sahrens * Otherwise, the metadata checksum defaults to fletcher4. 221fa9e4066Sahrens */ 222fa9e4066Sahrens checksum = osi->os_checksum; 223fa9e4066Sahrens 224fa9e4066Sahrens if (zio_checksum_table[checksum].ci_correctable && 225fa9e4066Sahrens !zio_checksum_table[checksum].ci_zbt) 226fa9e4066Sahrens osi->os_md_checksum = checksum; 227fa9e4066Sahrens else 228fa9e4066Sahrens osi->os_md_checksum = ZIO_CHECKSUM_FLETCHER_4; 229ea8dc4b6Seschrock osi->os_md_compress = ZIO_COMPRESS_LZJB; 230fa9e4066Sahrens 231fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++) { 232fa9e4066Sahrens list_create(&osi->os_dirty_dnodes[i], sizeof (dnode_t), 233fa9e4066Sahrens offsetof(dnode_t, dn_dirty_link[i])); 234fa9e4066Sahrens list_create(&osi->os_free_dnodes[i], sizeof (dnode_t), 235fa9e4066Sahrens offsetof(dnode_t, dn_dirty_link[i])); 236fa9e4066Sahrens } 237fa9e4066Sahrens list_create(&osi->os_dnodes, sizeof (dnode_t), 238fa9e4066Sahrens offsetof(dnode_t, dn_link)); 239fa9e4066Sahrens list_create(&osi->os_downgraded_dbufs, sizeof (dmu_buf_impl_t), 240fa9e4066Sahrens offsetof(dmu_buf_impl_t, db_link)); 241fa9e4066Sahrens 2425ad82045Snd mutex_init(&osi->os_lock, NULL, MUTEX_DEFAULT, NULL); 2435ad82045Snd mutex_init(&osi->os_obj_lock, NULL, MUTEX_DEFAULT, NULL); 2445ad82045Snd 245fa9e4066Sahrens osi->os_meta_dnode = dnode_special_open(osi, 246fa9e4066Sahrens &osi->os_phys->os_meta_dnode, DMU_META_DNODE_OBJECT); 247fa9e4066Sahrens 248fa9e4066Sahrens if (ds != NULL) { 249fa9e4066Sahrens winner = dsl_dataset_set_user_ptr(ds, osi, dmu_objset_evict); 250fa9e4066Sahrens if (winner) { 251fa9e4066Sahrens dmu_objset_evict(ds, osi); 252fa9e4066Sahrens osi = winner; 253fa9e4066Sahrens } 254fa9e4066Sahrens } 255fa9e4066Sahrens 256ea8dc4b6Seschrock *osip = osi; 257ea8dc4b6Seschrock return (0); 258fa9e4066Sahrens } 259fa9e4066Sahrens 260fa9e4066Sahrens /* called from zpl */ 261fa9e4066Sahrens int 262fa9e4066Sahrens dmu_objset_open(const char *name, dmu_objset_type_t type, int mode, 263fa9e4066Sahrens objset_t **osp) 264fa9e4066Sahrens { 265fa9e4066Sahrens dsl_dataset_t *ds; 266fa9e4066Sahrens int err; 267fa9e4066Sahrens objset_t *os; 268fa9e4066Sahrens objset_impl_t *osi; 269fa9e4066Sahrens 270fa9e4066Sahrens os = kmem_alloc(sizeof (objset_t), KM_SLEEP); 271fa9e4066Sahrens err = dsl_dataset_open(name, mode, os, &ds); 272fa9e4066Sahrens if (err) { 273fa9e4066Sahrens kmem_free(os, sizeof (objset_t)); 274fa9e4066Sahrens return (err); 275fa9e4066Sahrens } 276fa9e4066Sahrens 277fa9e4066Sahrens osi = dsl_dataset_get_user_ptr(ds); 278fa9e4066Sahrens if (osi == NULL) { 279ea8dc4b6Seschrock err = dmu_objset_open_impl(dsl_dataset_get_spa(ds), 280c717a561Smaybee ds, &ds->ds_phys->ds_bp, &osi); 281ea8dc4b6Seschrock if (err) { 282ea8dc4b6Seschrock dsl_dataset_close(ds, mode, os); 283ea8dc4b6Seschrock kmem_free(os, sizeof (objset_t)); 284ea8dc4b6Seschrock return (err); 285ea8dc4b6Seschrock } 286fa9e4066Sahrens } 287fa9e4066Sahrens 288fa9e4066Sahrens os->os = osi; 289fa9e4066Sahrens os->os_mode = mode; 290fa9e4066Sahrens 291fa9e4066Sahrens if (type != DMU_OST_ANY && type != os->os->os_phys->os_type) { 292fa9e4066Sahrens dmu_objset_close(os); 293fa9e4066Sahrens return (EINVAL); 294fa9e4066Sahrens } 295fa9e4066Sahrens *osp = os; 296fa9e4066Sahrens return (0); 297fa9e4066Sahrens } 298fa9e4066Sahrens 299fa9e4066Sahrens void 300fa9e4066Sahrens dmu_objset_close(objset_t *os) 301fa9e4066Sahrens { 302fa9e4066Sahrens dsl_dataset_close(os->os->os_dsl_dataset, os->os_mode, os); 303fa9e4066Sahrens kmem_free(os, sizeof (objset_t)); 304fa9e4066Sahrens } 305fa9e4066Sahrens 306436b2950Sperrin int 307436b2950Sperrin dmu_objset_evict_dbufs(objset_t *os, int try) 308ea8dc4b6Seschrock { 309ea8dc4b6Seschrock objset_impl_t *osi = os->os; 310ea8dc4b6Seschrock dnode_t *dn; 311c543ec06Sahrens 312c543ec06Sahrens mutex_enter(&osi->os_lock); 313c543ec06Sahrens 314c543ec06Sahrens /* process the mdn last, since the other dnodes have holds on it */ 315c543ec06Sahrens list_remove(&osi->os_dnodes, osi->os_meta_dnode); 316c543ec06Sahrens list_insert_tail(&osi->os_dnodes, osi->os_meta_dnode); 317ea8dc4b6Seschrock 318ea8dc4b6Seschrock /* 319c543ec06Sahrens * Find the first dnode with holds. We have to do this dance 320c543ec06Sahrens * because dnode_add_ref() only works if you already have a 321c543ec06Sahrens * hold. If there are no holds then it has no dbufs so OK to 322c543ec06Sahrens * skip. 323ea8dc4b6Seschrock */ 324c543ec06Sahrens for (dn = list_head(&osi->os_dnodes); 325c543ec06Sahrens dn && refcount_is_zero(&dn->dn_holds); 326c543ec06Sahrens dn = list_next(&osi->os_dnodes, dn)) 327c543ec06Sahrens continue; 328c543ec06Sahrens if (dn) 329c543ec06Sahrens dnode_add_ref(dn, FTAG); 330c543ec06Sahrens 331c543ec06Sahrens while (dn) { 332c543ec06Sahrens dnode_t *next_dn = dn; 333c543ec06Sahrens 334c543ec06Sahrens do { 335c543ec06Sahrens next_dn = list_next(&osi->os_dnodes, next_dn); 336c543ec06Sahrens } while (next_dn && refcount_is_zero(&next_dn->dn_holds)); 337c543ec06Sahrens if (next_dn) 338c543ec06Sahrens dnode_add_ref(next_dn, FTAG); 339c543ec06Sahrens 340c543ec06Sahrens mutex_exit(&osi->os_lock); 341436b2950Sperrin if (dnode_evict_dbufs(dn, try)) { 342436b2950Sperrin dnode_rele(dn, FTAG); 343436b2950Sperrin if (next_dn) 344436b2950Sperrin dnode_rele(next_dn, FTAG); 345436b2950Sperrin return (1); 346436b2950Sperrin } 347c543ec06Sahrens dnode_rele(dn, FTAG); 348c543ec06Sahrens mutex_enter(&osi->os_lock); 349c543ec06Sahrens dn = next_dn; 350ea8dc4b6Seschrock } 351ea8dc4b6Seschrock mutex_exit(&osi->os_lock); 352436b2950Sperrin return (0); 353ea8dc4b6Seschrock } 354ea8dc4b6Seschrock 355fa9e4066Sahrens void 356fa9e4066Sahrens dmu_objset_evict(dsl_dataset_t *ds, void *arg) 357fa9e4066Sahrens { 358fa9e4066Sahrens objset_impl_t *osi = arg; 359ea8dc4b6Seschrock objset_t os; 36099653d4eSeschrock int i; 361fa9e4066Sahrens 362fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++) { 363fa9e4066Sahrens ASSERT(list_head(&osi->os_dirty_dnodes[i]) == NULL); 364fa9e4066Sahrens ASSERT(list_head(&osi->os_free_dnodes[i]) == NULL); 365fa9e4066Sahrens } 366fa9e4066Sahrens 36799653d4eSeschrock if (ds && ds->ds_phys->ds_num_children == 0) { 36899653d4eSeschrock VERIFY(0 == dsl_prop_unregister(ds, "checksum", 36999653d4eSeschrock checksum_changed_cb, osi)); 37099653d4eSeschrock VERIFY(0 == dsl_prop_unregister(ds, "compression", 37199653d4eSeschrock compression_changed_cb, osi)); 372d0ad202dSahrens VERIFY(0 == dsl_prop_unregister(ds, "copies", 373d0ad202dSahrens copies_changed_cb, osi)); 374fa9e4066Sahrens } 375fa9e4066Sahrens 376ea8dc4b6Seschrock /* 377ea8dc4b6Seschrock * We should need only a single pass over the dnode list, since 378ea8dc4b6Seschrock * nothing can be added to the list at this point. 379ea8dc4b6Seschrock */ 380ea8dc4b6Seschrock os.os = osi; 381436b2950Sperrin (void) dmu_objset_evict_dbufs(&os, 0); 382ea8dc4b6Seschrock 383fa9e4066Sahrens ASSERT3P(list_head(&osi->os_dnodes), ==, osi->os_meta_dnode); 384fa9e4066Sahrens ASSERT3P(list_tail(&osi->os_dnodes), ==, osi->os_meta_dnode); 385fa9e4066Sahrens ASSERT3P(list_head(&osi->os_meta_dnode->dn_dbufs), ==, NULL); 386fa9e4066Sahrens 387fa9e4066Sahrens dnode_special_close(osi->os_meta_dnode); 388fa9e4066Sahrens zil_free(osi->os_zil); 389fa9e4066Sahrens 390c717a561Smaybee VERIFY(arc_buf_remove_ref(osi->os_phys_buf, &osi->os_phys_buf) == 1); 3915ad82045Snd mutex_destroy(&osi->os_lock); 3925ad82045Snd mutex_destroy(&osi->os_obj_lock); 393fa9e4066Sahrens kmem_free(osi, sizeof (objset_impl_t)); 394fa9e4066Sahrens } 395fa9e4066Sahrens 396fa9e4066Sahrens /* called from dsl for meta-objset */ 397fa9e4066Sahrens objset_impl_t * 398c717a561Smaybee dmu_objset_create_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp, 399c717a561Smaybee dmu_objset_type_t type, dmu_tx_t *tx) 400fa9e4066Sahrens { 401fa9e4066Sahrens objset_impl_t *osi; 402fa9e4066Sahrens dnode_t *mdn; 403fa9e4066Sahrens 404fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 405c717a561Smaybee VERIFY(0 == dmu_objset_open_impl(spa, ds, bp, &osi)); 406fa9e4066Sahrens mdn = osi->os_meta_dnode; 407fa9e4066Sahrens 408fa9e4066Sahrens dnode_allocate(mdn, DMU_OT_DNODE, 1 << DNODE_BLOCK_SHIFT, 409fa9e4066Sahrens DN_MAX_INDBLKSHIFT, DMU_OT_NONE, 0, tx); 410fa9e4066Sahrens 411fa9e4066Sahrens /* 412fa9e4066Sahrens * We don't want to have to increase the meta-dnode's nlevels 413fa9e4066Sahrens * later, because then we could do it in quescing context while 414fa9e4066Sahrens * we are also accessing it in open context. 415fa9e4066Sahrens * 416fa9e4066Sahrens * This precaution is not necessary for the MOS (ds == NULL), 417fa9e4066Sahrens * because the MOS is only updated in syncing context. 418fa9e4066Sahrens * This is most fortunate: the MOS is the only objset that 419fa9e4066Sahrens * needs to be synced multiple times as spa_sync() iterates 420fa9e4066Sahrens * to convergence, so minimizing its dn_nlevels matters. 421fa9e4066Sahrens */ 422ea8dc4b6Seschrock if (ds != NULL) { 423ea8dc4b6Seschrock int levels = 1; 424ea8dc4b6Seschrock 425ea8dc4b6Seschrock /* 426ea8dc4b6Seschrock * Determine the number of levels necessary for the meta-dnode 427ea8dc4b6Seschrock * to contain DN_MAX_OBJECT dnodes. 428ea8dc4b6Seschrock */ 429ea8dc4b6Seschrock while ((uint64_t)mdn->dn_nblkptr << (mdn->dn_datablkshift + 430ea8dc4b6Seschrock (levels - 1) * (mdn->dn_indblkshift - SPA_BLKPTRSHIFT)) < 431ea8dc4b6Seschrock DN_MAX_OBJECT * sizeof (dnode_phys_t)) 432ea8dc4b6Seschrock levels++; 433ea8dc4b6Seschrock 434fa9e4066Sahrens mdn->dn_next_nlevels[tx->tx_txg & TXG_MASK] = 435ea8dc4b6Seschrock mdn->dn_nlevels = levels; 436ea8dc4b6Seschrock } 437fa9e4066Sahrens 438fa9e4066Sahrens ASSERT(type != DMU_OST_NONE); 439fa9e4066Sahrens ASSERT(type != DMU_OST_ANY); 440fa9e4066Sahrens ASSERT(type < DMU_OST_NUMTYPES); 441fa9e4066Sahrens osi->os_phys->os_type = type; 442fa9e4066Sahrens 443fa9e4066Sahrens dsl_dataset_dirty(ds, tx); 444fa9e4066Sahrens 445fa9e4066Sahrens return (osi); 446fa9e4066Sahrens } 447fa9e4066Sahrens 448fa9e4066Sahrens struct oscarg { 449*ecd6cf80Smarks void (*userfunc)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx); 450fa9e4066Sahrens void *userarg; 451fa9e4066Sahrens dsl_dataset_t *clone_parent; 452fa9e4066Sahrens const char *lastname; 453fa9e4066Sahrens dmu_objset_type_t type; 454fa9e4066Sahrens }; 455fa9e4066Sahrens 456*ecd6cf80Smarks /*ARGSUSED*/ 457fa9e4066Sahrens static int 4581d452cf5Sahrens dmu_objset_create_check(void *arg1, void *arg2, dmu_tx_t *tx) 459fa9e4066Sahrens { 4601d452cf5Sahrens dsl_dir_t *dd = arg1; 4611d452cf5Sahrens struct oscarg *oa = arg2; 4621d452cf5Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 463fa9e4066Sahrens int err; 4641d452cf5Sahrens uint64_t ddobj; 4651d452cf5Sahrens 4661d452cf5Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 4671d452cf5Sahrens oa->lastname, sizeof (uint64_t), 1, &ddobj); 4681d452cf5Sahrens if (err != ENOENT) 4691d452cf5Sahrens return (err ? err : EEXIST); 4701d452cf5Sahrens 4711d452cf5Sahrens if (oa->clone_parent != NULL) { 4721d452cf5Sahrens /* 4731d452cf5Sahrens * You can't clone across pools. 4741d452cf5Sahrens */ 4751d452cf5Sahrens if (oa->clone_parent->ds_dir->dd_pool != dd->dd_pool) 4761d452cf5Sahrens return (EXDEV); 4771d452cf5Sahrens 4781d452cf5Sahrens /* 4791d452cf5Sahrens * You can only clone snapshots, not the head datasets. 4801d452cf5Sahrens */ 4811d452cf5Sahrens if (oa->clone_parent->ds_phys->ds_num_children == 0) 4821d452cf5Sahrens return (EINVAL); 4831d452cf5Sahrens } 484*ecd6cf80Smarks 4851d452cf5Sahrens return (0); 4861d452cf5Sahrens } 4871d452cf5Sahrens 4881d452cf5Sahrens static void 489*ecd6cf80Smarks dmu_objset_create_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 4901d452cf5Sahrens { 4911d452cf5Sahrens dsl_dir_t *dd = arg1; 4921d452cf5Sahrens struct oscarg *oa = arg2; 4931d452cf5Sahrens dsl_dataset_t *ds; 494c717a561Smaybee blkptr_t *bp; 4951d452cf5Sahrens uint64_t dsobj; 496fa9e4066Sahrens 497fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 498fa9e4066Sahrens 4991d452cf5Sahrens dsobj = dsl_dataset_create_sync(dd, oa->lastname, 500fa9e4066Sahrens oa->clone_parent, tx); 501fa9e4066Sahrens 5021d452cf5Sahrens VERIFY(0 == dsl_dataset_open_obj(dd->dd_pool, dsobj, NULL, 503ea8dc4b6Seschrock DS_MODE_STANDARD | DS_MODE_READONLY, FTAG, &ds)); 504c717a561Smaybee bp = dsl_dataset_get_blkptr(ds); 505c717a561Smaybee if (BP_IS_HOLE(bp)) { 506fa9e4066Sahrens objset_impl_t *osi; 507fa9e4066Sahrens 508fa9e4066Sahrens /* This is an empty dmu_objset; not a clone. */ 509fa9e4066Sahrens osi = dmu_objset_create_impl(dsl_dataset_get_spa(ds), 510c717a561Smaybee ds, bp, oa->type, tx); 511fa9e4066Sahrens 512fa9e4066Sahrens if (oa->userfunc) 513*ecd6cf80Smarks oa->userfunc(&osi->os, oa->userarg, cr, tx); 514fa9e4066Sahrens } 515*ecd6cf80Smarks 516*ecd6cf80Smarks /* 517*ecd6cf80Smarks * Create create time permission if any? 518*ecd6cf80Smarks */ 519*ecd6cf80Smarks dsl_deleg_set_create_perms(ds->ds_dir, tx, cr); 520*ecd6cf80Smarks 521*ecd6cf80Smarks spa_history_internal_log(LOG_DS_CREATE, dd->dd_pool->dp_spa, 522*ecd6cf80Smarks tx, cr, "dataset = %llu", dsobj); 523*ecd6cf80Smarks 524fa9e4066Sahrens dsl_dataset_close(ds, DS_MODE_STANDARD | DS_MODE_READONLY, FTAG); 525fa9e4066Sahrens } 526fa9e4066Sahrens 527fa9e4066Sahrens int 528fa9e4066Sahrens dmu_objset_create(const char *name, dmu_objset_type_t type, 529fa9e4066Sahrens objset_t *clone_parent, 530*ecd6cf80Smarks void (*func)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx), void *arg) 531fa9e4066Sahrens { 5321d452cf5Sahrens dsl_dir_t *pdd; 533fa9e4066Sahrens const char *tail; 534fa9e4066Sahrens int err = 0; 5351d452cf5Sahrens struct oscarg oa = { 0 }; 536fa9e4066Sahrens 5371d452cf5Sahrens ASSERT(strchr(name, '@') == NULL); 5381d452cf5Sahrens err = dsl_dir_open(name, FTAG, &pdd, &tail); 539ea8dc4b6Seschrock if (err) 540ea8dc4b6Seschrock return (err); 541fa9e4066Sahrens if (tail == NULL) { 5421d452cf5Sahrens dsl_dir_close(pdd, FTAG); 543fa9e4066Sahrens return (EEXIST); 544fa9e4066Sahrens } 545fa9e4066Sahrens 546fa9e4066Sahrens dprintf("name=%s\n", name); 547fa9e4066Sahrens 5481d452cf5Sahrens oa.userfunc = func; 5491d452cf5Sahrens oa.userarg = arg; 5501d452cf5Sahrens oa.lastname = tail; 5511d452cf5Sahrens oa.type = type; 552*ecd6cf80Smarks 5531d452cf5Sahrens if (clone_parent != NULL) { 554fa9e4066Sahrens /* 5551d452cf5Sahrens * You can't clone to a different type. 556fa9e4066Sahrens */ 5571d452cf5Sahrens if (clone_parent->os->os_phys->os_type != type) { 5581d452cf5Sahrens dsl_dir_close(pdd, FTAG); 5591d452cf5Sahrens return (EINVAL); 560fa9e4066Sahrens } 5611d452cf5Sahrens oa.clone_parent = clone_parent->os->os_dsl_dataset; 562fa9e4066Sahrens } 5631d452cf5Sahrens err = dsl_sync_task_do(pdd->dd_pool, dmu_objset_create_check, 5641d452cf5Sahrens dmu_objset_create_sync, pdd, &oa, 5); 5651d452cf5Sahrens dsl_dir_close(pdd, FTAG); 566fa9e4066Sahrens return (err); 567fa9e4066Sahrens } 568fa9e4066Sahrens 569fa9e4066Sahrens int 570fa9e4066Sahrens dmu_objset_destroy(const char *name) 571fa9e4066Sahrens { 572fa9e4066Sahrens objset_t *os; 573fa9e4066Sahrens int error; 574fa9e4066Sahrens 575fa9e4066Sahrens /* 576fa9e4066Sahrens * If it looks like we'll be able to destroy it, and there's 577fa9e4066Sahrens * an unplayed replay log sitting around, destroy the log. 578fa9e4066Sahrens * It would be nicer to do this in dsl_dataset_destroy_sync(), 579fa9e4066Sahrens * but the replay log objset is modified in open context. 580fa9e4066Sahrens */ 581fa9e4066Sahrens error = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_EXCLUSIVE, &os); 582fa9e4066Sahrens if (error == 0) { 583d80c45e0Sbonwick zil_destroy(dmu_objset_zil(os), B_FALSE); 584fa9e4066Sahrens dmu_objset_close(os); 585fa9e4066Sahrens } 586fa9e4066Sahrens 587fa9e4066Sahrens return (dsl_dataset_destroy(name)); 588fa9e4066Sahrens } 589fa9e4066Sahrens 590fa9e4066Sahrens int 591fa9e4066Sahrens dmu_objset_rollback(const char *name) 592fa9e4066Sahrens { 593fa9e4066Sahrens int err; 594fa9e4066Sahrens objset_t *os; 595fa9e4066Sahrens 5961d452cf5Sahrens err = dmu_objset_open(name, DMU_OST_ANY, 5971d452cf5Sahrens DS_MODE_EXCLUSIVE | DS_MODE_INCONSISTENT, &os); 598fa9e4066Sahrens if (err == 0) { 599fa9e4066Sahrens err = zil_suspend(dmu_objset_zil(os)); 600fa9e4066Sahrens if (err == 0) 601fa9e4066Sahrens zil_resume(dmu_objset_zil(os)); 602fa9e4066Sahrens if (err == 0) { 603fa9e4066Sahrens /* XXX uncache everything? */ 6041d452cf5Sahrens err = dsl_dataset_rollback(os->os->os_dsl_dataset); 605fa9e4066Sahrens } 6061d452cf5Sahrens dmu_objset_close(os); 607fa9e4066Sahrens } 608fa9e4066Sahrens return (err); 609fa9e4066Sahrens } 610fa9e4066Sahrens 6111d452cf5Sahrens struct snaparg { 6121d452cf5Sahrens dsl_sync_task_group_t *dstg; 6131d452cf5Sahrens char *snapname; 6141d452cf5Sahrens char failed[MAXPATHLEN]; 615*ecd6cf80Smarks boolean_t checkperms; 6161d452cf5Sahrens }; 6171d452cf5Sahrens 6181d452cf5Sahrens static int 6191d452cf5Sahrens dmu_objset_snapshot_one(char *name, void *arg) 6201d452cf5Sahrens { 6211d452cf5Sahrens struct snaparg *sn = arg; 6221d452cf5Sahrens objset_t *os; 623f2e10be3Srm dmu_objset_stats_t stat; 6241d452cf5Sahrens int err; 6251d452cf5Sahrens 6261d452cf5Sahrens (void) strcpy(sn->failed, name); 6271d452cf5Sahrens 628*ecd6cf80Smarks /* 629*ecd6cf80Smarks * Check permissions only when requested. This only applies when 630*ecd6cf80Smarks * doing a recursive snapshot. The permission checks for the starting 631*ecd6cf80Smarks * dataset have already been performed in zfs_secpolicy_snapshot() 632*ecd6cf80Smarks */ 633*ecd6cf80Smarks if (sn->checkperms == B_TRUE && 634*ecd6cf80Smarks (err = zfs_secpolicy_snapshot_perms(name, CRED()))) 635*ecd6cf80Smarks return (err); 636*ecd6cf80Smarks 6371d452cf5Sahrens err = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_STANDARD, &os); 6381d452cf5Sahrens if (err != 0) 6391d452cf5Sahrens return (err); 6401d452cf5Sahrens 641f2e10be3Srm /* 642f2e10be3Srm * If the objset is in an inconsistent state, return busy. 643f2e10be3Srm */ 644f2e10be3Srm dmu_objset_fast_stat(os, &stat); 645f2e10be3Srm if (stat.dds_inconsistent) { 646f2e10be3Srm dmu_objset_close(os); 647f2e10be3Srm return (EBUSY); 648f2e10be3Srm } 649f2e10be3Srm 6501d452cf5Sahrens /* 6511d452cf5Sahrens * NB: we need to wait for all in-flight changes to get to disk, 6521d452cf5Sahrens * so that we snapshot those changes. zil_suspend does this as 6531d452cf5Sahrens * a side effect. 6541d452cf5Sahrens */ 6551d452cf5Sahrens err = zil_suspend(dmu_objset_zil(os)); 6561d452cf5Sahrens if (err == 0) { 6571d452cf5Sahrens dsl_sync_task_create(sn->dstg, dsl_dataset_snapshot_check, 6581d452cf5Sahrens dsl_dataset_snapshot_sync, os, sn->snapname, 3); 659f2e10be3Srm } else { 660f2e10be3Srm dmu_objset_close(os); 6611d452cf5Sahrens } 662f2e10be3Srm 6631d452cf5Sahrens return (err); 6641d452cf5Sahrens } 6651d452cf5Sahrens 6661d452cf5Sahrens int 6671d452cf5Sahrens dmu_objset_snapshot(char *fsname, char *snapname, boolean_t recursive) 6681d452cf5Sahrens { 6691d452cf5Sahrens dsl_sync_task_t *dst; 6701d452cf5Sahrens struct snaparg sn = { 0 }; 6711d452cf5Sahrens char *cp; 6721d452cf5Sahrens spa_t *spa; 6731d452cf5Sahrens int err; 6741d452cf5Sahrens 6751d452cf5Sahrens (void) strcpy(sn.failed, fsname); 6761d452cf5Sahrens 6771d452cf5Sahrens cp = strchr(fsname, '/'); 6781d452cf5Sahrens if (cp) { 6791d452cf5Sahrens *cp = '\0'; 6801d452cf5Sahrens err = spa_open(fsname, &spa, FTAG); 6811d452cf5Sahrens *cp = '/'; 6821d452cf5Sahrens } else { 6831d452cf5Sahrens err = spa_open(fsname, &spa, FTAG); 6841d452cf5Sahrens } 6851d452cf5Sahrens if (err) 6861d452cf5Sahrens return (err); 6871d452cf5Sahrens 6881d452cf5Sahrens sn.dstg = dsl_sync_task_group_create(spa_get_dsl(spa)); 6891d452cf5Sahrens sn.snapname = snapname; 6901d452cf5Sahrens 6910b69c2f0Sahrens if (recursive) { 692*ecd6cf80Smarks sn.checkperms = B_TRUE; 6930b69c2f0Sahrens err = dmu_objset_find(fsname, 6940b69c2f0Sahrens dmu_objset_snapshot_one, &sn, DS_FIND_CHILDREN); 6950b69c2f0Sahrens } else { 696*ecd6cf80Smarks sn.checkperms = B_FALSE; 6971d452cf5Sahrens err = dmu_objset_snapshot_one(fsname, &sn); 6980b69c2f0Sahrens } 6991d452cf5Sahrens 7001d452cf5Sahrens if (err) 7011d452cf5Sahrens goto out; 7021d452cf5Sahrens 7031d452cf5Sahrens err = dsl_sync_task_group_wait(sn.dstg); 7041d452cf5Sahrens 7051d452cf5Sahrens for (dst = list_head(&sn.dstg->dstg_tasks); dst; 7061d452cf5Sahrens dst = list_next(&sn.dstg->dstg_tasks, dst)) { 7071d452cf5Sahrens objset_t *os = dst->dst_arg1; 7081d452cf5Sahrens if (dst->dst_err) 7091d452cf5Sahrens dmu_objset_name(os, sn.failed); 7101d452cf5Sahrens zil_resume(dmu_objset_zil(os)); 7111d452cf5Sahrens dmu_objset_close(os); 7121d452cf5Sahrens } 7131d452cf5Sahrens out: 7141d452cf5Sahrens if (err) 7151d452cf5Sahrens (void) strcpy(fsname, sn.failed); 7161d452cf5Sahrens dsl_sync_task_group_destroy(sn.dstg); 7171d452cf5Sahrens spa_close(spa, FTAG); 7181d452cf5Sahrens return (err); 7191d452cf5Sahrens } 7201d452cf5Sahrens 721fa9e4066Sahrens static void 722c717a561Smaybee dmu_objset_sync_dnodes(list_t *list, dmu_tx_t *tx) 723fa9e4066Sahrens { 724c717a561Smaybee dnode_t *dn; 725faafa6e3Sahrens 726c717a561Smaybee while (dn = list_head(list)) { 727c717a561Smaybee ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT); 728c717a561Smaybee ASSERT(dn->dn_dbuf->db_data_pending); 729c717a561Smaybee /* 730c717a561Smaybee * Initialize dn_zio outside dnode_sync() 731c717a561Smaybee * to accomodate meta-dnode 732c717a561Smaybee */ 733c717a561Smaybee dn->dn_zio = dn->dn_dbuf->db_data_pending->dr_zio; 734c717a561Smaybee ASSERT(dn->dn_zio); 735faafa6e3Sahrens 736c717a561Smaybee ASSERT3U(dn->dn_nlevels, <=, DN_MAX_LEVELS); 737c717a561Smaybee list_remove(list, dn); 738c717a561Smaybee dnode_sync(dn, tx); 739fa9e4066Sahrens } 740fa9e4066Sahrens } 741fa9e4066Sahrens 742fa9e4066Sahrens /* ARGSUSED */ 743fa9e4066Sahrens static void 744c717a561Smaybee ready(zio_t *zio, arc_buf_t *abuf, void *arg) 745fa9e4066Sahrens { 746fa9e4066Sahrens objset_impl_t *os = arg; 747c717a561Smaybee blkptr_t *bp = os->os_rootbp; 748c717a561Smaybee dnode_phys_t *dnp = &os->os_phys->os_meta_dnode; 749fa9e4066Sahrens int i; 750fa9e4066Sahrens 751fa9e4066Sahrens /* 752fa9e4066Sahrens * Update rootbp fill count. 753fa9e4066Sahrens */ 754c717a561Smaybee bp->blk_fill = 1; /* count the meta-dnode */ 755fa9e4066Sahrens for (i = 0; i < dnp->dn_nblkptr; i++) 756c717a561Smaybee bp->blk_fill += dnp->dn_blkptr[i].blk_fill; 757c717a561Smaybee } 758c717a561Smaybee 759c717a561Smaybee /* ARGSUSED */ 760c717a561Smaybee static void 761c717a561Smaybee killer(zio_t *zio, arc_buf_t *abuf, void *arg) 762c717a561Smaybee { 763c717a561Smaybee objset_impl_t *os = arg; 764c717a561Smaybee 765c717a561Smaybee ASSERT3U(zio->io_error, ==, 0); 766fa9e4066Sahrens 767fa9e4066Sahrens BP_SET_TYPE(zio->io_bp, DMU_OT_OBJSET); 768fa9e4066Sahrens BP_SET_LEVEL(zio->io_bp, 0); 769fa9e4066Sahrens 770fa9e4066Sahrens if (!DVA_EQUAL(BP_IDENTITY(zio->io_bp), 771fa9e4066Sahrens BP_IDENTITY(&zio->io_bp_orig))) { 772c717a561Smaybee if (zio->io_bp_orig.blk_birth == os->os_synctx->tx_txg) 773c717a561Smaybee dsl_dataset_block_kill(os->os_dsl_dataset, 774c717a561Smaybee &zio->io_bp_orig, NULL, os->os_synctx); 775fa9e4066Sahrens dsl_dataset_block_born(os->os_dsl_dataset, zio->io_bp, 776fa9e4066Sahrens os->os_synctx); 777fa9e4066Sahrens } 778c717a561Smaybee arc_release(os->os_phys_buf, &os->os_phys_buf); 779fa9e4066Sahrens } 780fa9e4066Sahrens 781fa9e4066Sahrens /* called from dsl */ 782fa9e4066Sahrens void 783c717a561Smaybee dmu_objset_sync(objset_impl_t *os, zio_t *pio, dmu_tx_t *tx) 784fa9e4066Sahrens { 785fa9e4066Sahrens int txgoff; 786ea8dc4b6Seschrock zbookmark_t zb; 787c717a561Smaybee zio_t *zio; 788c717a561Smaybee list_t *list; 789c717a561Smaybee dbuf_dirty_record_t *dr; 7909bc11082Sek int zio_flags; 791c717a561Smaybee 792c717a561Smaybee dprintf_ds(os->os_dsl_dataset, "txg=%llu\n", tx->tx_txg); 793fa9e4066Sahrens 794fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 795fa9e4066Sahrens /* XXX the write_done callback should really give us the tx... */ 796fa9e4066Sahrens os->os_synctx = tx; 797fa9e4066Sahrens 79887bd5c1eSahrens if (os->os_dsl_dataset == NULL) { 79987bd5c1eSahrens /* 80087bd5c1eSahrens * This is the MOS. If we have upgraded, 80187bd5c1eSahrens * spa_max_replication() could change, so reset 80287bd5c1eSahrens * os_copies here. 80387bd5c1eSahrens */ 80487bd5c1eSahrens os->os_copies = spa_max_replication(os->os_spa); 80587bd5c1eSahrens } 80687bd5c1eSahrens 807fa9e4066Sahrens /* 808c717a561Smaybee * Create the root block IO 809fa9e4066Sahrens */ 810ea8dc4b6Seschrock zb.zb_objset = os->os_dsl_dataset ? os->os_dsl_dataset->ds_object : 0; 811ea8dc4b6Seschrock zb.zb_object = 0; 812ea8dc4b6Seschrock zb.zb_level = -1; 813ea8dc4b6Seschrock zb.zb_blkid = 0; 8149bc11082Sek zio_flags = ZIO_FLAG_MUSTSUCCEED; 8159bc11082Sek if (dmu_ot[DMU_OT_OBJSET].ot_metadata || zb.zb_level != 0) 8169bc11082Sek zio_flags |= ZIO_FLAG_METADATA; 817c717a561Smaybee if (BP_IS_OLDER(os->os_rootbp, tx->tx_txg)) 818c717a561Smaybee dsl_dataset_block_kill(os->os_dsl_dataset, 819c717a561Smaybee os->os_rootbp, pio, tx); 820c717a561Smaybee zio = arc_write(pio, os->os_spa, os->os_md_checksum, 82144cd46caSbillm os->os_md_compress, 822d0ad202dSahrens dmu_get_replication_level(os, &zb, DMU_OT_OBJSET), 823c717a561Smaybee tx->tx_txg, os->os_rootbp, os->os_phys_buf, ready, killer, os, 8249bc11082Sek ZIO_PRIORITY_ASYNC_WRITE, zio_flags, &zb); 825c717a561Smaybee 826c717a561Smaybee /* 827c717a561Smaybee * Sync meta-dnode - the parent IO for the sync is the root block 828c717a561Smaybee */ 829c717a561Smaybee os->os_meta_dnode->dn_zio = zio; 830c717a561Smaybee dnode_sync(os->os_meta_dnode, tx); 831c717a561Smaybee 832c717a561Smaybee txgoff = tx->tx_txg & TXG_MASK; 833fa9e4066Sahrens 834c717a561Smaybee dmu_objset_sync_dnodes(&os->os_free_dnodes[txgoff], tx); 835c717a561Smaybee dmu_objset_sync_dnodes(&os->os_dirty_dnodes[txgoff], tx); 836fa9e4066Sahrens 837c717a561Smaybee list = &os->os_meta_dnode->dn_dirty_records[txgoff]; 838c717a561Smaybee while (dr = list_head(list)) { 839c717a561Smaybee ASSERT(dr->dr_dbuf->db_level == 0); 840c717a561Smaybee list_remove(list, dr); 841c717a561Smaybee if (dr->dr_zio) 842c717a561Smaybee zio_nowait(dr->dr_zio); 843c717a561Smaybee } 844c717a561Smaybee /* 845c717a561Smaybee * Free intent log blocks up to this tx. 846c717a561Smaybee */ 847c717a561Smaybee zil_sync(os->os_zil, tx); 848c717a561Smaybee zio_nowait(zio); 849fa9e4066Sahrens } 850fa9e4066Sahrens 851fa9e4066Sahrens void 852a2eea2e1Sahrens dmu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp, 853a2eea2e1Sahrens uint64_t *usedobjsp, uint64_t *availobjsp) 854fa9e4066Sahrens { 855a2eea2e1Sahrens dsl_dataset_space(os->os->os_dsl_dataset, refdbytesp, availbytesp, 856a2eea2e1Sahrens usedobjsp, availobjsp); 857a2eea2e1Sahrens } 858a2eea2e1Sahrens 859a2eea2e1Sahrens uint64_t 860a2eea2e1Sahrens dmu_objset_fsid_guid(objset_t *os) 861a2eea2e1Sahrens { 862a2eea2e1Sahrens return (dsl_dataset_fsid_guid(os->os->os_dsl_dataset)); 863a2eea2e1Sahrens } 864a2eea2e1Sahrens 865a2eea2e1Sahrens void 866a2eea2e1Sahrens dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat) 867a2eea2e1Sahrens { 868a2eea2e1Sahrens stat->dds_type = os->os->os_phys->os_type; 869a2eea2e1Sahrens if (os->os->os_dsl_dataset) 870a2eea2e1Sahrens dsl_dataset_fast_stat(os->os->os_dsl_dataset, stat); 871a2eea2e1Sahrens } 872a2eea2e1Sahrens 873a2eea2e1Sahrens void 874a2eea2e1Sahrens dmu_objset_stats(objset_t *os, nvlist_t *nv) 875a2eea2e1Sahrens { 876a2eea2e1Sahrens ASSERT(os->os->os_dsl_dataset || 877a2eea2e1Sahrens os->os->os_phys->os_type == DMU_OST_META); 878a2eea2e1Sahrens 879a2eea2e1Sahrens if (os->os->os_dsl_dataset != NULL) 880a2eea2e1Sahrens dsl_dataset_stats(os->os->os_dsl_dataset, nv); 881a2eea2e1Sahrens 882a2eea2e1Sahrens dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_TYPE, 883a2eea2e1Sahrens os->os->os_phys->os_type); 884fa9e4066Sahrens } 885fa9e4066Sahrens 886fa9e4066Sahrens int 887fa9e4066Sahrens dmu_objset_is_snapshot(objset_t *os) 888fa9e4066Sahrens { 889fa9e4066Sahrens if (os->os->os_dsl_dataset != NULL) 890fa9e4066Sahrens return (dsl_dataset_is_snapshot(os->os->os_dsl_dataset)); 891fa9e4066Sahrens else 892fa9e4066Sahrens return (B_FALSE); 893fa9e4066Sahrens } 894fa9e4066Sahrens 895fa9e4066Sahrens int 896fa9e4066Sahrens dmu_snapshot_list_next(objset_t *os, int namelen, char *name, 89787e5029aSahrens uint64_t *idp, uint64_t *offp) 898fa9e4066Sahrens { 899fa9e4066Sahrens dsl_dataset_t *ds = os->os->os_dsl_dataset; 900fa9e4066Sahrens zap_cursor_t cursor; 901fa9e4066Sahrens zap_attribute_t attr; 902fa9e4066Sahrens 903fa9e4066Sahrens if (ds->ds_phys->ds_snapnames_zapobj == 0) 904fa9e4066Sahrens return (ENOENT); 905fa9e4066Sahrens 906fa9e4066Sahrens zap_cursor_init_serialized(&cursor, 907fa9e4066Sahrens ds->ds_dir->dd_pool->dp_meta_objset, 908fa9e4066Sahrens ds->ds_phys->ds_snapnames_zapobj, *offp); 909fa9e4066Sahrens 91087e5029aSahrens if (zap_cursor_retrieve(&cursor, &attr) != 0) { 91187e5029aSahrens zap_cursor_fini(&cursor); 91287e5029aSahrens return (ENOENT); 91387e5029aSahrens } 91487e5029aSahrens 91587e5029aSahrens if (strlen(attr.za_name) + 1 > namelen) { 91687e5029aSahrens zap_cursor_fini(&cursor); 91787e5029aSahrens return (ENAMETOOLONG); 91887e5029aSahrens } 91987e5029aSahrens 92087e5029aSahrens (void) strcpy(name, attr.za_name); 92187e5029aSahrens if (idp) 92287e5029aSahrens *idp = attr.za_first_integer; 92387e5029aSahrens zap_cursor_advance(&cursor); 92487e5029aSahrens *offp = zap_cursor_serialize(&cursor); 92587e5029aSahrens zap_cursor_fini(&cursor); 92687e5029aSahrens 92787e5029aSahrens return (0); 92887e5029aSahrens } 92987e5029aSahrens 93087e5029aSahrens int 93187e5029aSahrens dmu_dir_list_next(objset_t *os, int namelen, char *name, 93287e5029aSahrens uint64_t *idp, uint64_t *offp) 93387e5029aSahrens { 93487e5029aSahrens dsl_dir_t *dd = os->os->os_dsl_dataset->ds_dir; 93587e5029aSahrens zap_cursor_t cursor; 93687e5029aSahrens zap_attribute_t attr; 93787e5029aSahrens 93887e5029aSahrens /* there is no next dir on a snapshot! */ 93987e5029aSahrens if (os->os->os_dsl_dataset->ds_object != 94087e5029aSahrens dd->dd_phys->dd_head_dataset_obj) 941fa9e4066Sahrens return (ENOENT); 942fa9e4066Sahrens 94387e5029aSahrens zap_cursor_init_serialized(&cursor, 94487e5029aSahrens dd->dd_pool->dp_meta_objset, 94587e5029aSahrens dd->dd_phys->dd_child_dir_zapobj, *offp); 94687e5029aSahrens 94787e5029aSahrens if (zap_cursor_retrieve(&cursor, &attr) != 0) { 94887e5029aSahrens zap_cursor_fini(&cursor); 94987e5029aSahrens return (ENOENT); 95087e5029aSahrens } 95187e5029aSahrens 95287e5029aSahrens if (strlen(attr.za_name) + 1 > namelen) { 95387e5029aSahrens zap_cursor_fini(&cursor); 954fa9e4066Sahrens return (ENAMETOOLONG); 95587e5029aSahrens } 956fa9e4066Sahrens 957fa9e4066Sahrens (void) strcpy(name, attr.za_name); 95887e5029aSahrens if (idp) 95987e5029aSahrens *idp = attr.za_first_integer; 960fa9e4066Sahrens zap_cursor_advance(&cursor); 961fa9e4066Sahrens *offp = zap_cursor_serialize(&cursor); 96287e5029aSahrens zap_cursor_fini(&cursor); 963fa9e4066Sahrens 964fa9e4066Sahrens return (0); 965fa9e4066Sahrens } 966fa9e4066Sahrens 967fa9e4066Sahrens /* 968fa9e4066Sahrens * Find all objsets under name, and for each, call 'func(child_name, arg)'. 969fa9e4066Sahrens */ 9701d452cf5Sahrens int 9711d452cf5Sahrens dmu_objset_find(char *name, int func(char *, void *), void *arg, int flags) 972fa9e4066Sahrens { 973fa9e4066Sahrens dsl_dir_t *dd; 974fa9e4066Sahrens objset_t *os; 975fa9e4066Sahrens uint64_t snapobj; 976fa9e4066Sahrens zap_cursor_t zc; 977b7661cccSmmusante zap_attribute_t *attr; 978fa9e4066Sahrens char *child; 979ea8dc4b6Seschrock int do_self, err; 980fa9e4066Sahrens 981ea8dc4b6Seschrock err = dsl_dir_open(name, FTAG, &dd, NULL); 982ea8dc4b6Seschrock if (err) 9831d452cf5Sahrens return (err); 984fa9e4066Sahrens 9851d452cf5Sahrens /* NB: the $MOS dir doesn't have a head dataset */ 986fa9e4066Sahrens do_self = (dd->dd_phys->dd_head_dataset_obj != 0); 987b7661cccSmmusante attr = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); 988fa9e4066Sahrens 989fa9e4066Sahrens /* 990fa9e4066Sahrens * Iterate over all children. 991fa9e4066Sahrens */ 9920b69c2f0Sahrens if (flags & DS_FIND_CHILDREN) { 9930b69c2f0Sahrens for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset, 9940b69c2f0Sahrens dd->dd_phys->dd_child_dir_zapobj); 995b7661cccSmmusante zap_cursor_retrieve(&zc, attr) == 0; 9960b69c2f0Sahrens (void) zap_cursor_advance(&zc)) { 997b7661cccSmmusante ASSERT(attr->za_integer_length == sizeof (uint64_t)); 998b7661cccSmmusante ASSERT(attr->za_num_integers == 1); 999fa9e4066Sahrens 10000b69c2f0Sahrens /* 10010b69c2f0Sahrens * No separating '/' because parent's name ends in /. 10020b69c2f0Sahrens */ 10030b69c2f0Sahrens child = kmem_alloc(MAXPATHLEN, KM_SLEEP); 10040b69c2f0Sahrens /* XXX could probably just use name here */ 10050b69c2f0Sahrens dsl_dir_name(dd, child); 10060b69c2f0Sahrens (void) strcat(child, "/"); 1007b7661cccSmmusante (void) strcat(child, attr->za_name); 10080b69c2f0Sahrens err = dmu_objset_find(child, func, arg, flags); 10090b69c2f0Sahrens kmem_free(child, MAXPATHLEN); 10100b69c2f0Sahrens if (err) 10110b69c2f0Sahrens break; 10120b69c2f0Sahrens } 10130b69c2f0Sahrens zap_cursor_fini(&zc); 10141d452cf5Sahrens 10150b69c2f0Sahrens if (err) { 10160b69c2f0Sahrens dsl_dir_close(dd, FTAG); 1017b7661cccSmmusante kmem_free(attr, sizeof (zap_attribute_t)); 10180b69c2f0Sahrens return (err); 10190b69c2f0Sahrens } 1020fa9e4066Sahrens } 1021fa9e4066Sahrens 1022fa9e4066Sahrens /* 1023fa9e4066Sahrens * Iterate over all snapshots. 1024fa9e4066Sahrens */ 1025fa9e4066Sahrens if ((flags & DS_FIND_SNAPSHOTS) && 1026fa9e4066Sahrens dmu_objset_open(name, DMU_OST_ANY, 1027fa9e4066Sahrens DS_MODE_STANDARD | DS_MODE_READONLY, &os) == 0) { 1028fa9e4066Sahrens 1029fa9e4066Sahrens snapobj = os->os->os_dsl_dataset->ds_phys->ds_snapnames_zapobj; 1030fa9e4066Sahrens dmu_objset_close(os); 1031fa9e4066Sahrens 1032fa9e4066Sahrens for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset, snapobj); 1033b7661cccSmmusante zap_cursor_retrieve(&zc, attr) == 0; 1034fa9e4066Sahrens (void) zap_cursor_advance(&zc)) { 1035b7661cccSmmusante ASSERT(attr->za_integer_length == sizeof (uint64_t)); 1036b7661cccSmmusante ASSERT(attr->za_num_integers == 1); 1037fa9e4066Sahrens 1038fa9e4066Sahrens child = kmem_alloc(MAXPATHLEN, KM_SLEEP); 1039fa9e4066Sahrens /* XXX could probably just use name here */ 1040fa9e4066Sahrens dsl_dir_name(dd, child); 1041fa9e4066Sahrens (void) strcat(child, "@"); 1042b7661cccSmmusante (void) strcat(child, attr->za_name); 10431d452cf5Sahrens err = func(child, arg); 1044fa9e4066Sahrens kmem_free(child, MAXPATHLEN); 10451d452cf5Sahrens if (err) 10461d452cf5Sahrens break; 1047fa9e4066Sahrens } 104887e5029aSahrens zap_cursor_fini(&zc); 1049fa9e4066Sahrens } 1050fa9e4066Sahrens 1051fa9e4066Sahrens dsl_dir_close(dd, FTAG); 1052b7661cccSmmusante kmem_free(attr, sizeof (zap_attribute_t)); 1053fa9e4066Sahrens 10541d452cf5Sahrens if (err) 10551d452cf5Sahrens return (err); 10561d452cf5Sahrens 1057fa9e4066Sahrens /* 1058fa9e4066Sahrens * Apply to self if appropriate. 1059fa9e4066Sahrens */ 1060fa9e4066Sahrens if (do_self) 10611d452cf5Sahrens err = func(name, arg); 10621d452cf5Sahrens return (err); 1063fa9e4066Sahrens } 1064