Lines Matching refs:zio
94 * An allocating zio is one that either currently has the DVA allocate
97 #define IO_IS_ALLOCATING(zio) ((zio)->io_orig_pipeline & ZIO_STAGE_DVA_ALLOCATE)
275 zio_push_transform(zio_t *zio, void *data, uint64_t size, uint64_t bufsize,
280 zt->zt_orig_data = zio->io_data;
281 zt->zt_orig_size = zio->io_size;
285 zt->zt_next = zio->io_transform_stack;
286 zio->io_transform_stack = zt;
288 zio->io_data = data;
289 zio->io_size = size;
293 zio_pop_transforms(zio_t *zio)
297 while ((zt = zio->io_transform_stack) != NULL) {
299 zt->zt_transform(zio,
303 zio_buf_free(zio->io_data, zt->zt_bufsize);
305 zio->io_data = zt->zt_orig_data;
306 zio->io_size = zt->zt_orig_size;
307 zio->io_transform_stack = zt->zt_next;
319 zio_subblock(zio_t *zio, void *data, uint64_t size)
321 ASSERT(zio->io_size > size);
323 if (zio->io_type == ZIO_TYPE_READ)
324 bcopy(zio->io_data, data, size);
328 zio_decompress(zio_t *zio, void *data, uint64_t size)
330 if (zio->io_error == 0 &&
331 zio_decompress_data(BP_GET_COMPRESS(zio->io_bp),
332 zio->io_data, data, zio->io_size, size) != 0)
333 zio->io_error = SET_ERROR(EIO);
433 zio_wait_for_children(zio_t *zio, enum zio_child child, enum zio_wait_type wait)
435 uint64_t *countp = &zio->io_children[child][wait];
438 mutex_enter(&zio->io_lock);
439 ASSERT(zio->io_stall == NULL);
441 zio->io_stage >>= 1;
442 ASSERT3U(zio->io_stage, !=, ZIO_STAGE_OPEN);
443 zio->io_stall = countp;
446 mutex_exit(&zio->io_lock);
452 zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait)
454 uint64_t *countp = &pio->io_children[zio->io_child_type][wait];
455 int *errorp = &pio->io_child_error[zio->io_child_type];
458 if (zio->io_error && !(zio->io_flags & ZIO_FLAG_DONT_PROPAGATE))
459 *errorp = zio_worst_error(*errorp, zio->io_error);
460 pio->io_reexecute |= zio->io_reexecute;
472 * Dispatch the parent zio in its own taskq so that
484 zio_inherit_child_errors(zio_t *zio, enum zio_child c)
486 if (zio->io_child_error[c] != 0 && zio->io_error == 0)
487 zio->io_error = zio->io_child_error[c];
526 zio_t *zio;
538 zio = kmem_cache_alloc(zio_cache, KM_SLEEP);
539 bzero(zio, sizeof (zio_t));
541 mutex_init(&zio->io_lock, NULL, MUTEX_DEFAULT, NULL);
542 cv_init(&zio->io_cv, NULL, CV_DEFAULT, NULL);
544 list_create(&zio->io_parent_list, sizeof (zio_link_t),
546 list_create(&zio->io_child_list, sizeof (zio_link_t),
548 metaslab_trace_init(&zio->io_alloc_list);
551 zio->io_child_type = ZIO_CHILD_VDEV;
553 zio->io_child_type = ZIO_CHILD_GANG;
555 zio->io_child_type = ZIO_CHILD_DDT;
557 zio->io_child_type = ZIO_CHILD_LOGICAL;
560 zio->io_bp = (blkptr_t *)bp;
561 zio->io_bp_copy = *bp;
562 zio->io_bp_orig = *bp;
564 zio->io_child_type == ZIO_CHILD_DDT)
565 zio->io_bp = &zio->io_bp_copy; /* so caller can free */
566 if (zio->io_child_type == ZIO_CHILD_LOGICAL)
567 zio->io_logical = zio;
568 if (zio->io_child_type > ZIO_CHILD_GANG && BP_IS_GANG(bp))
572 zio->io_spa = spa;
573 zio->io_txg = txg;
574 zio->io_done = done;
575 zio->io_private = private;
576 zio->io_type = type;
577 zio->io_priority = priority;
578 zio->io_vd = vd;
579 zio->io_offset = offset;
580 zio->io_orig_data = zio->io_data = data;
581 zio->io_orig_size = zio->io_size = psize;
582 zio->io_lsize = lsize;
583 zio->io_orig_flags = zio->io_flags = flags;
584 zio->io_orig_stage = zio->io_stage = stage;
585 zio->io_orig_pipeline = zio->io_pipeline = pipeline;
586 zio->io_pipeline_trace = ZIO_STAGE_OPEN;
588 zio->io_state[ZIO_WAIT_READY] = (stage >= ZIO_STAGE_READY);
589 zio->io_state[ZIO_WAIT_DONE] = (stage >= ZIO_STAGE_DONE);
592 zio->io_bookmark = *zb;
595 if (zio->io_logical == NULL)
596 zio->io_logical = pio->io_logical;
597 if (zio->io_child_type == ZIO_CHILD_GANG)
598 zio->io_gang_leader = pio->io_gang_leader;
599 zio_add_child(pio, zio);
602 return (zio);
606 zio_destroy(zio_t *zio)
608 metaslab_trace_fini(&zio->io_alloc_list);
609 list_destroy(&zio->io_parent_list);
610 list_destroy(&zio->io_child_list);
611 mutex_destroy(&zio->io_lock);
612 cv_destroy(&zio->io_cv);
613 kmem_cache_free(zio_cache, zio);
620 zio_t *zio;
622 zio = zio_create(pio, spa, 0, NULL, NULL, 0, 0, done, private,
626 return (zio);
722 zio_t *zio;
726 zio = zio_create(pio, spa, BP_PHYSICAL_BIRTH(bp), bp,
732 return (zio);
743 zio_t *zio;
754 zio = zio_create(pio, spa, txg, bp, data, lsize, psize, done, private,
759 zio->io_ready = ready;
760 zio->io_children_ready = children_ready;
761 zio->io_physdone = physdone;
762 zio->io_prop = *zp;
770 if (data == NULL && zio->io_prop.zp_dedup_verify) {
771 zio->io_prop.zp_dedup = zio->io_prop.zp_dedup_verify = B_FALSE;
774 return (zio);
782 zio_t *zio;
784 zio = zio_create(pio, spa, txg, bp, data, size, size, done, private,
788 return (zio);
792 zio_write_override(zio_t *zio, blkptr_t *bp, int copies, boolean_t nopwrite)
794 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
795 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
796 ASSERT(zio->io_stage == ZIO_STAGE_OPEN);
797 ASSERT(zio->io_txg == spa_syncing_txg(zio->io_spa));
804 zio->io_prop.zp_dedup = nopwrite ? B_FALSE : zio->io_prop.zp_dedup;
805 zio->io_prop.zp_nopwrite = nopwrite;
806 zio->io_prop.zp_copies = copies;
807 zio->io_bp_override = bp;
842 zio_t *zio;
863 zio = zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp),
867 return (zio);
874 zio_t *zio;
897 zio = zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp),
900 ASSERT0(zio->io_queued_timestamp);
902 return (zio);
909 zio_t *zio;
913 zio = zio_create(pio, spa, 0, NULL, NULL, 0, 0, done, private,
917 zio->io_cmd = cmd;
919 zio = zio_null(pio, spa, NULL, NULL, NULL, flags);
922 zio_nowait(zio_ioctl(zio, spa, vd->vdev_child[c], cmd,
926 return (zio);
934 zio_t *zio;
941 zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, size, done,
945 zio->io_prop.zp_checksum = checksum;
947 return (zio);
955 zio_t *zio;
962 zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, size, done,
966 zio->io_prop.zp_checksum = checksum;
977 zio_push_transform(zio, wbuf, size, size, NULL);
980 return (zio);
992 zio_t *zio;
1022 * top-level vdev, then the child zio is not an allocating I/O.
1040 zio = zio_create(pio, pio->io_spa, pio->io_txg, bp, data, size, size,
1043 ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
1045 zio->io_physdone = pio->io_physdone;
1046 if (vd->vdev_ops->vdev_op_leaf && zio->io_logical != NULL)
1047 zio->io_logical->io_phys_children++;
1049 return (zio);
1057 zio_t *zio;
1061 zio = zio_create(NULL, vd->vdev_spa, 0, NULL,
1067 return (zio);
1071 zio_flush(zio_t *zio, vdev_t *vd)
1073 zio_nowait(zio_ioctl(zio, zio->io_spa, vd, DKIOCFLUSHWRITECACHE,
1079 zio_shrink(zio_t *zio, uint64_t size)
1081 ASSERT(zio->io_executor == NULL);
1082 ASSERT(zio->io_orig_size == zio->io_size);
1083 ASSERT(size <= zio->io_size);
1090 ASSERT(BP_GET_COMPRESS(zio->io_bp) == ZIO_COMPRESS_OFF);
1091 if (!BP_IS_RAIDZ(zio->io_bp)) {
1093 ASSERT3U(zio->io_size, ==, zio->io_lsize);
1094 zio->io_orig_size = zio->io_size = zio->io_lsize = size;
1105 zio_read_bp_init(zio_t *zio)
1107 blkptr_t *bp = zio->io_bp;
1110 zio->io_child_type == ZIO_CHILD_LOGICAL &&
1111 !(zio->io_flags & ZIO_FLAG_RAW)) {
1116 zio_push_transform(zio, cbuf, psize, psize, zio_decompress);
1120 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1121 decode_embedded_bp_compressed(bp, zio->io_data);
1127 zio->io_flags |= ZIO_FLAG_DONT_CACHE;
1130 zio->io_flags |= ZIO_FLAG_DONT_CACHE;
1132 if (BP_GET_DEDUP(bp) && zio->io_child_type == ZIO_CHILD_LOGICAL)
1133 zio->io_pipeline = ZIO_DDT_READ_PIPELINE;
1139 zio_write_bp_init(zio_t *zio)
1141 if (!IO_IS_ALLOCATING(zio))
1144 ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
1146 if (zio->io_bp_override) {
1147 blkptr_t *bp = zio->io_bp;
1148 zio_prop_t *zp = &zio->io_prop;
1150 ASSERT(bp->blk_birth != zio->io_txg);
1151 ASSERT(BP_GET_DEDUP(zio->io_bp_override) == 0);
1153 *bp = *zio->io_bp_override;
1154 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1167 zio->io_flags |= ZIO_FLAG_NOPWRITE;
1181 zio->io_pipeline |= ZIO_STAGE_DDT_WRITE;
1189 zio->io_bp_override = NULL;
1190 *bp = zio->io_bp_orig;
1191 zio->io_pipeline = zio->io_orig_pipeline;
1198 zio_write_compress(zio_t *zio)
1200 spa_t *spa = zio->io_spa;
1201 zio_prop_t *zp = &zio->io_prop;
1203 blkptr_t *bp = zio->io_bp;
1204 uint64_t lsize = zio->io_lsize;
1205 uint64_t psize = zio->io_size;
1208 EQUIV(lsize != psize, (zio->io_flags & ZIO_FLAG_RAW) != 0);
1214 if (zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_READY) ||
1215 zio_wait_for_children(zio, ZIO_CHILD_LOGICAL, ZIO_WAIT_READY))
1218 if (!IO_IS_ALLOCATING(zio))
1221 if (zio->io_children_ready != NULL) {
1224 * associated with this zio in case it wants to modify the
1228 zio->io_children_ready(zio);
1231 ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
1232 ASSERT(zio->io_bp_override == NULL);
1234 if (!BP_IS_HOLE(bp) && bp->blk_birth == zio->io_txg) {
1246 ASSERT(zio->io_txg == spa_syncing_txg(spa));
1247 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1261 psize = zio_compress_data(compress, zio->io_data, cbuf, lsize);
1271 BP_SET_TYPE(bp, zio->io_prop.zp_type);
1272 BP_SET_LEVEL(bp, zio->io_prop.zp_level);
1274 bp->blk_birth = zio->io_txg;
1275 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1298 zio_push_transform(zio, cbuf,
1307 zio->io_bp_override = NULL;
1308 *bp = zio->io_bp_orig;
1309 zio->io_pipeline = zio->io_orig_pipeline;
1322 if (!BP_IS_HOLE(bp) && bp->blk_birth == zio->io_txg &&
1326 enum zio_stage gang_stages = zio->io_pipeline & ZIO_GANG_STAGES;
1327 zio->io_pipeline = ZIO_REWRITE_PIPELINE | gang_stages;
1328 zio->io_flags |= ZIO_FLAG_IO_REWRITE;
1331 zio->io_pipeline = ZIO_WRITE_PIPELINE;
1335 if (zio->io_bp_orig.blk_birth != 0 &&
1340 BP_SET_BIRTH(bp, zio->io_txg, 0);
1342 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1354 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1355 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
1356 zio->io_pipeline = ZIO_DDT_WRITE_PIPELINE;
1359 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1360 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
1361 zio->io_pipeline |= ZIO_STAGE_NOP_WRITE;
1368 zio_free_bp_init(zio_t *zio)
1370 blkptr_t *bp = zio->io_bp;
1372 if (zio->io_child_type == ZIO_CHILD_LOGICAL) {
1374 zio->io_pipeline = ZIO_DDT_FREE_PIPELINE;
1387 zio_taskq_dispatch(zio_t *zio, zio_taskq_type_t q, boolean_t cutinline)
1389 spa_t *spa = zio->io_spa;
1390 zio_type_t t = zio->io_type;
1398 if (zio->io_flags & (ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_PROBE))
1404 if (t == ZIO_TYPE_WRITE && zio->io_vd && zio->io_vd->vdev_aux)
1411 if (zio->io_priority == ZIO_PRIORITY_NOW &&
1418 * NB: We are assuming that the zio can only be dispatched
1420 * to dispatch the zio to another taskq at the same time.
1422 ASSERT(zio->io_tqent.tqent_next == NULL);
1423 spa_taskq_dispatch_ent(spa, t, q, (task_func_t *)zio_execute, zio,
1424 flags, &zio->io_tqent);
1428 zio_taskq_member(zio_t *zio, zio_taskq_type_t q)
1430 kthread_t *executor = zio->io_executor;
1431 spa_t *spa = zio->io_spa;
1446 zio_issue_async(zio_t *zio)
1448 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
1454 zio_interrupt(zio_t *zio)
1456 zio_taskq_dispatch(zio, ZIO_TASKQ_INTERRUPT, B_FALSE);
1460 zio_delay_interrupt(zio_t *zio)
1464 * rather than trying to implement the function, the zio delay
1472 * delay; issuing it directly to the zio layer.
1474 if (zio->io_target_timestamp != 0) {
1477 if (now >= zio->io_target_timestamp) {
1482 * directly to the zio layer. This is likely due to
1489 DTRACE_PROBE2(zio__delay__miss, zio_t *, zio,
1492 zio_interrupt(zio);
1494 hrtime_t diff = zio->io_target_timestamp - now;
1496 DTRACE_PROBE3(zio__delay__hit, zio_t *, zio,
1500 (void (*)(void *))zio_interrupt, zio, diff, 1, 0);
1507 DTRACE_PROBE1(zio__delay__skip, zio_t *, zio);
1508 zio_interrupt(zio);
1530 zio_execute(zio_t *zio)
1532 zio->io_executor = curthread;
1534 ASSERT3U(zio->io_queued_timestamp, >, 0);
1536 while (zio->io_stage < ZIO_STAGE_DONE) {
1537 enum zio_stage pipeline = zio->io_pipeline;
1538 enum zio_stage stage = zio->io_stage;
1541 ASSERT(!MUTEX_HELD(&zio->io_lock));
1543 ASSERT(zio->io_stall == NULL);
1560 if ((stage & ZIO_BLOCKING_STAGES) && zio->io_vd == NULL &&
1561 zio_taskq_member(zio, ZIO_TASKQ_INTERRUPT)) {
1564 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, cut);
1568 zio->io_stage = stage;
1569 zio->io_pipeline_trace |= zio->io_stage;
1570 rv = zio_pipeline[highbit64(stage) - 1](zio);
1585 zio_wait(zio_t *zio)
1589 ASSERT(zio->io_stage == ZIO_STAGE_OPEN);
1590 ASSERT(zio->io_executor == NULL);
1592 zio->io_waiter = curthread;
1593 ASSERT0(zio->io_queued_timestamp);
1594 zio->io_queued_timestamp = gethrtime();
1596 zio_execute(zio);
1598 mutex_enter(&zio->io_lock);
1599 while (zio->io_executor != NULL)
1600 cv_wait(&zio->io_cv, &zio->io_lock);
1601 mutex_exit(&zio->io_lock);
1603 error = zio->io_error;
1604 zio_destroy(zio);
1610 zio_nowait(zio_t *zio)
1612 ASSERT(zio->io_executor == NULL);
1614 if (zio->io_child_type == ZIO_CHILD_LOGICAL &&
1615 zio_unique_parent(zio) == NULL) {
1621 spa_t *spa = zio->io_spa;
1623 zio_add_child(spa->spa_async_zio_root[CPU_SEQID], zio);
1626 ASSERT0(zio->io_queued_timestamp);
1627 zio->io_queued_timestamp = gethrtime();
1628 zio_execute(zio);
1691 zio_suspend(spa_t *spa, zio_t *zio)
1709 if (zio != NULL) {
1710 ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
1711 ASSERT(zio != spa->spa_suspend_zio_root);
1712 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1713 ASSERT(zio_unique_parent(zio) == NULL);
1714 ASSERT(zio->io_stage == ZIO_STAGE_DONE);
1715 zio_add_child(spa->spa_suspend_zio_root, zio);
1832 zio_t *zio;
1835 zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
1848 zio_checksum_compute(zio, BP_GET_CHECKSUM(bp),
1856 zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
1858 zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
1863 return (zio);
1891 static void zio_gang_tree_assemble_done(zio_t *zio);
1948 zio_gang_tree_assemble_done(zio_t *zio)
1950 zio_t *gio = zio->io_gang_leader;
1951 zio_gang_node_t *gn = zio->io_private;
1952 blkptr_t *bp = zio->io_bp;
1954 ASSERT(gio == zio_unique_parent(zio));
1955 ASSERT(zio->io_child_count == 0);
1957 if (zio->io_error)
1961 byteswap_uint64_array(zio->io_data, zio->io_size);
1963 ASSERT(zio->io_data == gn->gn_gbh);
1964 ASSERT(zio->io_size == SPA_GANGBLOCKSIZE);
1979 zio_t *zio;
1989 zio = zio_gang_issue_func[gio->io_type](pio, bp, gn, data);
1998 zio_gang_tree_issue(zio, gn->gn_child[g], gbp, data);
2006 if (zio != pio)
2007 zio_nowait(zio);
2011 zio_gang_assemble(zio_t *zio)
2013 blkptr_t *bp = zio->io_bp;
2015 ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == NULL);
2016 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2018 zio->io_gang_leader = zio;
2020 zio_gang_tree_assemble(zio, bp, &zio->io_gang_tree);
2026 zio_gang_issue(zio_t *zio)
2028 blkptr_t *bp = zio->io_bp;
2030 if (zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_DONE))
2033 ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == zio);
2034 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2036 if (zio->io_child_error[ZIO_CHILD_GANG] == 0)
2037 zio_gang_tree_issue(zio, zio->io_gang_tree, bp, zio->io_data);
2039 zio_gang_tree_free(&zio->io_gang_tree);
2041 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
2047 zio_write_gang_member_ready(zio_t *zio)
2049 zio_t *pio = zio_unique_parent(zio);
2050 zio_t *gio = zio->io_gang_leader;
2051 dva_t *cdva = zio->io_bp->blk_dva;
2055 if (BP_IS_HOLE(zio->io_bp))
2058 ASSERT(BP_IS_HOLE(&zio->io_bp_orig));
2060 ASSERT(zio->io_child_type == ZIO_CHILD_GANG);
2061 ASSERT3U(zio->io_prop.zp_copies, ==, gio->io_prop.zp_copies);
2062 ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(zio->io_bp));
2064 ASSERT3U(BP_GET_NDVAS(zio->io_bp), <=, BP_GET_NDVAS(pio->io_bp));
2067 for (int d = 0; d < BP_GET_NDVAS(zio->io_bp); d++) {
2083 zio_t *zio;
2103 * The logical zio has already placed a reservation for
2150 zio = zio_rewrite(pio, spa, txg, bp, gbh, SPA_GANGBLOCKSIZE, NULL, NULL,
2170 zio_t *cio = zio_write(zio, spa, txg, &gbh->zg_blkptr[g],
2192 * Set pio's pipeline to just wait for zio to finish.
2196 zio_nowait(zio);
2220 zio_nop_write(zio_t *zio)
2222 blkptr_t *bp = zio->io_bp;
2223 blkptr_t *bp_orig = &zio->io_bp_orig;
2224 zio_prop_t *zp = &zio->io_prop;
2227 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
2230 ASSERT(zio->io_bp_override == NULL);
2231 ASSERT(IO_IS_ALLOCATING(zio));
2262 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
2263 zio->io_flags |= ZIO_FLAG_NOPWRITE;
2275 zio_ddt_child_read_done(zio_t *zio)
2277 blkptr_t *bp = zio->io_bp;
2278 ddt_entry_t *dde = zio->io_private;
2280 zio_t *pio = zio_unique_parent(zio);
2284 if (zio->io_error == 0)
2286 if (zio->io_error == 0 && dde->dde_repair_data == NULL)
2287 dde->dde_repair_data = zio->io_data;
2289 zio_buf_free(zio->io_data, zio->io_size);
2294 zio_ddt_read_start(zio_t *zio)
2296 blkptr_t *bp = zio->io_bp;
2299 ASSERT(BP_GET_PSIZE(bp) == zio->io_size);
2300 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
2302 if (zio->io_child_error[ZIO_CHILD_DDT]) {
2303 ddt_t *ddt = ddt_select(zio->io_spa, bp);
2309 ASSERT(zio->io_vsd == NULL);
2310 zio->io_vsd = dde;
2320 zio_nowait(zio_read(zio, zio->io_spa, &blk,
2321 zio_buf_alloc(zio->io_size), zio->io_size,
2322 zio_ddt_child_read_done, dde, zio->io_priority,
2323 ZIO_DDT_CHILD_FLAGS(zio) | ZIO_FLAG_DONT_PROPAGATE,
2324 &zio->io_bookmark));
2329 zio_nowait(zio_read(zio, zio->io_spa, bp,
2330 zio->io_data, zio->io_size, NULL, NULL, zio->io_priority,
2331 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark));
2337 zio_ddt_read_done(zio_t *zio)
2339 blkptr_t *bp = zio->io_bp;
2341 if (zio_wait_for_children(zio, ZIO_CHILD_DDT, ZIO_WAIT_DONE))
2345 ASSERT(BP_GET_PSIZE(bp) == zio->io_size);
2346 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
2348 if (zio->io_child_error[ZIO_CHILD_DDT]) {
2349 ddt_t *ddt = ddt_select(zio->io_spa, bp);
2350 ddt_entry_t *dde = zio->io_vsd;
2352 ASSERT(spa_load_state(zio->io_spa) != SPA_LOAD_NONE);
2356 zio->io_stage = ZIO_STAGE_DDT_READ_START >> 1;
2357 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
2361 bcopy(dde->dde_repair_data, zio->io_data, zio->io_size);
2362 zio->io_child_error[ZIO_CHILD_DDT] = 0;
2365 zio->io_vsd = NULL;
2368 ASSERT(zio->io_vsd == NULL);
2374 zio_ddt_collision(zio_t *zio, ddt_t *ddt, ddt_entry_t *dde)
2376 spa_t *spa = zio->io_spa;
2377 boolean_t do_raw = (zio->io_flags & ZIO_FLAG_RAW);
2379 /* We should never get a raw, override zio */
2380 ASSERT(!(zio->io_bp_override && do_raw));
2384 * because when zio->io_bp is an override bp, we will not have
2392 return (lio->io_orig_size != zio->io_orig_size ||
2393 bcmp(zio->io_orig_data, lio->io_orig_data,
2394 zio->io_orig_size) != 0);
2405 blkptr_t blk = *zio->io_bp;
2423 ASSERT3U(zio->io_size, ==, zio->io_orig_size);
2424 ASSERT0(bcmp(zio->io_data, zio->io_orig_data,
2425 zio->io_size));
2426 ASSERT3P(zio->io_transform_stack, ==, NULL);
2431 zio_flags, &aflags, &zio->io_bookmark);
2434 if (arc_buf_size(abuf) != zio->io_orig_size ||
2435 bcmp(abuf->b_data, zio->io_orig_data,
2436 zio->io_orig_size) != 0)
2450 zio_ddt_child_write_ready(zio_t *zio)
2452 int p = zio->io_prop.zp_copies;
2453 ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp);
2454 ddt_entry_t *dde = zio->io_private;
2458 if (zio->io_error)
2463 ASSERT(dde->dde_lead_zio[p] == zio);
2465 ddt_phys_fill(ddp, zio->io_bp);
2468 while ((pio = zio_walk_parents(zio, &zl)) != NULL)
2469 ddt_bp_fill(ddp, pio->io_bp, zio->io_txg);
2475 zio_ddt_child_write_done(zio_t *zio)
2477 int p = zio->io_prop.zp_copies;
2478 ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp);
2479 ddt_entry_t *dde = zio->io_private;
2485 ASSERT(dde->dde_lead_zio[p] == zio);
2488 if (zio->io_error == 0) {
2490 while (zio_walk_parents(zio, &zl) != NULL)
2500 zio_ddt_ditto_write_done(zio_t *zio)
2503 zio_prop_t *zp = &zio->io_prop;
2504 blkptr_t *bp = zio->io_bp;
2505 ddt_t *ddt = ddt_select(zio->io_spa, bp);
2506 ddt_entry_t *dde = zio->io_private;
2513 ASSERT(dde->dde_lead_zio[p] == zio);
2516 if (zio->io_error == 0) {
2521 ddt_phys_free(ddt, ddk, ddp, zio->io_txg);
2529 zio_ddt_write(zio_t *zio)
2531 spa_t *spa = zio->io_spa;
2532 blkptr_t *bp = zio->io_bp;
2533 uint64_t txg = zio->io_txg;
2534 zio_prop_t *zp = &zio->io_prop;
2545 ASSERT(BP_IS_HOLE(bp) || zio->io_bp_override);
2546 ASSERT(!(zio->io_bp_override && (zio->io_flags & ZIO_FLAG_RAW)));
2552 if (zp->zp_dedup_verify && zio_ddt_collision(zio, ddt, dde)) {
2562 zio_pop_transforms(zio);
2563 zio->io_stage = ZIO_STAGE_OPEN;
2570 zio->io_pipeline = ZIO_WRITE_PIPELINE;
2591 if (zio->io_bp_override) {
2592 zio_pop_transforms(zio);
2593 zio->io_stage = ZIO_STAGE_OPEN;
2594 zio->io_pipeline = ZIO_WRITE_PIPELINE;
2595 zio->io_bp_override = NULL;
2601 dio = zio_write(zio, spa, txg, bp, zio->io_orig_data,
2602 zio->io_orig_size, zio->io_orig_size, &czp, NULL, NULL,
2603 NULL, zio_ddt_ditto_write_done, dde, zio->io_priority,
2604 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark);
2606 zio_push_transform(dio, zio->io_data, zio->io_size, 0, NULL);
2614 zio_add_child(zio, dde->dde_lead_zio[p]);
2617 } else if (zio->io_bp_override) {
2619 ASSERT(BP_EQUAL(bp, zio->io_bp_override));
2623 cio = zio_write(zio, spa, txg, bp, zio->io_orig_data,
2624 zio->io_orig_size, zio->io_orig_size, zp,
2626 zio_ddt_child_write_done, dde, zio->io_priority,
2627 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark);
2629 zio_push_transform(cio, zio->io_data, zio->io_size, 0, NULL);
2646 zio_ddt_free(zio_t *zio)
2648 spa_t *spa = zio->io_spa;
2649 blkptr_t *bp = zio->io_bp;
2655 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
2675 zio_t *zio;
2679 zio = avl_first(&spa->spa_alloc_tree);
2680 if (zio == NULL)
2683 ASSERT(IO_IS_ALLOCATING(zio));
2686 * Try to place a reservation for this zio. If we're unable to
2690 zio->io_prop.zp_copies, zio, 0)) {
2694 avl_remove(&spa->spa_alloc_tree, zio);
2695 ASSERT3U(zio->io_stage, <, ZIO_STAGE_DVA_ALLOCATE);
2697 return (zio);
2701 zio_dva_throttle(zio_t *zio)
2703 spa_t *spa = zio->io_spa;
2706 if (zio->io_priority == ZIO_PRIORITY_SYNC_WRITE ||
2707 !spa_normal_class(zio->io_spa)->mc_alloc_throttle_enabled ||
2708 zio->io_child_type == ZIO_CHILD_GANG ||
2709 zio->io_flags & ZIO_FLAG_NODATA) {
2713 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2715 ASSERT3U(zio->io_queued_timestamp, >, 0);
2716 ASSERT(zio->io_stage == ZIO_STAGE_DVA_THROTTLE);
2720 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
2721 avl_add(&spa->spa_alloc_tree, zio);
2723 nio = zio_io_to_allocate(zio->io_spa);
2726 if (nio == zio)
2731 zio->io_queued_timestamp);
2734 * We are passing control to a new zio so make sure that
2749 zio_t *zio;
2752 zio = zio_io_to_allocate(spa);
2754 if (zio == NULL)
2757 ASSERT3U(zio->io_stage, ==, ZIO_STAGE_DVA_THROTTLE);
2758 ASSERT0(zio->io_error);
2759 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_TRUE);
2763 zio_dva_allocate(zio_t *zio)
2765 spa_t *spa = zio->io_spa;
2767 blkptr_t *bp = zio->io_bp;
2771 if (zio->io_gang_leader == NULL) {
2772 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2773 zio->io_gang_leader = zio;
2778 ASSERT3U(zio->io_prop.zp_copies, >, 0);
2779 ASSERT3U(zio->io_prop.zp_copies, <=, spa_max_replication(spa));
2780 ASSERT3U(zio->io_size, ==, BP_GET_PSIZE(bp));
2782 if (zio->io_flags & ZIO_FLAG_NODATA) {
2785 if (zio->io_flags & ZIO_FLAG_GANG_CHILD) {
2788 if (zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE) {
2792 error = metaslab_alloc(spa, mc, zio->io_size, bp,
2793 zio->io_prop.zp_copies, zio->io_txg, NULL, flags,
2794 &zio->io_alloc_list, zio);
2797 spa_dbgmsg(spa, "%s: metaslab allocation failure: zio %p, "
2798 "size %llu, error %d", spa_name(spa), zio, zio->io_size,
2800 if (error == ENOSPC && zio->io_size > SPA_MINBLOCKSIZE)
2801 return (zio_write_gang_block(zio));
2802 zio->io_error = error;
2809 zio_dva_free(zio_t *zio)
2811 metaslab_free(zio->io_spa, zio->io_bp, zio->io_txg, B_FALSE);
2817 zio_dva_claim(zio_t *zio)
2821 error = metaslab_claim(zio->io_spa, zio->io_bp, zio->io_txg);
2823 zio->io_error = error;
2834 zio_dva_unallocate(zio_t *zio, zio_gang_node_t *gn, blkptr_t *bp)
2836 ASSERT(bp->blk_birth == zio->io_txg || BP_IS_HOLE(bp));
2837 ASSERT(zio->io_bp_override == NULL);
2840 metaslab_free(zio->io_spa, bp, bp->blk_birth, B_TRUE);
2844 zio_dva_unallocate(zio, gn->gn_child[g],
2923 zio_vdev_io_start(zio_t *zio)
2925 vdev_t *vd = zio->io_vd;
2927 spa_t *spa = zio->io_spa;
2929 ASSERT(zio->io_error == 0);
2930 ASSERT(zio->io_child_error[ZIO_CHILD_VDEV] == 0);
2933 if (!(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
2934 spa_config_enter(spa, SCL_ZIO, zio, RW_READER);
2939 vdev_mirror_ops.vdev_op_io_start(zio);
2943 ASSERT3P(zio->io_logical, !=, zio);
2955 if (!(zio->io_flags & ZIO_FLAG_SCAN_THREAD) && zio->io_bp != NULL &&
2957 zio->io_bookmark.zb_objset != DMU_META_OBJSET &&
2958 zio->io_txg != spa_syncing_txg(spa)) {
2967 if (!(zio->io_flags & ZIO_FLAG_PHYSICAL) &&
2968 P2PHASE(zio->io_size, align) != 0) {
2970 uint64_t asize = P2ROUNDUP(zio->io_size, align);
2973 if (zio->io_type == ZIO_TYPE_WRITE) {
2974 bcopy(zio->io_data, abuf, zio->io_size);
2975 bzero(abuf + zio->io_size, asize - zio->io_size);
2977 zio_push_transform(zio, abuf, asize, asize, zio_subblock);
2984 if (!(zio->io_flags & ZIO_FLAG_PHYSICAL)) {
2985 ASSERT0(P2PHASE(zio->io_offset, align));
2986 ASSERT0(P2PHASE(zio->io_size, align));
2992 ASSERT0(P2PHASE(zio->io_offset, SPA_MINBLOCKSIZE));
2993 ASSERT0(P2PHASE(zio->io_size, SPA_MINBLOCKSIZE));
2996 VERIFY(zio->io_type != ZIO_TYPE_WRITE || spa_writeable(spa));
3001 * then don't do the I/O unless zio's txg is actually in vd's DTL.
3011 if ((zio->io_flags & ZIO_FLAG_IO_REPAIR) &&
3012 !(zio->io_flags & ZIO_FLAG_SELF_HEAL) &&
3013 zio->io_txg != 0 && /* not a delegated i/o */
3014 !vdev_dtl_contains(vd, DTL_PARTIAL, zio->io_txg, 1)) {
3015 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
3016 zio_vdev_io_bypass(zio);
3021 (zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE)) {
3023 if (zio->io_type == ZIO_TYPE_READ && vdev_cache_read(zio))
3026 if ((zio = vdev_queue_io(zio)) == NULL)
3029 if (!vdev_accessible(vd, zio)) {
3030 zio->io_error = SET_ERROR(ENXIO);
3031 zio_interrupt(zio);
3036 vd->vdev_ops->vdev_op_io_start(zio);
3041 zio_vdev_io_done(zio_t *zio)
3043 vdev_t *vd = zio->io_vd;
3047 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV, ZIO_WAIT_DONE))
3050 ASSERT(zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE);
3054 vdev_queue_io_done(zio);
3056 if (zio->io_type == ZIO_TYPE_WRITE)
3057 vdev_cache_write(zio);
3059 if (zio_injection_enabled && zio->io_error == 0)
3060 zio->io_error = zio_handle_device_injection(vd,
3061 zio, EIO);
3063 if (zio_injection_enabled && zio->io_error == 0)
3064 zio->io_error = zio_handle_label_injection(zio, EIO);
3066 if (zio->io_error) {
3067 if (!vdev_accessible(vd, zio)) {
3068 zio->io_error = SET_ERROR(ENXIO);
3075 ops->vdev_op_io_done(zio);
3078 VERIFY(vdev_probe(vd, zio) == NULL);
3097 zio_vsd_default_cksum_report(zio_t *zio, zio_cksum_report_t *zcr, void *ignored)
3099 void *buf = zio_buf_alloc(zio->io_size);
3101 bcopy(zio->io_data, buf, zio->io_size);
3103 zcr->zcr_cbinfo = zio->io_size;
3110 zio_vdev_io_assess(zio_t *zio)
3112 vdev_t *vd = zio->io_vd;
3114 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV, ZIO_WAIT_DONE))
3117 if (vd == NULL && !(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
3118 spa_config_exit(zio->io_spa, SCL_ZIO, zio);
3120 if (zio->io_vsd != NULL) {
3121 zio->io_vsd_ops->vsd_free(zio);
3122 zio->io_vsd = NULL;
3125 if (zio_injection_enabled && zio->io_error == 0)
3126 zio->io_error = zio_handle_fault_injection(zio, EIO);
3134 if (zio->io_error && vd == NULL &&
3135 !(zio->io_flags & (ZIO_FLAG_DONT_RETRY | ZIO_FLAG_IO_RETRY))) {
3136 ASSERT(!(zio->io_flags & ZIO_FLAG_DONT_QUEUE)); /* not a leaf */
3137 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_BYPASS)); /* not a leaf */
3138 zio->io_error = 0;
3139 zio->io_flags |= ZIO_FLAG_IO_RETRY |
3141 zio->io_stage = ZIO_STAGE_VDEV_IO_START >> 1;
3142 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE,
3151 if (zio->io_error && vd != NULL && vd->vdev_ops->vdev_op_leaf &&
3152 !vdev_accessible(vd, zio))
3153 zio->io_error = SET_ERROR(ENXIO);
3159 if (zio->io_error == ENXIO && zio->io_type == ZIO_TYPE_WRITE &&
3169 if ((zio->io_error == ENOTSUP || zio->io_error == ENOTTY) &&
3170 zio->io_type == ZIO_TYPE_IOCTL &&
3171 zio->io_cmd == DKIOCFLUSHWRITECACHE && vd != NULL)
3174 if (zio->io_error)
3175 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
3178 zio->io_physdone != NULL) {
3179 ASSERT(!(zio->io_flags & ZIO_FLAG_DELEGATED));
3180 ASSERT(zio->io_child_type == ZIO_CHILD_VDEV);
3181 zio->io_physdone(zio->io_logical);
3188 zio_vdev_io_reissue(zio_t *zio)
3190 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START);
3191 ASSERT(zio->io_error == 0);
3193 zio->io_stage >>= 1;
3197 zio_vdev_io_redone(zio_t *zio)
3199 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_DONE);
3201 zio->io_stage >>= 1;
3205 zio_vdev_io_bypass(zio_t *zio)
3207 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START);
3208 ASSERT(zio->io_error == 0);
3210 zio->io_flags |= ZIO_FLAG_IO_BYPASS;
3211 zio->io_stage = ZIO_STAGE_VDEV_IO_ASSESS >> 1;
3220 zio_checksum_generate(zio_t *zio)
3222 blkptr_t *bp = zio->io_bp;
3230 checksum = zio->io_prop.zp_checksum;
3237 if (BP_IS_GANG(bp) && zio->io_child_type == ZIO_CHILD_GANG) {
3238 ASSERT(!IO_IS_ALLOCATING(zio));
3245 zio_checksum_compute(zio, checksum, zio->io_data, zio->io_size);
3251 zio_checksum_verify(zio_t *zio)
3254 blkptr_t *bp = zio->io_bp;
3257 ASSERT(zio->io_vd != NULL);
3264 if (zio->io_prop.zp_checksum == ZIO_CHECKSUM_OFF)
3267 ASSERT(zio->io_prop.zp_checksum == ZIO_CHECKSUM_LABEL);
3270 if ((error = zio_checksum_error(zio, &info)) != 0) {
3271 zio->io_error = error;
3273 !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
3274 zfs_ereport_start_checksum(zio->io_spa,
3275 zio->io_vd, zio, zio->io_offset,
3276 zio->io_size, NULL, &info);
3287 zio_checksum_verified(zio_t *zio)
3289 zio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY;
3324 zio_ready(zio_t *zio)
3326 blkptr_t *bp = zio->io_bp;
3330 if (zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_READY) ||
3331 zio_wait_for_children(zio, ZIO_CHILD_DDT, ZIO_WAIT_READY))
3334 if (zio->io_ready) {
3335 ASSERT(IO_IS_ALLOCATING(zio));
3336 ASSERT(bp->blk_birth == zio->io_txg || BP_IS_HOLE(bp) ||
3337 (zio->io_flags & ZIO_FLAG_NOPWRITE));
3338 ASSERT(zio->io_children[ZIO_CHILD_GANG][ZIO_WAIT_READY] == 0);
3340 zio->io_ready(zio);
3343 if (bp != NULL && bp != &zio->io_bp_copy)
3344 zio->io_bp_copy = *bp;
3346 if (zio->io_error != 0) {
3347 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
3349 if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
3350 ASSERT(IO_IS_ALLOCATING(zio));
3351 ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
3357 spa_normal_class(zio->io_spa),
3358 zio->io_prop.zp_copies, zio);
3359 zio_allocate_dispatch(zio->io_spa);
3363 mutex_enter(&zio->io_lock);
3364 zio->io_state[ZIO_WAIT_READY] = 1;
3365 pio = zio_walk_parents(zio, &zl);
3366 mutex_exit(&zio->io_lock);
3369 * As we notify zio's parents, new parents could be added.
3370 * New parents go to the head of zio's io_parent_list, however,
3371 * so we will (correctly) not notify them. The remainder of zio's
3376 pio_next = zio_walk_parents(zio, &zl);
3377 zio_notify_parent(pio, zio, ZIO_WAIT_READY);
3380 if (zio->io_flags & ZIO_FLAG_NODATA) {
3382 zio->io_flags &= ~ZIO_FLAG_NODATA;
3384 ASSERT((uintptr_t)zio->io_data < SPA_MAXBLOCKSIZE);
3385 zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
3390 zio->io_spa->spa_syncing_txg == zio->io_txg)
3391 zio_handle_ignored_writes(zio);
3400 zio_dva_throttle_done(zio_t *zio)
3402 zio_t *lio = zio->io_logical;
3403 zio_t *pio = zio_unique_parent(zio);
3404 vdev_t *vd = zio->io_vd;
3407 ASSERT3P(zio->io_bp, !=, NULL);
3408 ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
3409 ASSERT3U(zio->io_priority, ==, ZIO_PRIORITY_ASYNC_WRITE);
3410 ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
3413 ASSERT(!(zio->io_flags & (ZIO_FLAG_IO_REPAIR | ZIO_FLAG_IO_RETRY)));
3414 ASSERT(zio->io_flags & ZIO_FLAG_IO_ALLOCATING);
3422 * throttle needs to know the allocating parent zio so we must find
3436 ASSERT3P(zio, !=, zio->io_logical);
3437 ASSERT(zio->io_logical != NULL);
3438 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REPAIR));
3439 ASSERT0(zio->io_flags & ZIO_FLAG_NOPWRITE);
3442 metaslab_group_alloc_decrement(zio->io_spa, vd->vdev_id, pio, flags);
3445 metaslab_class_throttle_unreserve(spa_normal_class(zio->io_spa),
3453 zio_allocate_dispatch(zio->io_spa);
3457 zio_done(zio_t *zio)
3459 spa_t *spa = zio->io_spa;
3460 zio_t *lio = zio->io_logical;
3461 blkptr_t *bp = zio->io_bp;
3462 vdev_t *vd = zio->io_vd;
3463 uint64_t psize = zio->io_size;
3472 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV, ZIO_WAIT_DONE) ||
3473 zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_DONE) ||
3474 zio_wait_for_children(zio, ZIO_CHILD_DDT, ZIO_WAIT_DONE) ||
3475 zio_wait_for_children(zio, ZIO_CHILD_LOGICAL, ZIO_WAIT_DONE))
3484 if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING &&
3485 zio->io_child_type == ZIO_CHILD_VDEV) {
3487 zio_dva_throttle_done(zio);
3494 if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
3495 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
3496 ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
3498 metaslab_group_alloc_verify(spa, zio->io_bp, zio);
3499 VERIFY(refcount_not_held(&mc->mc_alloc_slots, zio));
3504 ASSERT(zio->io_children[c][w] == 0);
3509 ASSERT(bcmp(bp, &zio->io_bp_copy, sizeof (blkptr_t)) == 0 ||
3510 (bp == zio_unique_parent(zio)->io_bp));
3511 if (zio->io_type == ZIO_TYPE_WRITE && !BP_IS_HOLE(bp) &&
3512 zio->io_bp_override == NULL &&
3513 !(zio->io_flags & ZIO_FLAG_IO_REPAIR)) {
3515 ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(bp));
3519 if (zio->io_flags & ZIO_FLAG_NOPWRITE)
3520 VERIFY(BP_EQUAL(bp, &zio->io_bp_orig));
3526 zio_inherit_child_errors(zio, ZIO_CHILD_VDEV);
3527 zio_inherit_child_errors(zio, ZIO_CHILD_GANG);
3528 zio_inherit_child_errors(zio, ZIO_CHILD_DDT);
3534 if (zio->io_error == 0) {
3535 while (zio->io_cksum_report != NULL) {
3536 zio_cksum_report_t *zcr = zio->io_cksum_report;
3539 char *abuf = zio->io_data;
3543 bcopy(zio->io_data, abuf, psize);
3547 zio->io_cksum_report = zcr->zcr_next;
3557 zio_pop_transforms(zio); /* note: may set zio->io_error */
3559 vdev_stat_update(zio, psize);
3561 if (zio->io_error) {
3568 if (zio->io_error != ECKSUM && vd != NULL && !vdev_is_dead(vd))
3569 zfs_ereport_post(FM_EREPORT_ZFS_IO, spa, vd, zio, 0, 0);
3571 if ((zio->io_error == EIO || !(zio->io_flags &
3573 zio == lio) {
3578 spa_log_error(spa, zio);
3579 zfs_ereport_post(FM_EREPORT_ZFS_DATA, spa, NULL, zio,
3584 if (zio->io_error && zio == lio) {
3586 * Determine whether zio should be reexecuted. This will
3590 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
3592 if (IO_IS_ALLOCATING(zio) &&
3593 !(zio->io_flags & ZIO_FLAG_CANFAIL)) {
3594 if (zio->io_error != ENOSPC)
3595 zio->io_reexecute |= ZIO_REEXECUTE_NOW;
3597 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
3600 if ((zio->io_type == ZIO_TYPE_READ ||
3601 zio->io_type == ZIO_TYPE_FREE) &&
3602 !(zio->io_flags & ZIO_FLAG_SCAN_THREAD) &&
3603 zio->io_error == ENXIO &&
3606 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
3608 if (!(zio->io_flags & ZIO_FLAG_CANFAIL) && !zio->io_reexecute)
3609 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
3623 * errors with errors that happened to the zio itself when
3626 zio_inherit_child_errors(zio, ZIO_CHILD_LOGICAL);
3628 if ((zio->io_error || zio->io_reexecute) &&
3629 IO_IS_ALLOCATING(zio) && zio->io_gang_leader == zio &&
3630 !(zio->io_flags & (ZIO_FLAG_IO_REWRITE | ZIO_FLAG_NOPWRITE)))
3631 zio_dva_unallocate(zio, zio->io_gang_tree, bp);
3633 zio_gang_tree_free(&zio->io_gang_tree);
3638 if ((zio->io_flags & ZIO_FLAG_GODFATHER) &&
3639 (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND))
3640 zio->io_reexecute = 0;
3642 if (zio->io_reexecute) {
3656 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
3658 zio->io_gang_leader = NULL;
3660 mutex_enter(&zio->io_lock);
3661 zio->io_state[ZIO_WAIT_DONE] = 1;
3662 mutex_exit(&zio->io_lock);
3672 for (pio = zio_walk_parents(zio, &zl); pio != NULL;
3675 pio_next = zio_walk_parents(zio, &zl);
3678 (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND)) {
3679 zio_remove_child(pio, zio, remove_zl);
3680 zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
3684 if ((pio = zio_unique_parent(zio)) != NULL) {
3690 ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
3691 zio->io_flags |= ZIO_FLAG_DONT_PROPAGATE;
3692 zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
3693 } else if (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND) {
3698 zio_suspend(spa, zio);
3704 ASSERT(zio->io_tqent.tqent_next == NULL);
3706 ZIO_TASKQ_ISSUE, (task_func_t *)zio_reexecute, zio,
3707 0, &zio->io_tqent);
3712 ASSERT(zio->io_child_count == 0);
3713 ASSERT(zio->io_reexecute == 0);
3714 ASSERT(zio->io_error == 0 || (zio->io_flags & ZIO_FLAG_CANFAIL));
3719 while (zio->io_cksum_report != NULL) {
3720 zio_cksum_report_t *zcr = zio->io_cksum_report;
3721 zio->io_cksum_report = zcr->zcr_next;
3729 * particular zio is no longer discoverable for adoption, and as
3732 if (zio->io_done)
3733 zio->io_done(zio);
3735 mutex_enter(&zio->io_lock);
3736 zio->io_state[ZIO_WAIT_DONE] = 1;
3737 mutex_exit(&zio->io_lock);
3740 for (pio = zio_walk_parents(zio, &zl); pio != NULL; pio = pio_next) {
3742 pio_next = zio_walk_parents(zio, &zl);
3743 zio_remove_child(pio, zio, remove_zl);
3744 zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
3747 if (zio->io_waiter != NULL) {
3748 mutex_enter(&zio->io_lock);
3749 zio->io_executor = NULL;
3750 cv_broadcast(&zio->io_cv);
3751 mutex_exit(&zio->io_lock);
3753 zio_destroy(zio);