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 /* 22a4585abfSahrens * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27fa9e4066Sahrens 28ecd6cf80Smarks #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> 36ecd6cf80Smarks #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> 45ecd6cf80Smarks #include <sys/zfs_ioctl.h> 46fa9e4066Sahrens 47fa9e4066Sahrens spa_t * 48fa9e4066Sahrens dmu_objset_spa(objset_t *os) 49fa9e4066Sahrens { 50fa9e4066Sahrens return (os->os->os_spa); 51fa9e4066Sahrens } 52fa9e4066Sahrens 53fa9e4066Sahrens zilog_t * 54fa9e4066Sahrens dmu_objset_zil(objset_t *os) 55fa9e4066Sahrens { 56fa9e4066Sahrens return (os->os->os_zil); 57fa9e4066Sahrens } 58fa9e4066Sahrens 59fa9e4066Sahrens dsl_pool_t * 60fa9e4066Sahrens dmu_objset_pool(objset_t *os) 61fa9e4066Sahrens { 62fa9e4066Sahrens dsl_dataset_t *ds; 63fa9e4066Sahrens 64fa9e4066Sahrens if ((ds = os->os->os_dsl_dataset) != NULL && ds->ds_dir) 65fa9e4066Sahrens return (ds->ds_dir->dd_pool); 66fa9e4066Sahrens else 67fa9e4066Sahrens return (spa_get_dsl(os->os->os_spa)); 68fa9e4066Sahrens } 69fa9e4066Sahrens 70fa9e4066Sahrens dsl_dataset_t * 71fa9e4066Sahrens dmu_objset_ds(objset_t *os) 72fa9e4066Sahrens { 73fa9e4066Sahrens return (os->os->os_dsl_dataset); 74fa9e4066Sahrens } 75fa9e4066Sahrens 76fa9e4066Sahrens dmu_objset_type_t 77fa9e4066Sahrens dmu_objset_type(objset_t *os) 78fa9e4066Sahrens { 79fa9e4066Sahrens return (os->os->os_phys->os_type); 80fa9e4066Sahrens } 81fa9e4066Sahrens 82fa9e4066Sahrens void 83fa9e4066Sahrens dmu_objset_name(objset_t *os, char *buf) 84fa9e4066Sahrens { 85fa9e4066Sahrens dsl_dataset_name(os->os->os_dsl_dataset, buf); 86fa9e4066Sahrens } 87fa9e4066Sahrens 88fa9e4066Sahrens uint64_t 89fa9e4066Sahrens dmu_objset_id(objset_t *os) 90fa9e4066Sahrens { 91fa9e4066Sahrens dsl_dataset_t *ds = os->os->os_dsl_dataset; 92fa9e4066Sahrens 93fa9e4066Sahrens return (ds ? ds->ds_object : 0); 94fa9e4066Sahrens } 95fa9e4066Sahrens 96fa9e4066Sahrens static void 97fa9e4066Sahrens checksum_changed_cb(void *arg, uint64_t newval) 98fa9e4066Sahrens { 99fa9e4066Sahrens objset_impl_t *osi = arg; 100fa9e4066Sahrens 101fa9e4066Sahrens /* 102fa9e4066Sahrens * Inheritance should have been done by now. 103fa9e4066Sahrens */ 104fa9e4066Sahrens ASSERT(newval != ZIO_CHECKSUM_INHERIT); 105fa9e4066Sahrens 106fa9e4066Sahrens osi->os_checksum = zio_checksum_select(newval, ZIO_CHECKSUM_ON_VALUE); 107fa9e4066Sahrens } 108fa9e4066Sahrens 109fa9e4066Sahrens static void 110fa9e4066Sahrens compression_changed_cb(void *arg, uint64_t newval) 111fa9e4066Sahrens { 112fa9e4066Sahrens objset_impl_t *osi = arg; 113fa9e4066Sahrens 114fa9e4066Sahrens /* 115fa9e4066Sahrens * Inheritance and range checking should have been done by now. 116fa9e4066Sahrens */ 117fa9e4066Sahrens ASSERT(newval != ZIO_COMPRESS_INHERIT); 118fa9e4066Sahrens 119fa9e4066Sahrens osi->os_compress = zio_compress_select(newval, ZIO_COMPRESS_ON_VALUE); 120fa9e4066Sahrens } 121fa9e4066Sahrens 122d0ad202dSahrens static void 123d0ad202dSahrens copies_changed_cb(void *arg, uint64_t newval) 124d0ad202dSahrens { 125d0ad202dSahrens objset_impl_t *osi = arg; 126d0ad202dSahrens 127d0ad202dSahrens /* 128d0ad202dSahrens * Inheritance and range checking should have been done by now. 129d0ad202dSahrens */ 130d0ad202dSahrens ASSERT(newval > 0); 131d0ad202dSahrens ASSERT(newval <= spa_max_replication(osi->os_spa)); 132d0ad202dSahrens 133d0ad202dSahrens osi->os_copies = newval; 134d0ad202dSahrens } 135d0ad202dSahrens 1363baa08fcSek static void 1373baa08fcSek primary_cache_changed_cb(void *arg, uint64_t newval) 1383baa08fcSek { 1393baa08fcSek objset_impl_t *osi = arg; 1403baa08fcSek 1413baa08fcSek /* 1423baa08fcSek * Inheritance and range checking should have been done by now. 1433baa08fcSek */ 1443baa08fcSek ASSERT(newval == ZFS_CACHE_ALL || newval == ZFS_CACHE_NONE || 1453baa08fcSek newval == ZFS_CACHE_METADATA); 1463baa08fcSek 1473baa08fcSek osi->os_primary_cache = newval; 1483baa08fcSek } 1493baa08fcSek 1503baa08fcSek static void 1513baa08fcSek secondary_cache_changed_cb(void *arg, uint64_t newval) 1523baa08fcSek { 1533baa08fcSek objset_impl_t *osi = arg; 1543baa08fcSek 1553baa08fcSek /* 1563baa08fcSek * Inheritance and range checking should have been done by now. 1573baa08fcSek */ 1583baa08fcSek ASSERT(newval == ZFS_CACHE_ALL || newval == ZFS_CACHE_NONE || 1593baa08fcSek newval == ZFS_CACHE_METADATA); 1603baa08fcSek 1613baa08fcSek osi->os_secondary_cache = newval; 1623baa08fcSek } 1633baa08fcSek 164fa9e4066Sahrens void 165fa9e4066Sahrens dmu_objset_byteswap(void *buf, size_t size) 166fa9e4066Sahrens { 167fa9e4066Sahrens objset_phys_t *osp = buf; 168fa9e4066Sahrens 169fa9e4066Sahrens ASSERT(size == sizeof (objset_phys_t)); 170fa9e4066Sahrens dnode_byteswap(&osp->os_meta_dnode); 171fa9e4066Sahrens byteswap_uint64_array(&osp->os_zil_header, sizeof (zil_header_t)); 172fa9e4066Sahrens osp->os_type = BSWAP_64(osp->os_type); 173fa9e4066Sahrens } 174fa9e4066Sahrens 175ea8dc4b6Seschrock int 176ea8dc4b6Seschrock dmu_objset_open_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp, 177ea8dc4b6Seschrock objset_impl_t **osip) 178fa9e4066Sahrens { 17991ebeef5Sahrens objset_impl_t *osi; 180088f3894Sahrens int i, err; 181fa9e4066Sahrens 18291ebeef5Sahrens ASSERT(ds == NULL || MUTEX_HELD(&ds->ds_opening_lock)); 18391ebeef5Sahrens 184fa9e4066Sahrens osi = kmem_zalloc(sizeof (objset_impl_t), KM_SLEEP); 185fa9e4066Sahrens osi->os.os = osi; 186fa9e4066Sahrens osi->os_dsl_dataset = ds; 187fa9e4066Sahrens osi->os_spa = spa; 188c717a561Smaybee osi->os_rootbp = bp; 189c717a561Smaybee if (!BP_IS_HOLE(osi->os_rootbp)) { 19013506d1eSmaybee uint32_t aflags = ARC_WAIT; 191ea8dc4b6Seschrock zbookmark_t zb; 192ea8dc4b6Seschrock zb.zb_objset = ds ? ds->ds_object : 0; 193ea8dc4b6Seschrock zb.zb_object = 0; 194ea8dc4b6Seschrock zb.zb_level = -1; 195ea8dc4b6Seschrock zb.zb_blkid = 0; 1963baa08fcSek if (DMU_OS_IS_L2CACHEABLE(osi)) 1973baa08fcSek aflags |= ARC_L2CACHE; 198ea8dc4b6Seschrock 199c717a561Smaybee dprintf_bp(osi->os_rootbp, "reading %s", ""); 200088f3894Sahrens /* 201088f3894Sahrens * NB: when bprewrite scrub can change the bp, 202088f3894Sahrens * and this is called from dmu_objset_open_ds_os, the bp 203088f3894Sahrens * could change, and we'll need a lock. 204088f3894Sahrens */ 205088f3894Sahrens err = arc_read_nolock(NULL, spa, osi->os_rootbp, 206c717a561Smaybee arc_getbuf_func, &osi->os_phys_buf, 20713506d1eSmaybee ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_CANFAIL, &aflags, &zb); 208ea8dc4b6Seschrock if (err) { 209ea8dc4b6Seschrock kmem_free(osi, sizeof (objset_impl_t)); 210*b87f3af3Sperrin /* convert checksum errors into IO errors */ 211*b87f3af3Sperrin if (err == ECKSUM) 212*b87f3af3Sperrin err = EIO; 213ea8dc4b6Seschrock return (err); 214ea8dc4b6Seschrock } 215c717a561Smaybee osi->os_phys = osi->os_phys_buf->b_data; 216fa9e4066Sahrens } else { 217c717a561Smaybee osi->os_phys_buf = arc_buf_alloc(spa, sizeof (objset_phys_t), 218c717a561Smaybee &osi->os_phys_buf, ARC_BUFC_METADATA); 219c717a561Smaybee osi->os_phys = osi->os_phys_buf->b_data; 220fa9e4066Sahrens bzero(osi->os_phys, sizeof (objset_phys_t)); 221fa9e4066Sahrens } 222fa9e4066Sahrens 223fa9e4066Sahrens /* 224fa9e4066Sahrens * Note: the changed_cb will be called once before the register 225fa9e4066Sahrens * func returns, thus changing the checksum/compression from the 2263baa08fcSek * default (fletcher2/off). Snapshots don't need to know about 2273baa08fcSek * checksum/compression/copies. 228fa9e4066Sahrens */ 2293baa08fcSek if (ds) { 2303baa08fcSek err = dsl_prop_register(ds, "primarycache", 2313baa08fcSek primary_cache_changed_cb, osi); 232d0ad202dSahrens if (err == 0) 2333baa08fcSek err = dsl_prop_register(ds, "secondarycache", 2343baa08fcSek secondary_cache_changed_cb, osi); 2353baa08fcSek if (!dsl_dataset_is_snapshot(ds)) { 2363baa08fcSek if (err == 0) 2373baa08fcSek err = dsl_prop_register(ds, "checksum", 2383baa08fcSek checksum_changed_cb, osi); 2393baa08fcSek if (err == 0) 2403baa08fcSek err = dsl_prop_register(ds, "compression", 2413baa08fcSek compression_changed_cb, osi); 2423baa08fcSek if (err == 0) 2433baa08fcSek err = dsl_prop_register(ds, "copies", 2443baa08fcSek copies_changed_cb, osi); 2453baa08fcSek } 246ea8dc4b6Seschrock if (err) { 247c717a561Smaybee VERIFY(arc_buf_remove_ref(osi->os_phys_buf, 248c717a561Smaybee &osi->os_phys_buf) == 1); 249ea8dc4b6Seschrock kmem_free(osi, sizeof (objset_impl_t)); 250ea8dc4b6Seschrock return (err); 251ea8dc4b6Seschrock } 25299653d4eSeschrock } else if (ds == NULL) { 253fa9e4066Sahrens /* It's the meta-objset. */ 254fa9e4066Sahrens osi->os_checksum = ZIO_CHECKSUM_FLETCHER_4; 255ea8dc4b6Seschrock osi->os_compress = ZIO_COMPRESS_LZJB; 256d0ad202dSahrens osi->os_copies = spa_max_replication(spa); 2573baa08fcSek osi->os_primary_cache = ZFS_CACHE_ALL; 2583baa08fcSek osi->os_secondary_cache = ZFS_CACHE_ALL; 259fa9e4066Sahrens } 260fa9e4066Sahrens 261088f3894Sahrens osi->os_zil_header = osi->os_phys->os_zil_header; 262088f3894Sahrens osi->os_zil = zil_alloc(&osi->os, &osi->os_zil_header); 263fa9e4066Sahrens 264fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++) { 265fa9e4066Sahrens list_create(&osi->os_dirty_dnodes[i], sizeof (dnode_t), 266fa9e4066Sahrens offsetof(dnode_t, dn_dirty_link[i])); 267fa9e4066Sahrens list_create(&osi->os_free_dnodes[i], sizeof (dnode_t), 268fa9e4066Sahrens offsetof(dnode_t, dn_dirty_link[i])); 269fa9e4066Sahrens } 270fa9e4066Sahrens list_create(&osi->os_dnodes, sizeof (dnode_t), 271fa9e4066Sahrens offsetof(dnode_t, dn_link)); 272fa9e4066Sahrens list_create(&osi->os_downgraded_dbufs, sizeof (dmu_buf_impl_t), 273fa9e4066Sahrens offsetof(dmu_buf_impl_t, db_link)); 274fa9e4066Sahrens 2755ad82045Snd mutex_init(&osi->os_lock, NULL, MUTEX_DEFAULT, NULL); 2765ad82045Snd mutex_init(&osi->os_obj_lock, NULL, MUTEX_DEFAULT, NULL); 277f18faf3fSek mutex_init(&osi->os_user_ptr_lock, NULL, MUTEX_DEFAULT, NULL); 2785ad82045Snd 279fa9e4066Sahrens osi->os_meta_dnode = dnode_special_open(osi, 280fa9e4066Sahrens &osi->os_phys->os_meta_dnode, DMU_META_DNODE_OBJECT); 281fa9e4066Sahrens 28291ebeef5Sahrens /* 28391ebeef5Sahrens * We should be the only thread trying to do this because we 28491ebeef5Sahrens * have ds_opening_lock 28591ebeef5Sahrens */ 28691ebeef5Sahrens if (ds) { 28791ebeef5Sahrens VERIFY(NULL == dsl_dataset_set_user_ptr(ds, osi, 28891ebeef5Sahrens dmu_objset_evict)); 289fa9e4066Sahrens } 290fa9e4066Sahrens 291ea8dc4b6Seschrock *osip = osi; 292ea8dc4b6Seschrock return (0); 293fa9e4066Sahrens } 294fa9e4066Sahrens 2953cb34c60Sahrens static int 2963cb34c60Sahrens dmu_objset_open_ds_os(dsl_dataset_t *ds, objset_t *os, dmu_objset_type_t type) 2973cb34c60Sahrens { 2983cb34c60Sahrens objset_impl_t *osi; 2993cb34c60Sahrens 3003cb34c60Sahrens mutex_enter(&ds->ds_opening_lock); 3013cb34c60Sahrens osi = dsl_dataset_get_user_ptr(ds); 3023cb34c60Sahrens if (osi == NULL) { 303745cd3c5Smaybee int err; 304745cd3c5Smaybee 3053cb34c60Sahrens err = dmu_objset_open_impl(dsl_dataset_get_spa(ds), 3063cb34c60Sahrens ds, &ds->ds_phys->ds_bp, &osi); 307745cd3c5Smaybee if (err) { 308745cd3c5Smaybee mutex_exit(&ds->ds_opening_lock); 3093cb34c60Sahrens return (err); 310745cd3c5Smaybee } 3113cb34c60Sahrens } 3123cb34c60Sahrens mutex_exit(&ds->ds_opening_lock); 3133cb34c60Sahrens 3143cb34c60Sahrens os->os = osi; 315745cd3c5Smaybee os->os_mode = DS_MODE_NOHOLD; 3163cb34c60Sahrens 3173cb34c60Sahrens if (type != DMU_OST_ANY && type != os->os->os_phys->os_type) 3183cb34c60Sahrens return (EINVAL); 3193cb34c60Sahrens return (0); 3203cb34c60Sahrens } 3213cb34c60Sahrens 3223cb34c60Sahrens int 3233cb34c60Sahrens dmu_objset_open_ds(dsl_dataset_t *ds, dmu_objset_type_t type, objset_t **osp) 3243cb34c60Sahrens { 3253cb34c60Sahrens objset_t *os; 3263cb34c60Sahrens int err; 3273cb34c60Sahrens 3283cb34c60Sahrens os = kmem_alloc(sizeof (objset_t), KM_SLEEP); 3293cb34c60Sahrens err = dmu_objset_open_ds_os(ds, os, type); 3303cb34c60Sahrens if (err) 3313cb34c60Sahrens kmem_free(os, sizeof (objset_t)); 3323cb34c60Sahrens else 3333cb34c60Sahrens *osp = os; 3343cb34c60Sahrens return (err); 3353cb34c60Sahrens } 3363cb34c60Sahrens 337fa9e4066Sahrens /* called from zpl */ 338fa9e4066Sahrens int 339fa9e4066Sahrens dmu_objset_open(const char *name, dmu_objset_type_t type, int mode, 340fa9e4066Sahrens objset_t **osp) 341fa9e4066Sahrens { 342fa9e4066Sahrens objset_t *os; 343f18faf3fSek dsl_dataset_t *ds; 344f18faf3fSek int err; 345fa9e4066Sahrens 346745cd3c5Smaybee ASSERT(DS_MODE_TYPE(mode) == DS_MODE_USER || 347745cd3c5Smaybee DS_MODE_TYPE(mode) == DS_MODE_OWNER); 3483cb34c60Sahrens 349fa9e4066Sahrens os = kmem_alloc(sizeof (objset_t), KM_SLEEP); 350745cd3c5Smaybee if (DS_MODE_TYPE(mode) == DS_MODE_USER) 351745cd3c5Smaybee err = dsl_dataset_hold(name, os, &ds); 352745cd3c5Smaybee else 353745cd3c5Smaybee err = dsl_dataset_own(name, mode, os, &ds); 354fa9e4066Sahrens if (err) { 355fa9e4066Sahrens kmem_free(os, sizeof (objset_t)); 356fa9e4066Sahrens return (err); 357fa9e4066Sahrens } 358fa9e4066Sahrens 3593cb34c60Sahrens err = dmu_objset_open_ds_os(ds, os, type); 3603cb34c60Sahrens if (err) { 361745cd3c5Smaybee if (DS_MODE_TYPE(mode) == DS_MODE_USER) 362745cd3c5Smaybee dsl_dataset_rele(ds, os); 363745cd3c5Smaybee else 364745cd3c5Smaybee dsl_dataset_disown(ds, os); 3653cb34c60Sahrens kmem_free(os, sizeof (objset_t)); 3663cb34c60Sahrens } else { 367745cd3c5Smaybee os->os_mode = mode; 3683cb34c60Sahrens *osp = os; 369fa9e4066Sahrens } 3703cb34c60Sahrens return (err); 371fa9e4066Sahrens } 372fa9e4066Sahrens 373fa9e4066Sahrens void 374fa9e4066Sahrens dmu_objset_close(objset_t *os) 375fa9e4066Sahrens { 376745cd3c5Smaybee ASSERT(DS_MODE_TYPE(os->os_mode) == DS_MODE_USER || 377745cd3c5Smaybee DS_MODE_TYPE(os->os_mode) == DS_MODE_OWNER || 378745cd3c5Smaybee DS_MODE_TYPE(os->os_mode) == DS_MODE_NOHOLD); 379745cd3c5Smaybee 380745cd3c5Smaybee if (DS_MODE_TYPE(os->os_mode) == DS_MODE_USER) 381745cd3c5Smaybee dsl_dataset_rele(os->os->os_dsl_dataset, os); 382745cd3c5Smaybee else if (DS_MODE_TYPE(os->os_mode) == DS_MODE_OWNER) 383745cd3c5Smaybee dsl_dataset_disown(os->os->os_dsl_dataset, os); 384fa9e4066Sahrens kmem_free(os, sizeof (objset_t)); 385fa9e4066Sahrens } 386fa9e4066Sahrens 387436b2950Sperrin int 3881934e92fSmaybee dmu_objset_evict_dbufs(objset_t *os) 389ea8dc4b6Seschrock { 390ea8dc4b6Seschrock objset_impl_t *osi = os->os; 391ea8dc4b6Seschrock dnode_t *dn; 392c543ec06Sahrens 393c543ec06Sahrens mutex_enter(&osi->os_lock); 394c543ec06Sahrens 395c543ec06Sahrens /* process the mdn last, since the other dnodes have holds on it */ 396c543ec06Sahrens list_remove(&osi->os_dnodes, osi->os_meta_dnode); 397c543ec06Sahrens list_insert_tail(&osi->os_dnodes, osi->os_meta_dnode); 398ea8dc4b6Seschrock 399ea8dc4b6Seschrock /* 400c543ec06Sahrens * Find the first dnode with holds. We have to do this dance 401c543ec06Sahrens * because dnode_add_ref() only works if you already have a 402c543ec06Sahrens * hold. If there are no holds then it has no dbufs so OK to 403c543ec06Sahrens * skip. 404ea8dc4b6Seschrock */ 405c543ec06Sahrens for (dn = list_head(&osi->os_dnodes); 4061934e92fSmaybee dn && !dnode_add_ref(dn, FTAG); 407c543ec06Sahrens dn = list_next(&osi->os_dnodes, dn)) 408c543ec06Sahrens continue; 409c543ec06Sahrens 410c543ec06Sahrens while (dn) { 411c543ec06Sahrens dnode_t *next_dn = dn; 412c543ec06Sahrens 413c543ec06Sahrens do { 414c543ec06Sahrens next_dn = list_next(&osi->os_dnodes, next_dn); 4151934e92fSmaybee } while (next_dn && !dnode_add_ref(next_dn, FTAG)); 416c543ec06Sahrens 417c543ec06Sahrens mutex_exit(&osi->os_lock); 4181934e92fSmaybee dnode_evict_dbufs(dn); 419c543ec06Sahrens dnode_rele(dn, FTAG); 420c543ec06Sahrens mutex_enter(&osi->os_lock); 421c543ec06Sahrens dn = next_dn; 422ea8dc4b6Seschrock } 423ea8dc4b6Seschrock mutex_exit(&osi->os_lock); 4241934e92fSmaybee return (list_head(&osi->os_dnodes) != osi->os_meta_dnode); 425ea8dc4b6Seschrock } 426ea8dc4b6Seschrock 427fa9e4066Sahrens void 428fa9e4066Sahrens dmu_objset_evict(dsl_dataset_t *ds, void *arg) 429fa9e4066Sahrens { 430fa9e4066Sahrens objset_impl_t *osi = arg; 431ea8dc4b6Seschrock objset_t os; 43299653d4eSeschrock int i; 433fa9e4066Sahrens 434fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++) { 435fa9e4066Sahrens ASSERT(list_head(&osi->os_dirty_dnodes[i]) == NULL); 436fa9e4066Sahrens ASSERT(list_head(&osi->os_free_dnodes[i]) == NULL); 437fa9e4066Sahrens } 438fa9e4066Sahrens 4393baa08fcSek if (ds) { 4403baa08fcSek if (!dsl_dataset_is_snapshot(ds)) { 4413baa08fcSek VERIFY(0 == dsl_prop_unregister(ds, "checksum", 4423baa08fcSek checksum_changed_cb, osi)); 4433baa08fcSek VERIFY(0 == dsl_prop_unregister(ds, "compression", 4443baa08fcSek compression_changed_cb, osi)); 4453baa08fcSek VERIFY(0 == dsl_prop_unregister(ds, "copies", 4463baa08fcSek copies_changed_cb, osi)); 4473baa08fcSek } 4483baa08fcSek VERIFY(0 == dsl_prop_unregister(ds, "primarycache", 4493baa08fcSek primary_cache_changed_cb, osi)); 4503baa08fcSek VERIFY(0 == dsl_prop_unregister(ds, "secondarycache", 4513baa08fcSek secondary_cache_changed_cb, osi)); 452fa9e4066Sahrens } 453fa9e4066Sahrens 454ea8dc4b6Seschrock /* 455ea8dc4b6Seschrock * We should need only a single pass over the dnode list, since 456ea8dc4b6Seschrock * nothing can be added to the list at this point. 457ea8dc4b6Seschrock */ 458ea8dc4b6Seschrock os.os = osi; 4591934e92fSmaybee (void) dmu_objset_evict_dbufs(&os); 460ea8dc4b6Seschrock 461fa9e4066Sahrens ASSERT3P(list_head(&osi->os_dnodes), ==, osi->os_meta_dnode); 462fa9e4066Sahrens ASSERT3P(list_tail(&osi->os_dnodes), ==, osi->os_meta_dnode); 463fa9e4066Sahrens ASSERT3P(list_head(&osi->os_meta_dnode->dn_dbufs), ==, NULL); 464fa9e4066Sahrens 465fa9e4066Sahrens dnode_special_close(osi->os_meta_dnode); 466fa9e4066Sahrens zil_free(osi->os_zil); 467fa9e4066Sahrens 468c717a561Smaybee VERIFY(arc_buf_remove_ref(osi->os_phys_buf, &osi->os_phys_buf) == 1); 4695ad82045Snd mutex_destroy(&osi->os_lock); 4705ad82045Snd mutex_destroy(&osi->os_obj_lock); 471f18faf3fSek mutex_destroy(&osi->os_user_ptr_lock); 472fa9e4066Sahrens kmem_free(osi, sizeof (objset_impl_t)); 473fa9e4066Sahrens } 474fa9e4066Sahrens 475fa9e4066Sahrens /* called from dsl for meta-objset */ 476fa9e4066Sahrens objset_impl_t * 477c717a561Smaybee dmu_objset_create_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp, 478c717a561Smaybee dmu_objset_type_t type, dmu_tx_t *tx) 479fa9e4066Sahrens { 480fa9e4066Sahrens objset_impl_t *osi; 481fa9e4066Sahrens dnode_t *mdn; 482fa9e4066Sahrens 483fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 48491ebeef5Sahrens if (ds) 48591ebeef5Sahrens mutex_enter(&ds->ds_opening_lock); 486c717a561Smaybee VERIFY(0 == dmu_objset_open_impl(spa, ds, bp, &osi)); 48791ebeef5Sahrens if (ds) 48891ebeef5Sahrens mutex_exit(&ds->ds_opening_lock); 489fa9e4066Sahrens mdn = osi->os_meta_dnode; 490fa9e4066Sahrens 491fa9e4066Sahrens dnode_allocate(mdn, DMU_OT_DNODE, 1 << DNODE_BLOCK_SHIFT, 492fa9e4066Sahrens DN_MAX_INDBLKSHIFT, DMU_OT_NONE, 0, tx); 493fa9e4066Sahrens 494fa9e4066Sahrens /* 495fa9e4066Sahrens * We don't want to have to increase the meta-dnode's nlevels 496fa9e4066Sahrens * later, because then we could do it in quescing context while 497fa9e4066Sahrens * we are also accessing it in open context. 498fa9e4066Sahrens * 499fa9e4066Sahrens * This precaution is not necessary for the MOS (ds == NULL), 500fa9e4066Sahrens * because the MOS is only updated in syncing context. 501fa9e4066Sahrens * This is most fortunate: the MOS is the only objset that 502fa9e4066Sahrens * needs to be synced multiple times as spa_sync() iterates 503fa9e4066Sahrens * to convergence, so minimizing its dn_nlevels matters. 504fa9e4066Sahrens */ 505ea8dc4b6Seschrock if (ds != NULL) { 506ea8dc4b6Seschrock int levels = 1; 507ea8dc4b6Seschrock 508ea8dc4b6Seschrock /* 509ea8dc4b6Seschrock * Determine the number of levels necessary for the meta-dnode 510ea8dc4b6Seschrock * to contain DN_MAX_OBJECT dnodes. 511ea8dc4b6Seschrock */ 512ea8dc4b6Seschrock while ((uint64_t)mdn->dn_nblkptr << (mdn->dn_datablkshift + 513ea8dc4b6Seschrock (levels - 1) * (mdn->dn_indblkshift - SPA_BLKPTRSHIFT)) < 514ea8dc4b6Seschrock DN_MAX_OBJECT * sizeof (dnode_phys_t)) 515ea8dc4b6Seschrock levels++; 516ea8dc4b6Seschrock 517fa9e4066Sahrens mdn->dn_next_nlevels[tx->tx_txg & TXG_MASK] = 518ea8dc4b6Seschrock mdn->dn_nlevels = levels; 519ea8dc4b6Seschrock } 520fa9e4066Sahrens 521fa9e4066Sahrens ASSERT(type != DMU_OST_NONE); 522fa9e4066Sahrens ASSERT(type != DMU_OST_ANY); 523fa9e4066Sahrens ASSERT(type < DMU_OST_NUMTYPES); 524fa9e4066Sahrens osi->os_phys->os_type = type; 525fa9e4066Sahrens 526fa9e4066Sahrens dsl_dataset_dirty(ds, tx); 527fa9e4066Sahrens 528fa9e4066Sahrens return (osi); 529fa9e4066Sahrens } 530fa9e4066Sahrens 531fa9e4066Sahrens struct oscarg { 532ecd6cf80Smarks void (*userfunc)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx); 533fa9e4066Sahrens void *userarg; 534fa9e4066Sahrens dsl_dataset_t *clone_parent; 535fa9e4066Sahrens const char *lastname; 536fa9e4066Sahrens dmu_objset_type_t type; 537ab04eb8eStimh uint64_t flags; 538fa9e4066Sahrens }; 539fa9e4066Sahrens 540ecd6cf80Smarks /*ARGSUSED*/ 541fa9e4066Sahrens static int 5421d452cf5Sahrens dmu_objset_create_check(void *arg1, void *arg2, dmu_tx_t *tx) 543fa9e4066Sahrens { 5441d452cf5Sahrens dsl_dir_t *dd = arg1; 5451d452cf5Sahrens struct oscarg *oa = arg2; 5461d452cf5Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 547fa9e4066Sahrens int err; 5481d452cf5Sahrens uint64_t ddobj; 5491d452cf5Sahrens 5501d452cf5Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 5511d452cf5Sahrens oa->lastname, sizeof (uint64_t), 1, &ddobj); 5521d452cf5Sahrens if (err != ENOENT) 5531d452cf5Sahrens return (err ? err : EEXIST); 5541d452cf5Sahrens 5551d452cf5Sahrens if (oa->clone_parent != NULL) { 5561d452cf5Sahrens /* 5571d452cf5Sahrens * You can't clone across pools. 5581d452cf5Sahrens */ 5591d452cf5Sahrens if (oa->clone_parent->ds_dir->dd_pool != dd->dd_pool) 5601d452cf5Sahrens return (EXDEV); 5611d452cf5Sahrens 5621d452cf5Sahrens /* 5631d452cf5Sahrens * You can only clone snapshots, not the head datasets. 5641d452cf5Sahrens */ 5651d452cf5Sahrens if (oa->clone_parent->ds_phys->ds_num_children == 0) 5661d452cf5Sahrens return (EINVAL); 5671d452cf5Sahrens } 568ecd6cf80Smarks 5691d452cf5Sahrens return (0); 5701d452cf5Sahrens } 5711d452cf5Sahrens 5721d452cf5Sahrens static void 573ecd6cf80Smarks dmu_objset_create_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 5741d452cf5Sahrens { 5751d452cf5Sahrens dsl_dir_t *dd = arg1; 5761d452cf5Sahrens struct oscarg *oa = arg2; 5771d452cf5Sahrens dsl_dataset_t *ds; 578c717a561Smaybee blkptr_t *bp; 5791d452cf5Sahrens uint64_t dsobj; 580fa9e4066Sahrens 581fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 582fa9e4066Sahrens 5831d452cf5Sahrens dsobj = dsl_dataset_create_sync(dd, oa->lastname, 584ab04eb8eStimh oa->clone_parent, oa->flags, cr, tx); 585fa9e4066Sahrens 586745cd3c5Smaybee VERIFY(0 == dsl_dataset_hold_obj(dd->dd_pool, dsobj, FTAG, &ds)); 587c717a561Smaybee bp = dsl_dataset_get_blkptr(ds); 588c717a561Smaybee if (BP_IS_HOLE(bp)) { 589fa9e4066Sahrens objset_impl_t *osi; 590fa9e4066Sahrens 591fa9e4066Sahrens /* This is an empty dmu_objset; not a clone. */ 592fa9e4066Sahrens osi = dmu_objset_create_impl(dsl_dataset_get_spa(ds), 593c717a561Smaybee ds, bp, oa->type, tx); 594fa9e4066Sahrens 595fa9e4066Sahrens if (oa->userfunc) 596ecd6cf80Smarks oa->userfunc(&osi->os, oa->userarg, cr, tx); 597fa9e4066Sahrens } 598ecd6cf80Smarks 599ecd6cf80Smarks spa_history_internal_log(LOG_DS_CREATE, dd->dd_pool->dp_spa, 600ecd6cf80Smarks tx, cr, "dataset = %llu", dsobj); 601ecd6cf80Smarks 602745cd3c5Smaybee dsl_dataset_rele(ds, FTAG); 603fa9e4066Sahrens } 604fa9e4066Sahrens 605fa9e4066Sahrens int 606fa9e4066Sahrens dmu_objset_create(const char *name, dmu_objset_type_t type, 607ab04eb8eStimh objset_t *clone_parent, uint64_t flags, 608ecd6cf80Smarks void (*func)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx), void *arg) 609fa9e4066Sahrens { 6101d452cf5Sahrens dsl_dir_t *pdd; 611fa9e4066Sahrens const char *tail; 612fa9e4066Sahrens int err = 0; 6131d452cf5Sahrens struct oscarg oa = { 0 }; 614fa9e4066Sahrens 6151d452cf5Sahrens ASSERT(strchr(name, '@') == NULL); 6161d452cf5Sahrens err = dsl_dir_open(name, FTAG, &pdd, &tail); 617ea8dc4b6Seschrock if (err) 618ea8dc4b6Seschrock return (err); 619fa9e4066Sahrens if (tail == NULL) { 6201d452cf5Sahrens dsl_dir_close(pdd, FTAG); 621fa9e4066Sahrens return (EEXIST); 622fa9e4066Sahrens } 623fa9e4066Sahrens 624fa9e4066Sahrens dprintf("name=%s\n", name); 625fa9e4066Sahrens 6261d452cf5Sahrens oa.userfunc = func; 6271d452cf5Sahrens oa.userarg = arg; 6281d452cf5Sahrens oa.lastname = tail; 6291d452cf5Sahrens oa.type = type; 630ab04eb8eStimh oa.flags = flags; 631ecd6cf80Smarks 6321d452cf5Sahrens if (clone_parent != NULL) { 633fa9e4066Sahrens /* 6341d452cf5Sahrens * You can't clone to a different type. 635fa9e4066Sahrens */ 6361d452cf5Sahrens if (clone_parent->os->os_phys->os_type != type) { 6371d452cf5Sahrens dsl_dir_close(pdd, FTAG); 6381d452cf5Sahrens return (EINVAL); 639fa9e4066Sahrens } 6401d452cf5Sahrens oa.clone_parent = clone_parent->os->os_dsl_dataset; 641fa9e4066Sahrens } 6421d452cf5Sahrens err = dsl_sync_task_do(pdd->dd_pool, dmu_objset_create_check, 6431d452cf5Sahrens dmu_objset_create_sync, pdd, &oa, 5); 6441d452cf5Sahrens dsl_dir_close(pdd, FTAG); 645fa9e4066Sahrens return (err); 646fa9e4066Sahrens } 647fa9e4066Sahrens 648fa9e4066Sahrens int 649fa9e4066Sahrens dmu_objset_destroy(const char *name) 650fa9e4066Sahrens { 651fa9e4066Sahrens objset_t *os; 652fa9e4066Sahrens int error; 653fa9e4066Sahrens 654fa9e4066Sahrens /* 655fa9e4066Sahrens * If it looks like we'll be able to destroy it, and there's 656fa9e4066Sahrens * an unplayed replay log sitting around, destroy the log. 657fa9e4066Sahrens * It would be nicer to do this in dsl_dataset_destroy_sync(), 658fa9e4066Sahrens * but the replay log objset is modified in open context. 659fa9e4066Sahrens */ 6603cb34c60Sahrens error = dmu_objset_open(name, DMU_OST_ANY, 661745cd3c5Smaybee DS_MODE_OWNER|DS_MODE_READONLY|DS_MODE_INCONSISTENT, &os); 662fa9e4066Sahrens if (error == 0) { 6633cb34c60Sahrens dsl_dataset_t *ds = os->os->os_dsl_dataset; 664d80c45e0Sbonwick zil_destroy(dmu_objset_zil(os), B_FALSE); 6653cb34c60Sahrens 666745cd3c5Smaybee error = dsl_dataset_destroy(ds, os); 6673cb34c60Sahrens /* 6683cb34c60Sahrens * dsl_dataset_destroy() closes the ds. 6693cb34c60Sahrens */ 6703cb34c60Sahrens kmem_free(os, sizeof (objset_t)); 671fa9e4066Sahrens } 672fa9e4066Sahrens 6733cb34c60Sahrens return (error); 674fa9e4066Sahrens } 675fa9e4066Sahrens 6764ccbb6e7Sahrens /* 6774ccbb6e7Sahrens * This will close the objset. 6784ccbb6e7Sahrens */ 679fa9e4066Sahrens int 6804ccbb6e7Sahrens dmu_objset_rollback(objset_t *os) 681fa9e4066Sahrens { 682fa9e4066Sahrens int err; 6833cb34c60Sahrens dsl_dataset_t *ds; 684fa9e4066Sahrens 6853cb34c60Sahrens ds = os->os->os_dsl_dataset; 6864ccbb6e7Sahrens 687745cd3c5Smaybee if (!dsl_dataset_tryown(ds, TRUE, os)) { 6884ccbb6e7Sahrens dmu_objset_close(os); 6894ccbb6e7Sahrens return (EBUSY); 6904ccbb6e7Sahrens } 6914ccbb6e7Sahrens 6923cb34c60Sahrens err = dsl_dataset_rollback(ds, os->os->os_phys->os_type); 6933a8a1de4Sperrin 6943cb34c60Sahrens /* 6953cb34c60Sahrens * NB: we close the objset manually because the rollback 6963cb34c60Sahrens * actually implicitly called dmu_objset_evict(), thus freeing 6973cb34c60Sahrens * the objset_impl_t. 6983cb34c60Sahrens */ 699745cd3c5Smaybee dsl_dataset_disown(ds, os); 7003cb34c60Sahrens kmem_free(os, sizeof (objset_t)); 701fa9e4066Sahrens return (err); 702fa9e4066Sahrens } 703fa9e4066Sahrens 7041d452cf5Sahrens struct snaparg { 7051d452cf5Sahrens dsl_sync_task_group_t *dstg; 7061d452cf5Sahrens char *snapname; 7071d452cf5Sahrens char failed[MAXPATHLEN]; 708ecd6cf80Smarks boolean_t checkperms; 7093cb34c60Sahrens list_t objsets; 7103cb34c60Sahrens }; 7113cb34c60Sahrens 7123cb34c60Sahrens struct osnode { 7133cb34c60Sahrens list_node_t node; 7143cb34c60Sahrens objset_t *os; 7151d452cf5Sahrens }; 7161d452cf5Sahrens 7171d452cf5Sahrens static int 7181d452cf5Sahrens dmu_objset_snapshot_one(char *name, void *arg) 7191d452cf5Sahrens { 7201d452cf5Sahrens struct snaparg *sn = arg; 7211d452cf5Sahrens objset_t *os; 7221d452cf5Sahrens int err; 7231d452cf5Sahrens 7241d452cf5Sahrens (void) strcpy(sn->failed, name); 7251d452cf5Sahrens 726ecd6cf80Smarks /* 727ecd6cf80Smarks * Check permissions only when requested. This only applies when 728ecd6cf80Smarks * doing a recursive snapshot. The permission checks for the starting 729ecd6cf80Smarks * dataset have already been performed in zfs_secpolicy_snapshot() 730ecd6cf80Smarks */ 731ecd6cf80Smarks if (sn->checkperms == B_TRUE && 732ecd6cf80Smarks (err = zfs_secpolicy_snapshot_perms(name, CRED()))) 733ecd6cf80Smarks return (err); 734ecd6cf80Smarks 735745cd3c5Smaybee err = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_USER, &os); 7361d452cf5Sahrens if (err != 0) 7371d452cf5Sahrens return (err); 7381d452cf5Sahrens 739745cd3c5Smaybee /* If the objset is in an inconsistent state, return busy */ 740745cd3c5Smaybee if (os->os->os_dsl_dataset->ds_phys->ds_flags & DS_FLAG_INCONSISTENT) { 741f2e10be3Srm dmu_objset_close(os); 742f2e10be3Srm return (EBUSY); 743f2e10be3Srm } 744f2e10be3Srm 7451d452cf5Sahrens /* 7461d452cf5Sahrens * NB: we need to wait for all in-flight changes to get to disk, 7471d452cf5Sahrens * so that we snapshot those changes. zil_suspend does this as 7481d452cf5Sahrens * a side effect. 7491d452cf5Sahrens */ 7501d452cf5Sahrens err = zil_suspend(dmu_objset_zil(os)); 7511d452cf5Sahrens if (err == 0) { 7523cb34c60Sahrens struct osnode *osn; 7531d452cf5Sahrens dsl_sync_task_create(sn->dstg, dsl_dataset_snapshot_check, 7543cb34c60Sahrens dsl_dataset_snapshot_sync, os->os->os_dsl_dataset, 7553cb34c60Sahrens sn->snapname, 3); 7563cb34c60Sahrens osn = kmem_alloc(sizeof (struct osnode), KM_SLEEP); 7573cb34c60Sahrens osn->os = os; 7583cb34c60Sahrens list_insert_tail(&sn->objsets, osn); 759f2e10be3Srm } else { 760f2e10be3Srm dmu_objset_close(os); 7611d452cf5Sahrens } 762f2e10be3Srm 7631d452cf5Sahrens return (err); 7641d452cf5Sahrens } 7651d452cf5Sahrens 7661d452cf5Sahrens int 7671d452cf5Sahrens dmu_objset_snapshot(char *fsname, char *snapname, boolean_t recursive) 7681d452cf5Sahrens { 7691d452cf5Sahrens dsl_sync_task_t *dst; 7703cb34c60Sahrens struct osnode *osn; 7711d452cf5Sahrens struct snaparg sn = { 0 }; 7721d452cf5Sahrens spa_t *spa; 7731d452cf5Sahrens int err; 7741d452cf5Sahrens 7751d452cf5Sahrens (void) strcpy(sn.failed, fsname); 7761d452cf5Sahrens 77740feaa91Sahrens err = spa_open(fsname, &spa, FTAG); 7781d452cf5Sahrens if (err) 7791d452cf5Sahrens return (err); 7801d452cf5Sahrens 7811d452cf5Sahrens sn.dstg = dsl_sync_task_group_create(spa_get_dsl(spa)); 7821d452cf5Sahrens sn.snapname = snapname; 7833cb34c60Sahrens list_create(&sn.objsets, sizeof (struct osnode), 7843cb34c60Sahrens offsetof(struct osnode, node)); 7851d452cf5Sahrens 7860b69c2f0Sahrens if (recursive) { 787ecd6cf80Smarks sn.checkperms = B_TRUE; 7880b69c2f0Sahrens err = dmu_objset_find(fsname, 7890b69c2f0Sahrens dmu_objset_snapshot_one, &sn, DS_FIND_CHILDREN); 7900b69c2f0Sahrens } else { 791ecd6cf80Smarks sn.checkperms = B_FALSE; 7921d452cf5Sahrens err = dmu_objset_snapshot_one(fsname, &sn); 7930b69c2f0Sahrens } 7941d452cf5Sahrens 7951d452cf5Sahrens if (err) 7961d452cf5Sahrens goto out; 7971d452cf5Sahrens 7981d452cf5Sahrens err = dsl_sync_task_group_wait(sn.dstg); 7991d452cf5Sahrens 8001d452cf5Sahrens for (dst = list_head(&sn.dstg->dstg_tasks); dst; 8011d452cf5Sahrens dst = list_next(&sn.dstg->dstg_tasks, dst)) { 8023cb34c60Sahrens dsl_dataset_t *ds = dst->dst_arg1; 8031d452cf5Sahrens if (dst->dst_err) 8043cb34c60Sahrens dsl_dataset_name(ds, sn.failed); 8053cb34c60Sahrens } 8063cb34c60Sahrens 807a4585abfSahrens out: 8083cb34c60Sahrens while (osn = list_head(&sn.objsets)) { 8093cb34c60Sahrens list_remove(&sn.objsets, osn); 8103cb34c60Sahrens zil_resume(dmu_objset_zil(osn->os)); 8113cb34c60Sahrens dmu_objset_close(osn->os); 8123cb34c60Sahrens kmem_free(osn, sizeof (struct osnode)); 8131d452cf5Sahrens } 8143cb34c60Sahrens list_destroy(&sn.objsets); 815a4585abfSahrens 8161d452cf5Sahrens if (err) 8171d452cf5Sahrens (void) strcpy(fsname, sn.failed); 8181d452cf5Sahrens dsl_sync_task_group_destroy(sn.dstg); 8191d452cf5Sahrens spa_close(spa, FTAG); 8201d452cf5Sahrens return (err); 8211d452cf5Sahrens } 8221d452cf5Sahrens 823fa9e4066Sahrens static void 824c717a561Smaybee dmu_objset_sync_dnodes(list_t *list, dmu_tx_t *tx) 825fa9e4066Sahrens { 826c717a561Smaybee dnode_t *dn; 827faafa6e3Sahrens 828c717a561Smaybee while (dn = list_head(list)) { 829c717a561Smaybee ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT); 830c717a561Smaybee ASSERT(dn->dn_dbuf->db_data_pending); 831c717a561Smaybee /* 832c717a561Smaybee * Initialize dn_zio outside dnode_sync() 833c717a561Smaybee * to accomodate meta-dnode 834c717a561Smaybee */ 835c717a561Smaybee dn->dn_zio = dn->dn_dbuf->db_data_pending->dr_zio; 836c717a561Smaybee ASSERT(dn->dn_zio); 837faafa6e3Sahrens 838c717a561Smaybee ASSERT3U(dn->dn_nlevels, <=, DN_MAX_LEVELS); 839c717a561Smaybee list_remove(list, dn); 840c717a561Smaybee dnode_sync(dn, tx); 841fa9e4066Sahrens } 842fa9e4066Sahrens } 843fa9e4066Sahrens 844fa9e4066Sahrens /* ARGSUSED */ 845fa9e4066Sahrens static void 846c717a561Smaybee ready(zio_t *zio, arc_buf_t *abuf, void *arg) 847fa9e4066Sahrens { 848fa9e4066Sahrens objset_impl_t *os = arg; 849c717a561Smaybee blkptr_t *bp = os->os_rootbp; 850c717a561Smaybee dnode_phys_t *dnp = &os->os_phys->os_meta_dnode; 851fa9e4066Sahrens int i; 852fa9e4066Sahrens 8530a4e9518Sgw ASSERT(bp == zio->io_bp); 8540a4e9518Sgw 855fa9e4066Sahrens /* 856fa9e4066Sahrens * Update rootbp fill count. 857fa9e4066Sahrens */ 858c717a561Smaybee bp->blk_fill = 1; /* count the meta-dnode */ 859fa9e4066Sahrens for (i = 0; i < dnp->dn_nblkptr; i++) 860c717a561Smaybee bp->blk_fill += dnp->dn_blkptr[i].blk_fill; 8610a4e9518Sgw 8620a4e9518Sgw BP_SET_TYPE(bp, DMU_OT_OBJSET); 8630a4e9518Sgw BP_SET_LEVEL(bp, 0); 8640a4e9518Sgw 8650a4e9518Sgw /* We must do this after we've set the bp's type and level */ 8660a4e9518Sgw if (!DVA_EQUAL(BP_IDENTITY(bp), 8670a4e9518Sgw BP_IDENTITY(&zio->io_bp_orig))) { 8680a4e9518Sgw if (zio->io_bp_orig.blk_birth == os->os_synctx->tx_txg) 869cdb0ab79Smaybee (void) dsl_dataset_block_kill(os->os_dsl_dataset, 8700a4e9518Sgw &zio->io_bp_orig, NULL, os->os_synctx); 8710a4e9518Sgw dsl_dataset_block_born(os->os_dsl_dataset, bp, os->os_synctx); 8720a4e9518Sgw } 873c717a561Smaybee } 874c717a561Smaybee 875fa9e4066Sahrens /* called from dsl */ 876fa9e4066Sahrens void 877c717a561Smaybee dmu_objset_sync(objset_impl_t *os, zio_t *pio, dmu_tx_t *tx) 878fa9e4066Sahrens { 879fa9e4066Sahrens int txgoff; 880ea8dc4b6Seschrock zbookmark_t zb; 881088f3894Sahrens writeprops_t wp = { 0 }; 882c717a561Smaybee zio_t *zio; 883c717a561Smaybee list_t *list; 884c717a561Smaybee dbuf_dirty_record_t *dr; 885c717a561Smaybee 886c717a561Smaybee dprintf_ds(os->os_dsl_dataset, "txg=%llu\n", tx->tx_txg); 887fa9e4066Sahrens 888fa9e4066Sahrens ASSERT(dmu_tx_is_syncing(tx)); 889fa9e4066Sahrens /* XXX the write_done callback should really give us the tx... */ 890fa9e4066Sahrens os->os_synctx = tx; 891fa9e4066Sahrens 89287bd5c1eSahrens if (os->os_dsl_dataset == NULL) { 89387bd5c1eSahrens /* 89487bd5c1eSahrens * This is the MOS. If we have upgraded, 89587bd5c1eSahrens * spa_max_replication() could change, so reset 89687bd5c1eSahrens * os_copies here. 89787bd5c1eSahrens */ 89887bd5c1eSahrens os->os_copies = spa_max_replication(os->os_spa); 89987bd5c1eSahrens } 90087bd5c1eSahrens 901fa9e4066Sahrens /* 902c717a561Smaybee * Create the root block IO 903fa9e4066Sahrens */ 904ea8dc4b6Seschrock zb.zb_objset = os->os_dsl_dataset ? os->os_dsl_dataset->ds_object : 0; 905ea8dc4b6Seschrock zb.zb_object = 0; 906ea8dc4b6Seschrock zb.zb_level = -1; 907ea8dc4b6Seschrock zb.zb_blkid = 0; 90891ebeef5Sahrens if (BP_IS_OLDER(os->os_rootbp, tx->tx_txg)) { 909cdb0ab79Smaybee (void) dsl_dataset_block_kill(os->os_dsl_dataset, 910c717a561Smaybee os->os_rootbp, pio, tx); 91191ebeef5Sahrens } 912088f3894Sahrens wp.wp_type = DMU_OT_OBJSET; 913088f3894Sahrens wp.wp_copies = os->os_copies; 914088f3894Sahrens wp.wp_level = (uint8_t)-1; 915088f3894Sahrens wp.wp_oschecksum = os->os_checksum; 916088f3894Sahrens wp.wp_oscompress = os->os_compress; 917088f3894Sahrens arc_release(os->os_phys_buf, &os->os_phys_buf); 918088f3894Sahrens zio = arc_write(pio, os->os_spa, &wp, 9193baa08fcSek DMU_OS_IS_L2CACHEABLE(os), tx->tx_txg, os->os_rootbp, 9203baa08fcSek os->os_phys_buf, ready, NULL, os, ZIO_PRIORITY_ASYNC_WRITE, 9213baa08fcSek ZIO_FLAG_MUSTSUCCEED | ZIO_FLAG_METADATA, &zb); 922c717a561Smaybee 923c717a561Smaybee /* 924c717a561Smaybee * Sync meta-dnode - the parent IO for the sync is the root block 925c717a561Smaybee */ 926c717a561Smaybee os->os_meta_dnode->dn_zio = zio; 927c717a561Smaybee dnode_sync(os->os_meta_dnode, tx); 928c717a561Smaybee 929c717a561Smaybee txgoff = tx->tx_txg & TXG_MASK; 930fa9e4066Sahrens 931c717a561Smaybee dmu_objset_sync_dnodes(&os->os_free_dnodes[txgoff], tx); 932c717a561Smaybee dmu_objset_sync_dnodes(&os->os_dirty_dnodes[txgoff], tx); 933fa9e4066Sahrens 934c717a561Smaybee list = &os->os_meta_dnode->dn_dirty_records[txgoff]; 935c717a561Smaybee while (dr = list_head(list)) { 936c717a561Smaybee ASSERT(dr->dr_dbuf->db_level == 0); 937c717a561Smaybee list_remove(list, dr); 938c717a561Smaybee if (dr->dr_zio) 939c717a561Smaybee zio_nowait(dr->dr_zio); 940c717a561Smaybee } 941c717a561Smaybee /* 942c717a561Smaybee * Free intent log blocks up to this tx. 943c717a561Smaybee */ 944c717a561Smaybee zil_sync(os->os_zil, tx); 945088f3894Sahrens os->os_phys->os_zil_header = os->os_zil_header; 946c717a561Smaybee zio_nowait(zio); 947fa9e4066Sahrens } 948fa9e4066Sahrens 949fa9e4066Sahrens void 950a2eea2e1Sahrens dmu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp, 951a2eea2e1Sahrens uint64_t *usedobjsp, uint64_t *availobjsp) 952fa9e4066Sahrens { 953a2eea2e1Sahrens dsl_dataset_space(os->os->os_dsl_dataset, refdbytesp, availbytesp, 954a2eea2e1Sahrens usedobjsp, availobjsp); 955a2eea2e1Sahrens } 956a2eea2e1Sahrens 957a2eea2e1Sahrens uint64_t 958a2eea2e1Sahrens dmu_objset_fsid_guid(objset_t *os) 959a2eea2e1Sahrens { 960a2eea2e1Sahrens return (dsl_dataset_fsid_guid(os->os->os_dsl_dataset)); 961a2eea2e1Sahrens } 962a2eea2e1Sahrens 963a2eea2e1Sahrens void 964a2eea2e1Sahrens dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat) 965a2eea2e1Sahrens { 966a2eea2e1Sahrens stat->dds_type = os->os->os_phys->os_type; 967a2eea2e1Sahrens if (os->os->os_dsl_dataset) 968a2eea2e1Sahrens dsl_dataset_fast_stat(os->os->os_dsl_dataset, stat); 969a2eea2e1Sahrens } 970a2eea2e1Sahrens 971a2eea2e1Sahrens void 972a2eea2e1Sahrens dmu_objset_stats(objset_t *os, nvlist_t *nv) 973a2eea2e1Sahrens { 974a2eea2e1Sahrens ASSERT(os->os->os_dsl_dataset || 975a2eea2e1Sahrens os->os->os_phys->os_type == DMU_OST_META); 976a2eea2e1Sahrens 977a2eea2e1Sahrens if (os->os->os_dsl_dataset != NULL) 978a2eea2e1Sahrens dsl_dataset_stats(os->os->os_dsl_dataset, nv); 979a2eea2e1Sahrens 980a2eea2e1Sahrens dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_TYPE, 981a2eea2e1Sahrens os->os->os_phys->os_type); 982fa9e4066Sahrens } 983fa9e4066Sahrens 984fa9e4066Sahrens int 985fa9e4066Sahrens dmu_objset_is_snapshot(objset_t *os) 986fa9e4066Sahrens { 987fa9e4066Sahrens if (os->os->os_dsl_dataset != NULL) 988fa9e4066Sahrens return (dsl_dataset_is_snapshot(os->os->os_dsl_dataset)); 989fa9e4066Sahrens else 990fa9e4066Sahrens return (B_FALSE); 991fa9e4066Sahrens } 992fa9e4066Sahrens 993ab04eb8eStimh int 994ab04eb8eStimh dmu_snapshot_realname(objset_t *os, char *name, char *real, int maxlen, 995ab04eb8eStimh boolean_t *conflict) 996ab04eb8eStimh { 997ab04eb8eStimh dsl_dataset_t *ds = os->os->os_dsl_dataset; 998ab04eb8eStimh uint64_t ignored; 999ab04eb8eStimh 1000ab04eb8eStimh if (ds->ds_phys->ds_snapnames_zapobj == 0) 1001ab04eb8eStimh return (ENOENT); 1002ab04eb8eStimh 1003ab04eb8eStimh return (zap_lookup_norm(ds->ds_dir->dd_pool->dp_meta_objset, 1004ab04eb8eStimh ds->ds_phys->ds_snapnames_zapobj, name, 8, 1, &ignored, MT_FIRST, 1005ab04eb8eStimh real, maxlen, conflict)); 1006ab04eb8eStimh } 1007ab04eb8eStimh 1008fa9e4066Sahrens int 1009fa9e4066Sahrens dmu_snapshot_list_next(objset_t *os, int namelen, char *name, 1010b38f0970Sck uint64_t *idp, uint64_t *offp, boolean_t *case_conflict) 1011fa9e4066Sahrens { 1012fa9e4066Sahrens dsl_dataset_t *ds = os->os->os_dsl_dataset; 1013fa9e4066Sahrens zap_cursor_t cursor; 1014fa9e4066Sahrens zap_attribute_t attr; 1015fa9e4066Sahrens 1016fa9e4066Sahrens if (ds->ds_phys->ds_snapnames_zapobj == 0) 1017fa9e4066Sahrens return (ENOENT); 1018fa9e4066Sahrens 1019fa9e4066Sahrens zap_cursor_init_serialized(&cursor, 1020fa9e4066Sahrens ds->ds_dir->dd_pool->dp_meta_objset, 1021fa9e4066Sahrens ds->ds_phys->ds_snapnames_zapobj, *offp); 1022fa9e4066Sahrens 102387e5029aSahrens if (zap_cursor_retrieve(&cursor, &attr) != 0) { 102487e5029aSahrens zap_cursor_fini(&cursor); 102587e5029aSahrens return (ENOENT); 102687e5029aSahrens } 102787e5029aSahrens 102887e5029aSahrens if (strlen(attr.za_name) + 1 > namelen) { 102987e5029aSahrens zap_cursor_fini(&cursor); 103087e5029aSahrens return (ENAMETOOLONG); 103187e5029aSahrens } 103287e5029aSahrens 103387e5029aSahrens (void) strcpy(name, attr.za_name); 103487e5029aSahrens if (idp) 103587e5029aSahrens *idp = attr.za_first_integer; 1036b38f0970Sck if (case_conflict) 1037b38f0970Sck *case_conflict = attr.za_normalization_conflict; 103887e5029aSahrens zap_cursor_advance(&cursor); 103987e5029aSahrens *offp = zap_cursor_serialize(&cursor); 104087e5029aSahrens zap_cursor_fini(&cursor); 104187e5029aSahrens 104287e5029aSahrens return (0); 104387e5029aSahrens } 104487e5029aSahrens 104587e5029aSahrens int 104687e5029aSahrens dmu_dir_list_next(objset_t *os, int namelen, char *name, 104787e5029aSahrens uint64_t *idp, uint64_t *offp) 104887e5029aSahrens { 104987e5029aSahrens dsl_dir_t *dd = os->os->os_dsl_dataset->ds_dir; 105087e5029aSahrens zap_cursor_t cursor; 105187e5029aSahrens zap_attribute_t attr; 105287e5029aSahrens 105387e5029aSahrens /* there is no next dir on a snapshot! */ 105487e5029aSahrens if (os->os->os_dsl_dataset->ds_object != 105587e5029aSahrens dd->dd_phys->dd_head_dataset_obj) 1056fa9e4066Sahrens return (ENOENT); 1057fa9e4066Sahrens 105887e5029aSahrens zap_cursor_init_serialized(&cursor, 105987e5029aSahrens dd->dd_pool->dp_meta_objset, 106087e5029aSahrens dd->dd_phys->dd_child_dir_zapobj, *offp); 106187e5029aSahrens 106287e5029aSahrens if (zap_cursor_retrieve(&cursor, &attr) != 0) { 106387e5029aSahrens zap_cursor_fini(&cursor); 106487e5029aSahrens return (ENOENT); 106587e5029aSahrens } 106687e5029aSahrens 106787e5029aSahrens if (strlen(attr.za_name) + 1 > namelen) { 106887e5029aSahrens zap_cursor_fini(&cursor); 1069fa9e4066Sahrens return (ENAMETOOLONG); 107087e5029aSahrens } 1071fa9e4066Sahrens 1072fa9e4066Sahrens (void) strcpy(name, attr.za_name); 107387e5029aSahrens if (idp) 107487e5029aSahrens *idp = attr.za_first_integer; 1075fa9e4066Sahrens zap_cursor_advance(&cursor); 1076fa9e4066Sahrens *offp = zap_cursor_serialize(&cursor); 107787e5029aSahrens zap_cursor_fini(&cursor); 1078fa9e4066Sahrens 1079fa9e4066Sahrens return (0); 1080fa9e4066Sahrens } 1081fa9e4066Sahrens 1082088f3894Sahrens struct findarg { 1083088f3894Sahrens int (*func)(char *, void *); 1084088f3894Sahrens void *arg; 1085088f3894Sahrens }; 1086088f3894Sahrens 1087088f3894Sahrens /* ARGSUSED */ 1088088f3894Sahrens static int 1089088f3894Sahrens findfunc(spa_t *spa, uint64_t dsobj, const char *dsname, void *arg) 1090088f3894Sahrens { 1091088f3894Sahrens struct findarg *fa = arg; 1092088f3894Sahrens return (fa->func((char *)dsname, fa->arg)); 1093088f3894Sahrens } 1094088f3894Sahrens 1095fa9e4066Sahrens /* 1096fa9e4066Sahrens * Find all objsets under name, and for each, call 'func(child_name, arg)'. 1097088f3894Sahrens * Perhaps change all callers to use dmu_objset_find_spa()? 1098fa9e4066Sahrens */ 10991d452cf5Sahrens int 11001d452cf5Sahrens dmu_objset_find(char *name, int func(char *, void *), void *arg, int flags) 1101088f3894Sahrens { 1102088f3894Sahrens struct findarg fa; 1103088f3894Sahrens fa.func = func; 1104088f3894Sahrens fa.arg = arg; 1105088f3894Sahrens return (dmu_objset_find_spa(NULL, name, findfunc, &fa, flags)); 1106088f3894Sahrens } 1107088f3894Sahrens 1108088f3894Sahrens /* 1109088f3894Sahrens * Find all objsets under name, call func on each 1110088f3894Sahrens */ 1111088f3894Sahrens int 1112088f3894Sahrens dmu_objset_find_spa(spa_t *spa, const char *name, 1113088f3894Sahrens int func(spa_t *, uint64_t, const char *, void *), void *arg, int flags) 1114fa9e4066Sahrens { 1115fa9e4066Sahrens dsl_dir_t *dd; 1116088f3894Sahrens dsl_pool_t *dp; 1117088f3894Sahrens dsl_dataset_t *ds; 1118fa9e4066Sahrens zap_cursor_t zc; 1119b7661cccSmmusante zap_attribute_t *attr; 1120fa9e4066Sahrens char *child; 1121088f3894Sahrens uint64_t thisobj; 1122088f3894Sahrens int err; 1123fa9e4066Sahrens 1124088f3894Sahrens if (name == NULL) 1125088f3894Sahrens name = spa_name(spa); 1126088f3894Sahrens err = dsl_dir_open_spa(spa, name, FTAG, &dd, NULL); 1127ea8dc4b6Seschrock if (err) 11281d452cf5Sahrens return (err); 1129fa9e4066Sahrens 1130088f3894Sahrens /* Don't visit hidden ($MOS & $ORIGIN) objsets. */ 1131088f3894Sahrens if (dd->dd_myname[0] == '$') { 1132088f3894Sahrens dsl_dir_close(dd, FTAG); 1133088f3894Sahrens return (0); 1134088f3894Sahrens } 1135088f3894Sahrens 1136088f3894Sahrens thisobj = dd->dd_phys->dd_head_dataset_obj; 1137b7661cccSmmusante attr = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); 1138088f3894Sahrens dp = dd->dd_pool; 1139fa9e4066Sahrens 1140fa9e4066Sahrens /* 1141fa9e4066Sahrens * Iterate over all children. 1142fa9e4066Sahrens */ 11430b69c2f0Sahrens if (flags & DS_FIND_CHILDREN) { 1144088f3894Sahrens for (zap_cursor_init(&zc, dp->dp_meta_objset, 11450b69c2f0Sahrens dd->dd_phys->dd_child_dir_zapobj); 1146b7661cccSmmusante zap_cursor_retrieve(&zc, attr) == 0; 11470b69c2f0Sahrens (void) zap_cursor_advance(&zc)) { 1148b7661cccSmmusante ASSERT(attr->za_integer_length == sizeof (uint64_t)); 1149b7661cccSmmusante ASSERT(attr->za_num_integers == 1); 1150fa9e4066Sahrens 11510b69c2f0Sahrens child = kmem_alloc(MAXPATHLEN, KM_SLEEP); 1152088f3894Sahrens (void) strcpy(child, name); 11530b69c2f0Sahrens (void) strcat(child, "/"); 1154b7661cccSmmusante (void) strcat(child, attr->za_name); 1155088f3894Sahrens err = dmu_objset_find_spa(spa, child, func, arg, flags); 11560b69c2f0Sahrens kmem_free(child, MAXPATHLEN); 11570b69c2f0Sahrens if (err) 11580b69c2f0Sahrens break; 11590b69c2f0Sahrens } 11600b69c2f0Sahrens zap_cursor_fini(&zc); 11611d452cf5Sahrens 11620b69c2f0Sahrens if (err) { 11630b69c2f0Sahrens dsl_dir_close(dd, FTAG); 1164b7661cccSmmusante kmem_free(attr, sizeof (zap_attribute_t)); 11650b69c2f0Sahrens return (err); 11660b69c2f0Sahrens } 1167fa9e4066Sahrens } 1168fa9e4066Sahrens 1169fa9e4066Sahrens /* 1170fa9e4066Sahrens * Iterate over all snapshots. 1171fa9e4066Sahrens */ 1172088f3894Sahrens if (flags & DS_FIND_SNAPSHOTS) { 1173088f3894Sahrens if (!dsl_pool_sync_context(dp)) 1174088f3894Sahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 1175088f3894Sahrens err = dsl_dataset_hold_obj(dp, thisobj, FTAG, &ds); 1176088f3894Sahrens if (!dsl_pool_sync_context(dp)) 1177088f3894Sahrens rw_exit(&dp->dp_config_rwlock); 1178088f3894Sahrens 1179088f3894Sahrens if (err == 0) { 1180088f3894Sahrens uint64_t snapobj = ds->ds_phys->ds_snapnames_zapobj; 1181088f3894Sahrens dsl_dataset_rele(ds, FTAG); 1182088f3894Sahrens 1183088f3894Sahrens for (zap_cursor_init(&zc, dp->dp_meta_objset, snapobj); 1184088f3894Sahrens zap_cursor_retrieve(&zc, attr) == 0; 1185088f3894Sahrens (void) zap_cursor_advance(&zc)) { 1186088f3894Sahrens ASSERT(attr->za_integer_length == 1187088f3894Sahrens sizeof (uint64_t)); 1188088f3894Sahrens ASSERT(attr->za_num_integers == 1); 1189088f3894Sahrens 1190088f3894Sahrens child = kmem_alloc(MAXPATHLEN, KM_SLEEP); 1191088f3894Sahrens (void) strcpy(child, name); 1192088f3894Sahrens (void) strcat(child, "@"); 1193088f3894Sahrens (void) strcat(child, attr->za_name); 1194088f3894Sahrens err = func(spa, attr->za_first_integer, 1195088f3894Sahrens child, arg); 1196088f3894Sahrens kmem_free(child, MAXPATHLEN); 1197088f3894Sahrens if (err) 1198088f3894Sahrens break; 1199088f3894Sahrens } 1200088f3894Sahrens zap_cursor_fini(&zc); 1201fa9e4066Sahrens } 1202fa9e4066Sahrens } 1203fa9e4066Sahrens 1204fa9e4066Sahrens dsl_dir_close(dd, FTAG); 1205b7661cccSmmusante kmem_free(attr, sizeof (zap_attribute_t)); 1206fa9e4066Sahrens 12071d452cf5Sahrens if (err) 12081d452cf5Sahrens return (err); 12091d452cf5Sahrens 1210fa9e4066Sahrens /* 1211fa9e4066Sahrens * Apply to self if appropriate. 1212fa9e4066Sahrens */ 1213088f3894Sahrens err = func(spa, thisobj, name, arg); 12141d452cf5Sahrens return (err); 1215fa9e4066Sahrens } 1216f18faf3fSek 1217f18faf3fSek void 1218f18faf3fSek dmu_objset_set_user(objset_t *os, void *user_ptr) 1219f18faf3fSek { 1220f18faf3fSek ASSERT(MUTEX_HELD(&os->os->os_user_ptr_lock)); 1221f18faf3fSek os->os->os_user_ptr = user_ptr; 1222f18faf3fSek } 1223f18faf3fSek 1224f18faf3fSek void * 1225f18faf3fSek dmu_objset_get_user(objset_t *os) 1226f18faf3fSek { 1227f18faf3fSek ASSERT(MUTEX_HELD(&os->os->os_user_ptr_lock)); 1228f18faf3fSek return (os->os->os_user_ptr); 1229f18faf3fSek } 1230