1 789 ahrens /* 2 789 ahrens * CDDL HEADER START 3 789 ahrens * 4 789 ahrens * The contents of this file are subject to the terms of the 5 1544 eschrock * Common Development and Distribution License (the "License"). 6 1544 eschrock * You may not use this file except in compliance with the License. 7 789 ahrens * 8 789 ahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 789 ahrens * or http://www.opensolaris.org/os/licensing. 10 789 ahrens * See the License for the specific language governing permissions 11 789 ahrens * and limitations under the License. 12 789 ahrens * 13 789 ahrens * When distributing Covered Code, include this CDDL HEADER in each 14 789 ahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 789 ahrens * If applicable, add the following below this CDDL HEADER, with the 16 789 ahrens * fields enclosed by brackets "[]" replaced with your own identifying 17 789 ahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18 789 ahrens * 19 789 ahrens * CDDL HEADER END 20 789 ahrens */ 21 789 ahrens /* 22 9396 Matthew * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 789 ahrens * Use is subject to license terms. 24 789 ahrens */ 25 789 ahrens 26 789 ahrens #include <sys/dmu.h> 27 789 ahrens #include <sys/dmu_impl.h> 28 789 ahrens #include <sys/dmu_tx.h> 29 789 ahrens #include <sys/dbuf.h> 30 789 ahrens #include <sys/dnode.h> 31 789 ahrens #include <sys/zfs_context.h> 32 789 ahrens #include <sys/dmu_objset.h> 33 789 ahrens #include <sys/dmu_traverse.h> 34 789 ahrens #include <sys/dsl_dataset.h> 35 789 ahrens #include <sys/dsl_dir.h> 36 789 ahrens #include <sys/dsl_pool.h> 37 2199 ahrens #include <sys/dsl_synctask.h> 38 2885 ahrens #include <sys/dsl_prop.h> 39 789 ahrens #include <sys/dmu_zfetch.h> 40 789 ahrens #include <sys/zfs_ioctl.h> 41 789 ahrens #include <sys/zap.h> 42 1544 eschrock #include <sys/zio_checksum.h> 43 2688 maybee #ifdef _KERNEL 44 2688 maybee #include <sys/vmsystm.h> 45 7315 Jonathan #include <sys/zfs_znode.h> 46 2688 maybee #endif 47 789 ahrens 48 789 ahrens const dmu_object_type_info_t dmu_ot[DMU_OT_NUMTYPES] = { 49 789 ahrens { byteswap_uint8_array, TRUE, "unallocated" }, 50 789 ahrens { zap_byteswap, TRUE, "object directory" }, 51 789 ahrens { byteswap_uint64_array, TRUE, "object array" }, 52 789 ahrens { byteswap_uint8_array, TRUE, "packed nvlist" }, 53 789 ahrens { byteswap_uint64_array, TRUE, "packed nvlist size" }, 54 789 ahrens { byteswap_uint64_array, TRUE, "bplist" }, 55 789 ahrens { byteswap_uint64_array, TRUE, "bplist header" }, 56 789 ahrens { byteswap_uint64_array, TRUE, "SPA space map header" }, 57 789 ahrens { byteswap_uint64_array, TRUE, "SPA space map" }, 58 789 ahrens { byteswap_uint64_array, TRUE, "ZIL intent log" }, 59 789 ahrens { dnode_buf_byteswap, TRUE, "DMU dnode" }, 60 789 ahrens { dmu_objset_byteswap, TRUE, "DMU objset" }, 61 789 ahrens { byteswap_uint64_array, TRUE, "DSL directory" }, 62 789 ahrens { zap_byteswap, TRUE, "DSL directory child map"}, 63 789 ahrens { zap_byteswap, TRUE, "DSL dataset snap map" }, 64 789 ahrens { zap_byteswap, TRUE, "DSL props" }, 65 789 ahrens { byteswap_uint64_array, TRUE, "DSL dataset" }, 66 789 ahrens { zfs_znode_byteswap, TRUE, "ZFS znode" }, 67 5331 amw { zfs_oldacl_byteswap, TRUE, "ZFS V0 ACL" }, 68 789 ahrens { byteswap_uint8_array, FALSE, "ZFS plain file" }, 69 789 ahrens { zap_byteswap, TRUE, "ZFS directory" }, 70 789 ahrens { zap_byteswap, TRUE, "ZFS master node" }, 71 789 ahrens { zap_byteswap, TRUE, "ZFS delete queue" }, 72 789 ahrens { byteswap_uint8_array, FALSE, "zvol object" }, 73 789 ahrens { zap_byteswap, TRUE, "zvol prop" }, 74 789 ahrens { byteswap_uint8_array, FALSE, "other uint8[]" }, 75 789 ahrens { byteswap_uint64_array, FALSE, "other uint64[]" }, 76 789 ahrens { zap_byteswap, TRUE, "other ZAP" }, 77 1544 eschrock { zap_byteswap, TRUE, "persistent error log" }, 78 2926 ek110237 { byteswap_uint8_array, TRUE, "SPA history" }, 79 2926 ek110237 { byteswap_uint64_array, TRUE, "SPA history offsets" }, 80 4543 marks { zap_byteswap, TRUE, "Pool properties" }, 81 5331 amw { zap_byteswap, TRUE, "DSL permissions" }, 82 5331 amw { zfs_acl_byteswap, TRUE, "ZFS ACL" }, 83 5331 amw { byteswap_uint8_array, TRUE, "ZFS SYSACL" }, 84 5331 amw { byteswap_uint8_array, TRUE, "FUID table" }, 85 5339 marks { byteswap_uint64_array, TRUE, "FUID table size" }, 86 7046 ahrens { zap_byteswap, TRUE, "DSL dataset next clones"}, 87 7046 ahrens { zap_byteswap, TRUE, "scrub work queue" }, 88 9396 Matthew { zap_byteswap, TRUE, "ZFS user/group used" }, 89 9396 Matthew { zap_byteswap, TRUE, "ZFS user/group quota" }, 90 10242 chris { zap_byteswap, TRUE, "snapshot refcount tags"}, 91 10922 Jeff { zap_byteswap, TRUE, "DDT ZAP algorithm" }, 92 10922 Jeff { zap_byteswap, TRUE, "DDT statistics" }, 93 789 ahrens }; 94 789 ahrens 95 789 ahrens int 96 1544 eschrock dmu_buf_hold(objset_t *os, uint64_t object, uint64_t offset, 97 1544 eschrock void *tag, dmu_buf_t **dbp) 98 789 ahrens { 99 789 ahrens dnode_t *dn; 100 789 ahrens uint64_t blkid; 101 789 ahrens dmu_buf_impl_t *db; 102 1544 eschrock int err; 103 789 ahrens 104 10298 Matthew err = dnode_hold(os, object, FTAG, &dn); 105 1544 eschrock if (err) 106 1544 eschrock return (err); 107 789 ahrens blkid = dbuf_whichblock(dn, offset); 108 789 ahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 109 1544 eschrock db = dbuf_hold(dn, blkid, tag); 110 789 ahrens rw_exit(&dn->dn_struct_rwlock); 111 1544 eschrock if (db == NULL) { 112 1544 eschrock err = EIO; 113 1544 eschrock } else { 114 1544 eschrock err = dbuf_read(db, NULL, DB_RF_CANFAIL); 115 1544 eschrock if (err) { 116 1544 eschrock dbuf_rele(db, tag); 117 1544 eschrock db = NULL; 118 1544 eschrock } 119 1544 eschrock } 120 1544 eschrock 121 789 ahrens dnode_rele(dn, FTAG); 122 1544 eschrock *dbp = &db->db; 123 1544 eschrock return (err); 124 789 ahrens } 125 789 ahrens 126 789 ahrens int 127 789 ahrens dmu_bonus_max(void) 128 789 ahrens { 129 789 ahrens return (DN_MAX_BONUSLEN); 130 789 ahrens } 131 789 ahrens 132 4944 maybee int 133 4944 maybee dmu_set_bonus(dmu_buf_t *db, int newsize, dmu_tx_t *tx) 134 4944 maybee { 135 4944 maybee dnode_t *dn = ((dmu_buf_impl_t *)db)->db_dnode; 136 4944 maybee 137 4944 maybee if (dn->dn_bonus != (dmu_buf_impl_t *)db) 138 4944 maybee return (EINVAL); 139 4944 maybee if (newsize < 0 || newsize > db->db_size) 140 4944 maybee return (EINVAL); 141 4944 maybee dnode_setbonuslen(dn, newsize, tx); 142 4944 maybee return (0); 143 4944 maybee } 144 4944 maybee 145 789 ahrens /* 146 1544 eschrock * returns ENOENT, EIO, or 0. 147 789 ahrens */ 148 1544 eschrock int 149 1544 eschrock dmu_bonus_hold(objset_t *os, uint64_t object, void *tag, dmu_buf_t **dbp) 150 789 ahrens { 151 1544 eschrock dnode_t *dn; 152 789 ahrens dmu_buf_impl_t *db; 153 4944 maybee int error; 154 789 ahrens 155 10298 Matthew error = dnode_hold(os, object, FTAG, &dn); 156 4944 maybee if (error) 157 4944 maybee return (error); 158 789 ahrens 159 1544 eschrock rw_enter(&dn->dn_struct_rwlock, RW_READER); 160 1544 eschrock if (dn->dn_bonus == NULL) { 161 789 ahrens rw_exit(&dn->dn_struct_rwlock); 162 1544 eschrock rw_enter(&dn->dn_struct_rwlock, RW_WRITER); 163 1544 eschrock if (dn->dn_bonus == NULL) 164 4944 maybee dbuf_create_bonus(dn); 165 789 ahrens } 166 1544 eschrock db = dn->dn_bonus; 167 1544 eschrock rw_exit(&dn->dn_struct_rwlock); 168 4944 maybee 169 4944 maybee /* as long as the bonus buf is held, the dnode will be held */ 170 4944 maybee if (refcount_add(&db->db_holds, tag) == 1) 171 4944 maybee VERIFY(dnode_add_ref(dn, db)); 172 4944 maybee 173 789 ahrens dnode_rele(dn, FTAG); 174 1544 eschrock 175 1544 eschrock VERIFY(0 == dbuf_read(db, NULL, DB_RF_MUST_SUCCEED)); 176 1544 eschrock 177 1544 eschrock *dbp = &db->db; 178 1544 eschrock return (0); 179 789 ahrens } 180 789 ahrens 181 2391 maybee /* 182 2391 maybee * Note: longer-term, we should modify all of the dmu_buf_*() interfaces 183 2391 maybee * to take a held dnode rather than <os, object> -- the lookup is wasteful, 184 2391 maybee * and can induce severe lock contention when writing to several files 185 2391 maybee * whose dnodes are in the same block. 186 2391 maybee */ 187 2391 maybee static int 188 9512 Neil dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset, uint64_t length, 189 9512 Neil int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp, uint32_t flags) 190 789 ahrens { 191 7468 Mark dsl_pool_t *dp = NULL; 192 789 ahrens dmu_buf_t **dbp; 193 789 ahrens uint64_t blkid, nblks, i; 194 9512 Neil uint32_t dbuf_flags; 195 1544 eschrock int err; 196 1544 eschrock zio_t *zio; 197 7468 Mark hrtime_t start; 198 1544 eschrock 199 1544 eschrock ASSERT(length <= DMU_MAX_ACCESS); 200 789 ahrens 201 10209 Mark dbuf_flags = DB_RF_CANFAIL | DB_RF_NEVERWAIT | DB_RF_HAVESTRUCT; 202 9512 Neil if (flags & DMU_READ_NO_PREFETCH || length > zfetch_array_rd_sz) 203 9512 Neil dbuf_flags |= DB_RF_NOPREFETCH; 204 789 ahrens 205 789 ahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 206 789 ahrens if (dn->dn_datablkshift) { 207 789 ahrens int blkshift = dn->dn_datablkshift; 208 789 ahrens nblks = (P2ROUNDUP(offset+length, 1ULL<<blkshift) - 209 3912 lling P2ALIGN(offset, 1ULL<<blkshift)) >> blkshift; 210 789 ahrens } else { 211 3713 ahrens if (offset + length > dn->dn_datablksz) { 212 3713 ahrens zfs_panic_recover("zfs: accessing past end of object " 213 3713 ahrens "%llx/%llx (size=%u access=%llu+%llu)", 214 3713 ahrens (longlong_t)dn->dn_objset-> 215 3713 ahrens os_dsl_dataset->ds_object, 216 3713 ahrens (longlong_t)dn->dn_object, dn->dn_datablksz, 217 3713 ahrens (longlong_t)offset, (longlong_t)length); 218 10209 Mark rw_exit(&dn->dn_struct_rwlock); 219 3713 ahrens return (EIO); 220 3713 ahrens } 221 789 ahrens nblks = 1; 222 789 ahrens } 223 1544 eschrock dbp = kmem_zalloc(sizeof (dmu_buf_t *) * nblks, KM_SLEEP); 224 789 ahrens 225 7468 Mark if (dn->dn_objset->os_dsl_dataset) 226 7468 Mark dp = dn->dn_objset->os_dsl_dataset->ds_dir->dd_pool; 227 7468 Mark if (dp && dsl_pool_sync_context(dp)) 228 7468 Mark start = gethrtime(); 229 7754 Jeff zio = zio_root(dn->dn_objset->os_spa, NULL, NULL, ZIO_FLAG_CANFAIL); 230 789 ahrens blkid = dbuf_whichblock(dn, offset); 231 789 ahrens for (i = 0; i < nblks; i++) { 232 1544 eschrock dmu_buf_impl_t *db = dbuf_hold(dn, blkid+i, tag); 233 1544 eschrock if (db == NULL) { 234 1544 eschrock rw_exit(&dn->dn_struct_rwlock); 235 1544 eschrock dmu_buf_rele_array(dbp, nblks, tag); 236 1544 eschrock zio_nowait(zio); 237 1544 eschrock return (EIO); 238 1544 eschrock } 239 1544 eschrock /* initiate async i/o */ 240 2391 maybee if (read) { 241 9512 Neil (void) dbuf_read(db, zio, dbuf_flags); 242 1544 eschrock } 243 1544 eschrock dbp[i] = &db->db; 244 789 ahrens } 245 789 ahrens rw_exit(&dn->dn_struct_rwlock); 246 789 ahrens 247 1544 eschrock /* wait for async i/o */ 248 1544 eschrock err = zio_wait(zio); 249 7468 Mark /* track read overhead when we are in sync context */ 250 7468 Mark if (dp && dsl_pool_sync_context(dp)) 251 7468 Mark dp->dp_read_overhead += gethrtime() - start; 252 1544 eschrock if (err) { 253 1544 eschrock dmu_buf_rele_array(dbp, nblks, tag); 254 1544 eschrock return (err); 255 789 ahrens } 256 789 ahrens 257 1544 eschrock /* wait for other io to complete */ 258 1544 eschrock if (read) { 259 1544 eschrock for (i = 0; i < nblks; i++) { 260 1544 eschrock dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i]; 261 1544 eschrock mutex_enter(&db->db_mtx); 262 1544 eschrock while (db->db_state == DB_READ || 263 1544 eschrock db->db_state == DB_FILL) 264 1544 eschrock cv_wait(&db->db_changed, &db->db_mtx); 265 1544 eschrock if (db->db_state == DB_UNCACHED) 266 1544 eschrock err = EIO; 267 1544 eschrock mutex_exit(&db->db_mtx); 268 1544 eschrock if (err) { 269 1544 eschrock dmu_buf_rele_array(dbp, nblks, tag); 270 1544 eschrock return (err); 271 1544 eschrock } 272 1544 eschrock } 273 1544 eschrock } 274 789 ahrens 275 1544 eschrock *numbufsp = nblks; 276 1544 eschrock *dbpp = dbp; 277 1544 eschrock return (0); 278 2391 maybee } 279 2391 maybee 280 2885 ahrens static int 281 2391 maybee dmu_buf_hold_array(objset_t *os, uint64_t object, uint64_t offset, 282 2391 maybee uint64_t length, int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp) 283 2391 maybee { 284 2391 maybee dnode_t *dn; 285 2391 maybee int err; 286 2391 maybee 287 10298 Matthew err = dnode_hold(os, object, FTAG, &dn); 288 2391 maybee if (err) 289 2391 maybee return (err); 290 2391 maybee 291 2391 maybee err = dmu_buf_hold_array_by_dnode(dn, offset, length, read, tag, 292 9512 Neil numbufsp, dbpp, DMU_READ_PREFETCH); 293 2391 maybee 294 2391 maybee dnode_rele(dn, FTAG); 295 2391 maybee 296 2391 maybee return (err); 297 2391 maybee } 298 2391 maybee 299 2391 maybee int 300 2391 maybee dmu_buf_hold_array_by_bonus(dmu_buf_t *db, uint64_t offset, 301 2391 maybee uint64_t length, int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp) 302 2391 maybee { 303 2391 maybee dnode_t *dn = ((dmu_buf_impl_t *)db)->db_dnode; 304 2391 maybee int err; 305 2391 maybee 306 2391 maybee err = dmu_buf_hold_array_by_dnode(dn, offset, length, read, tag, 307 9512 Neil numbufsp, dbpp, DMU_READ_PREFETCH); 308 2391 maybee 309 2391 maybee return (err); 310 789 ahrens } 311 789 ahrens 312 789 ahrens void 313 1544 eschrock dmu_buf_rele_array(dmu_buf_t **dbp_fake, int numbufs, void *tag) 314 789 ahrens { 315 789 ahrens int i; 316 789 ahrens dmu_buf_impl_t **dbp = (dmu_buf_impl_t **)dbp_fake; 317 789 ahrens 318 789 ahrens if (numbufs == 0) 319 789 ahrens return; 320 789 ahrens 321 1544 eschrock for (i = 0; i < numbufs; i++) { 322 1544 eschrock if (dbp[i]) 323 1544 eschrock dbuf_rele(dbp[i], tag); 324 1544 eschrock } 325 789 ahrens 326 789 ahrens kmem_free(dbp, sizeof (dmu_buf_t *) * numbufs); 327 789 ahrens } 328 789 ahrens 329 789 ahrens void 330 789 ahrens dmu_prefetch(objset_t *os, uint64_t object, uint64_t offset, uint64_t len) 331 789 ahrens { 332 789 ahrens dnode_t *dn; 333 789 ahrens uint64_t blkid; 334 1544 eschrock int nblks, i, err; 335 2986 ek110237 336 2986 ek110237 if (zfs_prefetch_disable) 337 2986 ek110237 return; 338 789 ahrens 339 789 ahrens if (len == 0) { /* they're interested in the bonus buffer */ 340 10298 Matthew dn = os->os_meta_dnode; 341 789 ahrens 342 789 ahrens if (object == 0 || object >= DN_MAX_OBJECT) 343 789 ahrens return; 344 789 ahrens 345 789 ahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 346 789 ahrens blkid = dbuf_whichblock(dn, object * sizeof (dnode_phys_t)); 347 789 ahrens dbuf_prefetch(dn, blkid); 348 789 ahrens rw_exit(&dn->dn_struct_rwlock); 349 789 ahrens return; 350 789 ahrens } 351 789 ahrens 352 789 ahrens /* 353 789 ahrens * XXX - Note, if the dnode for the requested object is not 354 789 ahrens * already cached, we will do a *synchronous* read in the 355 789 ahrens * dnode_hold() call. The same is true for any indirects. 356 789 ahrens */ 357 10298 Matthew err = dnode_hold(os, object, FTAG, &dn); 358 1544 eschrock if (err != 0) 359 789 ahrens return; 360 789 ahrens 361 789 ahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 362 789 ahrens if (dn->dn_datablkshift) { 363 789 ahrens int blkshift = dn->dn_datablkshift; 364 789 ahrens nblks = (P2ROUNDUP(offset+len, 1<<blkshift) - 365 3912 lling P2ALIGN(offset, 1<<blkshift)) >> blkshift; 366 789 ahrens } else { 367 789 ahrens nblks = (offset < dn->dn_datablksz); 368 789 ahrens } 369 789 ahrens 370 789 ahrens if (nblks != 0) { 371 789 ahrens blkid = dbuf_whichblock(dn, offset); 372 789 ahrens for (i = 0; i < nblks; i++) 373 789 ahrens dbuf_prefetch(dn, blkid+i); 374 789 ahrens } 375 789 ahrens 376 789 ahrens rw_exit(&dn->dn_struct_rwlock); 377 789 ahrens 378 789 ahrens dnode_rele(dn, FTAG); 379 789 ahrens } 380 789 ahrens 381 9950 Mark /* 382 9950 Mark * Get the next "chunk" of file data to free. We traverse the file from 383 9950 Mark * the end so that the file gets shorter over time (if we crashes in the 384 9950 Mark * middle, this will leave us in a better state). We find allocated file 385 9950 Mark * data by simply searching the allocated level 1 indirects. 386 9950 Mark */ 387 6992 maybee static int 388 9950 Mark get_next_chunk(dnode_t *dn, uint64_t *start, uint64_t limit) 389 6992 maybee { 390 9950 Mark uint64_t len = *start - limit; 391 9950 Mark uint64_t blkcnt = 0; 392 9950 Mark uint64_t maxblks = DMU_MAX_ACCESS / (1ULL << (dn->dn_indblkshift + 1)); 393 9950 Mark uint64_t iblkrange = 394 7385 Mark dn->dn_datablksz * EPB(dn->dn_indblkshift, SPA_BLKPTRSHIFT); 395 6992 maybee 396 9950 Mark ASSERT(limit <= *start); 397 6992 maybee 398 9950 Mark if (len <= iblkrange * maxblks) { 399 9950 Mark *start = limit; 400 6992 maybee return (0); 401 6992 maybee } 402 9950 Mark ASSERT(ISP2(iblkrange)); 403 6992 maybee 404 9950 Mark while (*start > limit && blkcnt < maxblks) { 405 7385 Mark int err; 406 6992 maybee 407 9950 Mark /* find next allocated L1 indirect */ 408 6992 maybee err = dnode_next_offset(dn, 409 9950 Mark DNODE_FIND_BACKWARDS, start, 2, 1, 0); 410 9950 Mark 411 9950 Mark /* if there are no more, then we are done */ 412 9950 Mark if (err == ESRCH) { 413 9950 Mark *start = limit; 414 9950 Mark return (0); 415 9950 Mark } else if (err) { 416 6992 maybee return (err); 417 9950 Mark } 418 9950 Mark blkcnt += 1; 419 6992 maybee 420 9950 Mark /* reset offset to end of "next" block back */ 421 9950 Mark *start = P2ALIGN(*start, iblkrange); 422 9950 Mark if (*start <= limit) 423 9950 Mark *start = limit; 424 9950 Mark else 425 9950 Mark *start -= 1; 426 6992 maybee } 427 6992 maybee return (0); 428 6992 maybee } 429 6992 maybee 430 6992 maybee static int 431 6992 maybee dmu_free_long_range_impl(objset_t *os, dnode_t *dn, uint64_t offset, 432 6992 maybee uint64_t length, boolean_t free_dnode) 433 6992 maybee { 434 6992 maybee dmu_tx_t *tx; 435 6992 maybee uint64_t object_size, start, end, len; 436 6992 maybee boolean_t trunc = (length == DMU_OBJECT_END); 437 6992 maybee int align, err; 438 6992 maybee 439 6992 maybee align = 1 << dn->dn_datablkshift; 440 6992 maybee ASSERT(align > 0); 441 6992 maybee object_size = align == 1 ? dn->dn_datablksz : 442 6992 maybee (dn->dn_maxblkid + 1) << dn->dn_datablkshift; 443 6992 maybee 444 9396 Matthew end = offset + length; 445 9396 Matthew if (trunc || end > object_size) 446 6992 maybee end = object_size; 447 6992 maybee if (end <= offset) 448 6992 maybee return (0); 449 6992 maybee length = end - offset; 450 6992 maybee 451 6992 maybee while (length) { 452 6992 maybee start = end; 453 9396 Matthew /* assert(offset <= start) */ 454 6992 maybee err = get_next_chunk(dn, &start, offset); 455 6992 maybee if (err) 456 6992 maybee return (err); 457 6992 maybee len = trunc ? DMU_OBJECT_END : end - start; 458 6992 maybee 459 6992 maybee tx = dmu_tx_create(os); 460 6992 maybee dmu_tx_hold_free(tx, dn->dn_object, start, len); 461 6992 maybee err = dmu_tx_assign(tx, TXG_WAIT); 462 6992 maybee if (err) { 463 6992 maybee dmu_tx_abort(tx); 464 6992 maybee return (err); 465 6992 maybee } 466 6992 maybee 467 6992 maybee dnode_free_range(dn, start, trunc ? -1 : len, tx); 468 6992 maybee 469 7385 Mark if (start == 0 && free_dnode) { 470 7385 Mark ASSERT(trunc); 471 6992 maybee dnode_free(dn, tx); 472 7385 Mark } 473 6992 maybee 474 6992 maybee length -= end - start; 475 6992 maybee 476 6992 maybee dmu_tx_commit(tx); 477 6992 maybee end = start; 478 6992 maybee } 479 6992 maybee return (0); 480 6992 maybee } 481 6992 maybee 482 6992 maybee int 483 6992 maybee dmu_free_long_range(objset_t *os, uint64_t object, 484 6992 maybee uint64_t offset, uint64_t length) 485 6992 maybee { 486 6992 maybee dnode_t *dn; 487 6992 maybee int err; 488 6992 maybee 489 10298 Matthew err = dnode_hold(os, object, FTAG, &dn); 490 6992 maybee if (err != 0) 491 6992 maybee return (err); 492 6992 maybee err = dmu_free_long_range_impl(os, dn, offset, length, FALSE); 493 6992 maybee dnode_rele(dn, FTAG); 494 6992 maybee return (err); 495 6992 maybee } 496 6992 maybee 497 6992 maybee int 498 6992 maybee dmu_free_object(objset_t *os, uint64_t object) 499 6992 maybee { 500 6992 maybee dnode_t *dn; 501 6992 maybee dmu_tx_t *tx; 502 6992 maybee int err; 503 6992 maybee 504 10298 Matthew err = dnode_hold_impl(os, object, DNODE_MUST_BE_ALLOCATED, 505 6992 maybee FTAG, &dn); 506 6992 maybee if (err != 0) 507 6992 maybee return (err); 508 6992 maybee if (dn->dn_nlevels == 1) { 509 6992 maybee tx = dmu_tx_create(os); 510 6992 maybee dmu_tx_hold_bonus(tx, object); 511 6992 maybee dmu_tx_hold_free(tx, dn->dn_object, 0, DMU_OBJECT_END); 512 6992 maybee err = dmu_tx_assign(tx, TXG_WAIT); 513 6992 maybee if (err == 0) { 514 6992 maybee dnode_free_range(dn, 0, DMU_OBJECT_END, tx); 515 6992 maybee dnode_free(dn, tx); 516 6992 maybee dmu_tx_commit(tx); 517 6992 maybee } else { 518 6992 maybee dmu_tx_abort(tx); 519 6992 maybee } 520 6992 maybee } else { 521 6992 maybee err = dmu_free_long_range_impl(os, dn, 0, DMU_OBJECT_END, TRUE); 522 6992 maybee } 523 6992 maybee dnode_rele(dn, FTAG); 524 6992 maybee return (err); 525 6992 maybee } 526 6992 maybee 527 1544 eschrock int 528 789 ahrens dmu_free_range(objset_t *os, uint64_t object, uint64_t offset, 529 789 ahrens uint64_t size, dmu_tx_t *tx) 530 789 ahrens { 531 1544 eschrock dnode_t *dn; 532 10298 Matthew int err = dnode_hold(os, object, FTAG, &dn); 533 1544 eschrock if (err) 534 1544 eschrock return (err); 535 789 ahrens ASSERT(offset < UINT64_MAX); 536 789 ahrens ASSERT(size == -1ULL || size <= UINT64_MAX - offset); 537 789 ahrens dnode_free_range(dn, offset, size, tx); 538 789 ahrens dnode_rele(dn, FTAG); 539 1544 eschrock return (0); 540 789 ahrens } 541 789 ahrens 542 1544 eschrock int 543 1544 eschrock dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, 544 9512 Neil void *buf, uint32_t flags) 545 789 ahrens { 546 789 ahrens dnode_t *dn; 547 789 ahrens dmu_buf_t **dbp; 548 10209 Mark int numbufs, err; 549 789 ahrens 550 10298 Matthew err = dnode_hold(os, object, FTAG, &dn); 551 1544 eschrock if (err) 552 1544 eschrock return (err); 553 3638 billm 554 3638 billm /* 555 3638 billm * Deal with odd block sizes, where there can't be data past the first 556 3638 billm * block. If we ever do the tail block optimization, we will need to 557 3638 billm * handle that here as well. 558 3638 billm */ 559 10209 Mark if (dn->dn_maxblkid == 0) { 560 789 ahrens int newsz = offset > dn->dn_datablksz ? 0 : 561 789 ahrens MIN(size, dn->dn_datablksz - offset); 562 789 ahrens bzero((char *)buf + newsz, size - newsz); 563 789 ahrens size = newsz; 564 789 ahrens } 565 789 ahrens 566 789 ahrens while (size > 0) { 567 789 ahrens uint64_t mylen = MIN(size, DMU_MAX_ACCESS / 2); 568 10209 Mark int i; 569 789 ahrens 570 789 ahrens /* 571 789 ahrens * NB: we could do this block-at-a-time, but it's nice 572 789 ahrens * to be reading in parallel. 573 789 ahrens */ 574 2885 ahrens err = dmu_buf_hold_array_by_dnode(dn, offset, mylen, 575 9512 Neil TRUE, FTAG, &numbufs, &dbp, flags); 576 1544 eschrock if (err) 577 4944 maybee break; 578 789 ahrens 579 789 ahrens for (i = 0; i < numbufs; i++) { 580 789 ahrens int tocpy; 581 789 ahrens int bufoff; 582 789 ahrens dmu_buf_t *db = dbp[i]; 583 789 ahrens 584 789 ahrens ASSERT(size > 0); 585 789 ahrens 586 789 ahrens bufoff = offset - db->db_offset; 587 789 ahrens tocpy = (int)MIN(db->db_size - bufoff, size); 588 789 ahrens 589 789 ahrens bcopy((char *)db->db_data + bufoff, buf, tocpy); 590 789 ahrens 591 789 ahrens offset += tocpy; 592 789 ahrens size -= tocpy; 593 789 ahrens buf = (char *)buf + tocpy; 594 789 ahrens } 595 1544 eschrock dmu_buf_rele_array(dbp, numbufs, FTAG); 596 789 ahrens } 597 2885 ahrens dnode_rele(dn, FTAG); 598 4944 maybee return (err); 599 789 ahrens } 600 789 ahrens 601 789 ahrens void 602 789 ahrens dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, 603 789 ahrens const void *buf, dmu_tx_t *tx) 604 789 ahrens { 605 789 ahrens dmu_buf_t **dbp; 606 789 ahrens int numbufs, i; 607 789 ahrens 608 2391 maybee if (size == 0) 609 2391 maybee return; 610 2391 maybee 611 1544 eschrock VERIFY(0 == dmu_buf_hold_array(os, object, offset, size, 612 1544 eschrock FALSE, FTAG, &numbufs, &dbp)); 613 789 ahrens 614 789 ahrens for (i = 0; i < numbufs; i++) { 615 789 ahrens int tocpy; 616 789 ahrens int bufoff; 617 789 ahrens dmu_buf_t *db = dbp[i]; 618 789 ahrens 619 789 ahrens ASSERT(size > 0); 620 789 ahrens 621 789 ahrens bufoff = offset - db->db_offset; 622 789 ahrens tocpy = (int)MIN(db->db_size - bufoff, size); 623 789 ahrens 624 789 ahrens ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size); 625 789 ahrens 626 789 ahrens if (tocpy == db->db_size) 627 789 ahrens dmu_buf_will_fill(db, tx); 628 789 ahrens else 629 789 ahrens dmu_buf_will_dirty(db, tx); 630 789 ahrens 631 789 ahrens bcopy(buf, (char *)db->db_data + bufoff, tocpy); 632 789 ahrens 633 789 ahrens if (tocpy == db->db_size) 634 789 ahrens dmu_buf_fill_done(db, tx); 635 789 ahrens 636 789 ahrens offset += tocpy; 637 789 ahrens size -= tocpy; 638 789 ahrens buf = (char *)buf + tocpy; 639 789 ahrens } 640 1544 eschrock dmu_buf_rele_array(dbp, numbufs, FTAG); 641 789 ahrens } 642 789 ahrens 643 7872 Tim void 644 7872 Tim dmu_prealloc(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, 645 7872 Tim dmu_tx_t *tx) 646 7872 Tim { 647 7872 Tim dmu_buf_t **dbp; 648 7872 Tim int numbufs, i; 649 7872 Tim 650 7872 Tim if (size == 0) 651 7872 Tim return; 652 7872 Tim 653 7872 Tim VERIFY(0 == dmu_buf_hold_array(os, object, offset, size, 654 7872 Tim FALSE, FTAG, &numbufs, &dbp)); 655 7872 Tim 656 7872 Tim for (i = 0; i < numbufs; i++) { 657 7872 Tim dmu_buf_t *db = dbp[i]; 658 7872 Tim 659 7872 Tim dmu_buf_will_not_fill(db, tx); 660 7872 Tim } 661 7872 Tim dmu_buf_rele_array(dbp, numbufs, FTAG); 662 7872 Tim } 663 7872 Tim 664 789 ahrens #ifdef _KERNEL 665 789 ahrens int 666 3638 billm dmu_read_uio(objset_t *os, uint64_t object, uio_t *uio, uint64_t size) 667 3638 billm { 668 3638 billm dmu_buf_t **dbp; 669 3638 billm int numbufs, i, err; 670 3638 billm 671 3638 billm /* 672 3638 billm * NB: we could do this block-at-a-time, but it's nice 673 3638 billm * to be reading in parallel. 674 3638 billm */ 675 3638 billm err = dmu_buf_hold_array(os, object, uio->uio_loffset, size, TRUE, FTAG, 676 3638 billm &numbufs, &dbp); 677 3638 billm if (err) 678 3638 billm return (err); 679 3638 billm 680 3638 billm for (i = 0; i < numbufs; i++) { 681 3638 billm int tocpy; 682 3638 billm int bufoff; 683 3638 billm dmu_buf_t *db = dbp[i]; 684 3638 billm 685 3638 billm ASSERT(size > 0); 686 3638 billm 687 3638 billm bufoff = uio->uio_loffset - db->db_offset; 688 3638 billm tocpy = (int)MIN(db->db_size - bufoff, size); 689 3638 billm 690 3638 billm err = uiomove((char *)db->db_data + bufoff, tocpy, 691 3638 billm UIO_READ, uio); 692 3638 billm if (err) 693 3638 billm break; 694 3638 billm 695 3638 billm size -= tocpy; 696 3638 billm } 697 3638 billm dmu_buf_rele_array(dbp, numbufs, FTAG); 698 3638 billm 699 3638 billm return (err); 700 3638 billm } 701 3638 billm 702 3638 billm int 703 3638 billm dmu_write_uio(objset_t *os, uint64_t object, uio_t *uio, uint64_t size, 704 3638 billm dmu_tx_t *tx) 705 789 ahrens { 706 789 ahrens dmu_buf_t **dbp; 707 789 ahrens int numbufs, i; 708 789 ahrens int err = 0; 709 2391 maybee 710 2391 maybee if (size == 0) 711 2391 maybee return (0); 712 789 ahrens 713 3638 billm err = dmu_buf_hold_array(os, object, uio->uio_loffset, size, 714 1544 eschrock FALSE, FTAG, &numbufs, &dbp); 715 1544 eschrock if (err) 716 1544 eschrock return (err); 717 789 ahrens 718 789 ahrens for (i = 0; i < numbufs; i++) { 719 789 ahrens int tocpy; 720 789 ahrens int bufoff; 721 789 ahrens dmu_buf_t *db = dbp[i]; 722 789 ahrens 723 789 ahrens ASSERT(size > 0); 724 789 ahrens 725 3638 billm bufoff = uio->uio_loffset - db->db_offset; 726 789 ahrens tocpy = (int)MIN(db->db_size - bufoff, size); 727 789 ahrens 728 789 ahrens ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size); 729 789 ahrens 730 789 ahrens if (tocpy == db->db_size) 731 789 ahrens dmu_buf_will_fill(db, tx); 732 789 ahrens else 733 789 ahrens dmu_buf_will_dirty(db, tx); 734 789 ahrens 735 789 ahrens /* 736 789 ahrens * XXX uiomove could block forever (eg. nfs-backed 737 789 ahrens * pages). There needs to be a uiolockdown() function 738 789 ahrens * to lock the pages in memory, so that uiomove won't 739 789 ahrens * block. 740 789 ahrens */ 741 789 ahrens err = uiomove((char *)db->db_data + bufoff, tocpy, 742 789 ahrens UIO_WRITE, uio); 743 2688 maybee 744 2688 maybee if (tocpy == db->db_size) 745 2688 maybee dmu_buf_fill_done(db, tx); 746 2688 maybee 747 2688 maybee if (err) 748 2688 maybee break; 749 2688 maybee 750 2688 maybee size -= tocpy; 751 2688 maybee } 752 2688 maybee dmu_buf_rele_array(dbp, numbufs, FTAG); 753 2688 maybee return (err); 754 2688 maybee } 755 2688 maybee 756 2688 maybee int 757 2688 maybee dmu_write_pages(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, 758 2688 maybee page_t *pp, dmu_tx_t *tx) 759 2688 maybee { 760 2688 maybee dmu_buf_t **dbp; 761 2688 maybee int numbufs, i; 762 2688 maybee int err; 763 2688 maybee 764 2688 maybee if (size == 0) 765 2688 maybee return (0); 766 2688 maybee 767 2688 maybee err = dmu_buf_hold_array(os, object, offset, size, 768 2688 maybee FALSE, FTAG, &numbufs, &dbp); 769 2688 maybee if (err) 770 2688 maybee return (err); 771 2688 maybee 772 2688 maybee for (i = 0; i < numbufs; i++) { 773 2688 maybee int tocpy, copied, thiscpy; 774 2688 maybee int bufoff; 775 2688 maybee dmu_buf_t *db = dbp[i]; 776 2688 maybee caddr_t va; 777 2688 maybee 778 2688 maybee ASSERT(size > 0); 779 2688 maybee ASSERT3U(db->db_size, >=, PAGESIZE); 780 2688 maybee 781 2688 maybee bufoff = offset - db->db_offset; 782 2688 maybee tocpy = (int)MIN(db->db_size - bufoff, size); 783 2688 maybee 784 2688 maybee ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size); 785 2688 maybee 786 2688 maybee if (tocpy == db->db_size) 787 2688 maybee dmu_buf_will_fill(db, tx); 788 2688 maybee else 789 2688 maybee dmu_buf_will_dirty(db, tx); 790 2688 maybee 791 2688 maybee for (copied = 0; copied < tocpy; copied += PAGESIZE) { 792 2688 maybee ASSERT3U(pp->p_offset, ==, db->db_offset + bufoff); 793 2688 maybee thiscpy = MIN(PAGESIZE, tocpy - copied); 794 7315 Jonathan va = zfs_map_page(pp, S_READ); 795 2688 maybee bcopy(va, (char *)db->db_data + bufoff, thiscpy); 796 7315 Jonathan zfs_unmap_page(pp, va); 797 2688 maybee pp = pp->p_next; 798 2688 maybee bufoff += PAGESIZE; 799 2688 maybee } 800 789 ahrens 801 789 ahrens if (tocpy == db->db_size) 802 789 ahrens dmu_buf_fill_done(db, tx); 803 789 ahrens 804 789 ahrens offset += tocpy; 805 789 ahrens size -= tocpy; 806 789 ahrens } 807 1544 eschrock dmu_buf_rele_array(dbp, numbufs, FTAG); 808 789 ahrens return (err); 809 789 ahrens } 810 789 ahrens #endif 811 789 ahrens 812 9412 Aleksandr /* 813 9412 Aleksandr * Allocate a loaned anonymous arc buffer. 814 9412 Aleksandr */ 815 9412 Aleksandr arc_buf_t * 816 9412 Aleksandr dmu_request_arcbuf(dmu_buf_t *handle, int size) 817 9412 Aleksandr { 818 9412 Aleksandr dnode_t *dn = ((dmu_buf_impl_t *)handle)->db_dnode; 819 9412 Aleksandr 820 9412 Aleksandr return (arc_loan_buf(dn->dn_objset->os_spa, size)); 821 9412 Aleksandr } 822 9412 Aleksandr 823 9412 Aleksandr /* 824 9412 Aleksandr * Free a loaned arc buffer. 825 9412 Aleksandr */ 826 9412 Aleksandr void 827 9412 Aleksandr dmu_return_arcbuf(arc_buf_t *buf) 828 9412 Aleksandr { 829 9412 Aleksandr arc_return_buf(buf, FTAG); 830 9412 Aleksandr VERIFY(arc_buf_remove_ref(buf, FTAG) == 1); 831 9412 Aleksandr } 832 9412 Aleksandr 833 9412 Aleksandr /* 834 9412 Aleksandr * When possible directly assign passed loaned arc buffer to a dbuf. 835 9412 Aleksandr * If this is not possible copy the contents of passed arc buf via 836 9412 Aleksandr * dmu_write(). 837 9412 Aleksandr */ 838 9412 Aleksandr void 839 9412 Aleksandr dmu_assign_arcbuf(dmu_buf_t *handle, uint64_t offset, arc_buf_t *buf, 840 9412 Aleksandr dmu_tx_t *tx) 841 9412 Aleksandr { 842 9412 Aleksandr dnode_t *dn = ((dmu_buf_impl_t *)handle)->db_dnode; 843 9412 Aleksandr dmu_buf_impl_t *db; 844 9412 Aleksandr uint32_t blksz = (uint32_t)arc_buf_size(buf); 845 9412 Aleksandr uint64_t blkid; 846 9412 Aleksandr 847 9412 Aleksandr rw_enter(&dn->dn_struct_rwlock, RW_READER); 848 9412 Aleksandr blkid = dbuf_whichblock(dn, offset); 849 9412 Aleksandr VERIFY((db = dbuf_hold(dn, blkid, FTAG)) != NULL); 850 9412 Aleksandr rw_exit(&dn->dn_struct_rwlock); 851 9412 Aleksandr 852 9412 Aleksandr if (offset == db->db.db_offset && blksz == db->db.db_size) { 853 9412 Aleksandr dbuf_assign_arcbuf(db, buf, tx); 854 9412 Aleksandr dbuf_rele(db, FTAG); 855 9412 Aleksandr } else { 856 9412 Aleksandr dbuf_rele(db, FTAG); 857 10298 Matthew dmu_write(dn->dn_objset, dn->dn_object, offset, blksz, 858 9412 Aleksandr buf->b_data, tx); 859 9412 Aleksandr dmu_return_arcbuf(buf); 860 9412 Aleksandr } 861 9412 Aleksandr } 862 9412 Aleksandr 863 2237 maybee typedef struct { 864 10922 Jeff dbuf_dirty_record_t *dsa_dr; 865 10922 Jeff dmu_sync_cb_t *dsa_done; 866 10922 Jeff zgd_t *dsa_zgd; 867 10922 Jeff dmu_tx_t *dsa_tx; 868 3547 maybee } dmu_sync_arg_t; 869 2237 maybee 870 2237 maybee /* ARGSUSED */ 871 2237 maybee static void 872 7754 Jeff dmu_sync_ready(zio_t *zio, arc_buf_t *buf, void *varg) 873 7754 Jeff { 874 10922 Jeff dmu_sync_arg_t *dsa = varg; 875 10922 Jeff dmu_buf_t *db = dsa->dsa_zgd->zgd_db; 876 10922 Jeff dnode_t *dn = ((dmu_buf_impl_t *)db)->db_dnode; 877 7754 Jeff blkptr_t *bp = zio->io_bp; 878 10800 Neil 879 10922 Jeff if (zio->io_error == 0) { 880 10922 Jeff if (BP_IS_HOLE(bp)) { 881 10922 Jeff /* 882 10922 Jeff * A block of zeros may compress to a hole, but the 883 10922 Jeff * block size still needs to be known for replay. 884 10922 Jeff */ 885 10922 Jeff BP_SET_LSIZE(bp, db->db_size); 886 10922 Jeff } else { 887 10922 Jeff ASSERT(BP_GET_TYPE(bp) == dn->dn_type); 888 10922 Jeff ASSERT(BP_GET_LEVEL(bp) == 0); 889 10922 Jeff bp->blk_fill = 1; 890 10922 Jeff } 891 7754 Jeff } 892 10922 Jeff } 893 10922 Jeff 894 10922 Jeff static void 895 10922 Jeff dmu_sync_late_arrival_ready(zio_t *zio) 896 10922 Jeff { 897 10922 Jeff dmu_sync_ready(zio, NULL, zio->io_private); 898 7754 Jeff } 899 7754 Jeff 900 7754 Jeff /* ARGSUSED */ 901 7754 Jeff static void 902 2237 maybee dmu_sync_done(zio_t *zio, arc_buf_t *buf, void *varg) 903 2237 maybee { 904 10922 Jeff dmu_sync_arg_t *dsa = varg; 905 10922 Jeff dbuf_dirty_record_t *dr = dsa->dsa_dr; 906 3547 maybee dmu_buf_impl_t *db = dr->dr_dbuf; 907 2237 maybee 908 10810 Neil mutex_enter(&db->db_mtx); 909 10810 Neil ASSERT(dr->dt.dl.dr_override_state == DR_IN_DMU_SYNC); 910 10922 Jeff if (zio->io_error == 0) { 911 10922 Jeff dr->dt.dl.dr_overridden_by = *zio->io_bp; 912 10922 Jeff dr->dt.dl.dr_override_state = DR_OVERRIDDEN; 913 10922 Jeff dr->dt.dl.dr_copies = zio->io_prop.zp_copies; 914 10922 Jeff if (BP_IS_HOLE(&dr->dt.dl.dr_overridden_by)) 915 10922 Jeff BP_ZERO(&dr->dt.dl.dr_overridden_by); 916 10922 Jeff } else { 917 10922 Jeff dr->dt.dl.dr_override_state = DR_NOT_OVERRIDDEN; 918 10922 Jeff } 919 2237 maybee cv_broadcast(&db->db_changed); 920 10810 Neil mutex_exit(&db->db_mtx); 921 10810 Neil 922 10922 Jeff dsa->dsa_done(dsa->dsa_zgd, zio->io_error); 923 3547 maybee 924 10922 Jeff kmem_free(dsa, sizeof (*dsa)); 925 10922 Jeff } 926 10922 Jeff 927 10922 Jeff static void 928 10922 Jeff dmu_sync_late_arrival_done(zio_t *zio) 929 10922 Jeff { 930 10922 Jeff blkptr_t *bp = zio->io_bp; 931 10922 Jeff dmu_sync_arg_t *dsa = zio->io_private; 932 10922 Jeff 933 10922 Jeff if (zio->io_error == 0 && !BP_IS_HOLE(bp)) { 934 10922 Jeff ASSERT(zio->io_bp->blk_birth == zio->io_txg); 935 10922 Jeff ASSERT(zio->io_txg > spa_syncing_txg(zio->io_spa)); 936 10922 Jeff zio_free(zio->io_spa, zio->io_txg, zio->io_bp); 937 10922 Jeff } 938 10922 Jeff 939 10922 Jeff dmu_tx_commit(dsa->dsa_tx); 940 10922 Jeff 941 10922 Jeff dsa->dsa_done(dsa->dsa_zgd, zio->io_error); 942 10922 Jeff 943 10922 Jeff kmem_free(dsa, sizeof (*dsa)); 944 10922 Jeff } 945 10922 Jeff 946 10922 Jeff static int 947 10922 Jeff dmu_sync_late_arrival(zio_t *pio, objset_t *os, dmu_sync_cb_t *done, zgd_t *zgd, 948 10922 Jeff zio_prop_t *zp, zbookmark_t *zb) 949 10922 Jeff { 950 10922 Jeff dmu_sync_arg_t *dsa; 951 10922 Jeff dmu_tx_t *tx; 952 10922 Jeff 953 10922 Jeff tx = dmu_tx_create(os); 954 10922 Jeff dmu_tx_hold_space(tx, zgd->zgd_db->db_size); 955 10922 Jeff if (dmu_tx_assign(tx, TXG_NOWAIT) != 0) { 956 10922 Jeff dmu_tx_abort(tx); 957 10922 Jeff return (EIO); /* Make zl_get_data do txg_waited_synced() */ 958 10922 Jeff } 959 10922 Jeff 960 10922 Jeff dsa = kmem_alloc(sizeof (dmu_sync_arg_t), KM_SLEEP); 961 10922 Jeff dsa->dsa_dr = NULL; 962 10922 Jeff dsa->dsa_done = done; 963 10922 Jeff dsa->dsa_zgd = zgd; 964 10922 Jeff dsa->dsa_tx = tx; 965 10922 Jeff 966 10922 Jeff zio_nowait(zio_write(pio, os->os_spa, dmu_tx_get_txg(tx), zgd->zgd_bp, 967 10922 Jeff zgd->zgd_db->db_data, zgd->zgd_db->db_size, zp, 968 10922 Jeff dmu_sync_late_arrival_ready, dmu_sync_late_arrival_done, dsa, 969 10922 Jeff ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_CANFAIL, zb)); 970 10922 Jeff 971 10922 Jeff return (0); 972 2237 maybee } 973 2237 maybee 974 789 ahrens /* 975 2237 maybee * Intent log support: sync the block associated with db to disk. 976 2237 maybee * N.B. and XXX: the caller is responsible for making sure that the 977 2237 maybee * data isn't changing while dmu_sync() is writing it. 978 789 ahrens * 979 789 ahrens * Return values: 980 789 ahrens * 981 2237 maybee * EEXIST: this txg has already been synced, so there's nothing to to. 982 789 ahrens * The caller should not log the write. 983 789 ahrens * 984 789 ahrens * ENOENT: the block was dbuf_free_range()'d, so there's nothing to do. 985 789 ahrens * The caller should not log the write. 986 789 ahrens * 987 2237 maybee * EALREADY: this block is already in the process of being synced. 988 2237 maybee * The caller should track its progress (somehow). 989 789 ahrens * 990 10922 Jeff * EIO: could not do the I/O. 991 10922 Jeff * The caller should do a txg_wait_synced(). 992 789 ahrens * 993 10922 Jeff * 0: the I/O has been initiated. 994 10922 Jeff * The caller should log this blkptr in the done callback. 995 10922 Jeff * It is possible that the I/O will fail, in which case 996 10922 Jeff * the error will be reported to the done callback and 997 10922 Jeff * propagated to pio from zio_done(). 998 789 ahrens */ 999 789 ahrens int 1000 10922 Jeff dmu_sync(zio_t *pio, uint64_t txg, dmu_sync_cb_t *done, zgd_t *zgd) 1001 789 ahrens { 1002 10922 Jeff blkptr_t *bp = zgd->zgd_bp; 1003 10922 Jeff dmu_buf_impl_t *db = (dmu_buf_impl_t *)zgd->zgd_db; 1004 10298 Matthew objset_t *os = db->db_objset; 1005 10922 Jeff dsl_dataset_t *ds = os->os_dsl_dataset; 1006 3547 maybee dbuf_dirty_record_t *dr; 1007 10922 Jeff dmu_sync_arg_t *dsa; 1008 2237 maybee zbookmark_t zb; 1009 10922 Jeff zio_prop_t zp; 1010 789 ahrens 1011 10922 Jeff ASSERT(pio != NULL); 1012 789 ahrens ASSERT(BP_IS_HOLE(bp)); 1013 789 ahrens ASSERT(txg != 0); 1014 789 ahrens 1015 10922 Jeff SET_BOOKMARK(&zb, ds->ds_object, 1016 10922 Jeff db->db.db_object, db->db_level, db->db_blkid); 1017 10922 Jeff 1018 10922 Jeff dmu_write_policy(os, db->db_dnode, db->db_level, WP_DMU_SYNC, &zp); 1019 789 ahrens 1020 789 ahrens /* 1021 10922 Jeff * If we're frozen (running ziltest), we always need to generate a bp. 1022 1544 eschrock */ 1023 10922 Jeff if (txg > spa_freeze_txg(os->os_spa)) 1024 10922 Jeff return (dmu_sync_late_arrival(pio, os, done, zgd, &zp, &zb)); 1025 1544 eschrock 1026 1544 eschrock /* 1027 10922 Jeff * Grabbing db_mtx now provides a barrier between dbuf_sync_leaf() 1028 10922 Jeff * and us. If we determine that this txg is not yet syncing, 1029 10922 Jeff * but it begins to sync a moment later, that's OK because the 1030 10922 Jeff * sync thread will block in dbuf_sync_leaf() until we drop db_mtx. 1031 789 ahrens */ 1032 10922 Jeff mutex_enter(&db->db_mtx); 1033 10922 Jeff 1034 10922 Jeff if (txg <= spa_last_synced_txg(os->os_spa)) { 1035 789 ahrens /* 1036 10922 Jeff * This txg has already synced. There's nothing to do. 1037 789 ahrens */ 1038 10922 Jeff mutex_exit(&db->db_mtx); 1039 2237 maybee return (EEXIST); 1040 789 ahrens } 1041 789 ahrens 1042 10922 Jeff if (txg <= spa_syncing_txg(os->os_spa)) { 1043 10922 Jeff /* 1044 10922 Jeff * This txg is currently syncing, so we can't mess with 1045 10922 Jeff * the dirty record anymore; just write a new log block. 1046 10922 Jeff */ 1047 10922 Jeff mutex_exit(&db->db_mtx); 1048 10922 Jeff return (dmu_sync_late_arrival(pio, os, done, zgd, &zp, &zb)); 1049 2237 maybee } 1050 2237 maybee 1051 3547 maybee dr = db->db_last_dirty; 1052 10922 Jeff while (dr && dr->dr_txg != txg) 1053 3547 maybee dr = dr->dr_next; 1054 10922 Jeff 1055 10922 Jeff if (dr == NULL) { 1056 2237 maybee /* 1057 10922 Jeff * There's no dr for this dbuf, so it must have been freed. 1058 2237 maybee * There's no need to log writes to freed blocks, so we're done. 1059 2237 maybee */ 1060 2237 maybee mutex_exit(&db->db_mtx); 1061 789 ahrens return (ENOENT); 1062 789 ahrens } 1063 789 ahrens 1064 3547 maybee ASSERT(dr->dr_txg == txg); 1065 10922 Jeff if (dr->dt.dl.dr_override_state == DR_IN_DMU_SYNC || 1066 10922 Jeff dr->dt.dl.dr_override_state == DR_OVERRIDDEN) { 1067 3547 maybee /* 1068 10922 Jeff * We have already issued a sync write for this buffer, 1069 10922 Jeff * or this buffer has already been synced. It could not 1070 10922 Jeff * have been dirtied since, or we would have cleared the state. 1071 3547 maybee */ 1072 3547 maybee mutex_exit(&db->db_mtx); 1073 3547 maybee return (EALREADY); 1074 3547 maybee } 1075 3547 maybee 1076 10922 Jeff ASSERT(dr->dt.dl.dr_override_state == DR_NOT_OVERRIDDEN); 1077 3547 maybee dr->dt.dl.dr_override_state = DR_IN_DMU_SYNC; 1078 2237 maybee mutex_exit(&db->db_mtx); 1079 789 ahrens 1080 10922 Jeff dsa = kmem_alloc(sizeof (dmu_sync_arg_t), KM_SLEEP); 1081 10922 Jeff dsa->dsa_dr = dr; 1082 10922 Jeff dsa->dsa_done = done; 1083 10922 Jeff dsa->dsa_zgd = zgd; 1084 10922 Jeff dsa->dsa_tx = NULL; 1085 7754 Jeff 1086 10922 Jeff zio_nowait(arc_write(pio, os->os_spa, txg, 1087 10922 Jeff bp, dr->dt.dl.dr_data, DBUF_IS_L2CACHEABLE(db), &zp, 1088 10922 Jeff dmu_sync_ready, dmu_sync_done, dsa, 1089 10922 Jeff ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_CANFAIL, &zb)); 1090 7754 Jeff 1091 10922 Jeff return (0); 1092 789 ahrens } 1093 789 ahrens 1094 789 ahrens int 1095 789 ahrens dmu_object_set_blocksize(objset_t *os, uint64_t object, uint64_t size, int ibs, 1096 789 ahrens dmu_tx_t *tx) 1097 789 ahrens { 1098 1544 eschrock dnode_t *dn; 1099 1544 eschrock int err; 1100 1544 eschrock 1101 10298 Matthew err = dnode_hold(os, object, FTAG, &dn); 1102 1544 eschrock if (err) 1103 1544 eschrock return (err); 1104 1544 eschrock err = dnode_set_blksz(dn, size, ibs, tx); 1105 789 ahrens dnode_rele(dn, FTAG); 1106 789 ahrens return (err); 1107 789 ahrens } 1108 789 ahrens 1109 789 ahrens void 1110 789 ahrens dmu_object_set_checksum(objset_t *os, uint64_t object, uint8_t checksum, 1111 789 ahrens dmu_tx_t *tx) 1112 789 ahrens { 1113 1544 eschrock dnode_t *dn; 1114 1544 eschrock 1115 1544 eschrock /* XXX assumes dnode_hold will not get an i/o error */ 1116 10298 Matthew (void) dnode_hold(os, object, FTAG, &dn); 1117 789 ahrens ASSERT(checksum < ZIO_CHECKSUM_FUNCTIONS); 1118 789 ahrens dn->dn_checksum = checksum; 1119 789 ahrens dnode_setdirty(dn, tx); 1120 789 ahrens dnode_rele(dn, FTAG); 1121 789 ahrens } 1122 789 ahrens 1123 789 ahrens void 1124 789 ahrens dmu_object_set_compress(objset_t *os, uint64_t object, uint8_t compress, 1125 789 ahrens dmu_tx_t *tx) 1126 789 ahrens { 1127 1544 eschrock dnode_t *dn; 1128 1544 eschrock 1129 1544 eschrock /* XXX assumes dnode_hold will not get an i/o error */ 1130 10298 Matthew (void) dnode_hold(os, object, FTAG, &dn); 1131 789 ahrens ASSERT(compress < ZIO_COMPRESS_FUNCTIONS); 1132 789 ahrens dn->dn_compress = compress; 1133 789 ahrens dnode_setdirty(dn, tx); 1134 789 ahrens dnode_rele(dn, FTAG); 1135 789 ahrens } 1136 789 ahrens 1137 10922 Jeff int zfs_mdcomp_disable = 0; 1138 10922 Jeff 1139 10922 Jeff void 1140 10922 Jeff dmu_write_policy(objset_t *os, dnode_t *dn, int level, int wp, zio_prop_t *zp) 1141 10922 Jeff { 1142 10922 Jeff dmu_object_type_t type = dn ? dn->dn_type : DMU_OT_OBJSET; 1143 10922 Jeff boolean_t ismd = (level > 0 || dmu_ot[type].ot_metadata); 1144 10922 Jeff enum zio_checksum checksum = os->os_checksum; 1145 10922 Jeff enum zio_compress compress = os->os_compress; 1146 10922 Jeff enum zio_checksum dedup_checksum = os->os_dedup_checksum; 1147 10922 Jeff boolean_t dedup; 1148 10922 Jeff boolean_t dedup_verify = os->os_dedup_verify; 1149 10922 Jeff int copies = os->os_copies; 1150 10922 Jeff 1151 10922 Jeff /* 1152 10922 Jeff * Determine checksum setting. 1153 10922 Jeff */ 1154 10922 Jeff if (ismd) { 1155 10922 Jeff /* 1156 10922 Jeff * Metadata always gets checksummed. If the data 1157 10922 Jeff * checksum is multi-bit correctable, and it's not a 1158 10922 Jeff * ZBT-style checksum, then it's suitable for metadata 1159 10922 Jeff * as well. Otherwise, the metadata checksum defaults 1160 10922 Jeff * to fletcher4. 1161 10922 Jeff */ 1162 10922 Jeff if (zio_checksum_table[checksum].ci_correctable < 1 || 1163 10922 Jeff zio_checksum_table[checksum].ci_zbt) 1164 10922 Jeff checksum = ZIO_CHECKSUM_FLETCHER_4; 1165 10922 Jeff } else { 1166 10922 Jeff checksum = zio_checksum_select(dn->dn_checksum, checksum); 1167 10922 Jeff } 1168 10922 Jeff 1169 10922 Jeff /* 1170 10922 Jeff * Determine compression setting. 1171 10922 Jeff */ 1172 10922 Jeff if (ismd) { 1173 10922 Jeff /* 1174 10922 Jeff * XXX -- we should design a compression algorithm 1175 10922 Jeff * that specializes in arrays of bps. 1176 10922 Jeff */ 1177 10922 Jeff compress = zfs_mdcomp_disable ? ZIO_COMPRESS_EMPTY : 1178 10922 Jeff ZIO_COMPRESS_LZJB; 1179 10922 Jeff } else { 1180 10922 Jeff compress = zio_compress_select(dn->dn_compress, compress); 1181 10922 Jeff } 1182 10922 Jeff 1183 10922 Jeff /* 1184 10922 Jeff * Determine dedup setting. If we are in dmu_sync(), we won't 1185 10922 Jeff * actually dedup now because that's all done in syncing context; 1186 10922 Jeff * but we do want to use the dedup checkum. If the checksum is not 1187 10922 Jeff * strong enough to ensure unique signatures, force dedup_verify. 1188 10922 Jeff */ 1189 10922 Jeff dedup = (!ismd && dedup_checksum != ZIO_CHECKSUM_OFF); 1190 10922 Jeff if (dedup) { 1191 10922 Jeff checksum = dedup_checksum; 1192 10922 Jeff if (!zio_checksum_table[checksum].ci_dedup) 1193 10922 Jeff dedup_verify = 1; 1194 10922 Jeff } 1195 10922 Jeff 1196 10922 Jeff if (wp & WP_DMU_SYNC) 1197 10922 Jeff dedup = 0; 1198 10922 Jeff 1199 10922 Jeff if (wp & WP_NOFILL) { 1200 10922 Jeff ASSERT(!ismd && level == 0); 1201 10922 Jeff checksum = ZIO_CHECKSUM_OFF; 1202 10922 Jeff compress = ZIO_COMPRESS_OFF; 1203 10922 Jeff dedup = B_FALSE; 1204 10922 Jeff } 1205 10922 Jeff 1206 10922 Jeff zp->zp_checksum = checksum; 1207 10922 Jeff zp->zp_compress = compress; 1208 10922 Jeff zp->zp_type = type; 1209 10922 Jeff zp->zp_level = level; 1210 10922 Jeff zp->zp_copies = MIN(copies + ismd, spa_max_replication(os->os_spa)); 1211 10922 Jeff zp->zp_dedup = dedup; 1212 10922 Jeff zp->zp_dedup_verify = dedup && dedup_verify; 1213 10922 Jeff } 1214 10922 Jeff 1215 789 ahrens int 1216 789 ahrens dmu_offset_next(objset_t *os, uint64_t object, boolean_t hole, uint64_t *off) 1217 789 ahrens { 1218 789 ahrens dnode_t *dn; 1219 789 ahrens int i, err; 1220 789 ahrens 1221 10298 Matthew err = dnode_hold(os, object, FTAG, &dn); 1222 1544 eschrock if (err) 1223 1544 eschrock return (err); 1224 789 ahrens /* 1225 789 ahrens * Sync any current changes before 1226 789 ahrens * we go trundling through the block pointers. 1227 789 ahrens */ 1228 789 ahrens for (i = 0; i < TXG_SIZE; i++) { 1229 1596 ahrens if (list_link_active(&dn->dn_dirty_link[i])) 1230 789 ahrens break; 1231 789 ahrens } 1232 789 ahrens if (i != TXG_SIZE) { 1233 789 ahrens dnode_rele(dn, FTAG); 1234 789 ahrens txg_wait_synced(dmu_objset_pool(os), 0); 1235 10298 Matthew err = dnode_hold(os, object, FTAG, &dn); 1236 1544 eschrock if (err) 1237 1544 eschrock return (err); 1238 789 ahrens } 1239 789 ahrens 1240 6992 maybee err = dnode_next_offset(dn, (hole ? DNODE_FIND_HOLE : 0), off, 1, 1, 0); 1241 789 ahrens dnode_rele(dn, FTAG); 1242 789 ahrens 1243 789 ahrens return (err); 1244 789 ahrens } 1245 789 ahrens 1246 789 ahrens void 1247 789 ahrens dmu_object_info_from_dnode(dnode_t *dn, dmu_object_info_t *doi) 1248 789 ahrens { 1249 10922 Jeff dnode_phys_t *dnp; 1250 10922 Jeff 1251 789 ahrens rw_enter(&dn->dn_struct_rwlock, RW_READER); 1252 789 ahrens mutex_enter(&dn->dn_mtx); 1253 10922 Jeff 1254 10922 Jeff dnp = dn->dn_phys; 1255 789 ahrens 1256 789 ahrens doi->doi_data_block_size = dn->dn_datablksz; 1257 789 ahrens doi->doi_metadata_block_size = dn->dn_indblkshift ? 1258 789 ahrens 1ULL << dn->dn_indblkshift : 0; 1259 10922 Jeff doi->doi_type = dn->dn_type; 1260 10922 Jeff doi->doi_bonus_type = dn->dn_bonustype; 1261 10922 Jeff doi->doi_bonus_size = dn->dn_bonuslen; 1262 789 ahrens doi->doi_indirection = dn->dn_nlevels; 1263 789 ahrens doi->doi_checksum = dn->dn_checksum; 1264 789 ahrens doi->doi_compress = dn->dn_compress; 1265 10922 Jeff doi->doi_physical_blocks_512 = (DN_USED_BYTES(dnp) + 256) >> 9; 1266 10922 Jeff doi->doi_max_offset = (dnp->dn_maxblkid + 1) * dn->dn_datablksz; 1267 10922 Jeff doi->doi_fill_count = 0; 1268 10922 Jeff for (int i = 0; i < dnp->dn_nblkptr; i++) 1269 10922 Jeff doi->doi_fill_count += dnp->dn_blkptr[i].blk_fill; 1270 789 ahrens 1271 789 ahrens mutex_exit(&dn->dn_mtx); 1272 789 ahrens rw_exit(&dn->dn_struct_rwlock); 1273 789 ahrens } 1274 789 ahrens 1275 789 ahrens /* 1276 789 ahrens * Get information on a DMU object. 1277 789 ahrens * If doi is NULL, just indicates whether the object exists. 1278 789 ahrens */ 1279 789 ahrens int 1280 789 ahrens dmu_object_info(objset_t *os, uint64_t object, dmu_object_info_t *doi) 1281 789 ahrens { 1282 1544 eschrock dnode_t *dn; 1283 10298 Matthew int err = dnode_hold(os, object, FTAG, &dn); 1284 789 ahrens 1285 1544 eschrock if (err) 1286 1544 eschrock return (err); 1287 789 ahrens 1288 789 ahrens if (doi != NULL) 1289 789 ahrens dmu_object_info_from_dnode(dn, doi); 1290 789 ahrens 1291 789 ahrens dnode_rele(dn, FTAG); 1292 789 ahrens return (0); 1293 789 ahrens } 1294 789 ahrens 1295 789 ahrens /* 1296 789 ahrens * As above, but faster; can be used when you have a held dbuf in hand. 1297 789 ahrens */ 1298 789 ahrens void 1299 789 ahrens dmu_object_info_from_db(dmu_buf_t *db, dmu_object_info_t *doi) 1300 789 ahrens { 1301 789 ahrens dmu_object_info_from_dnode(((dmu_buf_impl_t *)db)->db_dnode, doi); 1302 789 ahrens } 1303 789 ahrens 1304 789 ahrens /* 1305 789 ahrens * Faster still when you only care about the size. 1306 789 ahrens * This is specifically optimized for zfs_getattr(). 1307 789 ahrens */ 1308 789 ahrens void 1309 789 ahrens dmu_object_size_from_db(dmu_buf_t *db, uint32_t *blksize, u_longlong_t *nblk512) 1310 789 ahrens { 1311 789 ahrens dnode_t *dn = ((dmu_buf_impl_t *)db)->db_dnode; 1312 789 ahrens 1313 789 ahrens *blksize = dn->dn_datablksz; 1314 2082 eschrock /* add 1 for dnode space */ 1315 2082 eschrock *nblk512 = ((DN_USED_BYTES(dn->dn_phys) + SPA_MINBLOCKSIZE/2) >> 1316 2082 eschrock SPA_MINBLOCKSHIFT) + 1; 1317 1544 eschrock } 1318 1544 eschrock 1319 789 ahrens void 1320 789 ahrens byteswap_uint64_array(void *vbuf, size_t size) 1321 789 ahrens { 1322 789 ahrens uint64_t *buf = vbuf; 1323 789 ahrens size_t count = size >> 3; 1324 789 ahrens int i; 1325 789 ahrens 1326 789 ahrens ASSERT((size & 7) == 0); 1327 789 ahrens 1328 789 ahrens for (i = 0; i < count; i++) 1329 789 ahrens buf[i] = BSWAP_64(buf[i]); 1330 789 ahrens } 1331 789 ahrens 1332 789 ahrens void 1333 789 ahrens byteswap_uint32_array(void *vbuf, size_t size) 1334 789 ahrens { 1335 789 ahrens uint32_t *buf = vbuf; 1336 789 ahrens size_t count = size >> 2; 1337 789 ahrens int i; 1338 789 ahrens 1339 789 ahrens ASSERT((size & 3) == 0); 1340 789 ahrens 1341 789 ahrens for (i = 0; i < count; i++) 1342 789 ahrens buf[i] = BSWAP_32(buf[i]); 1343 789 ahrens } 1344 789 ahrens 1345 789 ahrens void 1346 789 ahrens byteswap_uint16_array(void *vbuf, size_t size) 1347 789 ahrens { 1348 789 ahrens uint16_t *buf = vbuf; 1349 789 ahrens size_t count = size >> 1; 1350 789 ahrens int i; 1351 789 ahrens 1352 789 ahrens ASSERT((size & 1) == 0); 1353 789 ahrens 1354 789 ahrens for (i = 0; i < count; i++) 1355 789 ahrens buf[i] = BSWAP_16(buf[i]); 1356 789 ahrens } 1357 789 ahrens 1358 789 ahrens /* ARGSUSED */ 1359 789 ahrens void 1360 789 ahrens byteswap_uint8_array(void *vbuf, size_t size) 1361 789 ahrens { 1362 789 ahrens } 1363 789 ahrens 1364 789 ahrens void 1365 789 ahrens dmu_init(void) 1366 789 ahrens { 1367 789 ahrens dbuf_init(); 1368 789 ahrens dnode_init(); 1369 10474 Richard zfetch_init(); 1370 789 ahrens arc_init(); 1371 5450 brendan l2arc_init(); 1372 789 ahrens } 1373 789 ahrens 1374 789 ahrens void 1375 789 ahrens dmu_fini(void) 1376 789 ahrens { 1377 789 ahrens arc_fini(); 1378 10474 Richard zfetch_fini(); 1379 789 ahrens dnode_fini(); 1380 789 ahrens dbuf_fini(); 1381 5450 brendan l2arc_fini(); 1382 789 ahrens } 1383
Indexes created Fri Nov 27 03:38:04 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.