1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6ea8dc4b6Seschrock * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 21fa9e4066Sahrens /* 22ea8dc4b6Seschrock * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27fa9e4066Sahrens 28fa9e4066Sahrens #include <sys/dmu.h> 29fa9e4066Sahrens #include <sys/dmu_impl.h> 30fa9e4066Sahrens #include <sys/dmu_tx.h> 31fa9e4066Sahrens #include <sys/dbuf.h> 32fa9e4066Sahrens #include <sys/dnode.h> 33fa9e4066Sahrens #include <sys/zfs_context.h> 34fa9e4066Sahrens #include <sys/dmu_objset.h> 35fa9e4066Sahrens #include <sys/dmu_traverse.h> 36fa9e4066Sahrens #include <sys/dsl_dataset.h> 37fa9e4066Sahrens #include <sys/dsl_dir.h> 38fa9e4066Sahrens #include <sys/dsl_pool.h> 39*1d452cf5Sahrens #include <sys/dsl_synctask.h> 40fa9e4066Sahrens #include <sys/dmu_zfetch.h> 41fa9e4066Sahrens #include <sys/zfs_ioctl.h> 42fa9e4066Sahrens #include <sys/zap.h> 43ea8dc4b6Seschrock #include <sys/zio_checksum.h> 44fa9e4066Sahrens 45fa9e4066Sahrens const dmu_object_type_info_t dmu_ot[DMU_OT_NUMTYPES] = { 46fa9e4066Sahrens { byteswap_uint8_array, TRUE, "unallocated" }, 47fa9e4066Sahrens { zap_byteswap, TRUE, "object directory" }, 48fa9e4066Sahrens { byteswap_uint64_array, TRUE, "object array" }, 49fa9e4066Sahrens { byteswap_uint8_array, TRUE, "packed nvlist" }, 50fa9e4066Sahrens { byteswap_uint64_array, TRUE, "packed nvlist size" }, 51fa9e4066Sahrens { byteswap_uint64_array, TRUE, "bplist" }, 52fa9e4066Sahrens { byteswap_uint64_array, TRUE, "bplist header" }, 53fa9e4066Sahrens { byteswap_uint64_array, TRUE, "SPA space map header" }, 54fa9e4066Sahrens { byteswap_uint64_array, TRUE, "SPA space map" }, 55fa9e4066Sahrens { byteswap_uint64_array, TRUE, "ZIL intent log" }, 56fa9e4066Sahrens { dnode_buf_byteswap, TRUE, "DMU dnode" }, 57fa9e4066Sahrens { dmu_objset_byteswap, TRUE, "DMU objset" }, 58fa9e4066Sahrens { byteswap_uint64_array, TRUE, "DSL directory" }, 59fa9e4066Sahrens { zap_byteswap, TRUE, "DSL directory child map"}, 60fa9e4066Sahrens { zap_byteswap, TRUE, "DSL dataset snap map" }, 61fa9e4066Sahrens { zap_byteswap, TRUE, "DSL props" }, 62fa9e4066Sahrens { byteswap_uint64_array, TRUE, "DSL dataset" }, 63fa9e4066Sahrens { zfs_znode_byteswap, TRUE, "ZFS znode" }, 64fa9e4066Sahrens { zfs_acl_byteswap, TRUE, "ZFS ACL" }, 65fa9e4066Sahrens { byteswap_uint8_array, FALSE, "ZFS plain file" }, 66fa9e4066Sahrens { zap_byteswap, TRUE, "ZFS directory" }, 67fa9e4066Sahrens { zap_byteswap, TRUE, "ZFS master node" }, 68fa9e4066Sahrens { zap_byteswap, TRUE, "ZFS delete queue" }, 69fa9e4066Sahrens { byteswap_uint8_array, FALSE, "zvol object" }, 70fa9e4066Sahrens { zap_byteswap, TRUE, "zvol prop" }, 71fa9e4066Sahrens { byteswap_uint8_array, FALSE, "other uint8[]" }, 72fa9e4066Sahrens { byteswap_uint64_array, FALSE, "other uint64[]" }, 73fa9e4066Sahrens { zap_byteswap, TRUE, "other ZAP" }, 74ea8dc4b6Seschrock { zap_byteswap, TRUE, "persistent error log" }, 75fa9e4066Sahrens }; 76fa9e4066Sahrens 77fa9e4066Sahrens int 78ea8dc4b6Seschrock dmu_buf_hold(objset_t *os, uint64_t object, uint64_t offset, 79ea8dc4b6Seschrock void *tag, dmu_buf_t **dbp) 80fa9e4066Sahrens { 81fa9e4066Sahrens dnode_t *dn; 82fa9e4066Sahrens uint64_t blkid; 83fa9e4066Sahrens dmu_buf_impl_t *db; 84ea8dc4b6Seschrock int err; 85fa9e4066Sahrens 86ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 87ea8dc4b6Seschrock if (err) 88ea8dc4b6Seschrock return (err); 89fa9e4066Sahrens blkid = dbuf_whichblock(dn, offset); 90fa9e4066Sahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 91ea8dc4b6Seschrock db = dbuf_hold(dn, blkid, tag); 92fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 93ea8dc4b6Seschrock if (db == NULL) { 94ea8dc4b6Seschrock err = EIO; 95ea8dc4b6Seschrock } else { 96ea8dc4b6Seschrock err = dbuf_read(db, NULL, DB_RF_CANFAIL); 97ea8dc4b6Seschrock if (err) { 98ea8dc4b6Seschrock dbuf_rele(db, tag); 99ea8dc4b6Seschrock db = NULL; 100ea8dc4b6Seschrock } 101ea8dc4b6Seschrock } 102fa9e4066Sahrens 103ea8dc4b6Seschrock dnode_rele(dn, FTAG); 104ea8dc4b6Seschrock *dbp = &db->db; 105ea8dc4b6Seschrock return (err); 106fa9e4066Sahrens } 107fa9e4066Sahrens 108fa9e4066Sahrens int 109fa9e4066Sahrens dmu_bonus_max(void) 110fa9e4066Sahrens { 111fa9e4066Sahrens return (DN_MAX_BONUSLEN); 112fa9e4066Sahrens } 113fa9e4066Sahrens 114fa9e4066Sahrens /* 115ea8dc4b6Seschrock * returns ENOENT, EIO, or 0. 116fa9e4066Sahrens */ 117ea8dc4b6Seschrock int 118ea8dc4b6Seschrock dmu_bonus_hold(objset_t *os, uint64_t object, void *tag, dmu_buf_t **dbp) 119fa9e4066Sahrens { 120ea8dc4b6Seschrock dnode_t *dn; 121ea8dc4b6Seschrock int err, count; 122fa9e4066Sahrens dmu_buf_impl_t *db; 123fa9e4066Sahrens 124ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 125ea8dc4b6Seschrock if (err) 126ea8dc4b6Seschrock return (err); 127fa9e4066Sahrens 128ea8dc4b6Seschrock rw_enter(&dn->dn_struct_rwlock, RW_READER); 129ea8dc4b6Seschrock if (dn->dn_bonus == NULL) { 130fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 131ea8dc4b6Seschrock rw_enter(&dn->dn_struct_rwlock, RW_WRITER); 132ea8dc4b6Seschrock if (dn->dn_bonus == NULL) 133ea8dc4b6Seschrock dn->dn_bonus = dbuf_create_bonus(dn); 134fa9e4066Sahrens } 135ea8dc4b6Seschrock db = dn->dn_bonus; 136ea8dc4b6Seschrock rw_exit(&dn->dn_struct_rwlock); 137ea8dc4b6Seschrock mutex_enter(&db->db_mtx); 138ea8dc4b6Seschrock count = refcount_add(&db->db_holds, tag); 139ea8dc4b6Seschrock mutex_exit(&db->db_mtx); 140ea8dc4b6Seschrock if (count == 1) 141ea8dc4b6Seschrock dnode_add_ref(dn, db); 142fa9e4066Sahrens dnode_rele(dn, FTAG); 143ea8dc4b6Seschrock 144ea8dc4b6Seschrock VERIFY(0 == dbuf_read(db, NULL, DB_RF_MUST_SUCCEED)); 145ea8dc4b6Seschrock 146ea8dc4b6Seschrock *dbp = &db->db; 147ea8dc4b6Seschrock return (0); 148fa9e4066Sahrens } 149fa9e4066Sahrens 150ea8dc4b6Seschrock int 151ea8dc4b6Seschrock dmu_buf_hold_array(objset_t *os, uint64_t object, uint64_t offset, 152ea8dc4b6Seschrock uint64_t length, int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp) 153fa9e4066Sahrens { 154ea8dc4b6Seschrock dnode_t *dn; 155fa9e4066Sahrens dmu_buf_t **dbp; 156fa9e4066Sahrens uint64_t blkid, nblks, i; 157ea8dc4b6Seschrock uint32_t flags; 158ea8dc4b6Seschrock int err; 159ea8dc4b6Seschrock zio_t *zio; 160ea8dc4b6Seschrock 161ea8dc4b6Seschrock ASSERT(length <= DMU_MAX_ACCESS); 162fa9e4066Sahrens 163fa9e4066Sahrens if (length == 0) { 164fa9e4066Sahrens if (numbufsp) 165fa9e4066Sahrens *numbufsp = 0; 166ea8dc4b6Seschrock *dbpp = NULL; 167ea8dc4b6Seschrock return (0); 168fa9e4066Sahrens } 169fa9e4066Sahrens 170ea8dc4b6Seschrock flags = DB_RF_CANFAIL | DB_RF_NEVERWAIT; 171e1930233Sbonwick if (length > zfetch_array_rd_sz) 172ea8dc4b6Seschrock flags |= DB_RF_NOPREFETCH; 173ea8dc4b6Seschrock 174ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 175ea8dc4b6Seschrock if (err) 176ea8dc4b6Seschrock return (err); 177ea8dc4b6Seschrock 178fa9e4066Sahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 179fa9e4066Sahrens if (dn->dn_datablkshift) { 180fa9e4066Sahrens int blkshift = dn->dn_datablkshift; 181fa9e4066Sahrens nblks = (P2ROUNDUP(offset+length, 1ULL<<blkshift) - 182fa9e4066Sahrens P2ALIGN(offset, 1ULL<<blkshift)) >> blkshift; 183fa9e4066Sahrens } else { 184fa9e4066Sahrens ASSERT3U(offset + length, <=, dn->dn_datablksz); 185fa9e4066Sahrens nblks = 1; 186fa9e4066Sahrens } 187ea8dc4b6Seschrock dbp = kmem_zalloc(sizeof (dmu_buf_t *) * nblks, KM_SLEEP); 188fa9e4066Sahrens 189ea8dc4b6Seschrock zio = zio_root(dn->dn_objset->os_spa, NULL, NULL, TRUE); 190fa9e4066Sahrens blkid = dbuf_whichblock(dn, offset); 191fa9e4066Sahrens for (i = 0; i < nblks; i++) { 192ea8dc4b6Seschrock dmu_buf_impl_t *db = dbuf_hold(dn, blkid+i, tag); 193ea8dc4b6Seschrock if (db == NULL) { 194ea8dc4b6Seschrock rw_exit(&dn->dn_struct_rwlock); 195ea8dc4b6Seschrock dmu_buf_rele_array(dbp, nblks, tag); 196ea8dc4b6Seschrock dnode_rele(dn, FTAG); 197ea8dc4b6Seschrock zio_nowait(zio); 198ea8dc4b6Seschrock return (EIO); 199ea8dc4b6Seschrock } 200ea8dc4b6Seschrock /* initiate async i/o */ 201ea8dc4b6Seschrock if (read && db->db_state == DB_UNCACHED) { 202ea8dc4b6Seschrock rw_exit(&dn->dn_struct_rwlock); 203ea8dc4b6Seschrock (void) dbuf_read(db, zio, flags); 204ea8dc4b6Seschrock rw_enter(&dn->dn_struct_rwlock, RW_READER); 205ea8dc4b6Seschrock } 206ea8dc4b6Seschrock dbp[i] = &db->db; 207fa9e4066Sahrens } 208fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 209fa9e4066Sahrens dnode_rele(dn, FTAG); 210fa9e4066Sahrens 211ea8dc4b6Seschrock /* wait for async i/o */ 212ea8dc4b6Seschrock err = zio_wait(zio); 213ea8dc4b6Seschrock if (err) { 214ea8dc4b6Seschrock dmu_buf_rele_array(dbp, nblks, tag); 215ea8dc4b6Seschrock return (err); 216ea8dc4b6Seschrock } 217fa9e4066Sahrens 218ea8dc4b6Seschrock /* wait for other io to complete */ 219ea8dc4b6Seschrock if (read) { 220ea8dc4b6Seschrock for (i = 0; i < nblks; i++) { 221ea8dc4b6Seschrock dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i]; 222ea8dc4b6Seschrock mutex_enter(&db->db_mtx); 223ea8dc4b6Seschrock while (db->db_state == DB_READ || 224ea8dc4b6Seschrock db->db_state == DB_FILL) 225ea8dc4b6Seschrock cv_wait(&db->db_changed, &db->db_mtx); 226ea8dc4b6Seschrock if (db->db_state == DB_UNCACHED) 227ea8dc4b6Seschrock err = EIO; 228ea8dc4b6Seschrock mutex_exit(&db->db_mtx); 229ea8dc4b6Seschrock if (err) { 230ea8dc4b6Seschrock dmu_buf_rele_array(dbp, nblks, tag); 231ea8dc4b6Seschrock return (err); 232ea8dc4b6Seschrock } 233ea8dc4b6Seschrock } 234ea8dc4b6Seschrock } 235fa9e4066Sahrens 236ea8dc4b6Seschrock *numbufsp = nblks; 237ea8dc4b6Seschrock *dbpp = dbp; 238ea8dc4b6Seschrock return (0); 239fa9e4066Sahrens } 240fa9e4066Sahrens 241fa9e4066Sahrens void 242ea8dc4b6Seschrock dmu_buf_rele_array(dmu_buf_t **dbp_fake, int numbufs, void *tag) 243fa9e4066Sahrens { 244fa9e4066Sahrens int i; 245fa9e4066Sahrens dmu_buf_impl_t **dbp = (dmu_buf_impl_t **)dbp_fake; 246fa9e4066Sahrens 247fa9e4066Sahrens if (numbufs == 0) 248fa9e4066Sahrens return; 249fa9e4066Sahrens 250ea8dc4b6Seschrock for (i = 0; i < numbufs; i++) { 251ea8dc4b6Seschrock if (dbp[i]) 252ea8dc4b6Seschrock dbuf_rele(dbp[i], tag); 253ea8dc4b6Seschrock } 254fa9e4066Sahrens 255fa9e4066Sahrens kmem_free(dbp, sizeof (dmu_buf_t *) * numbufs); 256fa9e4066Sahrens } 257fa9e4066Sahrens 258fa9e4066Sahrens void 259fa9e4066Sahrens dmu_prefetch(objset_t *os, uint64_t object, uint64_t offset, uint64_t len) 260fa9e4066Sahrens { 261fa9e4066Sahrens dnode_t *dn; 262fa9e4066Sahrens uint64_t blkid; 263ea8dc4b6Seschrock int nblks, i, err; 264fa9e4066Sahrens 265fa9e4066Sahrens if (len == 0) { /* they're interested in the bonus buffer */ 266fa9e4066Sahrens dn = os->os->os_meta_dnode; 267fa9e4066Sahrens 268fa9e4066Sahrens if (object == 0 || object >= DN_MAX_OBJECT) 269fa9e4066Sahrens return; 270fa9e4066Sahrens 271fa9e4066Sahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 272fa9e4066Sahrens blkid = dbuf_whichblock(dn, object * sizeof (dnode_phys_t)); 273fa9e4066Sahrens dbuf_prefetch(dn, blkid); 274fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 275fa9e4066Sahrens return; 276fa9e4066Sahrens } 277fa9e4066Sahrens 278fa9e4066Sahrens /* 279fa9e4066Sahrens * XXX - Note, if the dnode for the requested object is not 280fa9e4066Sahrens * already cached, we will do a *synchronous* read in the 281fa9e4066Sahrens * dnode_hold() call. The same is true for any indirects. 282fa9e4066Sahrens */ 283ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 284ea8dc4b6Seschrock if (err != 0) 285fa9e4066Sahrens return; 286fa9e4066Sahrens 287fa9e4066Sahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 288fa9e4066Sahrens if (dn->dn_datablkshift) { 289fa9e4066Sahrens int blkshift = dn->dn_datablkshift; 290fa9e4066Sahrens nblks = (P2ROUNDUP(offset+len, 1<<blkshift) - 291fa9e4066Sahrens P2ALIGN(offset, 1<<blkshift)) >> blkshift; 292fa9e4066Sahrens } else { 293fa9e4066Sahrens nblks = (offset < dn->dn_datablksz); 294fa9e4066Sahrens } 295fa9e4066Sahrens 296fa9e4066Sahrens if (nblks != 0) { 297fa9e4066Sahrens blkid = dbuf_whichblock(dn, offset); 298fa9e4066Sahrens for (i = 0; i < nblks; i++) 299fa9e4066Sahrens dbuf_prefetch(dn, blkid+i); 300fa9e4066Sahrens } 301fa9e4066Sahrens 302fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 303fa9e4066Sahrens 304fa9e4066Sahrens dnode_rele(dn, FTAG); 305fa9e4066Sahrens } 306fa9e4066Sahrens 307ea8dc4b6Seschrock int 308fa9e4066Sahrens dmu_free_range(objset_t *os, uint64_t object, uint64_t offset, 309fa9e4066Sahrens uint64_t size, dmu_tx_t *tx) 310fa9e4066Sahrens { 311ea8dc4b6Seschrock dnode_t *dn; 312ea8dc4b6Seschrock int err = dnode_hold(os->os, object, FTAG, &dn); 313ea8dc4b6Seschrock if (err) 314ea8dc4b6Seschrock return (err); 315fa9e4066Sahrens ASSERT(offset < UINT64_MAX); 316fa9e4066Sahrens ASSERT(size == -1ULL || size <= UINT64_MAX - offset); 317fa9e4066Sahrens dnode_free_range(dn, offset, size, tx); 318fa9e4066Sahrens dnode_rele(dn, FTAG); 319ea8dc4b6Seschrock return (0); 320fa9e4066Sahrens } 321fa9e4066Sahrens 322ea8dc4b6Seschrock int 323ea8dc4b6Seschrock dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, 324ea8dc4b6Seschrock void *buf) 325fa9e4066Sahrens { 326fa9e4066Sahrens dnode_t *dn; 327fa9e4066Sahrens dmu_buf_t **dbp; 328ea8dc4b6Seschrock int numbufs, i, err; 329fa9e4066Sahrens 330ea8dc4b6Seschrock /* 331ea8dc4b6Seschrock * Deal with odd block sizes, where there can't be data past the 332ea8dc4b6Seschrock * first block. 333ea8dc4b6Seschrock */ 334ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 335ea8dc4b6Seschrock if (err) 336ea8dc4b6Seschrock return (err); 337fa9e4066Sahrens if (dn->dn_datablkshift == 0) { 338fa9e4066Sahrens int newsz = offset > dn->dn_datablksz ? 0 : 339fa9e4066Sahrens MIN(size, dn->dn_datablksz - offset); 340fa9e4066Sahrens bzero((char *)buf + newsz, size - newsz); 341fa9e4066Sahrens size = newsz; 342fa9e4066Sahrens } 343fa9e4066Sahrens dnode_rele(dn, FTAG); 344fa9e4066Sahrens 345fa9e4066Sahrens while (size > 0) { 346fa9e4066Sahrens uint64_t mylen = MIN(size, DMU_MAX_ACCESS / 2); 347fa9e4066Sahrens int err; 348fa9e4066Sahrens 349fa9e4066Sahrens /* 350fa9e4066Sahrens * NB: we could do this block-at-a-time, but it's nice 351fa9e4066Sahrens * to be reading in parallel. 352fa9e4066Sahrens */ 353ea8dc4b6Seschrock err = dmu_buf_hold_array(os, object, offset, mylen, 354ea8dc4b6Seschrock TRUE, FTAG, &numbufs, &dbp); 355ea8dc4b6Seschrock if (err) 356fa9e4066Sahrens return (err); 357fa9e4066Sahrens 358fa9e4066Sahrens for (i = 0; i < numbufs; i++) { 359fa9e4066Sahrens int tocpy; 360fa9e4066Sahrens int bufoff; 361fa9e4066Sahrens dmu_buf_t *db = dbp[i]; 362fa9e4066Sahrens 363fa9e4066Sahrens ASSERT(size > 0); 364fa9e4066Sahrens 365fa9e4066Sahrens bufoff = offset - db->db_offset; 366fa9e4066Sahrens tocpy = (int)MIN(db->db_size - bufoff, size); 367fa9e4066Sahrens 368fa9e4066Sahrens bcopy((char *)db->db_data + bufoff, buf, tocpy); 369fa9e4066Sahrens 370fa9e4066Sahrens offset += tocpy; 371fa9e4066Sahrens size -= tocpy; 372fa9e4066Sahrens buf = (char *)buf + tocpy; 373fa9e4066Sahrens } 374ea8dc4b6Seschrock dmu_buf_rele_array(dbp, numbufs, FTAG); 375fa9e4066Sahrens } 376fa9e4066Sahrens return (0); 377fa9e4066Sahrens } 378fa9e4066Sahrens 379fa9e4066Sahrens void 380fa9e4066Sahrens dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, 381fa9e4066Sahrens const void *buf, dmu_tx_t *tx) 382fa9e4066Sahrens { 383fa9e4066Sahrens dmu_buf_t **dbp; 384fa9e4066Sahrens int numbufs, i; 385fa9e4066Sahrens 386ea8dc4b6Seschrock VERIFY(0 == dmu_buf_hold_array(os, object, offset, size, 387ea8dc4b6Seschrock FALSE, FTAG, &numbufs, &dbp)); 388fa9e4066Sahrens 389fa9e4066Sahrens for (i = 0; i < numbufs; i++) { 390fa9e4066Sahrens int tocpy; 391fa9e4066Sahrens int bufoff; 392fa9e4066Sahrens dmu_buf_t *db = dbp[i]; 393fa9e4066Sahrens 394fa9e4066Sahrens ASSERT(size > 0); 395fa9e4066Sahrens 396fa9e4066Sahrens bufoff = offset - db->db_offset; 397fa9e4066Sahrens tocpy = (int)MIN(db->db_size - bufoff, size); 398fa9e4066Sahrens 399fa9e4066Sahrens ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size); 400fa9e4066Sahrens 401fa9e4066Sahrens if (tocpy == db->db_size) 402fa9e4066Sahrens dmu_buf_will_fill(db, tx); 403fa9e4066Sahrens else 404fa9e4066Sahrens dmu_buf_will_dirty(db, tx); 405fa9e4066Sahrens 406fa9e4066Sahrens bcopy(buf, (char *)db->db_data + bufoff, tocpy); 407fa9e4066Sahrens 408fa9e4066Sahrens if (tocpy == db->db_size) 409fa9e4066Sahrens dmu_buf_fill_done(db, tx); 410fa9e4066Sahrens 411fa9e4066Sahrens offset += tocpy; 412fa9e4066Sahrens size -= tocpy; 413fa9e4066Sahrens buf = (char *)buf + tocpy; 414fa9e4066Sahrens } 415ea8dc4b6Seschrock dmu_buf_rele_array(dbp, numbufs, FTAG); 416fa9e4066Sahrens } 417fa9e4066Sahrens 418fa9e4066Sahrens #ifdef _KERNEL 419fa9e4066Sahrens int 420fa9e4066Sahrens dmu_write_uio(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, 421fa9e4066Sahrens uio_t *uio, dmu_tx_t *tx) 422fa9e4066Sahrens { 423fa9e4066Sahrens dmu_buf_t **dbp; 424fa9e4066Sahrens int numbufs, i; 425fa9e4066Sahrens int err = 0; 426fa9e4066Sahrens 427ea8dc4b6Seschrock err = dmu_buf_hold_array(os, object, offset, size, 428ea8dc4b6Seschrock FALSE, FTAG, &numbufs, &dbp); 429ea8dc4b6Seschrock if (err) 430ea8dc4b6Seschrock return (err); 431fa9e4066Sahrens 432fa9e4066Sahrens for (i = 0; i < numbufs; i++) { 433fa9e4066Sahrens int tocpy; 434fa9e4066Sahrens int bufoff; 435fa9e4066Sahrens dmu_buf_t *db = dbp[i]; 436fa9e4066Sahrens 437fa9e4066Sahrens ASSERT(size > 0); 438fa9e4066Sahrens 439fa9e4066Sahrens bufoff = offset - db->db_offset; 440fa9e4066Sahrens tocpy = (int)MIN(db->db_size - bufoff, size); 441fa9e4066Sahrens 442fa9e4066Sahrens ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size); 443fa9e4066Sahrens 444fa9e4066Sahrens if (tocpy == db->db_size) 445fa9e4066Sahrens dmu_buf_will_fill(db, tx); 446fa9e4066Sahrens else 447fa9e4066Sahrens dmu_buf_will_dirty(db, tx); 448fa9e4066Sahrens 449fa9e4066Sahrens /* 450fa9e4066Sahrens * XXX uiomove could block forever (eg. nfs-backed 451fa9e4066Sahrens * pages). There needs to be a uiolockdown() function 452fa9e4066Sahrens * to lock the pages in memory, so that uiomove won't 453fa9e4066Sahrens * block. 454fa9e4066Sahrens */ 455fa9e4066Sahrens err = uiomove((char *)db->db_data + bufoff, tocpy, 456fa9e4066Sahrens UIO_WRITE, uio); 457fa9e4066Sahrens 458fa9e4066Sahrens if (tocpy == db->db_size) 459fa9e4066Sahrens dmu_buf_fill_done(db, tx); 460fa9e4066Sahrens 461fa9e4066Sahrens if (err) 462fa9e4066Sahrens break; 463fa9e4066Sahrens 464fa9e4066Sahrens offset += tocpy; 465fa9e4066Sahrens size -= tocpy; 466fa9e4066Sahrens } 467ea8dc4b6Seschrock dmu_buf_rele_array(dbp, numbufs, FTAG); 468fa9e4066Sahrens return (err); 469fa9e4066Sahrens } 470fa9e4066Sahrens #endif 471fa9e4066Sahrens 472*1d452cf5Sahrens /* 473*1d452cf5Sahrens * XXX move send/recv stuff to its own new file! 474*1d452cf5Sahrens */ 475*1d452cf5Sahrens 476fa9e4066Sahrens struct backuparg { 477fa9e4066Sahrens dmu_replay_record_t *drr; 478fa9e4066Sahrens vnode_t *vp; 479fa9e4066Sahrens objset_t *os; 480ea8dc4b6Seschrock zio_cksum_t zc; 481fa9e4066Sahrens int err; 482fa9e4066Sahrens }; 483fa9e4066Sahrens 484fa9e4066Sahrens static int 485fa9e4066Sahrens dump_bytes(struct backuparg *ba, void *buf, int len) 486fa9e4066Sahrens { 487fa9e4066Sahrens ssize_t resid; /* have to get resid to get detailed errno */ 488fa9e4066Sahrens ASSERT3U(len % 8, ==, 0); 489ea8dc4b6Seschrock 490ea8dc4b6Seschrock fletcher_4_incremental_native(buf, len, &ba->zc); 491fa9e4066Sahrens ba->err = vn_rdwr(UIO_WRITE, ba->vp, 492fa9e4066Sahrens (caddr_t)buf, len, 49393fcfe85Sahrens 0, UIO_SYSSPACE, FAPPEND, RLIM64_INFINITY, CRED(), &resid); 494fa9e4066Sahrens return (ba->err); 495fa9e4066Sahrens } 496fa9e4066Sahrens 497fa9e4066Sahrens static int 498fa9e4066Sahrens dump_free(struct backuparg *ba, uint64_t object, uint64_t offset, 499fa9e4066Sahrens uint64_t length) 500fa9e4066Sahrens { 501fa9e4066Sahrens /* write a FREE record */ 502fa9e4066Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 503fa9e4066Sahrens ba->drr->drr_type = DRR_FREE; 504fa9e4066Sahrens ba->drr->drr_u.drr_free.drr_object = object; 505fa9e4066Sahrens ba->drr->drr_u.drr_free.drr_offset = offset; 506fa9e4066Sahrens ba->drr->drr_u.drr_free.drr_length = length; 507fa9e4066Sahrens 508fa9e4066Sahrens if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t))) 509fa9e4066Sahrens return (EINTR); 510fa9e4066Sahrens return (0); 511fa9e4066Sahrens } 512fa9e4066Sahrens 513fa9e4066Sahrens static int 514fa9e4066Sahrens dump_data(struct backuparg *ba, dmu_object_type_t type, 515fa9e4066Sahrens uint64_t object, uint64_t offset, int blksz, void *data) 516fa9e4066Sahrens { 517fa9e4066Sahrens /* write a DATA record */ 518fa9e4066Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 519fa9e4066Sahrens ba->drr->drr_type = DRR_WRITE; 520fa9e4066Sahrens ba->drr->drr_u.drr_write.drr_object = object; 521fa9e4066Sahrens ba->drr->drr_u.drr_write.drr_type = type; 522fa9e4066Sahrens ba->drr->drr_u.drr_write.drr_offset = offset; 523fa9e4066Sahrens ba->drr->drr_u.drr_write.drr_length = blksz; 524fa9e4066Sahrens 525fa9e4066Sahrens if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t))) 526fa9e4066Sahrens return (EINTR); 527fa9e4066Sahrens if (dump_bytes(ba, data, blksz)) 528fa9e4066Sahrens return (EINTR); 529fa9e4066Sahrens return (0); 530fa9e4066Sahrens } 531fa9e4066Sahrens 532fa9e4066Sahrens static int 533fa9e4066Sahrens dump_freeobjects(struct backuparg *ba, uint64_t firstobj, uint64_t numobjs) 534fa9e4066Sahrens { 535fa9e4066Sahrens /* write a FREEOBJECTS record */ 536fa9e4066Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 537fa9e4066Sahrens ba->drr->drr_type = DRR_FREEOBJECTS; 538fa9e4066Sahrens ba->drr->drr_u.drr_freeobjects.drr_firstobj = firstobj; 539fa9e4066Sahrens ba->drr->drr_u.drr_freeobjects.drr_numobjs = numobjs; 540fa9e4066Sahrens 541fa9e4066Sahrens if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t))) 542fa9e4066Sahrens return (EINTR); 543fa9e4066Sahrens return (0); 544fa9e4066Sahrens } 545fa9e4066Sahrens 546fa9e4066Sahrens static int 547fa9e4066Sahrens dump_dnode(struct backuparg *ba, uint64_t object, dnode_phys_t *dnp) 548fa9e4066Sahrens { 549fa9e4066Sahrens if (dnp == NULL || dnp->dn_type == DMU_OT_NONE) 550fa9e4066Sahrens return (dump_freeobjects(ba, object, 1)); 551fa9e4066Sahrens 552fa9e4066Sahrens /* write an OBJECT record */ 553fa9e4066Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 554fa9e4066Sahrens ba->drr->drr_type = DRR_OBJECT; 555fa9e4066Sahrens ba->drr->drr_u.drr_object.drr_object = object; 556fa9e4066Sahrens ba->drr->drr_u.drr_object.drr_type = dnp->dn_type; 557fa9e4066Sahrens ba->drr->drr_u.drr_object.drr_bonustype = dnp->dn_bonustype; 558fa9e4066Sahrens ba->drr->drr_u.drr_object.drr_blksz = 559fa9e4066Sahrens dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT; 560fa9e4066Sahrens ba->drr->drr_u.drr_object.drr_bonuslen = dnp->dn_bonuslen; 561fa9e4066Sahrens ba->drr->drr_u.drr_object.drr_checksum = dnp->dn_checksum; 562fa9e4066Sahrens ba->drr->drr_u.drr_object.drr_compress = dnp->dn_compress; 563fa9e4066Sahrens 564fa9e4066Sahrens if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t))) 565fa9e4066Sahrens return (EINTR); 566fa9e4066Sahrens 567fa9e4066Sahrens if (dump_bytes(ba, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8))) 568fa9e4066Sahrens return (EINTR); 569fa9e4066Sahrens 570fa9e4066Sahrens /* free anything past the end of the file */ 571fa9e4066Sahrens if (dump_free(ba, object, (dnp->dn_maxblkid + 1) * 572fa9e4066Sahrens (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL)) 573fa9e4066Sahrens return (EINTR); 574fa9e4066Sahrens if (ba->err) 575fa9e4066Sahrens return (EINTR); 576fa9e4066Sahrens return (0); 577fa9e4066Sahrens } 578fa9e4066Sahrens 579fa9e4066Sahrens #define BP_SPAN(dnp, level) \ 580fa9e4066Sahrens (((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \ 581fa9e4066Sahrens (level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) 582fa9e4066Sahrens 583fa9e4066Sahrens static int 584fa9e4066Sahrens backup_cb(traverse_blk_cache_t *bc, spa_t *spa, void *arg) 585fa9e4066Sahrens { 586fa9e4066Sahrens struct backuparg *ba = arg; 587fa9e4066Sahrens uint64_t object = bc->bc_bookmark.zb_object; 588fa9e4066Sahrens int level = bc->bc_bookmark.zb_level; 589fa9e4066Sahrens uint64_t blkid = bc->bc_bookmark.zb_blkid; 590fa9e4066Sahrens blkptr_t *bp = bc->bc_blkptr.blk_birth ? &bc->bc_blkptr : NULL; 591fa9e4066Sahrens dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE; 592fa9e4066Sahrens void *data = bc->bc_data; 593fa9e4066Sahrens int err = 0; 594fa9e4066Sahrens 595ea8dc4b6Seschrock if (issig(JUSTLOOKING) && issig(FORREAL)) 596fa9e4066Sahrens return (EINTR); 597fa9e4066Sahrens 598fa9e4066Sahrens ASSERT(data || bp == NULL); 599fa9e4066Sahrens 600fa9e4066Sahrens if (bp == NULL && object == 0) { 601fa9e4066Sahrens uint64_t span = BP_SPAN(bc->bc_dnode, level); 602fa9e4066Sahrens uint64_t dnobj = (blkid * span) >> DNODE_SHIFT; 603fa9e4066Sahrens err = dump_freeobjects(ba, dnobj, span >> DNODE_SHIFT); 604fa9e4066Sahrens } else if (bp == NULL) { 605fa9e4066Sahrens uint64_t span = BP_SPAN(bc->bc_dnode, level); 606fa9e4066Sahrens err = dump_free(ba, object, blkid * span, span); 607fa9e4066Sahrens } else if (data && level == 0 && type == DMU_OT_DNODE) { 608fa9e4066Sahrens dnode_phys_t *blk = data; 609fa9e4066Sahrens int i; 610fa9e4066Sahrens int blksz = BP_GET_LSIZE(bp); 611fa9e4066Sahrens 612fa9e4066Sahrens for (i = 0; i < blksz >> DNODE_SHIFT; i++) { 613fa9e4066Sahrens uint64_t dnobj = 614fa9e4066Sahrens (blkid << (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i; 615fa9e4066Sahrens err = dump_dnode(ba, dnobj, blk+i); 616fa9e4066Sahrens if (err) 617fa9e4066Sahrens break; 618fa9e4066Sahrens } 619fa9e4066Sahrens } else if (level == 0 && 620fa9e4066Sahrens type != DMU_OT_DNODE && type != DMU_OT_OBJSET) { 621fa9e4066Sahrens int blksz = BP_GET_LSIZE(bp); 622fa9e4066Sahrens if (data == NULL) { 623fa9e4066Sahrens arc_buf_t *abuf; 624ea8dc4b6Seschrock zbookmark_t zb; 625fa9e4066Sahrens 626ea8dc4b6Seschrock zb.zb_objset = ba->os->os->os_dsl_dataset->ds_object; 627ea8dc4b6Seschrock zb.zb_object = object; 628ea8dc4b6Seschrock zb.zb_level = level; 629ea8dc4b6Seschrock zb.zb_blkid = blkid; 630fa9e4066Sahrens (void) arc_read(NULL, spa, bp, 631fa9e4066Sahrens dmu_ot[type].ot_byteswap, arc_getbuf_func, &abuf, 632fa9e4066Sahrens ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_MUSTSUCCEED, 633ea8dc4b6Seschrock ARC_WAIT, &zb); 634fa9e4066Sahrens 635fa9e4066Sahrens if (abuf) { 636fa9e4066Sahrens err = dump_data(ba, type, object, blkid * blksz, 637fa9e4066Sahrens blksz, abuf->b_data); 638ea8dc4b6Seschrock (void) arc_buf_remove_ref(abuf, &abuf); 639fa9e4066Sahrens } 640fa9e4066Sahrens } else { 641fa9e4066Sahrens err = dump_data(ba, type, object, blkid * blksz, 642fa9e4066Sahrens blksz, data); 643fa9e4066Sahrens } 644fa9e4066Sahrens } 645fa9e4066Sahrens 646fa9e4066Sahrens ASSERT(err == 0 || err == EINTR); 647fa9e4066Sahrens return (err); 648fa9e4066Sahrens } 649fa9e4066Sahrens 650fa9e4066Sahrens int 651fa9e4066Sahrens dmu_sendbackup(objset_t *tosnap, objset_t *fromsnap, vnode_t *vp) 652fa9e4066Sahrens { 653fa9e4066Sahrens dsl_dataset_t *ds = tosnap->os->os_dsl_dataset; 654fa9e4066Sahrens dsl_dataset_t *fromds = fromsnap ? fromsnap->os->os_dsl_dataset : NULL; 655fa9e4066Sahrens dmu_replay_record_t *drr; 656fa9e4066Sahrens struct backuparg ba; 657fa9e4066Sahrens int err; 658fa9e4066Sahrens 659fa9e4066Sahrens /* tosnap must be a snapshot */ 660fa9e4066Sahrens if (ds->ds_phys->ds_next_snap_obj == 0) 661fa9e4066Sahrens return (EINVAL); 662fa9e4066Sahrens 663fa9e4066Sahrens /* fromsnap must be an earlier snapshot from the same fs as tosnap */ 664fa9e4066Sahrens if (fromds && (ds->ds_dir != fromds->ds_dir || 665fa9e4066Sahrens fromds->ds_phys->ds_creation_txg >= 666fa9e4066Sahrens ds->ds_phys->ds_creation_txg)) 667fa9e4066Sahrens return (EXDEV); 668fa9e4066Sahrens 669fa9e4066Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 670fa9e4066Sahrens drr->drr_type = DRR_BEGIN; 671fa9e4066Sahrens drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC; 672fa9e4066Sahrens drr->drr_u.drr_begin.drr_version = DMU_BACKUP_VERSION; 673fa9e4066Sahrens drr->drr_u.drr_begin.drr_creation_time = 674fa9e4066Sahrens ds->ds_phys->ds_creation_time; 675fa9e4066Sahrens drr->drr_u.drr_begin.drr_type = tosnap->os->os_phys->os_type; 676fa9e4066Sahrens drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid; 677fa9e4066Sahrens if (fromds) 678fa9e4066Sahrens drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid; 679fa9e4066Sahrens dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname); 680fa9e4066Sahrens 681fa9e4066Sahrens ba.drr = drr; 682fa9e4066Sahrens ba.vp = vp; 683fa9e4066Sahrens ba.os = tosnap; 684ea8dc4b6Seschrock ZIO_SET_CHECKSUM(&ba.zc, 0, 0, 0, 0); 685fa9e4066Sahrens 686fa9e4066Sahrens if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t))) { 687fa9e4066Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 688fa9e4066Sahrens return (ba.err); 689fa9e4066Sahrens } 690fa9e4066Sahrens 691fa9e4066Sahrens err = traverse_dsl_dataset(ds, 692fa9e4066Sahrens fromds ? fromds->ds_phys->ds_creation_txg : 0, 693fa9e4066Sahrens ADVANCE_PRE | ADVANCE_HOLES | ADVANCE_DATA | ADVANCE_NOLOCK, 694fa9e4066Sahrens backup_cb, &ba); 695fa9e4066Sahrens 696fa9e4066Sahrens if (err) { 697fa9e4066Sahrens if (err == EINTR && ba.err) 698fa9e4066Sahrens err = ba.err; 699fa9e4066Sahrens return (err); 700fa9e4066Sahrens } 701fa9e4066Sahrens 702fa9e4066Sahrens bzero(drr, sizeof (dmu_replay_record_t)); 703fa9e4066Sahrens drr->drr_type = DRR_END; 704ea8dc4b6Seschrock drr->drr_u.drr_end.drr_checksum = ba.zc; 705fa9e4066Sahrens 706fa9e4066Sahrens if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t))) 707fa9e4066Sahrens return (ba.err); 708fa9e4066Sahrens 709fa9e4066Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 710fa9e4066Sahrens 711fa9e4066Sahrens return (0); 712fa9e4066Sahrens } 713fa9e4066Sahrens 714fa9e4066Sahrens struct restorearg { 715fa9e4066Sahrens int err; 716fa9e4066Sahrens int byteswap; 717fa9e4066Sahrens vnode_t *vp; 718fa9e4066Sahrens char *buf; 719fa9e4066Sahrens uint64_t voff; 720fa9e4066Sahrens int buflen; /* number of valid bytes in buf */ 721fa9e4066Sahrens int bufoff; /* next offset to read */ 722fa9e4066Sahrens int bufsize; /* amount of memory allocated for buf */ 723ea8dc4b6Seschrock zio_cksum_t zc; 724fa9e4066Sahrens }; 725fa9e4066Sahrens 726*1d452cf5Sahrens /* ARGSUSED */ 727fa9e4066Sahrens static int 728*1d452cf5Sahrens replay_incremental_check(void *arg1, void *arg2, dmu_tx_t *tx) 729fa9e4066Sahrens { 730*1d452cf5Sahrens dsl_dataset_t *ds = arg1; 731*1d452cf5Sahrens struct drr_begin *drrb = arg2; 732fa9e4066Sahrens const char *snapname; 733*1d452cf5Sahrens int err; 734fa9e4066Sahrens uint64_t val; 735fa9e4066Sahrens 736fa9e4066Sahrens /* must already be a snapshot of this fs */ 737*1d452cf5Sahrens if (ds->ds_phys->ds_prev_snap_obj == 0) 738*1d452cf5Sahrens return (ENODEV); 739fa9e4066Sahrens 740fa9e4066Sahrens /* most recent snapshot must match fromguid */ 741*1d452cf5Sahrens if (ds->ds_prev->ds_phys->ds_guid != drrb->drr_fromguid) 742*1d452cf5Sahrens return (ENODEV); 743fa9e4066Sahrens /* must not have any changes since most recent snapshot */ 744fa9e4066Sahrens if (ds->ds_phys->ds_bp.blk_birth > 745*1d452cf5Sahrens ds->ds_prev->ds_phys->ds_creation_txg) 746*1d452cf5Sahrens return (ETXTBSY); 747fa9e4066Sahrens 748fa9e4066Sahrens /* new snapshot name must not exist */ 749fa9e4066Sahrens snapname = strrchr(drrb->drr_toname, '@'); 750*1d452cf5Sahrens if (snapname == NULL) 751*1d452cf5Sahrens return (EEXIST); 752*1d452cf5Sahrens 753fa9e4066Sahrens snapname++; 754*1d452cf5Sahrens err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 755fa9e4066Sahrens ds->ds_phys->ds_snapnames_zapobj, snapname, 8, 1, &val); 756*1d452cf5Sahrens if (err == 0) 757*1d452cf5Sahrens return (EEXIST); 758*1d452cf5Sahrens if (err != ENOENT) 759fa9e4066Sahrens return (err); 760fa9e4066Sahrens 761*1d452cf5Sahrens return (0); 762*1d452cf5Sahrens } 763fa9e4066Sahrens 764*1d452cf5Sahrens /* ARGSUSED */ 765*1d452cf5Sahrens static void 766*1d452cf5Sahrens replay_incremental_sync(void *arg1, void *arg2, dmu_tx_t *tx) 767*1d452cf5Sahrens { 768*1d452cf5Sahrens dsl_dataset_t *ds = arg1; 769fa9e4066Sahrens dmu_buf_will_dirty(ds->ds_dbuf, tx); 77099653d4eSeschrock ds->ds_phys->ds_flags |= DS_FLAG_INCONSISTENT; 771fa9e4066Sahrens } 772fa9e4066Sahrens 773*1d452cf5Sahrens /* ARGSUSED */ 774fa9e4066Sahrens static int 775*1d452cf5Sahrens replay_full_check(void *arg1, void *arg2, dmu_tx_t *tx) 776fa9e4066Sahrens { 777*1d452cf5Sahrens dsl_dir_t *dd = arg1; 778*1d452cf5Sahrens struct drr_begin *drrb = arg2; 779*1d452cf5Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 780*1d452cf5Sahrens char *cp; 781*1d452cf5Sahrens uint64_t val; 782fa9e4066Sahrens int err; 783fa9e4066Sahrens 784*1d452cf5Sahrens cp = strchr(drrb->drr_toname, '@'); 785fa9e4066Sahrens *cp = '\0'; 786*1d452cf5Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 787*1d452cf5Sahrens strrchr(drrb->drr_toname, '/') + 1, 788*1d452cf5Sahrens sizeof (uint64_t), 1, &val); 789*1d452cf5Sahrens *cp = '@'; 790fa9e4066Sahrens 791*1d452cf5Sahrens if (err != ENOENT) 792*1d452cf5Sahrens return (err ? err : EEXIST); 793*1d452cf5Sahrens 794*1d452cf5Sahrens return (0); 795*1d452cf5Sahrens } 796fa9e4066Sahrens 797*1d452cf5Sahrens static void 798*1d452cf5Sahrens replay_full_sync(void *arg1, void *arg2, dmu_tx_t *tx) 799*1d452cf5Sahrens { 800*1d452cf5Sahrens dsl_dir_t *dd = arg1; 801*1d452cf5Sahrens struct drr_begin *drrb = arg2; 802*1d452cf5Sahrens char *cp; 803*1d452cf5Sahrens dsl_dataset_t *ds; 804*1d452cf5Sahrens uint64_t dsobj; 805*1d452cf5Sahrens 806*1d452cf5Sahrens cp = strchr(drrb->drr_toname, '@'); 807*1d452cf5Sahrens *cp = '\0'; 808*1d452cf5Sahrens dsobj = dsl_dataset_create_sync(dd, strrchr(drrb->drr_toname, '/') + 1, 809*1d452cf5Sahrens NULL, tx); 810*1d452cf5Sahrens *cp = '@'; 811fa9e4066Sahrens 812*1d452cf5Sahrens VERIFY(0 == dsl_dataset_open_obj(dd->dd_pool, dsobj, NULL, 813ea8dc4b6Seschrock DS_MODE_EXCLUSIVE, FTAG, &ds)); 814fa9e4066Sahrens 815fa9e4066Sahrens (void) dmu_objset_create_impl(dsl_dataset_get_spa(ds), 816fa9e4066Sahrens ds, drrb->drr_type, tx); 817fa9e4066Sahrens 818fa9e4066Sahrens dmu_buf_will_dirty(ds->ds_dbuf, tx); 81999653d4eSeschrock ds->ds_phys->ds_flags |= DS_FLAG_INCONSISTENT; 820fa9e4066Sahrens 821fa9e4066Sahrens dsl_dataset_close(ds, DS_MODE_EXCLUSIVE, FTAG); 822fa9e4066Sahrens } 823fa9e4066Sahrens 824fa9e4066Sahrens static int 825*1d452cf5Sahrens replay_end_check(void *arg1, void *arg2, dmu_tx_t *tx) 826fa9e4066Sahrens { 827*1d452cf5Sahrens objset_t *os = arg1; 828*1d452cf5Sahrens struct drr_begin *drrb = arg2; 829fa9e4066Sahrens char *snapname; 830fa9e4066Sahrens 831fa9e4066Sahrens /* XXX verify that drr_toname is in dd */ 832fa9e4066Sahrens 833fa9e4066Sahrens snapname = strchr(drrb->drr_toname, '@'); 834fa9e4066Sahrens if (snapname == NULL) 835fa9e4066Sahrens return (EINVAL); 836fa9e4066Sahrens snapname++; 837fa9e4066Sahrens 838*1d452cf5Sahrens return (dsl_dataset_snapshot_check(os, snapname, tx)); 839*1d452cf5Sahrens } 840*1d452cf5Sahrens 841*1d452cf5Sahrens static void 842*1d452cf5Sahrens replay_end_sync(void *arg1, void *arg2, dmu_tx_t *tx) 843*1d452cf5Sahrens { 844*1d452cf5Sahrens objset_t *os = arg1; 845*1d452cf5Sahrens struct drr_begin *drrb = arg2; 846*1d452cf5Sahrens char *snapname; 847*1d452cf5Sahrens dsl_dataset_t *ds, *hds; 848*1d452cf5Sahrens 849*1d452cf5Sahrens snapname = strchr(drrb->drr_toname, '@') + 1; 850*1d452cf5Sahrens 851*1d452cf5Sahrens dsl_dataset_snapshot_sync(os, snapname, tx); 852fa9e4066Sahrens 853fa9e4066Sahrens /* set snapshot's creation time and guid */ 854*1d452cf5Sahrens hds = os->os->os_dsl_dataset; 855*1d452cf5Sahrens VERIFY(0 == dsl_dataset_open_obj(hds->ds_dir->dd_pool, 856*1d452cf5Sahrens hds->ds_phys->ds_prev_snap_obj, NULL, 857e1930233Sbonwick DS_MODE_PRIMARY | DS_MODE_READONLY | DS_MODE_INCONSISTENT, 858e1930233Sbonwick FTAG, &ds)); 859fa9e4066Sahrens 860fa9e4066Sahrens dmu_buf_will_dirty(ds->ds_dbuf, tx); 861fa9e4066Sahrens ds->ds_phys->ds_creation_time = drrb->drr_creation_time; 862fa9e4066Sahrens ds->ds_phys->ds_guid = drrb->drr_toguid; 86399653d4eSeschrock ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 864fa9e4066Sahrens 865fa9e4066Sahrens dsl_dataset_close(ds, DS_MODE_PRIMARY, FTAG); 866fa9e4066Sahrens 867*1d452cf5Sahrens dmu_buf_will_dirty(hds->ds_dbuf, tx); 868*1d452cf5Sahrens hds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 869fa9e4066Sahrens } 870fa9e4066Sahrens 871fa9e4066Sahrens void * 872fa9e4066Sahrens restore_read(struct restorearg *ra, int len) 873fa9e4066Sahrens { 874fa9e4066Sahrens void *rv; 875fa9e4066Sahrens 876fa9e4066Sahrens /* some things will require 8-byte alignment, so everything must */ 877fa9e4066Sahrens ASSERT3U(len % 8, ==, 0); 878fa9e4066Sahrens 879fa9e4066Sahrens while (ra->buflen - ra->bufoff < len) { 880fa9e4066Sahrens ssize_t resid; 881fa9e4066Sahrens int leftover = ra->buflen - ra->bufoff; 882fa9e4066Sahrens 883fa9e4066Sahrens (void) memmove(ra->buf, ra->buf + ra->bufoff, leftover); 884fa9e4066Sahrens ra->err = vn_rdwr(UIO_READ, ra->vp, 885fa9e4066Sahrens (caddr_t)ra->buf + leftover, ra->bufsize - leftover, 886fa9e4066Sahrens ra->voff, UIO_SYSSPACE, FAPPEND, 88793fcfe85Sahrens RLIM64_INFINITY, CRED(), &resid); 888fa9e4066Sahrens 889fa9e4066Sahrens ra->voff += ra->bufsize - leftover - resid; 890fa9e4066Sahrens ra->buflen = ra->bufsize - resid; 891fa9e4066Sahrens ra->bufoff = 0; 892fa9e4066Sahrens if (resid == ra->bufsize - leftover) 893fa9e4066Sahrens ra->err = EINVAL; 894fa9e4066Sahrens if (ra->err) 895fa9e4066Sahrens return (NULL); 896ea8dc4b6Seschrock /* Could compute checksum here? */ 897fa9e4066Sahrens } 898fa9e4066Sahrens 899fa9e4066Sahrens ASSERT3U(ra->bufoff % 8, ==, 0); 900fa9e4066Sahrens ASSERT3U(ra->buflen - ra->bufoff, >=, len); 901fa9e4066Sahrens rv = ra->buf + ra->bufoff; 902fa9e4066Sahrens ra->bufoff += len; 903ea8dc4b6Seschrock if (ra->byteswap) 904ea8dc4b6Seschrock fletcher_4_incremental_byteswap(rv, len, &ra->zc); 905ea8dc4b6Seschrock else 906ea8dc4b6Seschrock fletcher_4_incremental_native(rv, len, &ra->zc); 907fa9e4066Sahrens return (rv); 908fa9e4066Sahrens } 909fa9e4066Sahrens 910fa9e4066Sahrens static void 911fa9e4066Sahrens backup_byteswap(dmu_replay_record_t *drr) 912fa9e4066Sahrens { 913fa9e4066Sahrens #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X)) 914fa9e4066Sahrens #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X)) 915fa9e4066Sahrens drr->drr_type = BSWAP_32(drr->drr_type); 916fa9e4066Sahrens switch (drr->drr_type) { 917fa9e4066Sahrens case DRR_BEGIN: 918fa9e4066Sahrens DO64(drr_begin.drr_magic); 919fa9e4066Sahrens DO64(drr_begin.drr_version); 920fa9e4066Sahrens DO64(drr_begin.drr_creation_time); 921fa9e4066Sahrens DO32(drr_begin.drr_type); 922fa9e4066Sahrens DO64(drr_begin.drr_toguid); 923fa9e4066Sahrens DO64(drr_begin.drr_fromguid); 924fa9e4066Sahrens break; 925fa9e4066Sahrens case DRR_OBJECT: 926fa9e4066Sahrens DO64(drr_object.drr_object); 927fa9e4066Sahrens /* DO64(drr_object.drr_allocation_txg); */ 928fa9e4066Sahrens DO32(drr_object.drr_type); 929fa9e4066Sahrens DO32(drr_object.drr_bonustype); 930fa9e4066Sahrens DO32(drr_object.drr_blksz); 931fa9e4066Sahrens DO32(drr_object.drr_bonuslen); 932fa9e4066Sahrens break; 933fa9e4066Sahrens case DRR_FREEOBJECTS: 934fa9e4066Sahrens DO64(drr_freeobjects.drr_firstobj); 935fa9e4066Sahrens DO64(drr_freeobjects.drr_numobjs); 936fa9e4066Sahrens break; 937fa9e4066Sahrens case DRR_WRITE: 938fa9e4066Sahrens DO64(drr_write.drr_object); 939fa9e4066Sahrens DO32(drr_write.drr_type); 940fa9e4066Sahrens DO64(drr_write.drr_offset); 941fa9e4066Sahrens DO64(drr_write.drr_length); 942fa9e4066Sahrens break; 943fa9e4066Sahrens case DRR_FREE: 944fa9e4066Sahrens DO64(drr_free.drr_object); 945fa9e4066Sahrens DO64(drr_free.drr_offset); 946fa9e4066Sahrens DO64(drr_free.drr_length); 947fa9e4066Sahrens break; 948fa9e4066Sahrens case DRR_END: 949ea8dc4b6Seschrock DO64(drr_end.drr_checksum.zc_word[0]); 950ea8dc4b6Seschrock DO64(drr_end.drr_checksum.zc_word[1]); 951ea8dc4b6Seschrock DO64(drr_end.drr_checksum.zc_word[2]); 952ea8dc4b6Seschrock DO64(drr_end.drr_checksum.zc_word[3]); 953fa9e4066Sahrens break; 954fa9e4066Sahrens } 955fa9e4066Sahrens #undef DO64 956fa9e4066Sahrens #undef DO32 957fa9e4066Sahrens } 958fa9e4066Sahrens 959fa9e4066Sahrens static int 960fa9e4066Sahrens restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro) 961fa9e4066Sahrens { 962fa9e4066Sahrens int err; 963fa9e4066Sahrens dmu_tx_t *tx; 964fa9e4066Sahrens 965fa9e4066Sahrens err = dmu_object_info(os, drro->drr_object, NULL); 966fa9e4066Sahrens 967fa9e4066Sahrens if (err != 0 && err != ENOENT) 968fa9e4066Sahrens return (EINVAL); 969fa9e4066Sahrens 970fa9e4066Sahrens if (drro->drr_type == DMU_OT_NONE || 971fa9e4066Sahrens drro->drr_type >= DMU_OT_NUMTYPES || 972fa9e4066Sahrens drro->drr_bonustype >= DMU_OT_NUMTYPES || 973fa9e4066Sahrens drro->drr_checksum >= ZIO_CHECKSUM_FUNCTIONS || 974fa9e4066Sahrens drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS || 975fa9e4066Sahrens P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) || 976fa9e4066Sahrens drro->drr_blksz < SPA_MINBLOCKSIZE || 977fa9e4066Sahrens drro->drr_blksz > SPA_MAXBLOCKSIZE || 978fa9e4066Sahrens drro->drr_bonuslen > DN_MAX_BONUSLEN) { 979fa9e4066Sahrens return (EINVAL); 980fa9e4066Sahrens } 981fa9e4066Sahrens 982fa9e4066Sahrens tx = dmu_tx_create(os); 983fa9e4066Sahrens 984fa9e4066Sahrens if (err == ENOENT) { 985fa9e4066Sahrens /* currently free, want to be allocated */ 986fa9e4066Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 987fa9e4066Sahrens dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, 1); 988fa9e4066Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 989fa9e4066Sahrens if (err) { 990fa9e4066Sahrens dmu_tx_abort(tx); 991fa9e4066Sahrens return (err); 992fa9e4066Sahrens } 993fa9e4066Sahrens err = dmu_object_claim(os, drro->drr_object, 994fa9e4066Sahrens drro->drr_type, drro->drr_blksz, 995fa9e4066Sahrens drro->drr_bonustype, drro->drr_bonuslen, tx); 996fa9e4066Sahrens } else { 997fa9e4066Sahrens /* currently allocated, want to be allocated */ 998fa9e4066Sahrens dmu_tx_hold_bonus(tx, drro->drr_object); 999fa9e4066Sahrens /* 1000fa9e4066Sahrens * We may change blocksize, so need to 1001fa9e4066Sahrens * hold_write 1002fa9e4066Sahrens */ 1003fa9e4066Sahrens dmu_tx_hold_write(tx, drro->drr_object, 0, 1); 1004fa9e4066Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1005fa9e4066Sahrens if (err) { 1006fa9e4066Sahrens dmu_tx_abort(tx); 1007fa9e4066Sahrens return (err); 1008fa9e4066Sahrens } 1009fa9e4066Sahrens 1010fa9e4066Sahrens err = dmu_object_reclaim(os, drro->drr_object, 1011fa9e4066Sahrens drro->drr_type, drro->drr_blksz, 1012fa9e4066Sahrens drro->drr_bonustype, drro->drr_bonuslen, tx); 1013fa9e4066Sahrens } 1014fa9e4066Sahrens if (err) { 1015fa9e4066Sahrens dmu_tx_commit(tx); 1016fa9e4066Sahrens return (EINVAL); 1017fa9e4066Sahrens } 1018fa9e4066Sahrens 1019fa9e4066Sahrens dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksum, tx); 1020fa9e4066Sahrens dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx); 1021fa9e4066Sahrens 1022fa9e4066Sahrens if (drro->drr_bonuslen) { 1023fa9e4066Sahrens dmu_buf_t *db; 1024fa9e4066Sahrens void *data; 1025ea8dc4b6Seschrock VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db)); 1026fa9e4066Sahrens dmu_buf_will_dirty(db, tx); 1027fa9e4066Sahrens 1028fa9e4066Sahrens ASSERT3U(db->db_size, ==, drro->drr_bonuslen); 1029fa9e4066Sahrens data = restore_read(ra, P2ROUNDUP(db->db_size, 8)); 1030fa9e4066Sahrens if (data == NULL) { 1031fa9e4066Sahrens dmu_tx_commit(tx); 1032fa9e4066Sahrens return (ra->err); 1033fa9e4066Sahrens } 1034fa9e4066Sahrens bcopy(data, db->db_data, db->db_size); 1035fa9e4066Sahrens if (ra->byteswap) { 1036fa9e4066Sahrens dmu_ot[drro->drr_bonustype].ot_byteswap(db->db_data, 1037fa9e4066Sahrens drro->drr_bonuslen); 1038fa9e4066Sahrens } 1039ea8dc4b6Seschrock dmu_buf_rele(db, FTAG); 1040fa9e4066Sahrens } 1041fa9e4066Sahrens dmu_tx_commit(tx); 1042fa9e4066Sahrens return (0); 1043fa9e4066Sahrens } 1044fa9e4066Sahrens 1045fa9e4066Sahrens /* ARGSUSED */ 1046fa9e4066Sahrens static int 1047fa9e4066Sahrens restore_freeobjects(struct restorearg *ra, objset_t *os, 1048fa9e4066Sahrens struct drr_freeobjects *drrfo) 1049fa9e4066Sahrens { 1050fa9e4066Sahrens uint64_t obj; 1051fa9e4066Sahrens 1052fa9e4066Sahrens if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj) 1053fa9e4066Sahrens return (EINVAL); 1054fa9e4066Sahrens 1055fa9e4066Sahrens for (obj = drrfo->drr_firstobj; 1056fa9e4066Sahrens obj < drrfo->drr_firstobj + drrfo->drr_numobjs; obj++) { 1057fa9e4066Sahrens dmu_tx_t *tx; 1058fa9e4066Sahrens int err; 1059fa9e4066Sahrens 1060fa9e4066Sahrens if (dmu_object_info(os, obj, NULL) != 0) 1061fa9e4066Sahrens continue; 1062fa9e4066Sahrens 1063fa9e4066Sahrens tx = dmu_tx_create(os); 1064fa9e4066Sahrens dmu_tx_hold_bonus(tx, obj); 1065fa9e4066Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1066fa9e4066Sahrens if (err) { 1067fa9e4066Sahrens dmu_tx_abort(tx); 1068fa9e4066Sahrens return (err); 1069fa9e4066Sahrens } 1070fa9e4066Sahrens err = dmu_object_free(os, obj, tx); 1071fa9e4066Sahrens dmu_tx_commit(tx); 1072fa9e4066Sahrens if (err && err != ENOENT) 1073fa9e4066Sahrens return (EINVAL); 1074fa9e4066Sahrens } 1075fa9e4066Sahrens return (0); 1076fa9e4066Sahrens } 1077fa9e4066Sahrens 1078fa9e4066Sahrens static int 1079fa9e4066Sahrens restore_write(struct restorearg *ra, objset_t *os, 1080fa9e4066Sahrens struct drr_write *drrw) 1081fa9e4066Sahrens { 1082fa9e4066Sahrens dmu_tx_t *tx; 1083fa9e4066Sahrens void *data; 1084fa9e4066Sahrens int err; 1085fa9e4066Sahrens 1086fa9e4066Sahrens if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset || 1087fa9e4066Sahrens drrw->drr_type >= DMU_OT_NUMTYPES) 1088fa9e4066Sahrens return (EINVAL); 1089fa9e4066Sahrens 1090fa9e4066Sahrens data = restore_read(ra, drrw->drr_length); 1091fa9e4066Sahrens if (data == NULL) 1092fa9e4066Sahrens return (ra->err); 1093fa9e4066Sahrens 1094fa9e4066Sahrens if (dmu_object_info(os, drrw->drr_object, NULL) != 0) 1095fa9e4066Sahrens return (EINVAL); 1096fa9e4066Sahrens 1097fa9e4066Sahrens tx = dmu_tx_create(os); 1098fa9e4066Sahrens 1099fa9e4066Sahrens dmu_tx_hold_write(tx, drrw->drr_object, 1100fa9e4066Sahrens drrw->drr_offset, drrw->drr_length); 1101fa9e4066Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1102fa9e4066Sahrens if (err) { 1103fa9e4066Sahrens dmu_tx_abort(tx); 1104fa9e4066Sahrens return (err); 1105fa9e4066Sahrens } 1106fa9e4066Sahrens if (ra->byteswap) 1107fa9e4066Sahrens dmu_ot[drrw->drr_type].ot_byteswap(data, drrw->drr_length); 1108fa9e4066Sahrens dmu_write(os, drrw->drr_object, 1109fa9e4066Sahrens drrw->drr_offset, drrw->drr_length, data, tx); 1110fa9e4066Sahrens dmu_tx_commit(tx); 1111fa9e4066Sahrens return (0); 1112fa9e4066Sahrens } 1113fa9e4066Sahrens 1114fa9e4066Sahrens /* ARGSUSED */ 1115fa9e4066Sahrens static int 1116fa9e4066Sahrens restore_free(struct restorearg *ra, objset_t *os, 1117fa9e4066Sahrens struct drr_free *drrf) 1118fa9e4066Sahrens { 1119fa9e4066Sahrens dmu_tx_t *tx; 1120fa9e4066Sahrens int err; 1121fa9e4066Sahrens 1122fa9e4066Sahrens if (drrf->drr_length != -1ULL && 1123fa9e4066Sahrens drrf->drr_offset + drrf->drr_length < drrf->drr_offset) 1124fa9e4066Sahrens return (EINVAL); 1125fa9e4066Sahrens 1126fa9e4066Sahrens if (dmu_object_info(os, drrf->drr_object, NULL) != 0) 1127fa9e4066Sahrens return (EINVAL); 1128fa9e4066Sahrens 1129fa9e4066Sahrens tx = dmu_tx_create(os); 1130fa9e4066Sahrens 1131fa9e4066Sahrens dmu_tx_hold_free(tx, drrf->drr_object, 1132fa9e4066Sahrens drrf->drr_offset, drrf->drr_length); 1133fa9e4066Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1134fa9e4066Sahrens if (err) { 1135fa9e4066Sahrens dmu_tx_abort(tx); 1136fa9e4066Sahrens return (err); 1137fa9e4066Sahrens } 1138ea8dc4b6Seschrock err = dmu_free_range(os, drrf->drr_object, 1139fa9e4066Sahrens drrf->drr_offset, drrf->drr_length, tx); 1140fa9e4066Sahrens dmu_tx_commit(tx); 1141ea8dc4b6Seschrock return (err); 1142fa9e4066Sahrens } 1143fa9e4066Sahrens 1144fa9e4066Sahrens int 1145ea8dc4b6Seschrock dmu_recvbackup(char *tosnap, struct drr_begin *drrb, uint64_t *sizep, 1146fa9e4066Sahrens vnode_t *vp, uint64_t voffset) 1147fa9e4066Sahrens { 1148fa9e4066Sahrens struct restorearg ra; 1149fa9e4066Sahrens dmu_replay_record_t *drr; 1150ea8dc4b6Seschrock char *cp; 1151fa9e4066Sahrens objset_t *os = NULL; 1152ea8dc4b6Seschrock zio_cksum_t pzc; 1153fa9e4066Sahrens 1154fa9e4066Sahrens bzero(&ra, sizeof (ra)); 1155fa9e4066Sahrens ra.vp = vp; 1156fa9e4066Sahrens ra.voff = voffset; 1157fa9e4066Sahrens ra.bufsize = 1<<20; 1158fa9e4066Sahrens ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP); 1159fa9e4066Sahrens 1160fa9e4066Sahrens if (drrb->drr_magic == DMU_BACKUP_MAGIC) { 1161fa9e4066Sahrens ra.byteswap = FALSE; 1162fa9e4066Sahrens } else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) { 1163fa9e4066Sahrens ra.byteswap = TRUE; 1164fa9e4066Sahrens } else { 1165fa9e4066Sahrens ra.err = EINVAL; 1166fa9e4066Sahrens goto out; 1167fa9e4066Sahrens } 1168fa9e4066Sahrens 1169ea8dc4b6Seschrock /* 1170ea8dc4b6Seschrock * NB: this assumes that struct drr_begin will be the largest in 1171ea8dc4b6Seschrock * dmu_replay_record_t's drr_u, and thus we don't need to pad it 1172ea8dc4b6Seschrock * with zeros to make it the same length as we wrote out. 1173ea8dc4b6Seschrock */ 1174ea8dc4b6Seschrock ((dmu_replay_record_t *)ra.buf)->drr_type = DRR_BEGIN; 1175ea8dc4b6Seschrock ((dmu_replay_record_t *)ra.buf)->drr_pad = 0; 1176ea8dc4b6Seschrock ((dmu_replay_record_t *)ra.buf)->drr_u.drr_begin = *drrb; 1177ea8dc4b6Seschrock if (ra.byteswap) { 1178ea8dc4b6Seschrock fletcher_4_incremental_byteswap(ra.buf, 1179ea8dc4b6Seschrock sizeof (dmu_replay_record_t), &ra.zc); 1180ea8dc4b6Seschrock } else { 1181ea8dc4b6Seschrock fletcher_4_incremental_native(ra.buf, 1182ea8dc4b6Seschrock sizeof (dmu_replay_record_t), &ra.zc); 1183ea8dc4b6Seschrock } 1184ea8dc4b6Seschrock (void) strcpy(drrb->drr_toname, tosnap); /* for the sync funcs */ 1185ea8dc4b6Seschrock 1186fa9e4066Sahrens if (ra.byteswap) { 1187fa9e4066Sahrens drrb->drr_magic = BSWAP_64(drrb->drr_magic); 1188fa9e4066Sahrens drrb->drr_version = BSWAP_64(drrb->drr_version); 1189fa9e4066Sahrens drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time); 1190fa9e4066Sahrens drrb->drr_type = BSWAP_32(drrb->drr_type); 1191fa9e4066Sahrens drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 1192fa9e4066Sahrens drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid); 1193fa9e4066Sahrens } 1194fa9e4066Sahrens 1195fa9e4066Sahrens ASSERT3U(drrb->drr_magic, ==, DMU_BACKUP_MAGIC); 1196fa9e4066Sahrens 1197fa9e4066Sahrens if (drrb->drr_version != DMU_BACKUP_VERSION || 1198fa9e4066Sahrens drrb->drr_type >= DMU_OST_NUMTYPES || 1199fa9e4066Sahrens strchr(drrb->drr_toname, '@') == NULL) { 1200fa9e4066Sahrens ra.err = EINVAL; 1201fa9e4066Sahrens goto out; 1202fa9e4066Sahrens } 1203fa9e4066Sahrens 1204fa9e4066Sahrens /* 1205fa9e4066Sahrens * Process the begin in syncing context. 1206fa9e4066Sahrens */ 1207fa9e4066Sahrens if (drrb->drr_fromguid) { 1208fa9e4066Sahrens /* incremental backup */ 1209*1d452cf5Sahrens dsl_dataset_t *ds = NULL; 1210fa9e4066Sahrens 1211fa9e4066Sahrens cp = strchr(tosnap, '@'); 1212fa9e4066Sahrens *cp = '\0'; 1213*1d452cf5Sahrens ra.err = dsl_dataset_open(tosnap, DS_MODE_EXCLUSIVE, FTAG, &ds); 1214fa9e4066Sahrens *cp = '@'; 1215ea8dc4b6Seschrock if (ra.err) 1216fa9e4066Sahrens goto out; 1217fa9e4066Sahrens 1218*1d452cf5Sahrens ra.err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1219*1d452cf5Sahrens replay_incremental_check, replay_incremental_sync, 1220*1d452cf5Sahrens ds, drrb, 1); 1221*1d452cf5Sahrens dsl_dataset_close(ds, DS_MODE_EXCLUSIVE, FTAG); 1222fa9e4066Sahrens } else { 1223fa9e4066Sahrens /* full backup */ 1224*1d452cf5Sahrens dsl_dir_t *dd = NULL; 1225fa9e4066Sahrens const char *tail; 1226fa9e4066Sahrens 1227*1d452cf5Sahrens /* can't restore full backup into topmost fs, for now */ 1228*1d452cf5Sahrens if (strrchr(drrb->drr_toname, '/') == NULL) { 1229*1d452cf5Sahrens ra.err = EINVAL; 1230*1d452cf5Sahrens goto out; 1231*1d452cf5Sahrens } 1232*1d452cf5Sahrens 1233fa9e4066Sahrens cp = strchr(tosnap, '@'); 1234fa9e4066Sahrens *cp = '\0'; 1235ea8dc4b6Seschrock ra.err = dsl_dir_open(tosnap, FTAG, &dd, &tail); 1236fa9e4066Sahrens *cp = '@'; 1237ea8dc4b6Seschrock if (ra.err) 1238fa9e4066Sahrens goto out; 1239fa9e4066Sahrens if (tail == NULL) { 1240fa9e4066Sahrens ra.err = EEXIST; 1241fa9e4066Sahrens goto out; 1242fa9e4066Sahrens } 1243fa9e4066Sahrens 1244*1d452cf5Sahrens ra.err = dsl_sync_task_do(dd->dd_pool, replay_full_check, 1245*1d452cf5Sahrens replay_full_sync, dd, drrb, 5); 1246*1d452cf5Sahrens dsl_dir_close(dd, FTAG); 1247fa9e4066Sahrens } 1248fa9e4066Sahrens if (ra.err) 1249fa9e4066Sahrens goto out; 1250fa9e4066Sahrens 1251fa9e4066Sahrens /* 1252fa9e4066Sahrens * Open the objset we are modifying. 1253fa9e4066Sahrens */ 1254fa9e4066Sahrens 1255fa9e4066Sahrens cp = strchr(tosnap, '@'); 1256fa9e4066Sahrens *cp = '\0'; 1257fa9e4066Sahrens ra.err = dmu_objset_open(tosnap, DMU_OST_ANY, 1258e1930233Sbonwick DS_MODE_PRIMARY | DS_MODE_INCONSISTENT, &os); 1259fa9e4066Sahrens *cp = '@'; 1260fa9e4066Sahrens ASSERT3U(ra.err, ==, 0); 1261fa9e4066Sahrens 1262fa9e4066Sahrens /* 1263fa9e4066Sahrens * Read records and process them. 1264fa9e4066Sahrens */ 1265ea8dc4b6Seschrock pzc = ra.zc; 1266fa9e4066Sahrens while (ra.err == 0 && 1267fa9e4066Sahrens NULL != (drr = restore_read(&ra, sizeof (*drr)))) { 1268ea8dc4b6Seschrock if (issig(JUSTLOOKING) && issig(FORREAL)) { 1269fa9e4066Sahrens ra.err = EINTR; 1270fa9e4066Sahrens goto out; 1271fa9e4066Sahrens } 1272fa9e4066Sahrens 1273fa9e4066Sahrens if (ra.byteswap) 1274fa9e4066Sahrens backup_byteswap(drr); 1275fa9e4066Sahrens 1276fa9e4066Sahrens switch (drr->drr_type) { 1277fa9e4066Sahrens case DRR_OBJECT: 1278fa9e4066Sahrens { 1279fa9e4066Sahrens /* 1280fa9e4066Sahrens * We need to make a copy of the record header, 1281fa9e4066Sahrens * because restore_{object,write} may need to 1282fa9e4066Sahrens * restore_read(), which will invalidate drr. 1283fa9e4066Sahrens */ 1284fa9e4066Sahrens struct drr_object drro = drr->drr_u.drr_object; 1285fa9e4066Sahrens ra.err = restore_object(&ra, os, &drro); 1286fa9e4066Sahrens break; 1287fa9e4066Sahrens } 1288fa9e4066Sahrens case DRR_FREEOBJECTS: 1289fa9e4066Sahrens { 1290fa9e4066Sahrens struct drr_freeobjects drrfo = 1291fa9e4066Sahrens drr->drr_u.drr_freeobjects; 1292fa9e4066Sahrens ra.err = restore_freeobjects(&ra, os, &drrfo); 1293fa9e4066Sahrens break; 1294fa9e4066Sahrens } 1295fa9e4066Sahrens case DRR_WRITE: 1296fa9e4066Sahrens { 1297fa9e4066Sahrens struct drr_write drrw = drr->drr_u.drr_write; 1298fa9e4066Sahrens ra.err = restore_write(&ra, os, &drrw); 1299fa9e4066Sahrens break; 1300fa9e4066Sahrens } 1301fa9e4066Sahrens case DRR_FREE: 1302fa9e4066Sahrens { 1303fa9e4066Sahrens struct drr_free drrf = drr->drr_u.drr_free; 1304fa9e4066Sahrens ra.err = restore_free(&ra, os, &drrf); 1305fa9e4066Sahrens break; 1306fa9e4066Sahrens } 1307fa9e4066Sahrens case DRR_END: 1308ea8dc4b6Seschrock { 1309ea8dc4b6Seschrock struct drr_end drre = drr->drr_u.drr_end; 1310ea8dc4b6Seschrock /* 1311ea8dc4b6Seschrock * We compare against the *previous* checksum 1312ea8dc4b6Seschrock * value, because the stored checksum is of 1313ea8dc4b6Seschrock * everything before the DRR_END record. 1314ea8dc4b6Seschrock */ 1315ea8dc4b6Seschrock if (drre.drr_checksum.zc_word[0] != 0 && 1316ea8dc4b6Seschrock ((drre.drr_checksum.zc_word[0] - pzc.zc_word[0]) | 1317ea8dc4b6Seschrock (drre.drr_checksum.zc_word[1] - pzc.zc_word[1]) | 1318ea8dc4b6Seschrock (drre.drr_checksum.zc_word[2] - pzc.zc_word[2]) | 1319ea8dc4b6Seschrock (drre.drr_checksum.zc_word[3] - pzc.zc_word[3]))) { 1320ea8dc4b6Seschrock ra.err = ECKSUM; 1321ea8dc4b6Seschrock goto out; 1322ea8dc4b6Seschrock } 1323ea8dc4b6Seschrock 1324*1d452cf5Sahrens ra.err = dsl_sync_task_do(dmu_objset_ds(os)-> 1325*1d452cf5Sahrens ds_dir->dd_pool, replay_end_check, replay_end_sync, 1326*1d452cf5Sahrens os, drrb, 3); 1327fa9e4066Sahrens goto out; 1328ea8dc4b6Seschrock } 1329fa9e4066Sahrens default: 1330fa9e4066Sahrens ra.err = EINVAL; 1331fa9e4066Sahrens goto out; 1332fa9e4066Sahrens } 1333ea8dc4b6Seschrock pzc = ra.zc; 1334fa9e4066Sahrens } 1335fa9e4066Sahrens 1336fa9e4066Sahrens out: 1337fa9e4066Sahrens if (os) 1338fa9e4066Sahrens dmu_objset_close(os); 1339fa9e4066Sahrens 1340fa9e4066Sahrens /* 1341fa9e4066Sahrens * Make sure we don't rollback/destroy unless we actually 1342fa9e4066Sahrens * processed the begin properly. 'os' will only be set if this 1343fa9e4066Sahrens * is the case. 1344fa9e4066Sahrens */ 1345*1d452cf5Sahrens if (ra.err && os && tosnap && strchr(tosnap, '@')) { 1346fa9e4066Sahrens /* 1347fa9e4066Sahrens * rollback or destroy what we created, so we don't 1348fa9e4066Sahrens * leave it in the restoring state. 1349fa9e4066Sahrens */ 1350*1d452cf5Sahrens dsl_dataset_t *ds; 1351*1d452cf5Sahrens int err; 1352*1d452cf5Sahrens 1353*1d452cf5Sahrens cp = strchr(tosnap, '@'); 1354*1d452cf5Sahrens *cp = '\0'; 1355*1d452cf5Sahrens err = dsl_dataset_open(tosnap, 1356*1d452cf5Sahrens DS_MODE_EXCLUSIVE | DS_MODE_INCONSISTENT, 1357*1d452cf5Sahrens FTAG, &ds); 1358*1d452cf5Sahrens if (err == 0) { 1359*1d452cf5Sahrens txg_wait_synced(ds->ds_dir->dd_pool, 0); 1360*1d452cf5Sahrens if (drrb->drr_fromguid) { 1361*1d452cf5Sahrens /* incremental: rollback to most recent snap */ 1362*1d452cf5Sahrens (void) dsl_dataset_rollback(ds); 1363*1d452cf5Sahrens dsl_dataset_close(ds, DS_MODE_EXCLUSIVE, FTAG); 1364*1d452cf5Sahrens } else { 1365*1d452cf5Sahrens /* full: destroy whole fs */ 1366*1d452cf5Sahrens dsl_dataset_close(ds, DS_MODE_EXCLUSIVE, FTAG); 1367*1d452cf5Sahrens (void) dsl_dataset_destroy(tosnap); 1368fa9e4066Sahrens } 1369fa9e4066Sahrens } 1370*1d452cf5Sahrens *cp = '@'; 1371fa9e4066Sahrens } 1372fa9e4066Sahrens 1373fa9e4066Sahrens kmem_free(ra.buf, ra.bufsize); 1374fa9e4066Sahrens if (sizep) 1375fa9e4066Sahrens *sizep = ra.voff; 1376fa9e4066Sahrens return (ra.err); 1377fa9e4066Sahrens } 1378fa9e4066Sahrens 1379fa9e4066Sahrens /* 1380fa9e4066Sahrens * Intent log support: sync the block at <os, object, offset> to disk. 1381fa9e4066Sahrens * N.B. and XXX: the caller is responsible for serializing dmu_sync()s 1382fa9e4066Sahrens * of the same block, and for making sure that the data isn't changing 1383fa9e4066Sahrens * while dmu_sync() is writing it. 1384fa9e4066Sahrens * 1385fa9e4066Sahrens * Return values: 1386fa9e4066Sahrens * 1387fa9e4066Sahrens * EALREADY: this txg has already been synced, so there's nothing to to. 1388fa9e4066Sahrens * The caller should not log the write. 1389fa9e4066Sahrens * 1390fa9e4066Sahrens * ENOENT: the block was dbuf_free_range()'d, so there's nothing to do. 1391fa9e4066Sahrens * The caller should not log the write. 1392fa9e4066Sahrens * 1393fa9e4066Sahrens * EINPROGRESS: the block is in the process of being synced by the 1394fa9e4066Sahrens * usual mechanism (spa_sync()), so we can't sync it here. 1395fa9e4066Sahrens * The caller should txg_wait_synced() and not log the write. 1396fa9e4066Sahrens * 1397fa9e4066Sahrens * EBUSY: another thread is trying to dmu_sync() the same dbuf. 1398fa9e4066Sahrens * (This case cannot arise under the current locking rules.) 1399fa9e4066Sahrens * The caller should txg_wait_synced() and not log the write. 1400fa9e4066Sahrens * 1401fa9e4066Sahrens * ESTALE: the block was dirtied or freed while we were writing it, 1402fa9e4066Sahrens * so the data is no longer valid. 1403fa9e4066Sahrens * The caller should txg_wait_synced() and not log the write. 1404fa9e4066Sahrens * 1405fa9e4066Sahrens * 0: success. Sets *bp to the blkptr just written, and sets 1406fa9e4066Sahrens * *blkoff to the data's offset within that block. 1407fa9e4066Sahrens * The caller should log this blkptr/blkoff in its lr_write_t. 1408fa9e4066Sahrens */ 1409fa9e4066Sahrens int 1410fa9e4066Sahrens dmu_sync(objset_t *os, uint64_t object, uint64_t offset, uint64_t *blkoff, 1411fa9e4066Sahrens blkptr_t *bp, uint64_t txg) 1412fa9e4066Sahrens { 141344cd46caSbillm objset_impl_t *osi = os->os; 141444cd46caSbillm dsl_pool_t *dp = osi->os_dsl_dataset->ds_dir->dd_pool; 1415fa9e4066Sahrens tx_state_t *tx = &dp->dp_tx; 1416fa9e4066Sahrens dmu_buf_impl_t *db; 1417fa9e4066Sahrens blkptr_t *blk; 1418fa9e4066Sahrens int err; 1419ea8dc4b6Seschrock zbookmark_t zb; 1420fa9e4066Sahrens 1421fa9e4066Sahrens ASSERT(RW_LOCK_HELD(&tx->tx_suspend)); 1422fa9e4066Sahrens ASSERT(BP_IS_HOLE(bp)); 1423fa9e4066Sahrens ASSERT(txg != 0); 1424fa9e4066Sahrens 1425fa9e4066Sahrens dprintf("dmu_sync txg=%llu, s,o,q %llu %llu %llu\n", 1426fa9e4066Sahrens txg, tx->tx_synced_txg, tx->tx_open_txg, tx->tx_quiesced_txg); 1427fa9e4066Sahrens 1428ea8dc4b6Seschrock /* 1429ea8dc4b6Seschrock * XXX why is this routine using dmu_buf_*() and casting between 1430ea8dc4b6Seschrock * dmu_buf_impl_t and dmu_buf_t? 1431ea8dc4b6Seschrock */ 1432ea8dc4b6Seschrock 1433fa9e4066Sahrens /* 1434fa9e4066Sahrens * If this txg already synced, there's nothing to do. 1435fa9e4066Sahrens */ 1436fa9e4066Sahrens if (txg <= tx->tx_synced_txg) { 1437fa9e4066Sahrens /* 1438fa9e4066Sahrens * If we're running ziltest, we need the blkptr regardless. 1439fa9e4066Sahrens */ 1440fa9e4066Sahrens if (txg > spa_freeze_txg(dp->dp_spa)) { 1441ea8dc4b6Seschrock err = dmu_buf_hold(os, object, offset, 1442ea8dc4b6Seschrock FTAG, (dmu_buf_t **)&db); 1443ea8dc4b6Seschrock if (err) 1444ea8dc4b6Seschrock return (err); 1445fa9e4066Sahrens /* if db_blkptr == NULL, this was an empty write */ 1446fa9e4066Sahrens if (db->db_blkptr) 1447fa9e4066Sahrens *bp = *db->db_blkptr; /* structure assignment */ 1448fa9e4066Sahrens else 1449fa9e4066Sahrens bzero(bp, sizeof (blkptr_t)); 1450fa9e4066Sahrens *blkoff = offset - db->db.db_offset; 1451fa9e4066Sahrens ASSERT3U(*blkoff, <, db->db.db_size); 1452ea8dc4b6Seschrock dmu_buf_rele((dmu_buf_t *)db, FTAG); 1453fa9e4066Sahrens return (0); 1454fa9e4066Sahrens } 1455fa9e4066Sahrens return (EALREADY); 1456fa9e4066Sahrens } 1457fa9e4066Sahrens 1458fa9e4066Sahrens /* 1459fa9e4066Sahrens * If this txg is in the middle of syncing, just wait for it. 1460fa9e4066Sahrens */ 1461fa9e4066Sahrens if (txg == tx->tx_syncing_txg) { 1462fa9e4066Sahrens ASSERT(txg != tx->tx_open_txg); 1463fa9e4066Sahrens return (EINPROGRESS); 1464fa9e4066Sahrens } 1465fa9e4066Sahrens 1466ea8dc4b6Seschrock err = dmu_buf_hold(os, object, offset, FTAG, (dmu_buf_t **)&db); 1467ea8dc4b6Seschrock if (err) 1468ea8dc4b6Seschrock return (err); 1469fa9e4066Sahrens 1470fa9e4066Sahrens mutex_enter(&db->db_mtx); 1471fa9e4066Sahrens 1472fa9e4066Sahrens /* 1473fa9e4066Sahrens * If this dbuf isn't dirty, must have been free_range'd. 1474fa9e4066Sahrens * There's no need to log writes to freed blocks, so we're done. 1475fa9e4066Sahrens */ 1476fa9e4066Sahrens if (!list_link_active(&db->db_dirty_node[txg&TXG_MASK])) { 1477fa9e4066Sahrens mutex_exit(&db->db_mtx); 1478ea8dc4b6Seschrock dmu_buf_rele((dmu_buf_t *)db, FTAG); 1479fa9e4066Sahrens return (ENOENT); 1480fa9e4066Sahrens } 1481fa9e4066Sahrens 1482fa9e4066Sahrens blk = db->db_d.db_overridden_by[txg&TXG_MASK]; 1483fa9e4066Sahrens 1484fa9e4066Sahrens /* 1485fa9e4066Sahrens * If we already did a dmu_sync() of this dbuf in this txg, 1486fa9e4066Sahrens * free the old block before writing the new one. 1487fa9e4066Sahrens */ 1488fa9e4066Sahrens if (blk != NULL) { 1489fa9e4066Sahrens ASSERT(blk != IN_DMU_SYNC); 1490fa9e4066Sahrens if (blk == IN_DMU_SYNC) { 1491fa9e4066Sahrens mutex_exit(&db->db_mtx); 1492ea8dc4b6Seschrock dmu_buf_rele((dmu_buf_t *)db, FTAG); 1493fa9e4066Sahrens return (EBUSY); 1494fa9e4066Sahrens } 1495fa9e4066Sahrens arc_release(db->db_d.db_data_old[txg&TXG_MASK], db); 1496fa9e4066Sahrens if (!BP_IS_HOLE(blk)) { 149744cd46caSbillm (void) arc_free(NULL, osi->os_spa, txg, blk, 1498fa9e4066Sahrens NULL, NULL, ARC_WAIT); 1499fa9e4066Sahrens } 1500fa9e4066Sahrens kmem_free(blk, sizeof (blkptr_t)); 1501fa9e4066Sahrens } 1502fa9e4066Sahrens 1503fa9e4066Sahrens db->db_d.db_overridden_by[txg&TXG_MASK] = IN_DMU_SYNC; 1504fa9e4066Sahrens mutex_exit(&db->db_mtx); 1505fa9e4066Sahrens 1506fa9e4066Sahrens blk = kmem_alloc(sizeof (blkptr_t), KM_SLEEP); 1507fa9e4066Sahrens blk->blk_birth = 0; /* mark as invalid */ 1508fa9e4066Sahrens 150944cd46caSbillm zb.zb_objset = osi->os_dsl_dataset->ds_object; 1510ea8dc4b6Seschrock zb.zb_object = db->db.db_object; 1511ea8dc4b6Seschrock zb.zb_level = db->db_level; 1512ea8dc4b6Seschrock zb.zb_blkid = db->db_blkid; 151344cd46caSbillm err = arc_write(NULL, osi->os_spa, 151444cd46caSbillm zio_checksum_select(db->db_dnode->dn_checksum, osi->os_checksum), 151544cd46caSbillm zio_compress_select(db->db_dnode->dn_compress, osi->os_compress), 151644cd46caSbillm dmu_get_replication_level(osi->os_spa, &zb, db->db_dnode->dn_type), 1517fa9e4066Sahrens txg, blk, db->db_d.db_data_old[txg&TXG_MASK], NULL, NULL, 1518ea8dc4b6Seschrock ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_MUSTSUCCEED, ARC_WAIT, &zb); 1519fa9e4066Sahrens ASSERT(err == 0); 1520fa9e4066Sahrens 1521fa9e4066Sahrens if (!BP_IS_HOLE(blk)) { 1522fa9e4066Sahrens blk->blk_fill = 1; 1523fa9e4066Sahrens BP_SET_TYPE(blk, db->db_dnode->dn_type); 1524fa9e4066Sahrens BP_SET_LEVEL(blk, 0); 1525fa9e4066Sahrens } 1526fa9e4066Sahrens 1527fa9e4066Sahrens /* copy the block pointer back to caller */ 1528fa9e4066Sahrens *bp = *blk; /* structure assignment */ 1529fa9e4066Sahrens *blkoff = offset - db->db.db_offset; 1530fa9e4066Sahrens ASSERT3U(*blkoff, <, db->db.db_size); 1531fa9e4066Sahrens 1532fa9e4066Sahrens mutex_enter(&db->db_mtx); 1533fa9e4066Sahrens if (db->db_d.db_overridden_by[txg&TXG_MASK] != IN_DMU_SYNC) { 1534fa9e4066Sahrens /* we were dirtied/freed during the sync */ 1535fa9e4066Sahrens ASSERT3P(db->db_d.db_overridden_by[txg&TXG_MASK], ==, NULL); 1536fa9e4066Sahrens arc_release(db->db_d.db_data_old[txg&TXG_MASK], db); 1537fa9e4066Sahrens mutex_exit(&db->db_mtx); 1538ea8dc4b6Seschrock dmu_buf_rele((dmu_buf_t *)db, FTAG); 1539fa9e4066Sahrens /* Note that this block does not free on disk until txg syncs */ 1540fa9e4066Sahrens 1541fa9e4066Sahrens /* 1542fa9e4066Sahrens * XXX can we use ARC_NOWAIT here? 1543fa9e4066Sahrens * XXX should we be ignoring the return code? 1544fa9e4066Sahrens */ 1545fa9e4066Sahrens if (!BP_IS_HOLE(blk)) { 154644cd46caSbillm (void) arc_free(NULL, osi->os_spa, txg, blk, 1547fa9e4066Sahrens NULL, NULL, ARC_WAIT); 1548fa9e4066Sahrens } 1549fa9e4066Sahrens kmem_free(blk, sizeof (blkptr_t)); 1550fa9e4066Sahrens return (ESTALE); 1551fa9e4066Sahrens } 1552fa9e4066Sahrens 1553fa9e4066Sahrens db->db_d.db_overridden_by[txg&TXG_MASK] = blk; 1554fa9e4066Sahrens mutex_exit(&db->db_mtx); 1555ea8dc4b6Seschrock dmu_buf_rele((dmu_buf_t *)db, FTAG); 1556fa9e4066Sahrens ASSERT3U(txg, >, tx->tx_syncing_txg); 1557fa9e4066Sahrens return (0); 1558fa9e4066Sahrens } 1559fa9e4066Sahrens 1560fa9e4066Sahrens uint64_t 1561fa9e4066Sahrens dmu_object_max_nonzero_offset(objset_t *os, uint64_t object) 1562fa9e4066Sahrens { 1563ea8dc4b6Seschrock dnode_t *dn; 1564ea8dc4b6Seschrock 1565ea8dc4b6Seschrock /* XXX assumes dnode_hold will not get an i/o error */ 1566ea8dc4b6Seschrock (void) dnode_hold(os->os, object, FTAG, &dn); 1567fa9e4066Sahrens uint64_t rv = dnode_max_nonzero_offset(dn); 1568fa9e4066Sahrens dnode_rele(dn, FTAG); 1569fa9e4066Sahrens return (rv); 1570fa9e4066Sahrens } 1571fa9e4066Sahrens 1572fa9e4066Sahrens int 1573fa9e4066Sahrens dmu_object_set_blocksize(objset_t *os, uint64_t object, uint64_t size, int ibs, 1574fa9e4066Sahrens dmu_tx_t *tx) 1575fa9e4066Sahrens { 1576ea8dc4b6Seschrock dnode_t *dn; 1577ea8dc4b6Seschrock int err; 1578ea8dc4b6Seschrock 1579ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 1580ea8dc4b6Seschrock if (err) 1581ea8dc4b6Seschrock return (err); 1582ea8dc4b6Seschrock err = dnode_set_blksz(dn, size, ibs, tx); 1583fa9e4066Sahrens dnode_rele(dn, FTAG); 1584fa9e4066Sahrens return (err); 1585fa9e4066Sahrens } 1586fa9e4066Sahrens 1587fa9e4066Sahrens void 1588fa9e4066Sahrens dmu_object_set_checksum(objset_t *os, uint64_t object, uint8_t checksum, 1589fa9e4066Sahrens dmu_tx_t *tx) 1590fa9e4066Sahrens { 1591ea8dc4b6Seschrock dnode_t *dn; 1592ea8dc4b6Seschrock 1593ea8dc4b6Seschrock /* XXX assumes dnode_hold will not get an i/o error */ 1594ea8dc4b6Seschrock (void) dnode_hold(os->os, object, FTAG, &dn); 1595fa9e4066Sahrens ASSERT(checksum < ZIO_CHECKSUM_FUNCTIONS); 1596fa9e4066Sahrens dn->dn_checksum = checksum; 1597fa9e4066Sahrens dnode_setdirty(dn, tx); 1598fa9e4066Sahrens dnode_rele(dn, FTAG); 1599fa9e4066Sahrens } 1600fa9e4066Sahrens 1601fa9e4066Sahrens void 1602fa9e4066Sahrens dmu_object_set_compress(objset_t *os, uint64_t object, uint8_t compress, 1603fa9e4066Sahrens dmu_tx_t *tx) 1604fa9e4066Sahrens { 1605ea8dc4b6Seschrock dnode_t *dn; 1606ea8dc4b6Seschrock 1607ea8dc4b6Seschrock /* XXX assumes dnode_hold will not get an i/o error */ 1608ea8dc4b6Seschrock (void) dnode_hold(os->os, object, FTAG, &dn); 1609fa9e4066Sahrens ASSERT(compress < ZIO_COMPRESS_FUNCTIONS); 1610fa9e4066Sahrens dn->dn_compress = compress; 1611fa9e4066Sahrens dnode_setdirty(dn, tx); 1612fa9e4066Sahrens dnode_rele(dn, FTAG); 1613fa9e4066Sahrens } 1614fa9e4066Sahrens 161544cd46caSbillm /* 161644cd46caSbillm * XXX - eventually, this should take into account per-dataset (or 161744cd46caSbillm * even per-object?) user requests for higher levels of replication. 161844cd46caSbillm */ 161944cd46caSbillm int 162044cd46caSbillm dmu_get_replication_level(spa_t *spa, zbookmark_t *zb, dmu_object_type_t ot) 162144cd46caSbillm { 162244cd46caSbillm int ncopies = 1; 162344cd46caSbillm 162444cd46caSbillm if (dmu_ot[ot].ot_metadata) 162544cd46caSbillm ncopies++; 162644cd46caSbillm if (zb->zb_level != 0) 162744cd46caSbillm ncopies++; 162844cd46caSbillm if (zb->zb_objset == 0 && zb->zb_object == 0) 162944cd46caSbillm ncopies++; 163044cd46caSbillm return (MIN(ncopies, spa_max_replication(spa))); 163144cd46caSbillm } 163244cd46caSbillm 1633fa9e4066Sahrens int 1634fa9e4066Sahrens dmu_offset_next(objset_t *os, uint64_t object, boolean_t hole, uint64_t *off) 1635fa9e4066Sahrens { 1636fa9e4066Sahrens dnode_t *dn; 1637fa9e4066Sahrens int i, err; 1638fa9e4066Sahrens 1639ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 1640ea8dc4b6Seschrock if (err) 1641ea8dc4b6Seschrock return (err); 1642fa9e4066Sahrens /* 1643fa9e4066Sahrens * Sync any current changes before 1644fa9e4066Sahrens * we go trundling through the block pointers. 1645fa9e4066Sahrens */ 1646fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++) { 1647c543ec06Sahrens if (list_link_active(&dn->dn_dirty_link[i])) 1648fa9e4066Sahrens break; 1649fa9e4066Sahrens } 1650fa9e4066Sahrens if (i != TXG_SIZE) { 1651fa9e4066Sahrens dnode_rele(dn, FTAG); 1652fa9e4066Sahrens txg_wait_synced(dmu_objset_pool(os), 0); 1653ea8dc4b6Seschrock err = dnode_hold(os->os, object, FTAG, &dn); 1654ea8dc4b6Seschrock if (err) 1655ea8dc4b6Seschrock return (err); 1656fa9e4066Sahrens } 1657fa9e4066Sahrens 1658fa9e4066Sahrens err = dnode_next_offset(dn, hole, off, 1, 1); 1659fa9e4066Sahrens dnode_rele(dn, FTAG); 1660fa9e4066Sahrens 1661fa9e4066Sahrens return (err); 1662fa9e4066Sahrens } 1663fa9e4066Sahrens 1664fa9e4066Sahrens void 1665fa9e4066Sahrens dmu_object_info_from_dnode(dnode_t *dn, dmu_object_info_t *doi) 1666fa9e4066Sahrens { 1667fa9e4066Sahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 1668fa9e4066Sahrens mutex_enter(&dn->dn_mtx); 1669fa9e4066Sahrens 1670fa9e4066Sahrens doi->doi_data_block_size = dn->dn_datablksz; 1671fa9e4066Sahrens doi->doi_metadata_block_size = dn->dn_indblkshift ? 1672fa9e4066Sahrens 1ULL << dn->dn_indblkshift : 0; 1673fa9e4066Sahrens doi->doi_indirection = dn->dn_nlevels; 1674fa9e4066Sahrens doi->doi_checksum = dn->dn_checksum; 1675fa9e4066Sahrens doi->doi_compress = dn->dn_compress; 167699653d4eSeschrock doi->doi_physical_blks = (DN_USED_BYTES(dn->dn_phys) + 167799653d4eSeschrock SPA_MINBLOCKSIZE/2) >> SPA_MINBLOCKSHIFT; 1678fa9e4066Sahrens doi->doi_max_block_offset = dn->dn_phys->dn_maxblkid; 1679fa9e4066Sahrens doi->doi_type = dn->dn_type; 1680fa9e4066Sahrens doi->doi_bonus_size = dn->dn_bonuslen; 1681fa9e4066Sahrens doi->doi_bonus_type = dn->dn_bonustype; 1682fa9e4066Sahrens 1683fa9e4066Sahrens mutex_exit(&dn->dn_mtx); 1684fa9e4066Sahrens rw_exit(&dn->dn_struct_rwlock); 1685fa9e4066Sahrens } 1686fa9e4066Sahrens 1687fa9e4066Sahrens /* 1688fa9e4066Sahrens * Get information on a DMU object. 1689fa9e4066Sahrens * If doi is NULL, just indicates whether the object exists. 1690fa9e4066Sahrens */ 1691fa9e4066Sahrens int 1692fa9e4066Sahrens dmu_object_info(objset_t *os, uint64_t object, dmu_object_info_t *doi) 1693fa9e4066Sahrens { 1694ea8dc4b6Seschrock dnode_t *dn; 1695ea8dc4b6Seschrock int err = dnode_hold(os->os, object, FTAG, &dn); 1696fa9e4066Sahrens 1697ea8dc4b6Seschrock if (err) 1698ea8dc4b6Seschrock return (err); 1699fa9e4066Sahrens 1700fa9e4066Sahrens if (doi != NULL) 1701fa9e4066Sahrens dmu_object_info_from_dnode(dn, doi); 1702fa9e4066Sahrens 1703fa9e4066Sahrens dnode_rele(dn, FTAG); 1704fa9e4066Sahrens return (0); 1705fa9e4066Sahrens } 1706fa9e4066Sahrens 1707fa9e4066Sahrens /* 1708fa9e4066Sahrens * As above, but faster; can be used when you have a held dbuf in hand. 1709fa9e4066Sahrens */ 1710fa9e4066Sahrens void 1711fa9e4066Sahrens dmu_object_info_from_db(dmu_buf_t *db, dmu_object_info_t *doi) 1712fa9e4066Sahrens { 1713fa9e4066Sahrens dmu_object_info_from_dnode(((dmu_buf_impl_t *)db)->db_dnode, doi); 1714fa9e4066Sahrens } 1715fa9e4066Sahrens 1716fa9e4066Sahrens /* 1717fa9e4066Sahrens * Faster still when you only care about the size. 1718fa9e4066Sahrens * This is specifically optimized for zfs_getattr(). 1719fa9e4066Sahrens */ 1720fa9e4066Sahrens void 1721fa9e4066Sahrens dmu_object_size_from_db(dmu_buf_t *db, uint32_t *blksize, u_longlong_t *nblk512) 1722fa9e4066Sahrens { 1723fa9e4066Sahrens dnode_t *dn = ((dmu_buf_impl_t *)db)->db_dnode; 1724fa9e4066Sahrens 1725fa9e4066Sahrens *blksize = dn->dn_datablksz; 172699653d4eSeschrock /* add 1 for dnode space */ 172799653d4eSeschrock *nblk512 = ((DN_USED_BYTES(dn->dn_phys) + SPA_MINBLOCKSIZE/2) >> 172899653d4eSeschrock SPA_MINBLOCKSHIFT) + 1; 1729fa9e4066Sahrens } 1730fa9e4066Sahrens 1731ea8dc4b6Seschrock /* 1732ea8dc4b6Seschrock * Given a bookmark, return the name of the dataset, object, and range in 1733ea8dc4b6Seschrock * human-readable format. 1734ea8dc4b6Seschrock */ 1735ea8dc4b6Seschrock int 1736ea8dc4b6Seschrock spa_bookmark_name(spa_t *spa, zbookmark_t *zb, char *dsname, size_t dslen, 1737ea8dc4b6Seschrock char *objname, size_t objlen, char *range, size_t rangelen) 1738ea8dc4b6Seschrock { 1739ea8dc4b6Seschrock dsl_pool_t *dp; 1740ea8dc4b6Seschrock dsl_dataset_t *ds = NULL; 1741ea8dc4b6Seschrock objset_t *os = NULL; 1742ea8dc4b6Seschrock dnode_t *dn = NULL; 1743ea8dc4b6Seschrock int err, shift; 1744ea8dc4b6Seschrock 1745ea8dc4b6Seschrock if (dslen < MAXNAMELEN || objlen < 32 || rangelen < 64) 1746ea8dc4b6Seschrock return (ENOSPC); 1747ea8dc4b6Seschrock 1748ea8dc4b6Seschrock dp = spa_get_dsl(spa); 1749ea8dc4b6Seschrock if (zb->zb_objset != 0) { 1750ea8dc4b6Seschrock rw_enter(&dp->dp_config_rwlock, RW_READER); 1751ea8dc4b6Seschrock err = dsl_dataset_open_obj(dp, zb->zb_objset, 1752ea8dc4b6Seschrock NULL, DS_MODE_NONE, FTAG, &ds); 1753ea8dc4b6Seschrock if (err) { 1754ea8dc4b6Seschrock rw_exit(&dp->dp_config_rwlock); 1755ea8dc4b6Seschrock return (err); 1756ea8dc4b6Seschrock } 1757ea8dc4b6Seschrock dsl_dataset_name(ds, dsname); 1758ea8dc4b6Seschrock dsl_dataset_close(ds, DS_MODE_NONE, FTAG); 1759ea8dc4b6Seschrock rw_exit(&dp->dp_config_rwlock); 1760ea8dc4b6Seschrock 1761ea8dc4b6Seschrock err = dmu_objset_open(dsname, DMU_OST_ANY, DS_MODE_NONE, &os); 1762ea8dc4b6Seschrock if (err) 1763ea8dc4b6Seschrock goto out; 1764ea8dc4b6Seschrock 1765ea8dc4b6Seschrock } else { 1766ea8dc4b6Seschrock dsl_dataset_name(NULL, dsname); 1767ea8dc4b6Seschrock os = dp->dp_meta_objset; 1768ea8dc4b6Seschrock } 1769ea8dc4b6Seschrock 1770ea8dc4b6Seschrock 1771ea8dc4b6Seschrock if (zb->zb_object == DMU_META_DNODE_OBJECT) { 1772ea8dc4b6Seschrock (void) strncpy(objname, "mdn", objlen); 1773ea8dc4b6Seschrock } else { 1774ea8dc4b6Seschrock (void) snprintf(objname, objlen, "%lld", 1775ea8dc4b6Seschrock (longlong_t)zb->zb_object); 1776ea8dc4b6Seschrock } 1777ea8dc4b6Seschrock 1778ea8dc4b6Seschrock err = dnode_hold(os->os, zb->zb_object, FTAG, &dn); 1779ea8dc4b6Seschrock if (err) 1780ea8dc4b6Seschrock goto out; 1781ea8dc4b6Seschrock 1782ea8dc4b6Seschrock shift = (dn->dn_datablkshift?dn->dn_datablkshift:SPA_MAXBLOCKSHIFT) + 1783ea8dc4b6Seschrock zb->zb_level * (dn->dn_indblkshift - SPA_BLKPTRSHIFT); 1784ea8dc4b6Seschrock (void) snprintf(range, rangelen, "%llu-%llu", 1785ea8dc4b6Seschrock (u_longlong_t)(zb->zb_blkid << shift), 1786ea8dc4b6Seschrock (u_longlong_t)((zb->zb_blkid+1) << shift)); 1787ea8dc4b6Seschrock 1788ea8dc4b6Seschrock out: 1789ea8dc4b6Seschrock if (dn) 1790ea8dc4b6Seschrock dnode_rele(dn, FTAG); 1791ea8dc4b6Seschrock if (os && os != dp->dp_meta_objset) 1792ea8dc4b6Seschrock dmu_objset_close(os); 1793ea8dc4b6Seschrock return (err); 1794ea8dc4b6Seschrock } 1795ea8dc4b6Seschrock 1796fa9e4066Sahrens void 1797fa9e4066Sahrens byteswap_uint64_array(void *vbuf, size_t size) 1798fa9e4066Sahrens { 1799fa9e4066Sahrens uint64_t *buf = vbuf; 1800fa9e4066Sahrens size_t count = size >> 3; 1801fa9e4066Sahrens int i; 1802fa9e4066Sahrens 1803fa9e4066Sahrens ASSERT((size & 7) == 0); 1804fa9e4066Sahrens 1805fa9e4066Sahrens for (i = 0; i < count; i++) 1806fa9e4066Sahrens buf[i] = BSWAP_64(buf[i]); 1807fa9e4066Sahrens } 1808fa9e4066Sahrens 1809fa9e4066Sahrens void 1810fa9e4066Sahrens byteswap_uint32_array(void *vbuf, size_t size) 1811fa9e4066Sahrens { 1812fa9e4066Sahrens uint32_t *buf = vbuf; 1813fa9e4066Sahrens size_t count = size >> 2; 1814fa9e4066Sahrens int i; 1815fa9e4066Sahrens 1816fa9e4066Sahrens ASSERT((size & 3) == 0); 1817fa9e4066Sahrens 1818fa9e4066Sahrens for (i = 0; i < count; i++) 1819fa9e4066Sahrens buf[i] = BSWAP_32(buf[i]); 1820fa9e4066Sahrens } 1821fa9e4066Sahrens 1822fa9e4066Sahrens void 1823fa9e4066Sahrens byteswap_uint16_array(void *vbuf, size_t size) 1824fa9e4066Sahrens { 1825fa9e4066Sahrens uint16_t *buf = vbuf; 1826fa9e4066Sahrens size_t count = size >> 1; 1827fa9e4066Sahrens int i; 1828fa9e4066Sahrens 1829fa9e4066Sahrens ASSERT((size & 1) == 0); 1830fa9e4066Sahrens 1831fa9e4066Sahrens for (i = 0; i < count; i++) 1832fa9e4066Sahrens buf[i] = BSWAP_16(buf[i]); 1833fa9e4066Sahrens } 1834fa9e4066Sahrens 1835fa9e4066Sahrens /* ARGSUSED */ 1836fa9e4066Sahrens void 1837fa9e4066Sahrens byteswap_uint8_array(void *vbuf, size_t size) 1838fa9e4066Sahrens { 1839fa9e4066Sahrens } 1840fa9e4066Sahrens 1841fa9e4066Sahrens void 1842fa9e4066Sahrens dmu_init(void) 1843fa9e4066Sahrens { 1844fa9e4066Sahrens dbuf_init(); 1845fa9e4066Sahrens dnode_init(); 1846fa9e4066Sahrens arc_init(); 1847fa9e4066Sahrens } 1848fa9e4066Sahrens 1849fa9e4066Sahrens void 1850fa9e4066Sahrens dmu_fini(void) 1851fa9e4066Sahrens { 1852fa9e4066Sahrens arc_fini(); 1853fa9e4066Sahrens dnode_fini(); 1854fa9e4066Sahrens dbuf_fini(); 1855fa9e4066Sahrens } 1856