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 /* 22cdb0ab79Smaybee * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #include <sys/dmu.h> 27fa9e4066Sahrens #include <sys/dmu_impl.h> 28fa9e4066Sahrens #include <sys/dmu_tx.h> 29fa9e4066Sahrens #include <sys/dbuf.h> 30fa9e4066Sahrens #include <sys/dnode.h> 31fa9e4066Sahrens #include <sys/zfs_context.h> 32fa9e4066Sahrens #include <sys/dmu_objset.h> 33fa9e4066Sahrens #include <sys/dmu_traverse.h> 34fa9e4066Sahrens #include <sys/dsl_dataset.h> 35fa9e4066Sahrens #include <sys/dsl_dir.h> 36fa9e4066Sahrens #include <sys/dsl_pool.h> 371d452cf5Sahrens #include <sys/dsl_synctask.h> 38a2eea2e1Sahrens #include <sys/dsl_prop.h> 39fa9e4066Sahrens #include <sys/dmu_zfetch.h> 40fa9e4066Sahrens #include <sys/zfs_ioctl.h> 41fa9e4066Sahrens #include <sys/zap.h> 42ea8dc4b6Seschrock #include <sys/zio_checksum.h> 4344eda4d7Smaybee #ifdef _KERNEL 4444eda4d7Smaybee #include <sys/vmsystm.h> 45*0fab61baSJonathan W Adams #include <sys/zfs_znode.h> 4644eda4d7Smaybee #endif 47fa9e4066Sahrens 48fa9e4066Sahrens const dmu_object_type_info_t dmu_ot[DMU_OT_NUMTYPES] = { 49fa9e4066Sahrens { byteswap_uint8_array, TRUE, "unallocated" }, 50fa9e4066Sahrens { zap_byteswap, TRUE, "object directory" }, 51fa9e4066Sahrens { byteswap_uint64_array, TRUE, "object array" }, 52fa9e4066Sahrens { byteswap_uint8_array, TRUE, "packed nvlist" }, 53fa9e4066Sahrens { byteswap_uint64_array, TRUE, "packed nvlist size" }, 54fa9e4066Sahrens { byteswap_uint64_array, TRUE, "bplist" }, 55fa9e4066Sahrens { byteswap_uint64_array, TRUE, "bplist header" }, 56fa9e4066Sahrens { byteswap_uint64_array, TRUE, "SPA space map header" }, 57fa9e4066Sahrens { byteswap_uint64_array, TRUE, "SPA space map" }, 58fa9e4066Sahrens { byteswap_uint64_array, TRUE, "ZIL intent log" }, 59fa9e4066Sahrens { dnode_buf_byteswap, TRUE, "DMU dnode" }, 60fa9e4066Sahrens { dmu_objset_byteswap, TRUE, "DMU objset" }, 61fa9e4066Sahrens { byteswap_uint64_array, TRUE, "DSL directory" }, 62fa9e4066Sahrens { zap_byteswap, TRUE, "DSL directory child map"}, 63fa9e4066Sahrens { zap_byteswap, TRUE, "DSL dataset snap map" }, 64fa9e4066Sahrens { zap_byteswap, TRUE, "DSL props" }, 65fa9e4066Sahrens { byteswap_uint64_array, TRUE, "DSL dataset" }, 66fa9e4066Sahrens { zfs_znode_byteswap, TRUE, "ZFS znode" }, 67da6c28aaSamw { zfs_oldacl_byteswap, TRUE, "ZFS V0 ACL" }, 68fa9e4066Sahrens { byteswap_uint8_array, FALSE, "ZFS plain file" }, 69fa9e4066Sahrens { zap_byteswap, TRUE, "ZFS directory" }, 70fa9e4066Sahrens { zap_byteswap, TRUE, "ZFS master node" }, 71fa9e4066Sahrens { zap_byteswap, TRUE, "ZFS delete queue" }, 72fa9e4066Sahrens { byteswap_uint8_array, FALSE, "zvol object" }, 73fa9e4066Sahrens { zap_byteswap, TRUE, "zvol prop" }, 74fa9e4066Sahrens { byteswap_uint8_array, FALSE, "other uint8[]" }, 75fa9e4066Sahrens { byteswap_uint64_array, FALSE, "other uint64[]" }, 76fa9e4066Sahrens { zap_byteswap, TRUE, "other ZAP" }, 77ea8dc4b6Seschrock { zap_byteswap, TRUE, "persistent error log" }, 7806eeb2adSek { byteswap_uint8_array, TRUE, "SPA history" }, 7906eeb2adSek { byteswap_uint64_array, TRUE, "SPA history offsets" }, 80ecd6cf80Smarks { zap_byteswap, TRUE, "Pool properties" }, 81da6c28aaSamw { zap_byteswap, TRUE, "DSL permissions" }, 82da6c28aaSamw { zfs_acl_byteswap, TRUE, "ZFS ACL" }, 83da6c28aaSamw { byteswap_uint8_array, TRUE, "ZFS SYSACL" }, 84da6c28aaSamw { byteswap_uint8_array, TRUE, "FUID table" }, 85add89791Smarks { byteswap_uint64_array, TRUE, "FUID table size" }, 86088f3894Sahrens { zap_byteswap, TRUE, "DSL dataset next clones"}, 87088f3894Sahrens { zap_byteswap, TRUE, "scrub work queue" }, 88fa9e4066Sahrens }; 89fa9e4066Sahrens 90fa9e4066Sahrens int 91ea8dc4b6Seschrock dmu_buf_hold(objset_t *os, uint64_t object, uint64_t offset, 92ea8dc4b6Seschrock void *tag, dmu_buf_t **dbp) 93fa9e4066Sahrens { 94fa9e4066Sahrens dnode_t *dn; 95fa9e4066Sahrens uint64_t blkid; 96fa9e4066Sahrens dmu_buf_impl_t *db; 97ea8dc4b6Seschrock int err; 98fa9e4066Sahrens 99ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 100ea8dc4b6Seschrock if (err) 101ea8dc4b6Seschrock return (err); 102fa9e4066Sahrens blkid = dbuf_whichblock(dn, offset); 103fa9e4066Sahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 104ea8dc4b6Seschrock db = dbuf_hold(dn, blkid, tag); 105fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 106ea8dc4b6Seschrock if (db == NULL) { 107ea8dc4b6Seschrock err = EIO; 108ea8dc4b6Seschrock } else { 109ea8dc4b6Seschrock err = dbuf_read(db, NULL, DB_RF_CANFAIL); 110ea8dc4b6Seschrock if (err) { 111ea8dc4b6Seschrock dbuf_rele(db, tag); 112ea8dc4b6Seschrock db = NULL; 113ea8dc4b6Seschrock } 114ea8dc4b6Seschrock } 115fa9e4066Sahrens 116ea8dc4b6Seschrock dnode_rele(dn, FTAG); 117ea8dc4b6Seschrock *dbp = &db->db; 118ea8dc4b6Seschrock return (err); 119fa9e4066Sahrens } 120fa9e4066Sahrens 121fa9e4066Sahrens int 122fa9e4066Sahrens dmu_bonus_max(void) 123fa9e4066Sahrens { 124fa9e4066Sahrens return (DN_MAX_BONUSLEN); 125fa9e4066Sahrens } 126fa9e4066Sahrens 1271934e92fSmaybee int 1281934e92fSmaybee dmu_set_bonus(dmu_buf_t *db, int newsize, dmu_tx_t *tx) 1291934e92fSmaybee { 1301934e92fSmaybee dnode_t *dn = ((dmu_buf_impl_t *)db)->db_dnode; 1311934e92fSmaybee 1321934e92fSmaybee if (dn->dn_bonus != (dmu_buf_impl_t *)db) 1331934e92fSmaybee return (EINVAL); 1341934e92fSmaybee if (newsize < 0 || newsize > db->db_size) 1351934e92fSmaybee return (EINVAL); 1361934e92fSmaybee dnode_setbonuslen(dn, newsize, tx); 1371934e92fSmaybee return (0); 1381934e92fSmaybee } 1391934e92fSmaybee 140fa9e4066Sahrens /* 141ea8dc4b6Seschrock * returns ENOENT, EIO, or 0. 142fa9e4066Sahrens */ 143ea8dc4b6Seschrock int 144ea8dc4b6Seschrock dmu_bonus_hold(objset_t *os, uint64_t object, void *tag, dmu_buf_t **dbp) 145fa9e4066Sahrens { 146ea8dc4b6Seschrock dnode_t *dn; 147fa9e4066Sahrens dmu_buf_impl_t *db; 1481934e92fSmaybee int error; 149fa9e4066Sahrens 1501934e92fSmaybee error = dnode_hold(os->os, object, FTAG, &dn); 1511934e92fSmaybee if (error) 1521934e92fSmaybee return (error); 153fa9e4066Sahrens 154ea8dc4b6Seschrock rw_enter(&dn->dn_struct_rwlock, RW_READER); 155ea8dc4b6Seschrock if (dn->dn_bonus == NULL) { 156fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 157ea8dc4b6Seschrock rw_enter(&dn->dn_struct_rwlock, RW_WRITER); 158ea8dc4b6Seschrock if (dn->dn_bonus == NULL) 1591934e92fSmaybee dbuf_create_bonus(dn); 160fa9e4066Sahrens } 161ea8dc4b6Seschrock db = dn->dn_bonus; 162ea8dc4b6Seschrock rw_exit(&dn->dn_struct_rwlock); 1631934e92fSmaybee 1641934e92fSmaybee /* as long as the bonus buf is held, the dnode will be held */ 1651934e92fSmaybee if (refcount_add(&db->db_holds, tag) == 1) 1661934e92fSmaybee VERIFY(dnode_add_ref(dn, db)); 1671934e92fSmaybee 168fa9e4066Sahrens dnode_rele(dn, FTAG); 169ea8dc4b6Seschrock 170ea8dc4b6Seschrock VERIFY(0 == dbuf_read(db, NULL, DB_RF_MUST_SUCCEED)); 171ea8dc4b6Seschrock 172ea8dc4b6Seschrock *dbp = &db->db; 173ea8dc4b6Seschrock return (0); 174fa9e4066Sahrens } 175fa9e4066Sahrens 17613506d1eSmaybee /* 17713506d1eSmaybee * Note: longer-term, we should modify all of the dmu_buf_*() interfaces 17813506d1eSmaybee * to take a held dnode rather than <os, object> -- the lookup is wasteful, 17913506d1eSmaybee * and can induce severe lock contention when writing to several files 18013506d1eSmaybee * whose dnodes are in the same block. 18113506d1eSmaybee */ 18213506d1eSmaybee static int 18313506d1eSmaybee dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset, 184ea8dc4b6Seschrock uint64_t length, int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp) 185fa9e4066Sahrens { 186fa9e4066Sahrens dmu_buf_t **dbp; 187fa9e4066Sahrens uint64_t blkid, nblks, i; 188ea8dc4b6Seschrock uint32_t flags; 189ea8dc4b6Seschrock int err; 190ea8dc4b6Seschrock zio_t *zio; 191ea8dc4b6Seschrock 192ea8dc4b6Seschrock ASSERT(length <= DMU_MAX_ACCESS); 193fa9e4066Sahrens 194ea8dc4b6Seschrock flags = DB_RF_CANFAIL | DB_RF_NEVERWAIT; 195e1930233Sbonwick if (length > zfetch_array_rd_sz) 196ea8dc4b6Seschrock flags |= DB_RF_NOPREFETCH; 197ea8dc4b6Seschrock 198fa9e4066Sahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 199fa9e4066Sahrens if (dn->dn_datablkshift) { 200fa9e4066Sahrens int blkshift = dn->dn_datablkshift; 201fa9e4066Sahrens nblks = (P2ROUNDUP(offset+length, 1ULL<<blkshift) - 202b1b8ab34Slling P2ALIGN(offset, 1ULL<<blkshift)) >> blkshift; 203fa9e4066Sahrens } else { 2040125049cSahrens if (offset + length > dn->dn_datablksz) { 2050125049cSahrens zfs_panic_recover("zfs: accessing past end of object " 2060125049cSahrens "%llx/%llx (size=%u access=%llu+%llu)", 2070125049cSahrens (longlong_t)dn->dn_objset-> 2080125049cSahrens os_dsl_dataset->ds_object, 2090125049cSahrens (longlong_t)dn->dn_object, dn->dn_datablksz, 2100125049cSahrens (longlong_t)offset, (longlong_t)length); 2110125049cSahrens return (EIO); 2120125049cSahrens } 213fa9e4066Sahrens nblks = 1; 214fa9e4066Sahrens } 215ea8dc4b6Seschrock dbp = kmem_zalloc(sizeof (dmu_buf_t *) * nblks, KM_SLEEP); 216fa9e4066Sahrens 217ea8dc4b6Seschrock zio = zio_root(dn->dn_objset->os_spa, NULL, NULL, TRUE); 218fa9e4066Sahrens blkid = dbuf_whichblock(dn, offset); 219fa9e4066Sahrens for (i = 0; i < nblks; i++) { 220ea8dc4b6Seschrock dmu_buf_impl_t *db = dbuf_hold(dn, blkid+i, tag); 221ea8dc4b6Seschrock if (db == NULL) { 222ea8dc4b6Seschrock rw_exit(&dn->dn_struct_rwlock); 223ea8dc4b6Seschrock dmu_buf_rele_array(dbp, nblks, tag); 224ea8dc4b6Seschrock zio_nowait(zio); 225ea8dc4b6Seschrock return (EIO); 226ea8dc4b6Seschrock } 227ea8dc4b6Seschrock /* initiate async i/o */ 22813506d1eSmaybee if (read) { 229ea8dc4b6Seschrock rw_exit(&dn->dn_struct_rwlock); 230ea8dc4b6Seschrock (void) dbuf_read(db, zio, flags); 231ea8dc4b6Seschrock rw_enter(&dn->dn_struct_rwlock, RW_READER); 232ea8dc4b6Seschrock } 233ea8dc4b6Seschrock dbp[i] = &db->db; 234fa9e4066Sahrens } 235fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 236fa9e4066Sahrens 237ea8dc4b6Seschrock /* wait for async i/o */ 238ea8dc4b6Seschrock err = zio_wait(zio); 239ea8dc4b6Seschrock if (err) { 240ea8dc4b6Seschrock dmu_buf_rele_array(dbp, nblks, tag); 241ea8dc4b6Seschrock return (err); 242ea8dc4b6Seschrock } 243fa9e4066Sahrens 244ea8dc4b6Seschrock /* wait for other io to complete */ 245ea8dc4b6Seschrock if (read) { 246ea8dc4b6Seschrock for (i = 0; i < nblks; i++) { 247ea8dc4b6Seschrock dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i]; 248ea8dc4b6Seschrock mutex_enter(&db->db_mtx); 249ea8dc4b6Seschrock while (db->db_state == DB_READ || 250ea8dc4b6Seschrock db->db_state == DB_FILL) 251ea8dc4b6Seschrock cv_wait(&db->db_changed, &db->db_mtx); 252ea8dc4b6Seschrock if (db->db_state == DB_UNCACHED) 253ea8dc4b6Seschrock err = EIO; 254ea8dc4b6Seschrock mutex_exit(&db->db_mtx); 255ea8dc4b6Seschrock if (err) { 256ea8dc4b6Seschrock dmu_buf_rele_array(dbp, nblks, tag); 257ea8dc4b6Seschrock return (err); 258ea8dc4b6Seschrock } 259ea8dc4b6Seschrock } 260ea8dc4b6Seschrock } 261fa9e4066Sahrens 262ea8dc4b6Seschrock *numbufsp = nblks; 263ea8dc4b6Seschrock *dbpp = dbp; 264ea8dc4b6Seschrock return (0); 265fa9e4066Sahrens } 266fa9e4066Sahrens 267a2eea2e1Sahrens static int 26813506d1eSmaybee dmu_buf_hold_array(objset_t *os, uint64_t object, uint64_t offset, 26913506d1eSmaybee uint64_t length, int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp) 27013506d1eSmaybee { 27113506d1eSmaybee dnode_t *dn; 27213506d1eSmaybee int err; 27313506d1eSmaybee 27413506d1eSmaybee err = dnode_hold(os->os, object, FTAG, &dn); 27513506d1eSmaybee if (err) 27613506d1eSmaybee return (err); 27713506d1eSmaybee 27813506d1eSmaybee err = dmu_buf_hold_array_by_dnode(dn, offset, length, read, tag, 27913506d1eSmaybee numbufsp, dbpp); 28013506d1eSmaybee 28113506d1eSmaybee dnode_rele(dn, FTAG); 28213506d1eSmaybee 28313506d1eSmaybee return (err); 28413506d1eSmaybee } 28513506d1eSmaybee 28613506d1eSmaybee int 28713506d1eSmaybee dmu_buf_hold_array_by_bonus(dmu_buf_t *db, uint64_t offset, 28813506d1eSmaybee uint64_t length, int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp) 28913506d1eSmaybee { 29013506d1eSmaybee dnode_t *dn = ((dmu_buf_impl_t *)db)->db_dnode; 29113506d1eSmaybee int err; 29213506d1eSmaybee 29313506d1eSmaybee err = dmu_buf_hold_array_by_dnode(dn, offset, length, read, tag, 29413506d1eSmaybee numbufsp, dbpp); 29513506d1eSmaybee 29613506d1eSmaybee return (err); 29713506d1eSmaybee } 29813506d1eSmaybee 299fa9e4066Sahrens void 300ea8dc4b6Seschrock dmu_buf_rele_array(dmu_buf_t **dbp_fake, int numbufs, void *tag) 301fa9e4066Sahrens { 302fa9e4066Sahrens int i; 303fa9e4066Sahrens dmu_buf_impl_t **dbp = (dmu_buf_impl_t **)dbp_fake; 304fa9e4066Sahrens 305fa9e4066Sahrens if (numbufs == 0) 306fa9e4066Sahrens return; 307fa9e4066Sahrens 308ea8dc4b6Seschrock for (i = 0; i < numbufs; i++) { 309ea8dc4b6Seschrock if (dbp[i]) 310ea8dc4b6Seschrock dbuf_rele(dbp[i], tag); 311ea8dc4b6Seschrock } 312fa9e4066Sahrens 313fa9e4066Sahrens kmem_free(dbp, sizeof (dmu_buf_t *) * numbufs); 314fa9e4066Sahrens } 315fa9e4066Sahrens 316fa9e4066Sahrens void 317fa9e4066Sahrens dmu_prefetch(objset_t *os, uint64_t object, uint64_t offset, uint64_t len) 318fa9e4066Sahrens { 319fa9e4066Sahrens dnode_t *dn; 320fa9e4066Sahrens uint64_t blkid; 321ea8dc4b6Seschrock int nblks, i, err; 322fa9e4066Sahrens 323416e0cd8Sek if (zfs_prefetch_disable) 324416e0cd8Sek return; 325416e0cd8Sek 326fa9e4066Sahrens if (len == 0) { /* they're interested in the bonus buffer */ 327fa9e4066Sahrens dn = os->os->os_meta_dnode; 328fa9e4066Sahrens 329fa9e4066Sahrens if (object == 0 || object >= DN_MAX_OBJECT) 330fa9e4066Sahrens return; 331fa9e4066Sahrens 332fa9e4066Sahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 333fa9e4066Sahrens blkid = dbuf_whichblock(dn, object * sizeof (dnode_phys_t)); 334fa9e4066Sahrens dbuf_prefetch(dn, blkid); 335fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 336fa9e4066Sahrens return; 337fa9e4066Sahrens } 338fa9e4066Sahrens 339fa9e4066Sahrens /* 340fa9e4066Sahrens * XXX - Note, if the dnode for the requested object is not 341fa9e4066Sahrens * already cached, we will do a *synchronous* read in the 342fa9e4066Sahrens * dnode_hold() call. The same is true for any indirects. 343fa9e4066Sahrens */ 344ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 345ea8dc4b6Seschrock if (err != 0) 346fa9e4066Sahrens return; 347fa9e4066Sahrens 348fa9e4066Sahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 349fa9e4066Sahrens if (dn->dn_datablkshift) { 350fa9e4066Sahrens int blkshift = dn->dn_datablkshift; 351fa9e4066Sahrens nblks = (P2ROUNDUP(offset+len, 1<<blkshift) - 352b1b8ab34Slling P2ALIGN(offset, 1<<blkshift)) >> blkshift; 353fa9e4066Sahrens } else { 354fa9e4066Sahrens nblks = (offset < dn->dn_datablksz); 355fa9e4066Sahrens } 356fa9e4066Sahrens 357fa9e4066Sahrens if (nblks != 0) { 358fa9e4066Sahrens blkid = dbuf_whichblock(dn, offset); 359fa9e4066Sahrens for (i = 0; i < nblks; i++) 360fa9e4066Sahrens dbuf_prefetch(dn, blkid+i); 361fa9e4066Sahrens } 362fa9e4066Sahrens 363fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 364fa9e4066Sahrens 365fa9e4066Sahrens dnode_rele(dn, FTAG); 366fa9e4066Sahrens } 367fa9e4066Sahrens 368cdb0ab79Smaybee static int 369cdb0ab79Smaybee get_next_chunk(dnode_t *dn, uint64_t *offset, uint64_t limit) 370cdb0ab79Smaybee { 371cdb0ab79Smaybee uint64_t len = limit - *offset; 372cdb0ab79Smaybee uint64_t chunk_len = dn->dn_datablksz * DMU_MAX_DELETEBLKCNT; 373cdb0ab79Smaybee uint64_t dn_used; 374cdb0ab79Smaybee int err; 375cdb0ab79Smaybee 376cdb0ab79Smaybee ASSERT(limit <= *offset); 377cdb0ab79Smaybee 378cdb0ab79Smaybee dn_used = dn->dn_phys->dn_used << 379cdb0ab79Smaybee (dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES ? 0 : DEV_BSHIFT); 380cdb0ab79Smaybee if (len <= chunk_len || dn_used <= chunk_len) { 381cdb0ab79Smaybee *offset = limit; 382cdb0ab79Smaybee return (0); 383cdb0ab79Smaybee } 384cdb0ab79Smaybee 385cdb0ab79Smaybee while (*offset > limit) { 386cdb0ab79Smaybee uint64_t initial_offset = *offset; 387cdb0ab79Smaybee uint64_t delta; 388cdb0ab79Smaybee 389cdb0ab79Smaybee /* skip over allocated data */ 390cdb0ab79Smaybee err = dnode_next_offset(dn, 391cdb0ab79Smaybee DNODE_FIND_HOLE|DNODE_FIND_BACKWARDS, offset, 1, 1, 0); 392cdb0ab79Smaybee if (err == ESRCH) 393cdb0ab79Smaybee *offset = limit; 394cdb0ab79Smaybee else if (err) 395cdb0ab79Smaybee return (err); 396cdb0ab79Smaybee 397cdb0ab79Smaybee ASSERT3U(*offset, <=, initial_offset); 398cdb0ab79Smaybee delta = initial_offset - *offset; 399cdb0ab79Smaybee if (delta >= chunk_len) { 400cdb0ab79Smaybee *offset += delta - chunk_len; 401cdb0ab79Smaybee return (0); 402cdb0ab79Smaybee } 403cdb0ab79Smaybee chunk_len -= delta; 404cdb0ab79Smaybee 405cdb0ab79Smaybee /* skip over unallocated data */ 406cdb0ab79Smaybee err = dnode_next_offset(dn, 407cdb0ab79Smaybee DNODE_FIND_BACKWARDS, offset, 1, 1, 0); 408cdb0ab79Smaybee if (err == ESRCH) 409cdb0ab79Smaybee *offset = limit; 410cdb0ab79Smaybee else if (err) 411cdb0ab79Smaybee return (err); 412cdb0ab79Smaybee 413cdb0ab79Smaybee if (*offset < limit) 414cdb0ab79Smaybee *offset = limit; 415cdb0ab79Smaybee ASSERT3U(*offset, <, initial_offset); 416cdb0ab79Smaybee } 417cdb0ab79Smaybee return (0); 418cdb0ab79Smaybee } 419cdb0ab79Smaybee 420cdb0ab79Smaybee static int 421cdb0ab79Smaybee dmu_free_long_range_impl(objset_t *os, dnode_t *dn, uint64_t offset, 422cdb0ab79Smaybee uint64_t length, boolean_t free_dnode) 423cdb0ab79Smaybee { 424cdb0ab79Smaybee dmu_tx_t *tx; 425cdb0ab79Smaybee uint64_t object_size, start, end, len; 426cdb0ab79Smaybee boolean_t trunc = (length == DMU_OBJECT_END); 427cdb0ab79Smaybee int align, err; 428cdb0ab79Smaybee 429cdb0ab79Smaybee align = 1 << dn->dn_datablkshift; 430cdb0ab79Smaybee ASSERT(align > 0); 431cdb0ab79Smaybee object_size = align == 1 ? dn->dn_datablksz : 432cdb0ab79Smaybee (dn->dn_maxblkid + 1) << dn->dn_datablkshift; 433cdb0ab79Smaybee 434cdb0ab79Smaybee if (trunc || (end = offset + length) > object_size) 435cdb0ab79Smaybee end = object_size; 436cdb0ab79Smaybee if (end <= offset) 437cdb0ab79Smaybee return (0); 438cdb0ab79Smaybee length = end - offset; 439cdb0ab79Smaybee 440cdb0ab79Smaybee while (length) { 441cdb0ab79Smaybee start = end; 442cdb0ab79Smaybee err = get_next_chunk(dn, &start, offset); 443cdb0ab79Smaybee if (err) 444cdb0ab79Smaybee return (err); 445cdb0ab79Smaybee len = trunc ? DMU_OBJECT_END : end - start; 446cdb0ab79Smaybee 447cdb0ab79Smaybee tx = dmu_tx_create(os); 448cdb0ab79Smaybee dmu_tx_hold_free(tx, dn->dn_object, start, len); 449cdb0ab79Smaybee err = dmu_tx_assign(tx, TXG_WAIT); 450cdb0ab79Smaybee if (err) { 451cdb0ab79Smaybee dmu_tx_abort(tx); 452cdb0ab79Smaybee return (err); 453cdb0ab79Smaybee } 454cdb0ab79Smaybee 455cdb0ab79Smaybee dnode_free_range(dn, start, trunc ? -1 : len, tx); 456cdb0ab79Smaybee 457cdb0ab79Smaybee if (start == 0 && trunc && free_dnode) 458cdb0ab79Smaybee dnode_free(dn, tx); 459cdb0ab79Smaybee 460cdb0ab79Smaybee length -= end - start; 461cdb0ab79Smaybee 462cdb0ab79Smaybee dmu_tx_commit(tx); 463cdb0ab79Smaybee end = start; 464cdb0ab79Smaybee trunc = FALSE; 465cdb0ab79Smaybee } 466cdb0ab79Smaybee return (0); 467cdb0ab79Smaybee } 468cdb0ab79Smaybee 469cdb0ab79Smaybee int 470cdb0ab79Smaybee dmu_free_long_range(objset_t *os, uint64_t object, 471cdb0ab79Smaybee uint64_t offset, uint64_t length) 472cdb0ab79Smaybee { 473cdb0ab79Smaybee dnode_t *dn; 474cdb0ab79Smaybee int err; 475cdb0ab79Smaybee 476cdb0ab79Smaybee err = dnode_hold(os->os, object, FTAG, &dn); 477cdb0ab79Smaybee if (err != 0) 478cdb0ab79Smaybee return (err); 479cdb0ab79Smaybee err = dmu_free_long_range_impl(os, dn, offset, length, FALSE); 480cdb0ab79Smaybee dnode_rele(dn, FTAG); 481cdb0ab79Smaybee return (err); 482cdb0ab79Smaybee } 483cdb0ab79Smaybee 484cdb0ab79Smaybee int 485cdb0ab79Smaybee dmu_free_object(objset_t *os, uint64_t object) 486cdb0ab79Smaybee { 487cdb0ab79Smaybee dnode_t *dn; 488cdb0ab79Smaybee dmu_tx_t *tx; 489cdb0ab79Smaybee int err; 490cdb0ab79Smaybee 491cdb0ab79Smaybee err = dnode_hold_impl(os->os, object, DNODE_MUST_BE_ALLOCATED, 492cdb0ab79Smaybee FTAG, &dn); 493cdb0ab79Smaybee if (err != 0) 494cdb0ab79Smaybee return (err); 495cdb0ab79Smaybee if (dn->dn_nlevels == 1) { 496cdb0ab79Smaybee tx = dmu_tx_create(os); 497cdb0ab79Smaybee dmu_tx_hold_bonus(tx, object); 498cdb0ab79Smaybee dmu_tx_hold_free(tx, dn->dn_object, 0, DMU_OBJECT_END); 499cdb0ab79Smaybee err = dmu_tx_assign(tx, TXG_WAIT); 500cdb0ab79Smaybee if (err == 0) { 501cdb0ab79Smaybee dnode_free_range(dn, 0, DMU_OBJECT_END, tx); 502cdb0ab79Smaybee dnode_free(dn, tx); 503cdb0ab79Smaybee dmu_tx_commit(tx); 504cdb0ab79Smaybee } else { 505cdb0ab79Smaybee dmu_tx_abort(tx); 506cdb0ab79Smaybee } 507cdb0ab79Smaybee } else { 508cdb0ab79Smaybee err = dmu_free_long_range_impl(os, dn, 0, DMU_OBJECT_END, TRUE); 509cdb0ab79Smaybee } 510cdb0ab79Smaybee dnode_rele(dn, FTAG); 511cdb0ab79Smaybee return (err); 512cdb0ab79Smaybee } 513cdb0ab79Smaybee 514ea8dc4b6Seschrock int 515fa9e4066Sahrens dmu_free_range(objset_t *os, uint64_t object, uint64_t offset, 516fa9e4066Sahrens uint64_t size, dmu_tx_t *tx) 517fa9e4066Sahrens { 518ea8dc4b6Seschrock dnode_t *dn; 519ea8dc4b6Seschrock int err = dnode_hold(os->os, object, FTAG, &dn); 520ea8dc4b6Seschrock if (err) 521ea8dc4b6Seschrock return (err); 522fa9e4066Sahrens ASSERT(offset < UINT64_MAX); 523fa9e4066Sahrens ASSERT(size == -1ULL || size <= UINT64_MAX - offset); 524fa9e4066Sahrens dnode_free_range(dn, offset, size, tx); 525fa9e4066Sahrens dnode_rele(dn, FTAG); 526ea8dc4b6Seschrock return (0); 527fa9e4066Sahrens } 528fa9e4066Sahrens 529ea8dc4b6Seschrock int 530ea8dc4b6Seschrock dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, 531ea8dc4b6Seschrock void *buf) 532fa9e4066Sahrens { 533fa9e4066Sahrens dnode_t *dn; 534fa9e4066Sahrens dmu_buf_t **dbp; 535ea8dc4b6Seschrock int numbufs, i, err; 536fa9e4066Sahrens 537ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 538ea8dc4b6Seschrock if (err) 539ea8dc4b6Seschrock return (err); 540feb08c6bSbillm 541feb08c6bSbillm /* 542feb08c6bSbillm * Deal with odd block sizes, where there can't be data past the first 543feb08c6bSbillm * block. If we ever do the tail block optimization, we will need to 544feb08c6bSbillm * handle that here as well. 545feb08c6bSbillm */ 546fa9e4066Sahrens if (dn->dn_datablkshift == 0) { 547fa9e4066Sahrens int newsz = offset > dn->dn_datablksz ? 0 : 548fa9e4066Sahrens MIN(size, dn->dn_datablksz - offset); 549fa9e4066Sahrens bzero((char *)buf + newsz, size - newsz); 550fa9e4066Sahrens size = newsz; 551fa9e4066Sahrens } 552fa9e4066Sahrens 553fa9e4066Sahrens while (size > 0) { 554fa9e4066Sahrens uint64_t mylen = MIN(size, DMU_MAX_ACCESS / 2); 555fa9e4066Sahrens 556fa9e4066Sahrens /* 557fa9e4066Sahrens * NB: we could do this block-at-a-time, but it's nice 558fa9e4066Sahrens * to be reading in parallel. 559fa9e4066Sahrens */ 560a2eea2e1Sahrens err = dmu_buf_hold_array_by_dnode(dn, offset, mylen, 561ea8dc4b6Seschrock TRUE, FTAG, &numbufs, &dbp); 562ea8dc4b6Seschrock if (err) 5631934e92fSmaybee break; 564fa9e4066Sahrens 565fa9e4066Sahrens for (i = 0; i < numbufs; i++) { 566fa9e4066Sahrens int tocpy; 567fa9e4066Sahrens int bufoff; 568fa9e4066Sahrens dmu_buf_t *db = dbp[i]; 569fa9e4066Sahrens 570fa9e4066Sahrens ASSERT(size > 0); 571fa9e4066Sahrens 572fa9e4066Sahrens bufoff = offset - db->db_offset; 573fa9e4066Sahrens tocpy = (int)MIN(db->db_size - bufoff, size); 574fa9e4066Sahrens 575fa9e4066Sahrens bcopy((char *)db->db_data + bufoff, buf, tocpy); 576fa9e4066Sahrens 577fa9e4066Sahrens offset += tocpy; 578fa9e4066Sahrens size -= tocpy; 579fa9e4066Sahrens buf = (char *)buf + tocpy; 580fa9e4066Sahrens } 581ea8dc4b6Seschrock dmu_buf_rele_array(dbp, numbufs, FTAG); 582fa9e4066Sahrens } 583a2eea2e1Sahrens dnode_rele(dn, FTAG); 5841934e92fSmaybee return (err); 585fa9e4066Sahrens } 586fa9e4066Sahrens 587fa9e4066Sahrens void 588fa9e4066Sahrens dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, 589fa9e4066Sahrens const void *buf, dmu_tx_t *tx) 590fa9e4066Sahrens { 591fa9e4066Sahrens dmu_buf_t **dbp; 592fa9e4066Sahrens int numbufs, i; 593fa9e4066Sahrens 59413506d1eSmaybee if (size == 0) 59513506d1eSmaybee return; 59613506d1eSmaybee 597ea8dc4b6Seschrock VERIFY(0 == dmu_buf_hold_array(os, object, offset, size, 598ea8dc4b6Seschrock FALSE, FTAG, &numbufs, &dbp)); 599fa9e4066Sahrens 600fa9e4066Sahrens for (i = 0; i < numbufs; i++) { 601fa9e4066Sahrens int tocpy; 602fa9e4066Sahrens int bufoff; 603fa9e4066Sahrens dmu_buf_t *db = dbp[i]; 604fa9e4066Sahrens 605fa9e4066Sahrens ASSERT(size > 0); 606fa9e4066Sahrens 607fa9e4066Sahrens bufoff = offset - db->db_offset; 608fa9e4066Sahrens tocpy = (int)MIN(db->db_size - bufoff, size); 609fa9e4066Sahrens 610fa9e4066Sahrens ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size); 611fa9e4066Sahrens 612fa9e4066Sahrens if (tocpy == db->db_size) 613fa9e4066Sahrens dmu_buf_will_fill(db, tx); 614fa9e4066Sahrens else 615fa9e4066Sahrens dmu_buf_will_dirty(db, tx); 616fa9e4066Sahrens 617fa9e4066Sahrens bcopy(buf, (char *)db->db_data + bufoff, tocpy); 618fa9e4066Sahrens 619fa9e4066Sahrens if (tocpy == db->db_size) 620fa9e4066Sahrens dmu_buf_fill_done(db, tx); 621fa9e4066Sahrens 622fa9e4066Sahrens offset += tocpy; 623fa9e4066Sahrens size -= tocpy; 624fa9e4066Sahrens buf = (char *)buf + tocpy; 625fa9e4066Sahrens } 626ea8dc4b6Seschrock dmu_buf_rele_array(dbp, numbufs, FTAG); 627fa9e4066Sahrens } 628fa9e4066Sahrens 629fa9e4066Sahrens #ifdef _KERNEL 630fa9e4066Sahrens int 631feb08c6bSbillm dmu_read_uio(objset_t *os, uint64_t object, uio_t *uio, uint64_t size) 632feb08c6bSbillm { 633feb08c6bSbillm dmu_buf_t **dbp; 634feb08c6bSbillm int numbufs, i, err; 635feb08c6bSbillm 636feb08c6bSbillm /* 637feb08c6bSbillm * NB: we could do this block-at-a-time, but it's nice 638feb08c6bSbillm * to be reading in parallel. 639feb08c6bSbillm */ 640feb08c6bSbillm err = dmu_buf_hold_array(os, object, uio->uio_loffset, size, TRUE, FTAG, 641feb08c6bSbillm &numbufs, &dbp); 642feb08c6bSbillm if (err) 643feb08c6bSbillm return (err); 644feb08c6bSbillm 645feb08c6bSbillm for (i = 0; i < numbufs; i++) { 646feb08c6bSbillm int tocpy; 647feb08c6bSbillm int bufoff; 648feb08c6bSbillm dmu_buf_t *db = dbp[i]; 649feb08c6bSbillm 650feb08c6bSbillm ASSERT(size > 0); 651feb08c6bSbillm 652feb08c6bSbillm bufoff = uio->uio_loffset - db->db_offset; 653feb08c6bSbillm tocpy = (int)MIN(db->db_size - bufoff, size); 654feb08c6bSbillm 655feb08c6bSbillm err = uiomove((char *)db->db_data + bufoff, tocpy, 656feb08c6bSbillm UIO_READ, uio); 657feb08c6bSbillm if (err) 658feb08c6bSbillm break; 659feb08c6bSbillm 660feb08c6bSbillm size -= tocpy; 661feb08c6bSbillm } 662feb08c6bSbillm dmu_buf_rele_array(dbp, numbufs, FTAG); 663feb08c6bSbillm 664feb08c6bSbillm return (err); 665feb08c6bSbillm } 666feb08c6bSbillm 667feb08c6bSbillm int 668feb08c6bSbillm dmu_write_uio(objset_t *os, uint64_t object, uio_t *uio, uint64_t size, 669feb08c6bSbillm dmu_tx_t *tx) 670fa9e4066Sahrens { 671fa9e4066Sahrens dmu_buf_t **dbp; 672fa9e4066Sahrens int numbufs, i; 673fa9e4066Sahrens int err = 0; 674fa9e4066Sahrens 67513506d1eSmaybee if (size == 0) 67613506d1eSmaybee return (0); 67713506d1eSmaybee 678feb08c6bSbillm err = dmu_buf_hold_array(os, object, uio->uio_loffset, size, 679ea8dc4b6Seschrock FALSE, FTAG, &numbufs, &dbp); 680ea8dc4b6Seschrock if (err) 681ea8dc4b6Seschrock return (err); 682fa9e4066Sahrens 683fa9e4066Sahrens for (i = 0; i < numbufs; i++) { 684fa9e4066Sahrens int tocpy; 685fa9e4066Sahrens int bufoff; 686fa9e4066Sahrens dmu_buf_t *db = dbp[i]; 687fa9e4066Sahrens 688fa9e4066Sahrens ASSERT(size > 0); 689fa9e4066Sahrens 690feb08c6bSbillm bufoff = uio->uio_loffset - db->db_offset; 691fa9e4066Sahrens tocpy = (int)MIN(db->db_size - bufoff, size); 692fa9e4066Sahrens 693fa9e4066Sahrens ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size); 694fa9e4066Sahrens 695fa9e4066Sahrens if (tocpy == db->db_size) 696fa9e4066Sahrens dmu_buf_will_fill(db, tx); 697fa9e4066Sahrens else 698fa9e4066Sahrens dmu_buf_will_dirty(db, tx); 699fa9e4066Sahrens 700fa9e4066Sahrens /* 701fa9e4066Sahrens * XXX uiomove could block forever (eg. nfs-backed 702fa9e4066Sahrens * pages). There needs to be a uiolockdown() function 703fa9e4066Sahrens * to lock the pages in memory, so that uiomove won't 704fa9e4066Sahrens * block. 705fa9e4066Sahrens */ 706fa9e4066Sahrens err = uiomove((char *)db->db_data + bufoff, tocpy, 707fa9e4066Sahrens UIO_WRITE, uio); 708fa9e4066Sahrens 709fa9e4066Sahrens if (tocpy == db->db_size) 710fa9e4066Sahrens dmu_buf_fill_done(db, tx); 711fa9e4066Sahrens 712fa9e4066Sahrens if (err) 713fa9e4066Sahrens break; 714fa9e4066Sahrens 715fa9e4066Sahrens size -= tocpy; 716fa9e4066Sahrens } 717ea8dc4b6Seschrock dmu_buf_rele_array(dbp, numbufs, FTAG); 718fa9e4066Sahrens return (err); 719fa9e4066Sahrens } 72044eda4d7Smaybee 72144eda4d7Smaybee int 72244eda4d7Smaybee dmu_write_pages(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, 72344eda4d7Smaybee page_t *pp, dmu_tx_t *tx) 72444eda4d7Smaybee { 72544eda4d7Smaybee dmu_buf_t **dbp; 72644eda4d7Smaybee int numbufs, i; 72744eda4d7Smaybee int err; 72844eda4d7Smaybee 72944eda4d7Smaybee if (size == 0) 73044eda4d7Smaybee return (0); 73144eda4d7Smaybee 73244eda4d7Smaybee err = dmu_buf_hold_array(os, object, offset, size, 73344eda4d7Smaybee FALSE, FTAG, &numbufs, &dbp); 73444eda4d7Smaybee if (err) 73544eda4d7Smaybee return (err); 73644eda4d7Smaybee 73744eda4d7Smaybee for (i = 0; i < numbufs; i++) { 73844eda4d7Smaybee int tocpy, copied, thiscpy; 73944eda4d7Smaybee int bufoff; 74044eda4d7Smaybee dmu_buf_t *db = dbp[i]; 74144eda4d7Smaybee caddr_t va; 74244eda4d7Smaybee 74344eda4d7Smaybee ASSERT(size > 0); 74444eda4d7Smaybee ASSERT3U(db->db_size, >=, PAGESIZE); 74544eda4d7Smaybee 74644eda4d7Smaybee bufoff = offset - db->db_offset; 74744eda4d7Smaybee tocpy = (int)MIN(db->db_size - bufoff, size); 74844eda4d7Smaybee 74944eda4d7Smaybee ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size); 75044eda4d7Smaybee 75144eda4d7Smaybee if (tocpy == db->db_size) 75244eda4d7Smaybee dmu_buf_will_fill(db, tx); 75344eda4d7Smaybee else 75444eda4d7Smaybee dmu_buf_will_dirty(db, tx); 75544eda4d7Smaybee 75644eda4d7Smaybee for (copied = 0; copied < tocpy; copied += PAGESIZE) { 75744eda4d7Smaybee ASSERT3U(pp->p_offset, ==, db->db_offset + bufoff); 75844eda4d7Smaybee thiscpy = MIN(PAGESIZE, tocpy - copied); 759*0fab61baSJonathan W Adams va = zfs_map_page(pp, S_READ); 76044eda4d7Smaybee bcopy(va, (char *)db->db_data + bufoff, thiscpy); 761*0fab61baSJonathan W Adams zfs_unmap_page(pp, va); 76244eda4d7Smaybee pp = pp->p_next; 76344eda4d7Smaybee bufoff += PAGESIZE; 76444eda4d7Smaybee } 76544eda4d7Smaybee 76644eda4d7Smaybee if (tocpy == db->db_size) 76744eda4d7Smaybee dmu_buf_fill_done(db, tx); 76844eda4d7Smaybee 76944eda4d7Smaybee if (err) 77044eda4d7Smaybee break; 77144eda4d7Smaybee 77244eda4d7Smaybee offset += tocpy; 77344eda4d7Smaybee size -= tocpy; 77444eda4d7Smaybee } 77544eda4d7Smaybee dmu_buf_rele_array(dbp, numbufs, FTAG); 77644eda4d7Smaybee return (err); 77744eda4d7Smaybee } 778fa9e4066Sahrens #endif 779fa9e4066Sahrens 780c5c6ffa0Smaybee typedef struct { 781c717a561Smaybee dbuf_dirty_record_t *dr; 782c717a561Smaybee dmu_sync_cb_t *done; 783c717a561Smaybee void *arg; 784c717a561Smaybee } dmu_sync_arg_t; 785c5c6ffa0Smaybee 786c5c6ffa0Smaybee /* ARGSUSED */ 787c5c6ffa0Smaybee static void 788c5c6ffa0Smaybee dmu_sync_done(zio_t *zio, arc_buf_t *buf, void *varg) 789c5c6ffa0Smaybee { 790c717a561Smaybee dmu_sync_arg_t *in = varg; 791c717a561Smaybee dbuf_dirty_record_t *dr = in->dr; 792c717a561Smaybee dmu_buf_impl_t *db = dr->dr_dbuf; 793c5c6ffa0Smaybee dmu_sync_cb_t *done = in->done; 794c5c6ffa0Smaybee 795c5c6ffa0Smaybee if (!BP_IS_HOLE(zio->io_bp)) { 796c5c6ffa0Smaybee zio->io_bp->blk_fill = 1; 797c5c6ffa0Smaybee BP_SET_TYPE(zio->io_bp, db->db_dnode->dn_type); 798c5c6ffa0Smaybee BP_SET_LEVEL(zio->io_bp, 0); 799c5c6ffa0Smaybee } 800c5c6ffa0Smaybee 801c5c6ffa0Smaybee mutex_enter(&db->db_mtx); 802c717a561Smaybee ASSERT(dr->dt.dl.dr_override_state == DR_IN_DMU_SYNC); 803c717a561Smaybee dr->dt.dl.dr_overridden_by = *zio->io_bp; /* structure assignment */ 804c717a561Smaybee dr->dt.dl.dr_override_state = DR_OVERRIDDEN; 805c5c6ffa0Smaybee cv_broadcast(&db->db_changed); 806c5c6ffa0Smaybee mutex_exit(&db->db_mtx); 807c5c6ffa0Smaybee 808c5c6ffa0Smaybee if (done) 809c717a561Smaybee done(&(db->db), in->arg); 810c717a561Smaybee 811c717a561Smaybee kmem_free(in, sizeof (dmu_sync_arg_t)); 812c5c6ffa0Smaybee } 813c5c6ffa0Smaybee 814fa9e4066Sahrens /* 815c5c6ffa0Smaybee * Intent log support: sync the block associated with db to disk. 816c5c6ffa0Smaybee * N.B. and XXX: the caller is responsible for making sure that the 817c5c6ffa0Smaybee * data isn't changing while dmu_sync() is writing it. 818fa9e4066Sahrens * 819fa9e4066Sahrens * Return values: 820fa9e4066Sahrens * 821c5c6ffa0Smaybee * EEXIST: this txg has already been synced, so there's nothing to to. 822fa9e4066Sahrens * The caller should not log the write. 823fa9e4066Sahrens * 824fa9e4066Sahrens * ENOENT: the block was dbuf_free_range()'d, so there's nothing to do. 825fa9e4066Sahrens * The caller should not log the write. 826fa9e4066Sahrens * 827c5c6ffa0Smaybee * EALREADY: this block is already in the process of being synced. 828c5c6ffa0Smaybee * The caller should track its progress (somehow). 829fa9e4066Sahrens * 830c5c6ffa0Smaybee * EINPROGRESS: the IO has been initiated. 831c5c6ffa0Smaybee * The caller should log this blkptr in the callback. 832fa9e4066Sahrens * 833c5c6ffa0Smaybee * 0: completed. Sets *bp to the blkptr just written. 834c5c6ffa0Smaybee * The caller should log this blkptr immediately. 835fa9e4066Sahrens */ 836fa9e4066Sahrens int 837c5c6ffa0Smaybee dmu_sync(zio_t *pio, dmu_buf_t *db_fake, 838c5c6ffa0Smaybee blkptr_t *bp, uint64_t txg, dmu_sync_cb_t *done, void *arg) 839fa9e4066Sahrens { 840c5c6ffa0Smaybee dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake; 841c5c6ffa0Smaybee objset_impl_t *os = db->db_objset; 842c5c6ffa0Smaybee dsl_pool_t *dp = os->os_dsl_dataset->ds_dir->dd_pool; 843fa9e4066Sahrens tx_state_t *tx = &dp->dp_tx; 844c717a561Smaybee dbuf_dirty_record_t *dr; 845c717a561Smaybee dmu_sync_arg_t *in; 846ea8dc4b6Seschrock zbookmark_t zb; 847088f3894Sahrens writeprops_t wp = { 0 }; 848c717a561Smaybee zio_t *zio; 8499bc11082Sek int zio_flags; 850c5c6ffa0Smaybee int err; 851fa9e4066Sahrens 852fa9e4066Sahrens ASSERT(BP_IS_HOLE(bp)); 853fa9e4066Sahrens ASSERT(txg != 0); 854fa9e4066Sahrens 855c5c6ffa0Smaybee 856fa9e4066Sahrens dprintf("dmu_sync txg=%llu, s,o,q %llu %llu %llu\n", 857fa9e4066Sahrens txg, tx->tx_synced_txg, tx->tx_open_txg, tx->tx_quiesced_txg); 858fa9e4066Sahrens 859ea8dc4b6Seschrock /* 860c5c6ffa0Smaybee * XXX - would be nice if we could do this without suspending... 861ea8dc4b6Seschrock */ 862c5c6ffa0Smaybee txg_suspend(dp); 863ea8dc4b6Seschrock 864fa9e4066Sahrens /* 865fa9e4066Sahrens * If this txg already synced, there's nothing to do. 866fa9e4066Sahrens */ 867fa9e4066Sahrens if (txg <= tx->tx_synced_txg) { 868c5c6ffa0Smaybee txg_resume(dp); 869fa9e4066Sahrens /* 870fa9e4066Sahrens * If we're running ziltest, we need the blkptr regardless. 871fa9e4066Sahrens */ 872fa9e4066Sahrens if (txg > spa_freeze_txg(dp->dp_spa)) { 873fa9e4066Sahrens /* if db_blkptr == NULL, this was an empty write */ 874fa9e4066Sahrens if (db->db_blkptr) 875fa9e4066Sahrens *bp = *db->db_blkptr; /* structure assignment */ 876fa9e4066Sahrens return (0); 877fa9e4066Sahrens } 878c5c6ffa0Smaybee return (EEXIST); 879fa9e4066Sahrens } 880fa9e4066Sahrens 881fa9e4066Sahrens mutex_enter(&db->db_mtx); 882fa9e4066Sahrens 883c5c6ffa0Smaybee if (txg == tx->tx_syncing_txg) { 884c5c6ffa0Smaybee while (db->db_data_pending) { 885c5c6ffa0Smaybee /* 886c5c6ffa0Smaybee * IO is in-progress. Wait for it to finish. 887c5c6ffa0Smaybee * XXX - would be nice to be able to somehow "attach" 888c5c6ffa0Smaybee * this zio to the parent zio passed in. 889c5c6ffa0Smaybee */ 890c5c6ffa0Smaybee cv_wait(&db->db_changed, &db->db_mtx); 89113506d1eSmaybee if (!db->db_data_pending && 89213506d1eSmaybee db->db_blkptr && BP_IS_HOLE(db->db_blkptr)) { 89313506d1eSmaybee /* 89413506d1eSmaybee * IO was compressed away 89513506d1eSmaybee */ 89613506d1eSmaybee *bp = *db->db_blkptr; /* structure assignment */ 89713506d1eSmaybee mutex_exit(&db->db_mtx); 89813506d1eSmaybee txg_resume(dp); 89913506d1eSmaybee return (0); 90013506d1eSmaybee } 901c5c6ffa0Smaybee ASSERT(db->db_data_pending || 902c5c6ffa0Smaybee (db->db_blkptr && db->db_blkptr->blk_birth == txg)); 903c5c6ffa0Smaybee } 904fa9e4066Sahrens 905c5c6ffa0Smaybee if (db->db_blkptr && db->db_blkptr->blk_birth == txg) { 906c5c6ffa0Smaybee /* 907c5c6ffa0Smaybee * IO is already completed. 908c5c6ffa0Smaybee */ 909c5c6ffa0Smaybee *bp = *db->db_blkptr; /* structure assignment */ 910fa9e4066Sahrens mutex_exit(&db->db_mtx); 911c5c6ffa0Smaybee txg_resume(dp); 912c5c6ffa0Smaybee return (0); 913fa9e4066Sahrens } 914fa9e4066Sahrens } 915fa9e4066Sahrens 916c717a561Smaybee dr = db->db_last_dirty; 917c717a561Smaybee while (dr && dr->dr_txg > txg) 918c717a561Smaybee dr = dr->dr_next; 919c717a561Smaybee if (dr == NULL || dr->dr_txg < txg) { 920c5c6ffa0Smaybee /* 921c5c6ffa0Smaybee * This dbuf isn't dirty, must have been free_range'd. 922c5c6ffa0Smaybee * There's no need to log writes to freed blocks, so we're done. 923c5c6ffa0Smaybee */ 924c5c6ffa0Smaybee mutex_exit(&db->db_mtx); 925c5c6ffa0Smaybee txg_resume(dp); 926c5c6ffa0Smaybee return (ENOENT); 927c5c6ffa0Smaybee } 928c5c6ffa0Smaybee 929c717a561Smaybee ASSERT(dr->dr_txg == txg); 930c717a561Smaybee if (dr->dt.dl.dr_override_state == DR_IN_DMU_SYNC) { 931c717a561Smaybee /* 932c717a561Smaybee * We have already issued a sync write for this buffer. 933c717a561Smaybee */ 934c717a561Smaybee mutex_exit(&db->db_mtx); 935c717a561Smaybee txg_resume(dp); 936c717a561Smaybee return (EALREADY); 937c717a561Smaybee } else if (dr->dt.dl.dr_override_state == DR_OVERRIDDEN) { 938c717a561Smaybee /* 939c717a561Smaybee * This buffer has already been synced. It could not 940c717a561Smaybee * have been dirtied since, or we would have cleared the state. 941c717a561Smaybee */ 942c717a561Smaybee *bp = dr->dt.dl.dr_overridden_by; /* structure assignment */ 943c717a561Smaybee mutex_exit(&db->db_mtx); 944c717a561Smaybee txg_resume(dp); 945c717a561Smaybee return (0); 946c717a561Smaybee } 947c717a561Smaybee 948c717a561Smaybee dr->dt.dl.dr_override_state = DR_IN_DMU_SYNC; 949c717a561Smaybee in = kmem_alloc(sizeof (dmu_sync_arg_t), KM_SLEEP); 950c717a561Smaybee in->dr = dr; 951c5c6ffa0Smaybee in->done = done; 952c5c6ffa0Smaybee in->arg = arg; 953fa9e4066Sahrens mutex_exit(&db->db_mtx); 954c5c6ffa0Smaybee txg_resume(dp); 955fa9e4066Sahrens 956c5c6ffa0Smaybee zb.zb_objset = os->os_dsl_dataset->ds_object; 957ea8dc4b6Seschrock zb.zb_object = db->db.db_object; 958ea8dc4b6Seschrock zb.zb_level = db->db_level; 959ea8dc4b6Seschrock zb.zb_blkid = db->db_blkid; 9609bc11082Sek zio_flags = ZIO_FLAG_MUSTSUCCEED; 9619bc11082Sek if (dmu_ot[db->db_dnode->dn_type].ot_metadata || zb.zb_level != 0) 9629bc11082Sek zio_flags |= ZIO_FLAG_METADATA; 963088f3894Sahrens wp.wp_type = db->db_dnode->dn_type; 964088f3894Sahrens wp.wp_copies = os->os_copies; 965088f3894Sahrens wp.wp_level = db->db_level; 966088f3894Sahrens wp.wp_dnchecksum = db->db_dnode->dn_checksum; 967088f3894Sahrens wp.wp_oschecksum = os->os_checksum; 968088f3894Sahrens wp.wp_dncompress = db->db_dnode->dn_compress; 969088f3894Sahrens wp.wp_oscompress = os->os_compress; 970088f3894Sahrens zio = arc_write(pio, os->os_spa, &wp, 9713baa08fcSek DBUF_IS_L2CACHEABLE(db), txg, bp, dr->dt.dl.dr_data, NULL, 9723baa08fcSek dmu_sync_done, in, ZIO_PRIORITY_SYNC_WRITE, zio_flags, &zb); 973fa9e4066Sahrens 974c717a561Smaybee if (pio) { 975c717a561Smaybee zio_nowait(zio); 976c717a561Smaybee err = EINPROGRESS; 977c717a561Smaybee } else { 978c717a561Smaybee err = zio_wait(zio); 979c717a561Smaybee ASSERT(err == 0); 980c717a561Smaybee } 981c717a561Smaybee return (err); 982fa9e4066Sahrens } 983fa9e4066Sahrens 984fa9e4066Sahrens int 985fa9e4066Sahrens dmu_object_set_blocksize(objset_t *os, uint64_t object, uint64_t size, int ibs, 986fa9e4066Sahrens dmu_tx_t *tx) 987fa9e4066Sahrens { 988ea8dc4b6Seschrock dnode_t *dn; 989ea8dc4b6Seschrock int err; 990ea8dc4b6Seschrock 991ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 992ea8dc4b6Seschrock if (err) 993ea8dc4b6Seschrock return (err); 994ea8dc4b6Seschrock err = dnode_set_blksz(dn, size, ibs, tx); 995fa9e4066Sahrens dnode_rele(dn, FTAG); 996fa9e4066Sahrens return (err); 997fa9e4066Sahrens } 998fa9e4066Sahrens 999fa9e4066Sahrens void 1000fa9e4066Sahrens dmu_object_set_checksum(objset_t *os, uint64_t object, uint8_t checksum, 1001fa9e4066Sahrens dmu_tx_t *tx) 1002fa9e4066Sahrens { 1003ea8dc4b6Seschrock dnode_t *dn; 1004ea8dc4b6Seschrock 1005ea8dc4b6Seschrock /* XXX assumes dnode_hold will not get an i/o error */ 1006ea8dc4b6Seschrock (void) dnode_hold(os->os, object, FTAG, &dn); 1007fa9e4066Sahrens ASSERT(checksum < ZIO_CHECKSUM_FUNCTIONS); 1008fa9e4066Sahrens dn->dn_checksum = checksum; 1009fa9e4066Sahrens dnode_setdirty(dn, tx); 1010fa9e4066Sahrens dnode_rele(dn, FTAG); 1011fa9e4066Sahrens } 1012fa9e4066Sahrens 1013fa9e4066Sahrens void 1014fa9e4066Sahrens dmu_object_set_compress(objset_t *os, uint64_t object, uint8_t compress, 1015fa9e4066Sahrens dmu_tx_t *tx) 1016fa9e4066Sahrens { 1017ea8dc4b6Seschrock dnode_t *dn; 1018ea8dc4b6Seschrock 1019ea8dc4b6Seschrock /* XXX assumes dnode_hold will not get an i/o error */ 1020ea8dc4b6Seschrock (void) dnode_hold(os->os, object, FTAG, &dn); 1021fa9e4066Sahrens ASSERT(compress < ZIO_COMPRESS_FUNCTIONS); 1022fa9e4066Sahrens dn->dn_compress = compress; 1023fa9e4066Sahrens dnode_setdirty(dn, tx); 1024fa9e4066Sahrens dnode_rele(dn, FTAG); 1025fa9e4066Sahrens } 1026fa9e4066Sahrens 1027fa9e4066Sahrens int 1028fa9e4066Sahrens dmu_offset_next(objset_t *os, uint64_t object, boolean_t hole, uint64_t *off) 1029fa9e4066Sahrens { 1030fa9e4066Sahrens dnode_t *dn; 1031fa9e4066Sahrens int i, err; 1032fa9e4066Sahrens 1033ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 1034ea8dc4b6Seschrock if (err) 1035ea8dc4b6Seschrock return (err); 1036fa9e4066Sahrens /* 1037fa9e4066Sahrens * Sync any current changes before 1038fa9e4066Sahrens * we go trundling through the block pointers. 1039fa9e4066Sahrens */ 1040fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++) { 1041c543ec06Sahrens if (list_link_active(&dn->dn_dirty_link[i])) 1042fa9e4066Sahrens break; 1043fa9e4066Sahrens } 1044fa9e4066Sahrens if (i != TXG_SIZE) { 1045fa9e4066Sahrens dnode_rele(dn, FTAG); 1046fa9e4066Sahrens txg_wait_synced(dmu_objset_pool(os), 0); 1047ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 1048ea8dc4b6Seschrock if (err) 1049ea8dc4b6Seschrock return (err); 1050fa9e4066Sahrens } 1051fa9e4066Sahrens 1052cdb0ab79Smaybee err = dnode_next_offset(dn, (hole ? DNODE_FIND_HOLE : 0), off, 1, 1, 0); 1053fa9e4066Sahrens dnode_rele(dn, FTAG); 1054fa9e4066Sahrens 1055fa9e4066Sahrens return (err); 1056fa9e4066Sahrens } 1057fa9e4066Sahrens 1058fa9e4066Sahrens void 1059fa9e4066Sahrens dmu_object_info_from_dnode(dnode_t *dn, dmu_object_info_t *doi) 1060fa9e4066Sahrens { 1061fa9e4066Sahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 1062fa9e4066Sahrens mutex_enter(&dn->dn_mtx); 1063fa9e4066Sahrens 1064fa9e4066Sahrens doi->doi_data_block_size = dn->dn_datablksz; 1065fa9e4066Sahrens doi->doi_metadata_block_size = dn->dn_indblkshift ? 1066fa9e4066Sahrens 1ULL << dn->dn_indblkshift : 0; 1067fa9e4066Sahrens doi->doi_indirection = dn->dn_nlevels; 1068fa9e4066Sahrens doi->doi_checksum = dn->dn_checksum; 1069fa9e4066Sahrens doi->doi_compress = dn->dn_compress; 107099653d4eSeschrock doi->doi_physical_blks = (DN_USED_BYTES(dn->dn_phys) + 107199653d4eSeschrock SPA_MINBLOCKSIZE/2) >> SPA_MINBLOCKSHIFT; 1072fa9e4066Sahrens doi->doi_max_block_offset = dn->dn_phys->dn_maxblkid; 1073fa9e4066Sahrens doi->doi_type = dn->dn_type; 1074fa9e4066Sahrens doi->doi_bonus_size = dn->dn_bonuslen; 1075fa9e4066Sahrens doi->doi_bonus_type = dn->dn_bonustype; 1076fa9e4066Sahrens 1077fa9e4066Sahrens mutex_exit(&dn->dn_mtx); 1078fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 1079fa9e4066Sahrens } 1080fa9e4066Sahrens 1081fa9e4066Sahrens /* 1082fa9e4066Sahrens * Get information on a DMU object. 1083fa9e4066Sahrens * If doi is NULL, just indicates whether the object exists. 1084fa9e4066Sahrens */ 1085fa9e4066Sahrens int 1086fa9e4066Sahrens dmu_object_info(objset_t *os, uint64_t object, dmu_object_info_t *doi) 1087fa9e4066Sahrens { 1088ea8dc4b6Seschrock dnode_t *dn; 1089ea8dc4b6Seschrock int err = dnode_hold(os->os, object, FTAG, &dn); 1090fa9e4066Sahrens 1091ea8dc4b6Seschrock if (err) 1092ea8dc4b6Seschrock return (err); 1093fa9e4066Sahrens 1094fa9e4066Sahrens if (doi != NULL) 1095fa9e4066Sahrens dmu_object_info_from_dnode(dn, doi); 1096fa9e4066Sahrens 1097fa9e4066Sahrens dnode_rele(dn, FTAG); 1098fa9e4066Sahrens return (0); 1099fa9e4066Sahrens } 1100fa9e4066Sahrens 1101fa9e4066Sahrens /* 1102fa9e4066Sahrens * As above, but faster; can be used when you have a held dbuf in hand. 1103fa9e4066Sahrens */ 1104fa9e4066Sahrens void 1105fa9e4066Sahrens dmu_object_info_from_db(dmu_buf_t *db, dmu_object_info_t *doi) 1106fa9e4066Sahrens { 1107fa9e4066Sahrens dmu_object_info_from_dnode(((dmu_buf_impl_t *)db)->db_dnode, doi); 1108fa9e4066Sahrens } 1109fa9e4066Sahrens 1110fa9e4066Sahrens /* 1111fa9e4066Sahrens * Faster still when you only care about the size. 1112fa9e4066Sahrens * This is specifically optimized for zfs_getattr(). 1113fa9e4066Sahrens */ 1114fa9e4066Sahrens void 1115fa9e4066Sahrens dmu_object_size_from_db(dmu_buf_t *db, uint32_t *blksize, u_longlong_t *nblk512) 1116fa9e4066Sahrens { 1117fa9e4066Sahrens dnode_t *dn = ((dmu_buf_impl_t *)db)->db_dnode; 1118fa9e4066Sahrens 1119fa9e4066Sahrens *blksize = dn->dn_datablksz; 112099653d4eSeschrock /* add 1 for dnode space */ 112199653d4eSeschrock *nblk512 = ((DN_USED_BYTES(dn->dn_phys) + SPA_MINBLOCKSIZE/2) >> 112299653d4eSeschrock SPA_MINBLOCKSHIFT) + 1; 1123fa9e4066Sahrens } 1124fa9e4066Sahrens 1125fa9e4066Sahrens void 1126fa9e4066Sahrens byteswap_uint64_array(void *vbuf, size_t size) 1127fa9e4066Sahrens { 1128fa9e4066Sahrens uint64_t *buf = vbuf; 1129fa9e4066Sahrens size_t count = size >> 3; 1130fa9e4066Sahrens int i; 1131fa9e4066Sahrens 1132fa9e4066Sahrens ASSERT((size & 7) == 0); 1133fa9e4066Sahrens 1134fa9e4066Sahrens for (i = 0; i < count; i++) 1135fa9e4066Sahrens buf[i] = BSWAP_64(buf[i]); 1136fa9e4066Sahrens } 1137fa9e4066Sahrens 1138fa9e4066Sahrens void 1139fa9e4066Sahrens byteswap_uint32_array(void *vbuf, size_t size) 1140fa9e4066Sahrens { 1141fa9e4066Sahrens uint32_t *buf = vbuf; 1142fa9e4066Sahrens size_t count = size >> 2; 1143fa9e4066Sahrens int i; 1144fa9e4066Sahrens 1145fa9e4066Sahrens ASSERT((size & 3) == 0); 1146fa9e4066Sahrens 1147fa9e4066Sahrens for (i = 0; i < count; i++) 1148fa9e4066Sahrens buf[i] = BSWAP_32(buf[i]); 1149fa9e4066Sahrens } 1150fa9e4066Sahrens 1151fa9e4066Sahrens void 1152fa9e4066Sahrens byteswap_uint16_array(void *vbuf, size_t size) 1153fa9e4066Sahrens { 1154fa9e4066Sahrens uint16_t *buf = vbuf; 1155fa9e4066Sahrens size_t count = size >> 1; 1156fa9e4066Sahrens int i; 1157fa9e4066Sahrens 1158fa9e4066Sahrens ASSERT((size & 1) == 0); 1159fa9e4066Sahrens 1160fa9e4066Sahrens for (i = 0; i < count; i++) 1161fa9e4066Sahrens buf[i] = BSWAP_16(buf[i]); 1162fa9e4066Sahrens } 1163fa9e4066Sahrens 1164fa9e4066Sahrens /* ARGSUSED */ 1165fa9e4066Sahrens void 1166fa9e4066Sahrens byteswap_uint8_array(void *vbuf, size_t size) 1167fa9e4066Sahrens { 1168fa9e4066Sahrens } 1169fa9e4066Sahrens 1170fa9e4066Sahrens void 1171fa9e4066Sahrens dmu_init(void) 1172fa9e4066Sahrens { 1173fa9e4066Sahrens dbuf_init(); 1174fa9e4066Sahrens dnode_init(); 1175fa9e4066Sahrens arc_init(); 1176fa94a07fSbrendan l2arc_init(); 1177fa9e4066Sahrens } 1178fa9e4066Sahrens 1179fa9e4066Sahrens void 1180fa9e4066Sahrens dmu_fini(void) 1181fa9e4066Sahrens { 1182fa9e4066Sahrens arc_fini(); 1183fa9e4066Sahrens dnode_fini(); 1184fa9e4066Sahrens dbuf_fini(); 1185fa94a07fSbrendan l2arc_fini(); 1186fa9e4066Sahrens } 1187