Lines Matching defs:zio
47 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zio, CTLFLAG_RW, 0, "ZFS ZIO");
58 "Use uma(9) for ZIO allocations");
133 * An allocating zio is one that either currently has the DVA allocate
136 #define IO_IS_ALLOCATING(zio) ((zio)->io_orig_pipeline & ZIO_STAGE_DVA_ALLOCATE)
360 zio_push_transform(zio_t *zio, void *data, uint64_t size, uint64_t bufsize,
365 zt->zt_orig_data = zio->io_data;
366 zt->zt_orig_size = zio->io_size;
370 zt->zt_next = zio->io_transform_stack;
371 zio->io_transform_stack = zt;
373 zio->io_data = data;
374 zio->io_size = size;
378 zio_pop_transforms(zio_t *zio)
382 while ((zt = zio->io_transform_stack) != NULL) {
384 zt->zt_transform(zio,
388 zio_buf_free(zio->io_data, zt->zt_bufsize);
390 zio->io_data = zt->zt_orig_data;
391 zio->io_size = zt->zt_orig_size;
392 zio->io_transform_stack = zt->zt_next;
404 zio_subblock(zio_t *zio, void *data, uint64_t size)
406 ASSERT(zio->io_size > size);
408 if (zio->io_type == ZIO_TYPE_READ)
409 bcopy(zio->io_data, data, size);
413 zio_decompress(zio_t *zio, void *data, uint64_t size)
415 if (zio->io_error == 0 &&
416 zio_decompress_data(BP_GET_COMPRESS(zio->io_bp),
417 zio->io_data, data, zio->io_size, size) != 0)
418 zio->io_error = SET_ERROR(EIO);
518 zio_wait_for_children(zio_t *zio, enum zio_child child, enum zio_wait_type wait)
520 uint64_t *countp = &zio->io_children[child][wait];
523 mutex_enter(&zio->io_lock);
524 ASSERT(zio->io_stall == NULL);
526 zio->io_stage >>= 1;
527 ASSERT3U(zio->io_stage, !=, ZIO_STAGE_OPEN);
528 zio->io_stall = countp;
531 mutex_exit(&zio->io_lock);
537 zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait)
539 uint64_t *countp = &pio->io_children[zio->io_child_type][wait];
540 int *errorp = &pio->io_child_error[zio->io_child_type];
543 if (zio->io_error && !(zio->io_flags & ZIO_FLAG_DONT_PROPAGATE))
544 *errorp = zio_worst_error(*errorp, zio->io_error);
545 pio->io_reexecute |= zio->io_reexecute;
557 * Dispatch the parent zio in its own taskq so that
569 zio_inherit_child_errors(zio_t *zio, enum zio_child c)
571 if (zio->io_child_error[c] != 0 && zio->io_error == 0)
572 zio->io_error = zio->io_child_error[c];
626 zio_t *zio;
636 zio = kmem_cache_alloc(zio_cache, KM_SLEEP);
637 bzero(zio, sizeof (zio_t));
639 mutex_init(&zio->io_lock, NULL, MUTEX_DEFAULT, NULL);
640 cv_init(&zio->io_cv, NULL, CV_DEFAULT, NULL);
642 list_create(&zio->io_parent_list, sizeof (zio_link_t),
644 list_create(&zio->io_child_list, sizeof (zio_link_t),
646 metaslab_trace_init(&zio->io_alloc_list);
649 zio->io_child_type = ZIO_CHILD_VDEV;
651 zio->io_child_type = ZIO_CHILD_GANG;
653 zio->io_child_type = ZIO_CHILD_DDT;
655 zio->io_child_type = ZIO_CHILD_LOGICAL;
658 zio->io_bp = (blkptr_t *)bp;
659 zio->io_bp_copy = *bp;
660 zio->io_bp_orig = *bp;
662 zio->io_child_type == ZIO_CHILD_DDT)
663 zio->io_bp = &zio->io_bp_copy; /* so caller can free */
664 if (zio->io_child_type == ZIO_CHILD_LOGICAL)
665 zio->io_logical = zio;
666 if (zio->io_child_type > ZIO_CHILD_GANG && BP_IS_GANG(bp))
670 zio->io_spa = spa;
671 zio->io_txg = txg;
672 zio->io_done = done;
673 zio->io_private = private;
674 zio->io_type = type;
675 zio->io_priority = priority;
676 zio->io_vd = vd;
677 zio->io_offset = offset;
678 zio->io_orig_data = zio->io_data = data;
679 zio->io_orig_size = zio->io_size = size;
680 zio->io_orig_flags = zio->io_flags = flags;
681 zio->io_orig_stage = zio->io_stage = stage;
682 zio->io_orig_pipeline = zio->io_pipeline = pipeline;
683 zio->io_pipeline_trace = ZIO_STAGE_OPEN;
685 zio->io_state[ZIO_WAIT_READY] = (stage >= ZIO_STAGE_READY);
686 zio->io_state[ZIO_WAIT_DONE] = (stage >= ZIO_STAGE_DONE);
689 zio->io_bookmark = *zb;
692 if (zio->io_logical == NULL)
693 zio->io_logical = pio->io_logical;
694 if (zio->io_child_type == ZIO_CHILD_GANG)
695 zio->io_gang_leader = pio->io_gang_leader;
696 zio_add_child(pio, zio);
699 return (zio);
703 zio_destroy(zio_t *zio)
705 metaslab_trace_fini(&zio->io_alloc_list);
706 list_destroy(&zio->io_parent_list);
707 list_destroy(&zio->io_child_list);
708 mutex_destroy(&zio->io_lock);
709 cv_destroy(&zio->io_cv);
710 kmem_cache_free(zio_cache, zio);
717 zio_t *zio;
719 zio = zio_create(pio, spa, 0, NULL, NULL, 0, done, private,
723 return (zio);
819 zio_t *zio;
823 zio = zio_create(pio, spa, BP_PHYSICAL_BIRTH(bp), bp,
829 return (zio);
840 zio_t *zio;
851 zio = zio_create(pio, spa, txg, bp, data, size, done, private,
856 zio->io_ready = ready;
857 zio->io_children_ready = children_ready;
858 zio->io_physdone = physdone;
859 zio->io_prop = *zp;
867 if (data == NULL && zio->io_prop.zp_dedup_verify) {
868 zio->io_prop.zp_dedup = zio->io_prop.zp_dedup_verify = B_FALSE;
871 return (zio);
879 zio_t *zio;
881 zio = zio_create(pio, spa, txg, bp, data, size, done, private,
885 return (zio);
889 zio_write_override(zio_t *zio, blkptr_t *bp, int copies, boolean_t nopwrite)
891 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
892 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
893 ASSERT(zio->io_stage == ZIO_STAGE_OPEN);
894 ASSERT(zio->io_txg == spa_syncing_txg(zio->io_spa));
901 zio->io_prop.zp_dedup = nopwrite ? B_FALSE : zio->io_prop.zp_dedup;
902 zio->io_prop.zp_nopwrite = nopwrite;
903 zio->io_prop.zp_copies = copies;
904 zio->io_bp_override = bp;
940 zio_t *zio;
966 zio = zio_create(pio, spa, txg, bp, NULL, size,
970 return (zio);
977 zio_t *zio;
1000 zio = zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp),
1003 ASSERT0(zio->io_queued_timestamp);
1005 return (zio);
1013 zio_t *zio;
1017 zio = zio_create(pio, spa, 0, NULL, NULL, size, done, private,
1021 zio->io_cmd = cmd;
1023 zio = zio_null(pio, spa, NULL, NULL, NULL, flags);
1026 zio_nowait(zio_ioctl(zio, spa, vd->vdev_child[c], cmd,
1030 return (zio);
1038 zio_t *zio;
1045 zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, done, private,
1049 zio->io_prop.zp_checksum = checksum;
1051 return (zio);
1059 zio_t *zio;
1066 zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, done, private,
1070 zio->io_prop.zp_checksum = checksum;
1081 zio_push_transform(zio, wbuf, size, size, NULL);
1084 return (zio);
1096 zio_t *zio;
1130 * top-level vdev, then the child zio is not an allocating I/O.
1148 zio = zio_create(pio, pio->io_spa, pio->io_txg, bp, data, size,
1151 ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
1153 zio->io_physdone = pio->io_physdone;
1154 if (vd->vdev_ops->vdev_op_leaf && zio->io_logical != NULL)
1155 zio->io_logical->io_phys_children++;
1157 return (zio);
1165 zio_t *zio;
1169 zio = zio_create(NULL, vd->vdev_spa, 0, NULL,
1175 return (zio);
1179 zio_flush(zio_t *zio, vdev_t *vd)
1181 zio_nowait(zio_ioctl(zio, zio->io_spa, vd, DKIOCFLUSHWRITECACHE, 0, 0,
1187 zio_trim(zio_t *zio, spa_t *spa, vdev_t *vd, uint64_t offset, uint64_t size)
1192 return (zio_create(zio, spa, 0, NULL, NULL, size, NULL, NULL,
1199 zio_shrink(zio_t *zio, uint64_t size)
1201 ASSERT(zio->io_executor == NULL);
1202 ASSERT(zio->io_orig_size == zio->io_size);
1203 ASSERT(size <= zio->io_size);
1210 ASSERT(BP_GET_COMPRESS(zio->io_bp) == ZIO_COMPRESS_OFF);
1211 if (!BP_IS_RAIDZ(zio->io_bp))
1212 zio->io_orig_size = zio->io_size = size;
1222 zio_read_bp_init(zio_t *zio)
1224 blkptr_t *bp = zio->io_bp;
1227 zio->io_child_type == ZIO_CHILD_LOGICAL &&
1228 !(zio->io_flags & ZIO_FLAG_RAW)) {
1233 zio_push_transform(zio, cbuf, psize, psize, zio_decompress);
1237 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1238 decode_embedded_bp_compressed(bp, zio->io_data);
1244 zio->io_flags |= ZIO_FLAG_DONT_CACHE;
1247 zio->io_flags |= ZIO_FLAG_DONT_CACHE;
1249 if (BP_GET_DEDUP(bp) && zio->io_child_type == ZIO_CHILD_LOGICAL)
1250 zio->io_pipeline = ZIO_DDT_READ_PIPELINE;
1256 zio_write_bp_init(zio_t *zio)
1258 if (!IO_IS_ALLOCATING(zio))
1261 ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
1263 if (zio->io_bp_override) {
1264 blkptr_t *bp = zio->io_bp;
1265 zio_prop_t *zp = &zio->io_prop;
1267 ASSERT(bp->blk_birth != zio->io_txg);
1268 ASSERT(BP_GET_DEDUP(zio->io_bp_override) == 0);
1270 *bp = *zio->io_bp_override;
1271 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1284 zio->io_flags |= ZIO_FLAG_NOPWRITE;
1298 zio->io_pipeline |= ZIO_STAGE_DDT_WRITE;
1306 zio->io_bp_override = NULL;
1307 *bp = zio->io_bp_orig;
1308 zio->io_pipeline = zio->io_orig_pipeline;
1315 zio_write_compress(zio_t *zio)
1317 spa_t *spa = zio->io_spa;
1318 zio_prop_t *zp = &zio->io_prop;
1320 blkptr_t *bp = zio->io_bp;
1321 uint64_t lsize = zio->io_size;
1329 if (zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_READY) ||
1330 zio_wait_for_children(zio, ZIO_CHILD_LOGICAL, ZIO_WAIT_READY))
1333 if (!IO_IS_ALLOCATING(zio))
1336 if (zio->io_children_ready != NULL) {
1339 * associated with this zio in case it wants to modify the
1343 zio->io_children_ready(zio);
1346 ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
1347 ASSERT(zio->io_bp_override == NULL);
1349 if (!BP_IS_HOLE(bp) && bp->blk_birth == zio->io_txg) {
1361 ASSERT(zio->io_txg == spa_syncing_txg(spa));
1362 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1375 psize = zio_compress_data(compress, zio->io_data, cbuf, lsize);
1385 BP_SET_TYPE(bp, zio->io_prop.zp_type);
1386 BP_SET_LEVEL(bp, zio->io_prop.zp_level);
1388 bp->blk_birth = zio->io_txg;
1389 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1412 zio_push_transform(zio, cbuf,
1421 zio->io_bp_override = NULL;
1422 *bp = zio->io_bp_orig;
1423 zio->io_pipeline = zio->io_orig_pipeline;
1434 if (!BP_IS_HOLE(bp) && bp->blk_birth == zio->io_txg &&
1438 enum zio_stage gang_stages = zio->io_pipeline & ZIO_GANG_STAGES;
1439 zio->io_pipeline = ZIO_REWRITE_PIPELINE | gang_stages;
1440 zio->io_flags |= ZIO_FLAG_IO_REWRITE;
1443 zio->io_pipeline = ZIO_WRITE_PIPELINE;
1447 if (zio->io_bp_orig.blk_birth != 0 &&
1452 BP_SET_BIRTH(bp, zio->io_txg, 0);
1454 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1466 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1467 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
1468 zio->io_pipeline = ZIO_DDT_WRITE_PIPELINE;
1471 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1472 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
1473 zio->io_pipeline |= ZIO_STAGE_NOP_WRITE;
1480 zio_free_bp_init(zio_t *zio)
1482 blkptr_t *bp = zio->io_bp;
1484 if (zio->io_child_type == ZIO_CHILD_LOGICAL) {
1486 zio->io_pipeline = ZIO_DDT_FREE_PIPELINE;
1499 zio_taskq_dispatch(zio_t *zio, zio_taskq_type_t q, boolean_t cutinline)
1501 spa_t *spa = zio->io_spa;
1502 zio_type_t t = zio->io_type;
1512 if (zio->io_flags & (ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_PROBE))
1518 if (t == ZIO_TYPE_WRITE && zio->io_vd && zio->io_vd->vdev_aux)
1525 if (zio->io_priority == ZIO_PRIORITY_NOW &&
1532 * NB: We are assuming that the zio can only be dispatched
1534 * to dispatch the zio to another taskq at the same time.
1537 ASSERT(zio->io_tqent.tqent_next == NULL);
1539 ASSERT(zio->io_tqent.tqent_queued == 0);
1541 ASSERT(zio->io_tqent.tqent_task.ta_pending == 0);
1543 spa_taskq_dispatch_ent(spa, t, q, (task_func_t *)zio_execute, zio,
1544 flags, &zio->io_tqent);
1548 zio_taskq_member(zio_t *zio, zio_taskq_type_t q)
1550 kthread_t *executor = zio->io_executor;
1551 spa_t *spa = zio->io_spa;
1566 zio_issue_async(zio_t *zio)
1568 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
1574 zio_interrupt(zio_t *zio)
1576 zio_taskq_dispatch(zio, ZIO_TASKQ_INTERRUPT, B_FALSE);
1580 zio_delay_interrupt(zio_t *zio)
1584 * rather than trying to implement the function, the zio delay
1593 * delay; issuing it directly to the zio layer.
1595 if (zio->io_target_timestamp != 0) {
1598 if (now >= zio->io_target_timestamp) {
1603 * directly to the zio layer. This is likely due to
1610 DTRACE_PROBE2(zio__delay__miss, zio_t *, zio,
1613 zio_interrupt(zio);
1615 hrtime_t diff = zio->io_target_timestamp - now;
1617 DTRACE_PROBE3(zio__delay__hit, zio_t *, zio,
1621 (void (*)(void *))zio_interrupt, zio, diff, 1, 0);
1628 DTRACE_PROBE1(zio__delay__skip, zio_t *, zio);
1629 zio_interrupt(zio);
1651 zio_execute(zio_t *zio)
1653 zio->io_executor = curthread;
1655 ASSERT3U(zio->io_queued_timestamp, >, 0);
1657 while (zio->io_stage < ZIO_STAGE_DONE) {
1658 enum zio_stage pipeline = zio->io_pipeline;
1659 enum zio_stage stage = zio->io_stage;
1662 ASSERT(!MUTEX_HELD(&zio->io_lock));
1664 ASSERT(zio->io_stall == NULL);
1681 if ((stage & ZIO_BLOCKING_STAGES) && zio->io_vd == NULL &&
1682 zio_taskq_member(zio, ZIO_TASKQ_INTERRUPT)) {
1685 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, cut);
1689 zio->io_stage = stage;
1690 zio->io_pipeline_trace |= zio->io_stage;
1691 rv = zio_pipeline[highbit64(stage) - 1](zio);
1706 zio_wait(zio_t *zio)
1710 ASSERT(zio->io_stage == ZIO_STAGE_OPEN);
1711 ASSERT(zio->io_executor == NULL);
1713 zio->io_waiter = curthread;
1714 ASSERT0(zio->io_queued_timestamp);
1715 zio->io_queued_timestamp = gethrtime();
1717 zio_execute(zio);
1719 mutex_enter(&zio->io_lock);
1720 while (zio->io_executor != NULL)
1721 cv_wait(&zio->io_cv, &zio->io_lock);
1722 mutex_exit(&zio->io_lock);
1724 error = zio->io_error;
1725 zio_destroy(zio);
1731 zio_nowait(zio_t *zio)
1733 ASSERT(zio->io_executor == NULL);
1735 if (zio->io_child_type == ZIO_CHILD_LOGICAL &&
1736 zio_unique_parent(zio) == NULL) {
1742 spa_t *spa = zio->io_spa;
1744 zio_add_child(spa->spa_async_zio_root[CPU_SEQID], zio);
1747 ASSERT0(zio->io_queued_timestamp);
1748 zio->io_queued_timestamp = gethrtime();
1749 zio_execute(zio);
1812 zio_suspend(spa_t *spa, zio_t *zio)
1830 if (zio != NULL) {
1831 ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
1832 ASSERT(zio != spa->spa_suspend_zio_root);
1833 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1834 ASSERT(zio_unique_parent(zio) == NULL);
1835 ASSERT(zio->io_stage == ZIO_STAGE_DONE);
1836 zio_add_child(spa->spa_suspend_zio_root, zio);
1953 zio_t *zio;
1956 zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
1969 zio_checksum_compute(zio, BP_GET_CHECKSUM(bp),
1977 zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
1979 zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
1984 return (zio);
2013 static void zio_gang_tree_assemble_done(zio_t *zio);
2070 zio_gang_tree_assemble_done(zio_t *zio)
2072 zio_t *gio = zio->io_gang_leader;
2073 zio_gang_node_t *gn = zio->io_private;
2074 blkptr_t *bp = zio->io_bp;
2076 ASSERT(gio == zio_unique_parent(zio));
2077 ASSERT(zio->io_child_count == 0);
2079 if (zio->io_error)
2083 byteswap_uint64_array(zio->io_data, zio->io_size);
2085 ASSERT(zio->io_data == gn->gn_gbh);
2086 ASSERT(zio->io_size == SPA_GANGBLOCKSIZE);
2101 zio_t *zio;
2111 zio = zio_gang_issue_func[gio->io_type](pio, bp, gn, data);
2120 zio_gang_tree_issue(zio, gn->gn_child[g], gbp, data);
2128 if (zio != pio)
2129 zio_nowait(zio);
2133 zio_gang_assemble(zio_t *zio)
2135 blkptr_t *bp = zio->io_bp;
2137 ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == NULL);
2138 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2140 zio->io_gang_leader = zio;
2142 zio_gang_tree_assemble(zio, bp, &zio->io_gang_tree);
2148 zio_gang_issue(zio_t *zio)
2150 blkptr_t *bp = zio->io_bp;
2152 if (zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_DONE))
2155 ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == zio);
2156 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2158 if (zio->io_child_error[ZIO_CHILD_GANG] == 0)
2159 zio_gang_tree_issue(zio, zio->io_gang_tree, bp, zio->io_data);
2161 zio_gang_tree_free(&zio->io_gang_tree);
2163 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
2169 zio_write_gang_member_ready(zio_t *zio)
2171 zio_t *pio = zio_unique_parent(zio);
2172 zio_t *gio = zio->io_gang_leader;
2173 dva_t *cdva = zio->io_bp->blk_dva;
2177 if (BP_IS_HOLE(zio->io_bp))
2180 ASSERT(BP_IS_HOLE(&zio->io_bp_orig));
2182 ASSERT(zio->io_child_type == ZIO_CHILD_GANG);
2183 ASSERT3U(zio->io_prop.zp_copies, ==, gio->io_prop.zp_copies);
2184 ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(zio->io_bp));
2186 ASSERT3U(BP_GET_NDVAS(zio->io_bp), <=, BP_GET_NDVAS(pio->io_bp));
2189 for (int d = 0; d < BP_GET_NDVAS(zio->io_bp); d++) {
2205 zio_t *zio;
2225 * The logical zio has already placed a reservation for
2272 zio = zio_rewrite(pio, spa, txg, bp, gbh, SPA_GANGBLOCKSIZE, NULL, NULL,
2292 zio_t *cio = zio_write(zio, spa, txg, &gbh->zg_blkptr[g],
2314 * Set pio's pipeline to just wait for zio to finish.
2318 zio_nowait(zio);
2342 zio_nop_write(zio_t *zio)
2344 blkptr_t *bp = zio->io_bp;
2345 blkptr_t *bp_orig = &zio->io_bp_orig;
2346 zio_prop_t *zp = &zio->io_prop;
2349 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
2352 ASSERT(zio->io_bp_override == NULL);
2353 ASSERT(IO_IS_ALLOCATING(zio));
2384 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
2385 zio->io_flags |= ZIO_FLAG_NOPWRITE;
2397 zio_ddt_child_read_done(zio_t *zio)
2399 blkptr_t *bp = zio->io_bp;
2400 ddt_entry_t *dde = zio->io_private;
2402 zio_t *pio = zio_unique_parent(zio);
2406 if (zio->io_error == 0)
2408 if (zio->io_error == 0 && dde->dde_repair_data == NULL)
2409 dde->dde_repair_data = zio->io_data;
2411 zio_buf_free(zio->io_data, zio->io_size);
2416 zio_ddt_read_start(zio_t *zio)
2418 blkptr_t *bp = zio->io_bp;
2421 ASSERT(BP_GET_PSIZE(bp) == zio->io_size);
2422 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
2424 if (zio->io_child_error[ZIO_CHILD_DDT]) {
2425 ddt_t *ddt = ddt_select(zio->io_spa, bp);
2431 ASSERT(zio->io_vsd == NULL);
2432 zio->io_vsd = dde;
2442 zio_nowait(zio_read(zio, zio->io_spa, &blk,
2443 zio_buf_alloc(zio->io_size), zio->io_size,
2444 zio_ddt_child_read_done, dde, zio->io_priority,
2445 ZIO_DDT_CHILD_FLAGS(zio) | ZIO_FLAG_DONT_PROPAGATE,
2446 &zio->io_bookmark));
2451 zio_nowait(zio_read(zio, zio->io_spa, bp,
2452 zio->io_data, zio->io_size, NULL, NULL, zio->io_priority,
2453 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark));
2459 zio_ddt_read_done(zio_t *zio)
2461 blkptr_t *bp = zio->io_bp;
2463 if (zio_wait_for_children(zio, ZIO_CHILD_DDT, ZIO_WAIT_DONE))
2467 ASSERT(BP_GET_PSIZE(bp) == zio->io_size);
2468 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
2470 if (zio->io_child_error[ZIO_CHILD_DDT]) {
2471 ddt_t *ddt = ddt_select(zio->io_spa, bp);
2472 ddt_entry_t *dde = zio->io_vsd;
2474 ASSERT(spa_load_state(zio->io_spa) != SPA_LOAD_NONE);
2478 zio->io_stage = ZIO_STAGE_DDT_READ_START >> 1;
2479 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
2483 bcopy(dde->dde_repair_data, zio->io_data, zio->io_size);
2484 zio->io_child_error[ZIO_CHILD_DDT] = 0;
2487 zio->io_vsd = NULL;
2490 ASSERT(zio->io_vsd == NULL);
2496 zio_ddt_collision(zio_t *zio, ddt_t *ddt, ddt_entry_t *dde)
2498 spa_t *spa = zio->io_spa;
2502 * because when zio->io_bp is an override bp, we will not have
2510 return (lio->io_orig_size != zio->io_orig_size ||
2511 bcmp(zio->io_orig_data, lio->io_orig_data,
2512 zio->io_orig_size) != 0);
2522 blkptr_t blk = *zio->io_bp;
2532 &aflags, &zio->io_bookmark);
2535 if (arc_buf_size(abuf) != zio->io_orig_size ||
2536 bcmp(abuf->b_data, zio->io_orig_data,
2537 zio->io_orig_size) != 0)
2551 zio_ddt_child_write_ready(zio_t *zio)
2553 int p = zio->io_prop.zp_copies;
2554 ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp);
2555 ddt_entry_t *dde = zio->io_private;
2559 if (zio->io_error)
2564 ASSERT(dde->dde_lead_zio[p] == zio);
2566 ddt_phys_fill(ddp, zio->io_bp);
2569 while ((pio = zio_walk_parents(zio, &zl)) != NULL)
2570 ddt_bp_fill(ddp, pio->io_bp, zio->io_txg);
2576 zio_ddt_child_write_done(zio_t *zio)
2578 int p = zio->io_prop.zp_copies;
2579 ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp);
2580 ddt_entry_t *dde = zio->io_private;
2586 ASSERT(dde->dde_lead_zio[p] == zio);
2589 if (zio->io_error == 0) {
2591 while (zio_walk_parents(zio, &zl) != NULL)
2601 zio_ddt_ditto_write_done(zio_t *zio)
2604 zio_prop_t *zp = &zio->io_prop;
2605 blkptr_t *bp = zio->io_bp;
2606 ddt_t *ddt = ddt_select(zio->io_spa, bp);
2607 ddt_entry_t *dde = zio->io_private;
2614 ASSERT(dde->dde_lead_zio[p] == zio);
2617 if (zio->io_error == 0) {
2622 ddt_phys_free(ddt, ddk, ddp, zio->io_txg);
2630 zio_ddt_write(zio_t *zio)
2632 spa_t *spa = zio->io_spa;
2633 blkptr_t *bp = zio->io_bp;
2634 uint64_t txg = zio->io_txg;
2635 zio_prop_t *zp = &zio->io_prop;
2646 ASSERT(BP_IS_HOLE(bp) || zio->io_bp_override);
2652 if (zp->zp_dedup_verify && zio_ddt_collision(zio, ddt, dde)) {
2662 zio_pop_transforms(zio);
2663 zio->io_stage = ZIO_STAGE_OPEN;
2668 zio->io_pipeline = ZIO_WRITE_PIPELINE;
2689 if (zio->io_bp_override) {
2690 zio_pop_transforms(zio);
2691 zio->io_stage = ZIO_STAGE_OPEN;
2692 zio->io_pipeline = ZIO_WRITE_PIPELINE;
2693 zio->io_bp_override = NULL;
2699 dio = zio_write(zio, spa, txg, bp, zio->io_orig_data,
2700 zio->io_orig_size, &czp, NULL, NULL,
2701 NULL, zio_ddt_ditto_write_done, dde, zio->io_priority,
2702 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark);
2704 zio_push_transform(dio, zio->io_data, zio->io_size, 0, NULL);
2712 zio_add_child(zio, dde->dde_lead_zio[p]);
2715 } else if (zio->io_bp_override) {
2717 ASSERT(BP_EQUAL(bp, zio->io_bp_override));
2721 cio = zio_write(zio, spa, txg, bp, zio->io_orig_data,
2722 zio->io_orig_size, zp,
2724 zio_ddt_child_write_done, dde, zio->io_priority,
2725 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark);
2727 zio_push_transform(cio, zio->io_data, zio->io_size, 0, NULL);
2744 zio_ddt_free(zio_t *zio)
2746 spa_t *spa = zio->io_spa;
2747 blkptr_t *bp = zio->io_bp;
2753 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
2773 zio_t *zio;
2777 zio = avl_first(&spa->spa_alloc_tree);
2778 if (zio == NULL)
2781 ASSERT(IO_IS_ALLOCATING(zio));
2784 * Try to place a reservation for this zio. If we're unable to
2788 zio->io_prop.zp_copies, zio, 0)) {
2792 avl_remove(&spa->spa_alloc_tree, zio);
2793 ASSERT3U(zio->io_stage, <, ZIO_STAGE_DVA_ALLOCATE);
2795 return (zio);
2799 zio_dva_throttle(zio_t *zio)
2801 spa_t *spa = zio->io_spa;
2804 if (zio->io_priority == ZIO_PRIORITY_SYNC_WRITE ||
2805 !spa_normal_class(zio->io_spa)->mc_alloc_throttle_enabled ||
2806 zio->io_child_type == ZIO_CHILD_GANG ||
2807 zio->io_flags & ZIO_FLAG_NODATA) {
2811 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2813 ASSERT3U(zio->io_queued_timestamp, >, 0);
2814 ASSERT(zio->io_stage == ZIO_STAGE_DVA_THROTTLE);
2818 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
2819 avl_add(&spa->spa_alloc_tree, zio);
2821 nio = zio_io_to_allocate(zio->io_spa);
2824 if (nio == zio)
2829 zio->io_queued_timestamp);
2832 * We are passing control to a new zio so make sure that
2847 zio_t *zio;
2850 zio = zio_io_to_allocate(spa);
2852 if (zio == NULL)
2855 ASSERT3U(zio->io_stage, ==, ZIO_STAGE_DVA_THROTTLE);
2856 ASSERT0(zio->io_error);
2857 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_TRUE);
2861 zio_dva_allocate(zio_t *zio)
2863 spa_t *spa = zio->io_spa;
2865 blkptr_t *bp = zio->io_bp;
2869 if (zio->io_gang_leader == NULL) {
2870 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2871 zio->io_gang_leader = zio;
2876 ASSERT3U(zio->io_prop.zp_copies, >, 0);
2877 ASSERT3U(zio->io_prop.zp_copies, <=, spa_max_replication(spa));
2878 ASSERT3U(zio->io_size, ==, BP_GET_PSIZE(bp));
2880 if (zio->io_flags & ZIO_FLAG_NODATA) {
2883 if (zio->io_flags & ZIO_FLAG_GANG_CHILD) {
2886 if (zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE) {
2890 error = metaslab_alloc(spa, mc, zio->io_size, bp,
2891 zio->io_prop.zp_copies, zio->io_txg, NULL, flags,
2892 &zio->io_alloc_list, zio);
2895 spa_dbgmsg(spa, "%s: metaslab allocation failure: zio %p, "
2896 "size %llu, error %d", spa_name(spa), zio, zio->io_size,
2898 if (error == ENOSPC && zio->io_size > SPA_MINBLOCKSIZE)
2899 return (zio_write_gang_block(zio));
2900 zio->io_error = error;
2907 zio_dva_free(zio_t *zio)
2909 metaslab_free(zio->io_spa, zio->io_bp, zio->io_txg, B_FALSE);
2915 zio_dva_claim(zio_t *zio)
2919 error = metaslab_claim(zio->io_spa, zio->io_bp, zio->io_txg);
2921 zio->io_error = error;
2932 zio_dva_unallocate(zio_t *zio, zio_gang_node_t *gn, blkptr_t *bp)
2934 ASSERT(bp->blk_birth == zio->io_txg || BP_IS_HOLE(bp));
2935 ASSERT(zio->io_bp_override == NULL);
2938 metaslab_free(zio->io_spa, bp, bp->blk_birth, B_TRUE);
2942 zio_dva_unallocate(zio, gn->gn_child[g],
3020 zio_vdev_io_start(zio_t *zio)
3022 vdev_t *vd = zio->io_vd;
3024 spa_t *spa = zio->io_spa;
3027 ASSERT(zio->io_error == 0);
3028 ASSERT(zio->io_child_error[ZIO_CHILD_VDEV] == 0);
3031 if (!(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
3032 spa_config_enter(spa, SCL_ZIO, zio, RW_READER);
3037 vdev_mirror_ops.vdev_op_io_start(zio);
3041 if (vd->vdev_ops->vdev_op_leaf && zio->io_type == ZIO_TYPE_FREE &&
3042 zio->io_priority == ZIO_PRIORITY_NOW) {
3043 trim_map_free(vd, zio->io_offset, zio->io_size, zio->io_txg);
3047 ASSERT3P(zio->io_logical, !=, zio);
3059 if (!(zio->io_flags & ZIO_FLAG_SCAN_THREAD) && zio->io_bp != NULL &&
3061 zio->io_bookmark.zb_objset != DMU_META_OBJSET &&
3062 zio->io_txg != spa_syncing_txg(spa)) {
3071 if (!(zio->io_flags & ZIO_FLAG_PHYSICAL) &&
3072 P2PHASE(zio->io_size, align) != 0) {
3074 uint64_t asize = P2ROUNDUP(zio->io_size, align);
3076 if (zio->io_type == ZIO_TYPE_READ ||
3077 zio->io_type == ZIO_TYPE_WRITE)
3080 if (zio->io_type == ZIO_TYPE_WRITE) {
3081 bcopy(zio->io_data, abuf, zio->io_size);
3082 bzero(abuf + zio->io_size, asize - zio->io_size);
3084 zio_push_transform(zio, abuf, asize, abuf ? asize : 0,
3092 if (!(zio->io_flags & ZIO_FLAG_PHYSICAL)) {
3093 ASSERT0(P2PHASE(zio->io_offset, align));
3094 ASSERT0(P2PHASE(zio->io_size, align));
3102 ASSERT0(P2PHASE(zio->io_offset, log_align));
3103 ASSERT0(P2PHASE(zio->io_size, log_align));
3106 VERIFY(zio->io_type == ZIO_TYPE_READ || spa_writeable(spa));
3111 * then don't do the I/O unless zio's txg is actually in vd's DTL.
3121 if ((zio->io_flags & ZIO_FLAG_IO_REPAIR) &&
3122 !(zio->io_flags & ZIO_FLAG_SELF_HEAL) &&
3123 zio->io_txg != 0 && /* not a delegated i/o */
3124 !vdev_dtl_contains(vd, DTL_PARTIAL, zio->io_txg, 1)) {
3125 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
3126 zio_vdev_io_bypass(zio);
3131 switch (zio->io_type) {
3133 if (vdev_cache_read(zio))
3138 if ((zio = vdev_queue_io(zio)) == NULL)
3141 if (!vdev_accessible(vd, zio)) {
3142 zio->io_error = SET_ERROR(ENXIO);
3143 zio_interrupt(zio);
3153 if (zio->io_type == ZIO_TYPE_WRITE &&
3154 !(zio->io_flags & ZIO_FLAG_IO_REPAIR) &&
3155 !trim_map_write_start(zio))
3159 vd->vdev_ops->vdev_op_io_start(zio);
3164 zio_vdev_io_done(zio_t *zio)
3166 vdev_t *vd = zio->io_vd;
3170 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV, ZIO_WAIT_DONE))
3173 ASSERT(zio->io_type == ZIO_TYPE_READ ||
3174 zio->io_type == ZIO_TYPE_WRITE || zio->io_type == ZIO_TYPE_FREE);
3177 (zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE ||
3178 zio->io_type == ZIO_TYPE_FREE)) {
3180 if (zio->io_type == ZIO_TYPE_WRITE &&
3181 !(zio->io_flags & ZIO_FLAG_IO_REPAIR))
3182 trim_map_write_done(zio);
3184 vdev_queue_io_done(zio);
3186 if (zio->io_type == ZIO_TYPE_WRITE)
3187 vdev_cache_write(zio);
3189 if (zio_injection_enabled && zio->io_error == 0)
3190 zio->io_error = zio_handle_device_injection(vd,
3191 zio, EIO);
3193 if (zio_injection_enabled && zio->io_error == 0)
3194 zio->io_error = zio_handle_label_injection(zio, EIO);
3196 if (zio->io_error) {
3197 if (zio->io_error == ENOTSUP &&
3198 zio->io_type == ZIO_TYPE_FREE) {
3200 } else if (!vdev_accessible(vd, zio)) {
3201 zio->io_error = SET_ERROR(ENXIO);
3208 ops->vdev_op_io_done(zio);
3211 VERIFY(vdev_probe(vd, zio) == NULL);
3230 zio_vsd_default_cksum_report(zio_t *zio, zio_cksum_report_t *zcr, void *ignored)
3232 void *buf = zio_buf_alloc(zio->io_size);
3234 bcopy(zio->io_data, buf, zio->io_size);
3236 zcr->zcr_cbinfo = zio->io_size;
3243 zio_vdev_io_assess(zio_t *zio)
3245 vdev_t *vd = zio->io_vd;
3247 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV, ZIO_WAIT_DONE))
3250 if (vd == NULL && !(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
3251 spa_config_exit(zio->io_spa, SCL_ZIO, zio);
3253 if (zio->io_vsd != NULL) {
3254 zio->io_vsd_ops->vsd_free(zio);
3255 zio->io_vsd = NULL;
3258 if (zio_injection_enabled && zio->io_error == 0)
3259 zio->io_error = zio_handle_fault_injection(zio, EIO);
3261 if (zio->io_type == ZIO_TYPE_FREE &&
3262 zio->io_priority != ZIO_PRIORITY_NOW) {
3263 switch (zio->io_error) {
3265 ZIO_TRIM_STAT_INCR(bytes, zio->io_size);
3283 if (zio->io_error && vd == NULL &&
3284 !(zio->io_flags & (ZIO_FLAG_DONT_RETRY | ZIO_FLAG_IO_RETRY))) {
3285 ASSERT(!(zio->io_flags & ZIO_FLAG_DONT_QUEUE)); /* not a leaf */
3286 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_BYPASS)); /* not a leaf */
3287 zio->io_error = 0;
3288 zio->io_flags |= ZIO_FLAG_IO_RETRY |
3290 zio->io_stage = ZIO_STAGE_VDEV_IO_START >> 1;
3291 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE,
3300 if (zio->io_error && vd != NULL && vd->vdev_ops->vdev_op_leaf &&
3301 !vdev_accessible(vd, zio))
3302 zio->io_error = SET_ERROR(ENXIO);
3308 if (zio->io_error == ENXIO && zio->io_type == ZIO_TYPE_WRITE &&
3313 if (zio->io_error)
3314 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
3317 zio->io_physdone != NULL) {
3318 ASSERT(!(zio->io_flags & ZIO_FLAG_DELEGATED));
3319 ASSERT(zio->io_child_type == ZIO_CHILD_VDEV);
3320 zio->io_physdone(zio->io_logical);
3327 zio_vdev_io_reissue(zio_t *zio)
3329 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START);
3330 ASSERT(zio->io_error == 0);
3332 zio->io_stage >>= 1;
3336 zio_vdev_io_redone(zio_t *zio)
3338 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_DONE);
3340 zio->io_stage >>= 1;
3344 zio_vdev_io_bypass(zio_t *zio)
3346 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START);
3347 ASSERT(zio->io_error == 0);
3349 zio->io_flags |= ZIO_FLAG_IO_BYPASS;
3350 zio->io_stage = ZIO_STAGE_VDEV_IO_ASSESS >> 1;
3359 zio_checksum_generate(zio_t *zio)
3361 blkptr_t *bp = zio->io_bp;
3369 checksum = zio->io_prop.zp_checksum;
3376 if (BP_IS_GANG(bp) && zio->io_child_type == ZIO_CHILD_GANG) {
3377 ASSERT(!IO_IS_ALLOCATING(zio));
3384 zio_checksum_compute(zio, checksum, zio->io_data, zio->io_size);
3390 zio_checksum_verify(zio_t *zio)
3393 blkptr_t *bp = zio->io_bp;
3396 ASSERT(zio->io_vd != NULL);
3403 if (zio->io_prop.zp_checksum == ZIO_CHECKSUM_OFF)
3406 ASSERT(zio->io_prop.zp_checksum == ZIO_CHECKSUM_LABEL);
3409 if ((error = zio_checksum_error(zio, &info)) != 0) {
3410 zio->io_error = error;
3412 !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
3413 zfs_ereport_start_checksum(zio->io_spa,
3414 zio->io_vd, zio, zio->io_offset,
3415 zio->io_size, NULL, &info);
3426 zio_checksum_verified(zio_t *zio)
3428 zio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY;
3463 zio_ready(zio_t *zio)
3465 blkptr_t *bp = zio->io_bp;
3469 if (zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_READY) ||
3470 zio_wait_for_children(zio, ZIO_CHILD_DDT, ZIO_WAIT_READY))
3473 if (zio->io_ready) {
3474 ASSERT(IO_IS_ALLOCATING(zio));
3475 ASSERT(bp->blk_birth == zio->io_txg || BP_IS_HOLE(bp) ||
3476 (zio->io_flags & ZIO_FLAG_NOPWRITE));
3477 ASSERT(zio->io_children[ZIO_CHILD_GANG][ZIO_WAIT_READY] == 0);
3479 zio->io_ready(zio);
3482 if (bp != NULL && bp != &zio->io_bp_copy)
3483 zio->io_bp_copy = *bp;
3485 if (zio->io_error != 0) {
3486 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
3488 if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
3489 ASSERT(IO_IS_ALLOCATING(zio));
3490 ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
3496 spa_normal_class(zio->io_spa),
3497 zio->io_prop.zp_copies, zio);
3498 zio_allocate_dispatch(zio->io_spa);
3502 mutex_enter(&zio->io_lock);
3503 zio->io_state[ZIO_WAIT_READY] = 1;
3504 pio = zio_walk_parents(zio, &zl);
3505 mutex_exit(&zio->io_lock);
3508 * As we notify zio's parents, new parents could be added.
3509 * New parents go to the head of zio's io_parent_list, however,
3510 * so we will (correctly) not notify them. The remainder of zio's
3515 pio_next = zio_walk_parents(zio, &zl);
3516 zio_notify_parent(pio, zio, ZIO_WAIT_READY);
3519 if (zio->io_flags & ZIO_FLAG_NODATA) {
3521 zio->io_flags &= ~ZIO_FLAG_NODATA;
3523 ASSERT((uintptr_t)zio->io_data < SPA_MAXBLOCKSIZE);
3524 zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
3529 zio->io_spa->spa_syncing_txg == zio->io_txg)
3530 zio_handle_ignored_writes(zio);
3539 zio_dva_throttle_done(zio_t *zio)
3541 zio_t *lio = zio->io_logical;
3542 zio_t *pio = zio_unique_parent(zio);
3543 vdev_t *vd = zio->io_vd;
3546 ASSERT3P(zio->io_bp, !=, NULL);
3547 ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
3548 ASSERT3U(zio->io_priority, ==, ZIO_PRIORITY_ASYNC_WRITE);
3549 ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
3552 ASSERT(!(zio->io_flags & (ZIO_FLAG_IO_REPAIR | ZIO_FLAG_IO_RETRY)));
3553 ASSERT(zio->io_flags & ZIO_FLAG_IO_ALLOCATING);
3561 * throttle needs to know the allocating parent zio so we must find
3575 ASSERT3P(zio, !=, zio->io_logical);
3576 ASSERT(zio->io_logical != NULL);
3577 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REPAIR));
3578 ASSERT0(zio->io_flags & ZIO_FLAG_NOPWRITE);
3581 metaslab_group_alloc_decrement(zio->io_spa, vd->vdev_id, pio, flags);
3584 metaslab_class_throttle_unreserve(spa_normal_class(zio->io_spa),
3592 zio_allocate_dispatch(zio->io_spa);
3596 zio_done(zio_t *zio)
3598 spa_t *spa = zio->io_spa;
3599 zio_t *lio = zio->io_logical;
3600 blkptr_t *bp = zio->io_bp;
3601 vdev_t *vd = zio->io_vd;
3602 uint64_t psize = zio->io_size;
3611 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV, ZIO_WAIT_DONE) ||
3612 zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_DONE) ||
3613 zio_wait_for_children(zio, ZIO_CHILD_DDT, ZIO_WAIT_DONE) ||
3614 zio_wait_for_children(zio, ZIO_CHILD_LOGICAL, ZIO_WAIT_DONE))
3623 if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING &&
3624 zio->io_child_type == ZIO_CHILD_VDEV) {
3626 zio_dva_throttle_done(zio);
3633 if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
3634 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
3635 ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
3637 metaslab_group_alloc_verify(spa, zio->io_bp, zio);
3638 VERIFY(refcount_not_held(&mc->mc_alloc_slots, zio));
3643 ASSERT(zio->io_children[c][w] == 0);
3648 ASSERT(bcmp(bp, &zio->io_bp_copy, sizeof (blkptr_t)) == 0 ||
3649 (bp == zio_unique_parent(zio)->io_bp));
3650 if (zio->io_type == ZIO_TYPE_WRITE && !BP_IS_HOLE(bp) &&
3651 zio->io_bp_override == NULL &&
3652 !(zio->io_flags & ZIO_FLAG_IO_REPAIR)) {
3654 ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(bp));
3658 if (zio->io_flags & ZIO_FLAG_NOPWRITE)
3659 VERIFY(BP_EQUAL(bp, &zio->io_bp_orig));
3665 zio_inherit_child_errors(zio, ZIO_CHILD_VDEV);
3666 zio_inherit_child_errors(zio, ZIO_CHILD_GANG);
3667 zio_inherit_child_errors(zio, ZIO_CHILD_DDT);
3673 if (zio->io_error == 0) {
3674 while (zio->io_cksum_report != NULL) {
3675 zio_cksum_report_t *zcr = zio->io_cksum_report;
3678 char *abuf = zio->io_data;
3682 bcopy(zio->io_data, abuf, psize);
3686 zio->io_cksum_report = zcr->zcr_next;
3696 zio_pop_transforms(zio); /* note: may set zio->io_error */
3698 vdev_stat_update(zio, psize);
3700 if (zio->io_error) {
3707 if (zio->io_error != ECKSUM && vd != NULL && !vdev_is_dead(vd))
3708 zfs_ereport_post(FM_EREPORT_ZFS_IO, spa, vd, zio, 0, 0);
3710 if ((zio->io_error == EIO || !(zio->io_flags &
3712 zio == lio) {
3717 spa_log_error(spa, zio);
3718 zfs_ereport_post(FM_EREPORT_ZFS_DATA, spa, NULL, zio,
3723 if (zio->io_error && zio == lio) {
3725 * Determine whether zio should be reexecuted. This will
3729 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
3731 if (IO_IS_ALLOCATING(zio) &&
3732 !(zio->io_flags & ZIO_FLAG_CANFAIL)) {
3733 if (zio->io_error != ENOSPC)
3734 zio->io_reexecute |= ZIO_REEXECUTE_NOW;
3736 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
3739 if ((zio->io_type == ZIO_TYPE_READ ||
3740 zio->io_type == ZIO_TYPE_FREE) &&
3741 !(zio->io_flags & ZIO_FLAG_SCAN_THREAD) &&
3742 zio->io_error == ENXIO &&
3745 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
3747 if (!(zio->io_flags & ZIO_FLAG_CANFAIL) && !zio->io_reexecute)
3748 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
3762 * errors with errors that happened to the zio itself when
3765 zio_inherit_child_errors(zio, ZIO_CHILD_LOGICAL);
3767 if ((zio->io_error || zio->io_reexecute) &&
3768 IO_IS_ALLOCATING(zio) && zio->io_gang_leader == zio &&
3769 !(zio->io_flags & (ZIO_FLAG_IO_REWRITE | ZIO_FLAG_NOPWRITE)))
3770 zio_dva_unallocate(zio, zio->io_gang_tree, bp);
3772 zio_gang_tree_free(&zio->io_gang_tree);
3777 if ((zio->io_flags & ZIO_FLAG_GODFATHER) &&
3778 (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND))
3779 zio->io_reexecute = 0;
3781 if (zio->io_reexecute) {
3795 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
3797 zio->io_gang_leader = NULL;
3799 mutex_enter(&zio->io_lock);
3800 zio->io_state[ZIO_WAIT_DONE] = 1;
3801 mutex_exit(&zio->io_lock);
3811 for (pio = zio_walk_parents(zio, &zl); pio != NULL;
3814 pio_next = zio_walk_parents(zio, &zl);
3817 (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND)) {
3818 zio_remove_child(pio, zio, remove_zl);
3819 zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
3823 if ((pio = zio_unique_parent(zio)) != NULL) {
3829 ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
3830 zio->io_flags |= ZIO_FLAG_DONT_PROPAGATE;
3831 zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
3832 } else if (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND) {
3837 zio_suspend(spa, zio);
3844 ASSERT(zio->io_tqent.tqent_next == NULL);
3846 ASSERT(zio->io_tqent.tqent_queued == 0);
3848 ASSERT(zio->io_tqent.tqent_task.ta_pending == 0);
3851 ZIO_TASKQ_ISSUE, (task_func_t *)zio_reexecute, zio,
3852 0, &zio->io_tqent);
3857 ASSERT(zio->io_child_count == 0);
3858 ASSERT(zio->io_reexecute == 0);
3859 ASSERT(zio->io_error == 0 || (zio->io_flags & ZIO_FLAG_CANFAIL));
3864 while (zio->io_cksum_report != NULL) {
3865 zio_cksum_report_t *zcr = zio->io_cksum_report;
3866 zio->io_cksum_report = zcr->zcr_next;
3874 * particular zio is no longer discoverable for adoption, and as
3877 if (zio->io_done)
3878 zio->io_done(zio);
3880 mutex_enter(&zio->io_lock);
3881 zio->io_state[ZIO_WAIT_DONE] = 1;
3882 mutex_exit(&zio->io_lock);
3885 for (pio = zio_walk_parents(zio, &zl); pio != NULL; pio = pio_next) {
3887 pio_next = zio_walk_parents(zio, &zl);
3888 zio_remove_child(pio, zio, remove_zl);
3889 zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
3892 if (zio->io_waiter != NULL) {
3893 mutex_enter(&zio->io_lock);
3894 zio->io_executor = NULL;
3895 cv_broadcast(&zio->io_cv);
3896 mutex_exit(&zio->io_lock);
3898 zio_destroy(zio);
Indexes created Sat Feb 28 05:31:39 UTC 2026