Lines Matching refs:zio
51 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zio, CTLFLAG_RW, 0, "ZFS ZIO");
130 * An allocating zio is one that either currently has the DVA allocate
133 #define IO_IS_ALLOCATING(zio) ((zio)->io_orig_pipeline & ZIO_STAGE_DVA_ALLOCATE)
341 zio_push_transform(zio_t *zio, abd_t *data, uint64_t size, uint64_t bufsize,
347 * Ensure that anyone expecting this zio to contain a linear ABD isn't
351 IMPLY(abd_is_linear(zio->io_abd), abd_is_linear(data));
353 IMPLY(zio->io_abd != NULL && abd_is_linear(zio->io_abd),
357 zt->zt_orig_abd = zio->io_abd;
358 zt->zt_orig_size = zio->io_size;
362 zt->zt_next = zio->io_transform_stack;
363 zio->io_transform_stack = zt;
365 zio->io_abd = data;
366 zio->io_size = size;
370 zio_pop_transforms(zio_t *zio)
374 while ((zt = zio->io_transform_stack) != NULL) {
376 zt->zt_transform(zio,
380 abd_free(zio->io_abd);
382 zio->io_abd = zt->zt_orig_abd;
383 zio->io_size = zt->zt_orig_size;
384 zio->io_transform_stack = zt->zt_next;
396 zio_subblock(zio_t *zio, abd_t *data, uint64_t size)
398 ASSERT(zio->io_size > size);
400 if (zio->io_type == ZIO_TYPE_READ)
401 abd_copy(data, zio->io_abd, size);
405 zio_decompress(zio_t *zio, abd_t *data, uint64_t size)
407 if (zio->io_error == 0) {
409 int ret = zio_decompress_data(BP_GET_COMPRESS(zio->io_bp),
410 zio->io_abd, tmp, zio->io_size, size);
414 zio->io_error = SET_ERROR(EIO);
516 zio_wait_for_children(zio_t *zio, uint8_t childbits, enum zio_wait_type wait)
520 mutex_enter(&zio->io_lock);
521 ASSERT(zio->io_stall == NULL);
526 uint64_t *countp = &zio->io_children[c][wait];
528 zio->io_stage >>= 1;
529 ASSERT3U(zio->io_stage, !=, ZIO_STAGE_OPEN);
530 zio->io_stall = countp;
535 mutex_exit(&zio->io_lock);
540 zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait,
543 uint64_t *countp = &pio->io_children[zio->io_child_type][wait];
544 int *errorp = &pio->io_child_error[zio->io_child_type];
547 if (zio->io_error && !(zio->io_flags & ZIO_FLAG_DONT_PROPAGATE))
548 *errorp = zio_worst_error(*errorp, zio->io_error);
549 pio->io_reexecute |= zio->io_reexecute;
563 * so. Otherwise dispatch the parent zio as its own task.
566 * locking on the zio taskq's, reduces context switch
568 * read from disk typically causes at least 3 zio's: a
570 * zio. When the physical ZIO completes, we are able to call
571 * zio_done() on all 3 of these zio's from one invocation of
579 * parent-child relationships, as we do with the "mega zio"
593 zio_inherit_child_errors(zio_t *zio, enum zio_child c)
595 if (zio->io_child_error[c] != 0 && zio->io_error == 0)
596 zio->io_error = zio->io_child_error[c];
645 zio_t *zio;
657 zio = kmem_cache_alloc(zio_cache, KM_SLEEP);
658 bzero(zio, sizeof (zio_t));
660 mutex_init(&zio->io_lock, NULL, MUTEX_DEFAULT, NULL);
661 cv_init(&zio->io_cv, NULL, CV_DEFAULT, NULL);
663 list_create(&zio->io_parent_list, sizeof (zio_link_t),
665 list_create(&zio->io_child_list, sizeof (zio_link_t),
667 metaslab_trace_init(&zio->io_alloc_list);
670 zio->io_child_type = ZIO_CHILD_VDEV;
672 zio->io_child_type = ZIO_CHILD_GANG;
674 zio->io_child_type = ZIO_CHILD_DDT;
676 zio->io_child_type = ZIO_CHILD_LOGICAL;
679 zio->io_bp = (blkptr_t *)bp;
680 zio->io_bp_copy = *bp;
681 zio->io_bp_orig = *bp;
683 zio->io_child_type == ZIO_CHILD_DDT)
684 zio->io_bp = &zio->io_bp_copy; /* so caller can free */
685 if (zio->io_child_type == ZIO_CHILD_LOGICAL)
686 zio->io_logical = zio;
687 if (zio->io_child_type > ZIO_CHILD_GANG && BP_IS_GANG(bp))
691 zio->io_spa = spa;
692 zio->io_txg = txg;
693 zio->io_done = done;
694 zio->io_private = private;
695 zio->io_type = type;
696 zio->io_priority = priority;
697 zio->io_vd = vd;
698 zio->io_offset = offset;
699 zio->io_orig_abd = zio->io_abd = data;
700 zio->io_orig_size = zio->io_size = psize;
701 zio->io_lsize = lsize;
702 zio->io_orig_flags = zio->io_flags = flags;
703 zio->io_orig_stage = zio->io_stage = stage;
704 zio->io_orig_pipeline = zio->io_pipeline = pipeline;
705 zio->io_pipeline_trace = ZIO_STAGE_OPEN;
707 zio->io_state[ZIO_WAIT_READY] = (stage >= ZIO_STAGE_READY);
708 zio->io_state[ZIO_WAIT_DONE] = (stage >= ZIO_STAGE_DONE);
711 zio->io_bookmark = *zb;
714 if (zio->io_metaslab_class == NULL)
715 zio->io_metaslab_class = pio->io_metaslab_class;
716 if (zio->io_logical == NULL)
717 zio->io_logical = pio->io_logical;
718 if (zio->io_child_type == ZIO_CHILD_GANG)
719 zio->io_gang_leader = pio->io_gang_leader;
720 zio_add_child(pio, zio);
723 return (zio);
727 zio_destroy(zio_t *zio)
729 metaslab_trace_fini(&zio->io_alloc_list);
730 list_destroy(&zio->io_parent_list);
731 list_destroy(&zio->io_child_list);
732 mutex_destroy(&zio->io_lock);
733 cv_destroy(&zio->io_cv);
734 kmem_cache_free(zio_cache, zio);
741 zio_t *zio;
743 zio = zio_create(pio, spa, 0, NULL, NULL, 0, 0, done, private,
747 return (zio);
791 * will be done once the zio is executed in vdev_mirror_map_alloc.
880 zio_t *zio;
884 zio = zio_create(pio, spa, BP_PHYSICAL_BIRTH(bp), bp,
890 return (zio);
901 zio_t *zio;
912 zio = zio_create(pio, spa, txg, bp, data, lsize, psize, done, private,
917 zio->io_ready = ready;
918 zio->io_children_ready = children_ready;
919 zio->io_physdone = physdone;
920 zio->io_prop = *zp;
928 if (data == NULL && zio->io_prop.zp_dedup_verify) {
929 zio->io_prop.zp_dedup = zio->io_prop.zp_dedup_verify = B_FALSE;
932 return (zio);
940 zio_t *zio;
942 zio = zio_create(pio, spa, txg, bp, data, size, size, done, private,
946 return (zio);
950 zio_write_override(zio_t *zio, blkptr_t *bp, int copies, boolean_t nopwrite)
952 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
953 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
954 ASSERT(zio->io_stage == ZIO_STAGE_OPEN);
955 ASSERT(zio->io_txg == spa_syncing_txg(zio->io_spa));
962 zio->io_prop.zp_dedup = nopwrite ? B_FALSE : zio->io_prop.zp_dedup;
963 zio->io_prop.zp_nopwrite = nopwrite;
964 zio->io_prop.zp_copies = copies;
965 zio->io_bp_override = bp;
1003 zio_t *zio;
1030 zio = zio_create(pio, spa, txg, bp, NULL, size,
1034 return (zio);
1041 zio_t *zio;
1065 zio = zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp),
1068 ASSERT0(zio->io_queued_timestamp);
1070 return (zio);
1078 zio_t *zio;
1082 zio = zio_create(pio, spa, 0, NULL, NULL, 0, 0, done, private,
1086 zio->io_cmd = cmd;
1088 zio = zio_null(pio, spa, NULL, NULL, NULL, flags);
1091 zio_nowait(zio_ioctl(zio, spa, vd->vdev_child[c], cmd,
1095 return (zio);
1103 zio_t *zio;
1110 zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, size, done,
1114 zio->io_prop.zp_checksum = checksum;
1116 return (zio);
1124 zio_t *zio;
1131 zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, size, done,
1135 zio->io_prop.zp_checksum = checksum;
1147 zio_push_transform(zio, wbuf, size, size, NULL);
1150 return (zio);
1162 zio_t *zio;
1206 * top-level vdev, then the child zio is not an allocating I/O.
1223 zio = zio_create(pio, pio->io_spa, pio->io_txg, bp, data, size, size,
1226 ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
1228 zio->io_physdone = pio->io_physdone;
1229 if (vd->vdev_ops->vdev_op_leaf && zio->io_logical != NULL)
1230 zio->io_logical->io_phys_children++;
1232 return (zio);
1240 zio_t *zio;
1244 zio = zio_create(NULL, vd->vdev_spa, 0, NULL,
1250 return (zio);
1254 zio_flush(zio_t *zio, vdev_t *vd)
1256 zio_nowait(zio_ioctl(zio, zio->io_spa, vd, DKIOCFLUSHWRITECACHE, 0, 0,
1262 zio_trim(zio_t *zio, spa_t *spa, vdev_t *vd, uint64_t offset, uint64_t size)
1267 return (zio_create(zio, spa, 0, NULL, NULL, size, size, NULL, NULL,
1274 zio_shrink(zio_t *zio, uint64_t size)
1276 ASSERT3P(zio->io_executor, ==, NULL);
1277 ASSERT3P(zio->io_orig_size, ==, zio->io_size);
1278 ASSERT3U(size, <=, zio->io_size);
1285 ASSERT(BP_GET_COMPRESS(zio->io_bp) == ZIO_COMPRESS_OFF);
1286 if (!BP_IS_RAIDZ(zio->io_bp)) {
1288 ASSERT3U(zio->io_size, ==, zio->io_lsize);
1289 zio->io_orig_size = zio->io_size = zio->io_lsize = size;
1300 zio_read_bp_init(zio_t *zio)
1302 blkptr_t *bp = zio->io_bp;
1304 ASSERT3P(zio->io_bp, ==, &zio->io_bp_copy);
1307 zio->io_child_type == ZIO_CHILD_LOGICAL &&
1308 !(zio->io_flags & ZIO_FLAG_RAW)) {
1311 zio_push_transform(zio, abd_alloc_sametype(zio->io_abd, psize),
1316 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1319 void *data = abd_borrow_buf(zio->io_abd, psize);
1321 abd_return_buf_copy(zio->io_abd, data, psize);
1324 ASSERT3P(zio->io_bp, ==, &zio->io_bp_copy);
1328 zio->io_flags |= ZIO_FLAG_DONT_CACHE;
1331 zio->io_flags |= ZIO_FLAG_DONT_CACHE;
1333 if (BP_GET_DEDUP(bp) && zio->io_child_type == ZIO_CHILD_LOGICAL)
1334 zio->io_pipeline = ZIO_DDT_READ_PIPELINE;
1336 return (zio);
1340 zio_write_bp_init(zio_t *zio)
1342 if (!IO_IS_ALLOCATING(zio))
1343 return (zio);
1345 ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
1347 if (zio->io_bp_override) {
1348 blkptr_t *bp = zio->io_bp;
1349 zio_prop_t *zp = &zio->io_prop;
1351 ASSERT(bp->blk_birth != zio->io_txg);
1352 ASSERT(BP_GET_DEDUP(zio->io_bp_override) == 0);
1354 *bp = *zio->io_bp_override;
1355 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1358 return (zio);
1368 zio->io_flags |= ZIO_FLAG_NOPWRITE;
1369 return (zio);
1375 return (zio);
1382 zio->io_pipeline |= ZIO_STAGE_DDT_WRITE;
1383 return (zio);
1390 zio->io_bp_override = NULL;
1391 *bp = zio->io_bp_orig;
1392 zio->io_pipeline = zio->io_orig_pipeline;
1395 return (zio);
1399 zio_write_compress(zio_t *zio)
1401 spa_t *spa = zio->io_spa;
1402 zio_prop_t *zp = &zio->io_prop;
1404 blkptr_t *bp = zio->io_bp;
1405 uint64_t lsize = zio->io_lsize;
1406 uint64_t psize = zio->io_size;
1409 EQUIV(lsize != psize, (zio->io_flags & ZIO_FLAG_RAW) != 0);
1415 if (zio_wait_for_children(zio, ZIO_CHILD_LOGICAL_BIT |
1420 if (!IO_IS_ALLOCATING(zio))
1421 return (zio);
1423 if (zio->io_children_ready != NULL) {
1426 * associated with this zio in case it wants to modify the
1430 zio->io_children_ready(zio);
1433 ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
1434 ASSERT(zio->io_bp_override == NULL);
1436 if (!BP_IS_HOLE(bp) && bp->blk_birth == zio->io_txg) {
1448 ASSERT(zio->io_txg == spa_syncing_txg(spa));
1449 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1463 psize = zio_compress_data(compress, zio->io_abd, cbuf, lsize);
1473 BP_SET_TYPE(bp, zio->io_prop.zp_type);
1474 BP_SET_LEVEL(bp, zio->io_prop.zp_level);
1476 bp->blk_birth = zio->io_txg;
1477 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1480 return (zio);
1502 zio_push_transform(zio, cdata,
1511 zio->io_bp_override = NULL;
1512 *bp = zio->io_bp_orig;
1513 zio->io_pipeline = zio->io_orig_pipeline;
1526 if (!BP_IS_HOLE(bp) && bp->blk_birth == zio->io_txg &&
1530 enum zio_stage gang_stages = zio->io_pipeline & ZIO_GANG_STAGES;
1532 zio->io_pipeline = ZIO_REWRITE_PIPELINE | gang_stages;
1533 zio->io_flags |= ZIO_FLAG_IO_REWRITE;
1536 zio->io_pipeline = ZIO_WRITE_PIPELINE;
1540 if (zio->io_bp_orig.blk_birth != 0 &&
1545 BP_SET_BIRTH(bp, zio->io_txg, 0);
1547 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
1559 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1560 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
1561 zio->io_pipeline = ZIO_DDT_WRITE_PIPELINE;
1564 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1565 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
1566 zio->io_pipeline |= ZIO_STAGE_NOP_WRITE;
1569 return (zio);
1573 zio_free_bp_init(zio_t *zio)
1575 blkptr_t *bp = zio->io_bp;
1577 if (zio->io_child_type == ZIO_CHILD_LOGICAL) {
1579 zio->io_pipeline = ZIO_DDT_FREE_PIPELINE;
1582 ASSERT3P(zio->io_bp, ==, &zio->io_bp_copy);
1584 return (zio);
1594 zio_taskq_dispatch(zio_t *zio, zio_taskq_type_t q, boolean_t cutinline)
1596 spa_t *spa = zio->io_spa;
1597 zio_type_t t = zio->io_type;
1607 if (zio->io_flags & (ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_PROBE))
1613 if (t == ZIO_TYPE_WRITE && zio->io_vd && zio->io_vd->vdev_aux)
1620 if ((zio->io_priority == ZIO_PRIORITY_NOW ||
1621 zio->io_priority == ZIO_PRIORITY_SYNC_WRITE) &&
1628 * NB: We are assuming that the zio can only be dispatched
1630 * to dispatch the zio to another taskq at the same time.
1633 ASSERT(zio->io_tqent.tqent_next == NULL);
1635 ASSERT(zio->io_tqent.tqent_task.ta_pending == 0);
1637 spa_taskq_dispatch_ent(spa, t, q, (task_func_t *)zio_execute, zio,
1638 flags, &zio->io_tqent);
1642 zio_taskq_member(zio_t *zio, zio_taskq_type_t q)
1644 kthread_t *executor = zio->io_executor;
1645 spa_t *spa = zio->io_spa;
1660 zio_issue_async(zio_t *zio)
1662 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
1668 zio_interrupt(zio_t *zio)
1670 zio_taskq_dispatch(zio, ZIO_TASKQ_INTERRUPT, B_FALSE);
1674 zio_delay_interrupt(zio_t *zio)
1678 * rather than trying to implement the function, the zio delay
1686 * delay; issuing it directly to the zio layer.
1688 if (zio->io_target_timestamp != 0) {
1691 if (now >= zio->io_target_timestamp) {
1696 * directly to the zio layer. This is likely due to
1703 DTRACE_PROBE2(zio__delay__miss, zio_t *, zio,
1706 zio_interrupt(zio);
1708 hrtime_t diff = zio->io_target_timestamp - now;
1710 DTRACE_PROBE3(zio__delay__hit, zio_t *, zio,
1714 (void (*)(void *))zio_interrupt, zio, diff, 1, 0);
1721 DTRACE_PROBE1(zio__delay__skip, zio_t *, zio);
1722 zio_interrupt(zio);
1744 zio_execute(zio_t *zio)
1746 ASSERT3U(zio->io_queued_timestamp, >, 0);
1748 while (zio->io_stage < ZIO_STAGE_DONE) {
1749 enum zio_stage pipeline = zio->io_pipeline;
1750 enum zio_stage stage = zio->io_stage;
1752 zio->io_executor = curthread;
1754 ASSERT(!MUTEX_HELD(&zio->io_lock));
1756 ASSERT(zio->io_stall == NULL);
1773 if ((stage & ZIO_BLOCKING_STAGES) && zio->io_vd == NULL &&
1774 zio_taskq_member(zio, ZIO_TASKQ_INTERRUPT)) {
1777 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, cut);
1781 zio->io_stage = stage;
1782 zio->io_pipeline_trace |= zio->io_stage;
1785 * The zio pipeline stage returns the next zio to execute
1789 zio = zio_pipeline[highbit64(stage) - 1](zio);
1791 if (zio == NULL)
1802 zio_wait(zio_t *zio)
1806 ASSERT3P(zio->io_stage, ==, ZIO_STAGE_OPEN);
1807 ASSERT3P(zio->io_executor, ==, NULL);
1809 zio->io_waiter = curthread;
1810 ASSERT0(zio->io_queued_timestamp);
1811 zio->io_queued_timestamp = gethrtime();
1813 zio_execute(zio);
1815 mutex_enter(&zio->io_lock);
1816 while (zio->io_executor != NULL)
1817 cv_wait(&zio->io_cv, &zio->io_lock);
1818 mutex_exit(&zio->io_lock);
1820 error = zio->io_error;
1821 zio_destroy(zio);
1827 zio_nowait(zio_t *zio)
1829 ASSERT3P(zio->io_executor, ==, NULL);
1831 if (zio->io_child_type == ZIO_CHILD_LOGICAL &&
1832 zio_unique_parent(zio) == NULL) {
1838 spa_t *spa = zio->io_spa;
1840 zio_add_child(spa->spa_async_zio_root[CPU_SEQID], zio);
1843 ASSERT0(zio->io_queued_timestamp);
1844 zio->io_queued_timestamp = gethrtime();
1845 zio_execute(zio);
1910 zio_suspend(spa_t *spa, zio_t *zio, zio_suspend_reason_t reason)
1928 if (zio != NULL) {
1929 ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
1930 ASSERT(zio != spa->spa_suspend_zio_root);
1931 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
1932 ASSERT(zio_unique_parent(zio) == NULL);
1933 ASSERT(zio->io_stage == ZIO_STAGE_DONE);
1934 zio_add_child(spa->spa_suspend_zio_root, zio);
2038 zio_gang_issue_func_done(zio_t *zio)
2040 abd_put(zio->io_abd);
2060 zio_t *zio;
2065 zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
2081 zio_checksum_compute(zio, BP_GET_CHECKSUM(bp),
2091 zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
2093 zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
2099 return (zio);
2130 static void zio_gang_tree_assemble_done(zio_t *zio);
2188 zio_gang_tree_assemble_done(zio_t *zio)
2190 zio_t *gio = zio->io_gang_leader;
2191 zio_gang_node_t *gn = zio->io_private;
2192 blkptr_t *bp = zio->io_bp;
2194 ASSERT(gio == zio_unique_parent(zio));
2195 ASSERT(zio->io_child_count == 0);
2197 if (zio->io_error)
2202 byteswap_uint64_array(abd_to_buf(zio->io_abd), zio->io_size);
2204 ASSERT3P(abd_to_buf(zio->io_abd), ==, gn->gn_gbh);
2205 ASSERT(zio->io_size == SPA_GANGBLOCKSIZE);
2208 abd_put(zio->io_abd);
2223 zio_t *zio;
2233 zio = zio_gang_issue_func[gio->io_type](pio, bp, gn, data, offset);
2242 zio_gang_tree_issue(zio, gn->gn_child[g], gbp, data,
2251 if (zio != pio)
2252 zio_nowait(zio);
2256 zio_gang_assemble(zio_t *zio)
2258 blkptr_t *bp = zio->io_bp;
2260 ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == NULL);
2261 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2263 zio->io_gang_leader = zio;
2265 zio_gang_tree_assemble(zio, bp, &zio->io_gang_tree);
2267 return (zio);
2271 zio_gang_issue(zio_t *zio)
2273 blkptr_t *bp = zio->io_bp;
2275 if (zio_wait_for_children(zio, ZIO_CHILD_GANG_BIT, ZIO_WAIT_DONE)) {
2279 ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == zio);
2280 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2282 if (zio->io_child_error[ZIO_CHILD_GANG] == 0)
2283 zio_gang_tree_issue(zio, zio->io_gang_tree, bp, zio->io_abd,
2286 zio_gang_tree_free(&zio->io_gang_tree);
2288 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
2290 return (zio);
2294 zio_write_gang_member_ready(zio_t *zio)
2296 zio_t *pio = zio_unique_parent(zio);
2297 zio_t *gio = zio->io_gang_leader;
2298 dva_t *cdva = zio->io_bp->blk_dva;
2302 if (BP_IS_HOLE(zio->io_bp))
2305 ASSERT(BP_IS_HOLE(&zio->io_bp_orig));
2307 ASSERT(zio->io_child_type == ZIO_CHILD_GANG);
2308 ASSERT3U(zio->io_prop.zp_copies, ==, gio->io_prop.zp_copies);
2309 ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(zio->io_bp));
2311 ASSERT3U(BP_GET_NDVAS(zio->io_bp), <=, BP_GET_NDVAS(pio->io_bp));
2314 for (int d = 0; d < BP_GET_NDVAS(zio->io_bp); d++) {
2324 zio_write_gang_done(zio_t *zio)
2327 * The io_abd field will be NULL for a zio with no data. The io_flags
2331 if (zio->io_abd != NULL)
2332 abd_put(zio->io_abd);
2342 zio_t *zio;
2365 * The logical zio has already placed a reservation for
2413 zio = zio_rewrite(pio, spa, txg, bp, gbh_abd, SPA_GANGBLOCKSIZE,
2434 zio_t *cio = zio_write(zio, spa, txg, &gbh->zg_blkptr[g],
2457 * Set pio's pipeline to just wait for zio to finish.
2461 zio_nowait(zio);
2485 zio_nop_write(zio_t *zio)
2487 blkptr_t *bp = zio->io_bp;
2488 blkptr_t *bp_orig = &zio->io_bp_orig;
2489 zio_prop_t *zp = &zio->io_prop;
2492 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
2495 ASSERT(zio->io_bp_override == NULL);
2496 ASSERT(IO_IS_ALLOCATING(zio));
2511 return (zio);
2527 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
2528 zio->io_flags |= ZIO_FLAG_NOPWRITE;
2531 return (zio);
2540 zio_ddt_child_read_done(zio_t *zio)
2542 blkptr_t *bp = zio->io_bp;
2543 ddt_entry_t *dde = zio->io_private;
2545 zio_t *pio = zio_unique_parent(zio);
2549 if (zio->io_error == 0)
2552 if (zio->io_error == 0 && dde->dde_repair_abd == NULL)
2553 dde->dde_repair_abd = zio->io_abd;
2555 abd_free(zio->io_abd);
2560 zio_ddt_read_start(zio_t *zio)
2562 blkptr_t *bp = zio->io_bp;
2565 ASSERT(BP_GET_PSIZE(bp) == zio->io_size);
2566 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
2568 if (zio->io_child_error[ZIO_CHILD_DDT]) {
2569 ddt_t *ddt = ddt_select(zio->io_spa, bp);
2575 ASSERT(zio->io_vsd == NULL);
2576 zio->io_vsd = dde;
2579 return (zio);
2586 zio_nowait(zio_read(zio, zio->io_spa, &blk,
2587 abd_alloc_for_io(zio->io_size, B_TRUE),
2588 zio->io_size, zio_ddt_child_read_done, dde,
2589 zio->io_priority, ZIO_DDT_CHILD_FLAGS(zio) |
2590 ZIO_FLAG_DONT_PROPAGATE, &zio->io_bookmark));
2592 return (zio);
2595 zio_nowait(zio_read(zio, zio->io_spa, bp,
2596 zio->io_abd, zio->io_size, NULL, NULL, zio->io_priority,
2597 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark));
2599 return (zio);
2603 zio_ddt_read_done(zio_t *zio)
2605 blkptr_t *bp = zio->io_bp;
2607 if (zio_wait_for_children(zio, ZIO_CHILD_DDT_BIT, ZIO_WAIT_DONE)) {
2612 ASSERT(BP_GET_PSIZE(bp) == zio->io_size);
2613 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
2615 if (zio->io_child_error[ZIO_CHILD_DDT]) {
2616 ddt_t *ddt = ddt_select(zio->io_spa, bp);
2617 ddt_entry_t *dde = zio->io_vsd;
2619 ASSERT(spa_load_state(zio->io_spa) != SPA_LOAD_NONE);
2620 return (zio);
2623 zio->io_stage = ZIO_STAGE_DDT_READ_START >> 1;
2624 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
2628 abd_copy(zio->io_abd, dde->dde_repair_abd,
2629 zio->io_size);
2630 zio->io_child_error[ZIO_CHILD_DDT] = 0;
2633 zio->io_vsd = NULL;
2636 ASSERT(zio->io_vsd == NULL);
2638 return (zio);
2642 zio_ddt_collision(zio_t *zio, ddt_t *ddt, ddt_entry_t *dde)
2644 spa_t *spa = zio->io_spa;
2645 boolean_t do_raw = (zio->io_flags & ZIO_FLAG_RAW);
2647 /* We should never get a raw, override zio */
2648 ASSERT(!(zio->io_bp_override && do_raw));
2652 * because when zio->io_bp is an override bp, we will not have
2660 return (lio->io_orig_size != zio->io_orig_size ||
2661 abd_cmp(zio->io_orig_abd, lio->io_orig_abd,
2662 zio->io_orig_size) != 0);
2673 blkptr_t blk = *zio->io_bp;
2691 ASSERT3U(zio->io_size, ==, zio->io_orig_size);
2692 ASSERT0(abd_cmp(zio->io_abd, zio->io_orig_abd,
2693 zio->io_size));
2694 ASSERT3P(zio->io_transform_stack, ==, NULL);
2699 zio_flags, &aflags, &zio->io_bookmark);
2702 if (arc_buf_size(abuf) != zio->io_orig_size ||
2703 abd_cmp_buf(zio->io_orig_abd, abuf->b_data,
2704 zio->io_orig_size) != 0)
2718 zio_ddt_child_write_ready(zio_t *zio)
2720 int p = zio->io_prop.zp_copies;
2721 ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp);
2722 ddt_entry_t *dde = zio->io_private;
2726 if (zio->io_error)
2731 ASSERT(dde->dde_lead_zio[p] == zio);
2733 ddt_phys_fill(ddp, zio->io_bp);
2736 while ((pio = zio_walk_parents(zio, &zl)) != NULL)
2737 ddt_bp_fill(ddp, pio->io_bp, zio->io_txg);
2743 zio_ddt_child_write_done(zio_t *zio)
2745 int p = zio->io_prop.zp_copies;
2746 ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp);
2747 ddt_entry_t *dde = zio->io_private;
2753 ASSERT(dde->dde_lead_zio[p] == zio);
2756 if (zio->io_error == 0) {
2758 while (zio_walk_parents(zio, &zl) != NULL)
2768 zio_ddt_ditto_write_done(zio_t *zio)
2771 zio_prop_t *zp = &zio->io_prop;
2772 blkptr_t *bp = zio->io_bp;
2773 ddt_t *ddt = ddt_select(zio->io_spa, bp);
2774 ddt_entry_t *dde = zio->io_private;
2781 ASSERT(dde->dde_lead_zio[p] == zio);
2784 if (zio->io_error == 0) {
2789 ddt_phys_free(ddt, ddk, ddp, zio->io_txg);
2797 zio_ddt_write(zio_t *zio)
2799 spa_t *spa = zio->io_spa;
2800 blkptr_t *bp = zio->io_bp;
2801 uint64_t txg = zio->io_txg;
2802 zio_prop_t *zp = &zio->io_prop;
2813 ASSERT(BP_IS_HOLE(bp) || zio->io_bp_override);
2814 ASSERT(!(zio->io_bp_override && (zio->io_flags & ZIO_FLAG_RAW)));
2820 if (zp->zp_dedup_verify && zio_ddt_collision(zio, ddt, dde)) {
2830 zio_pop_transforms(zio);
2831 zio->io_stage = ZIO_STAGE_OPEN;
2838 zio->io_pipeline = ZIO_WRITE_PIPELINE;
2840 return (zio);
2859 if (zio->io_bp_override) {
2860 zio_pop_transforms(zio);
2861 zio->io_stage = ZIO_STAGE_OPEN;
2862 zio->io_pipeline = ZIO_WRITE_PIPELINE;
2863 zio->io_bp_override = NULL;
2866 return (zio);
2869 dio = zio_write(zio, spa, txg, bp, zio->io_orig_abd,
2870 zio->io_orig_size, zio->io_orig_size, &czp, NULL, NULL,
2871 NULL, zio_ddt_ditto_write_done, dde, zio->io_priority,
2872 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark);
2874 zio_push_transform(dio, zio->io_abd, zio->io_size, 0, NULL);
2882 zio_add_child(zio, dde->dde_lead_zio[p]);
2885 } else if (zio->io_bp_override) {
2887 ASSERT(BP_EQUAL(bp, zio->io_bp_override));
2891 cio = zio_write(zio, spa, txg, bp, zio->io_orig_abd,
2892 zio->io_orig_size, zio->io_orig_size, zp,
2894 zio_ddt_child_write_done, dde, zio->io_priority,
2895 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark);
2897 zio_push_transform(cio, zio->io_abd, zio->io_size, 0, NULL);
2908 return (zio);
2914 zio_ddt_free(zio_t *zio)
2916 spa_t *spa = zio->io_spa;
2917 blkptr_t *bp = zio->io_bp;
2923 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
2931 return (zio);
2943 zio_t *zio;
2947 zio = avl_first(&spa->spa_alloc_trees[allocator]);
2948 if (zio == NULL)
2951 ASSERT(IO_IS_ALLOCATING(zio));
2954 * Try to place a reservation for this zio. If we're unable to
2957 ASSERT3U(zio->io_allocator, ==, allocator);
2958 if (!metaslab_class_throttle_reserve(zio->io_metaslab_class,
2959 zio->io_prop.zp_copies, zio->io_allocator, zio, 0)) {
2963 avl_remove(&spa->spa_alloc_trees[allocator], zio);
2964 ASSERT3U(zio->io_stage, <, ZIO_STAGE_DVA_ALLOCATE);
2966 return (zio);
2970 zio_dva_throttle(zio_t *zio)
2972 spa_t *spa = zio->io_spa;
2977 mc = spa_preferred_class(spa, zio->io_size, zio->io_prop.zp_type,
2978 zio->io_prop.zp_level, zio->io_prop.zp_zpl_smallblk);
2980 if (zio->io_priority == ZIO_PRIORITY_SYNC_WRITE ||
2982 zio->io_child_type == ZIO_CHILD_GANG ||
2983 zio->io_flags & ZIO_FLAG_NODATA) {
2984 return (zio);
2987 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
2989 ASSERT3U(zio->io_queued_timestamp, >, 0);
2990 ASSERT(zio->io_stage == ZIO_STAGE_DVA_THROTTLE);
2992 zbookmark_phys_t *bm = &zio->io_bookmark;
3000 zio->io_allocator = cityhash4(bm->zb_objset, bm->zb_object,
3002 mutex_enter(&spa->spa_alloc_locks[zio->io_allocator]);
3003 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
3004 zio->io_metaslab_class = mc;
3005 avl_add(&spa->spa_alloc_trees[zio->io_allocator], zio);
3006 nio = zio_io_to_allocate(spa, zio->io_allocator);
3007 mutex_exit(&spa->spa_alloc_locks[zio->io_allocator]);
3015 zio_t *zio;
3018 zio = zio_io_to_allocate(spa, allocator);
3020 if (zio == NULL)
3023 ASSERT3U(zio->io_stage, ==, ZIO_STAGE_DVA_THROTTLE);
3024 ASSERT0(zio->io_error);
3025 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_TRUE);
3029 zio_dva_allocate(zio_t *zio)
3031 spa_t *spa = zio->io_spa;
3033 blkptr_t *bp = zio->io_bp;
3037 if (zio->io_gang_leader == NULL) {
3038 ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
3039 zio->io_gang_leader = zio;
3044 ASSERT3U(zio->io_prop.zp_copies, >, 0);
3045 ASSERT3U(zio->io_prop.zp_copies, <=, spa_max_replication(spa));
3046 ASSERT3U(zio->io_size, ==, BP_GET_PSIZE(bp));
3048 if (zio->io_flags & ZIO_FLAG_NODATA)
3050 if (zio->io_flags & ZIO_FLAG_GANG_CHILD)
3052 if (zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE)
3058 mc = zio->io_metaslab_class;
3060 mc = spa_preferred_class(spa, zio->io_size,
3061 zio->io_prop.zp_type, zio->io_prop.zp_level,
3062 zio->io_prop.zp_zpl_smallblk);
3063 zio->io_metaslab_class = mc;
3066 error = metaslab_alloc(spa, mc, zio->io_size, bp,
3067 zio->io_prop.zp_copies, zio->io_txg, NULL, flags,
3068 &zio->io_alloc_list, zio, zio->io_allocator);
3080 (zio->io_flags & ZIO_FLAG_IO_ALLOCATING)) {
3082 zio->io_prop.zp_copies, zio->io_allocator, zio);
3083 zio->io_flags &= ~ZIO_FLAG_IO_ALLOCATING;
3087 zio->io_prop.zp_copies, zio->io_allocator, zio,
3092 zio->io_metaslab_class = mc;
3094 error = metaslab_alloc(spa, mc, zio->io_size, bp,
3095 zio->io_prop.zp_copies, zio->io_txg, NULL, flags,
3096 &zio->io_alloc_list, zio, zio->io_allocator);
3100 zfs_dbgmsg("%s: metaslab allocation failure: zio %p, "
3101 "size %llu, error %d", spa_name(spa), zio, zio->io_size,
3103 if (error == ENOSPC && zio->io_size > SPA_MINBLOCKSIZE)
3104 return (zio_write_gang_block(zio));
3105 zio->io_error = error;
3108 return (zio);
3112 zio_dva_free(zio_t *zio)
3114 metaslab_free(zio->io_spa, zio->io_bp, zio->io_txg, B_FALSE);
3116 return (zio);
3120 zio_dva_claim(zio_t *zio)
3124 error = metaslab_claim(zio->io_spa, zio->io_bp, zio->io_txg);
3126 zio->io_error = error;
3128 return (zio);
3137 zio_dva_unallocate(zio_t *zio, zio_gang_node_t *gn, blkptr_t *bp)
3139 ASSERT(bp->blk_birth == zio->io_txg || BP_IS_HOLE(bp));
3140 ASSERT(zio->io_bp_override == NULL);
3143 metaslab_free(zio->io_spa, bp, bp->blk_birth, B_TRUE);
3147 zio_dva_unallocate(zio, gn->gn_child[g],
3233 zio_vdev_io_start(zio_t *zio)
3235 vdev_t *vd = zio->io_vd;
3237 spa_t *spa = zio->io_spa;
3240 ASSERT(zio->io_error == 0);
3241 ASSERT(zio->io_child_error[ZIO_CHILD_VDEV] == 0);
3244 if (!(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
3245 spa_config_enter(spa, SCL_ZIO, zio, RW_READER);
3250 vdev_mirror_ops.vdev_op_io_start(zio);
3254 if (vd->vdev_ops->vdev_op_leaf && zio->io_type == ZIO_TYPE_FREE &&
3255 zio->io_priority == ZIO_PRIORITY_NOW) {
3256 trim_map_free(vd, zio->io_offset, zio->io_size, zio->io_txg);
3257 return (zio);
3260 ASSERT3P(zio->io_logical, !=, zio);
3261 if (zio->io_type == ZIO_TYPE_WRITE) {
3264 if (zio->io_vd->vdev_removing) {
3269 ASSERT(zio->io_flags &
3285 if (!(zio->io_flags & ZIO_FLAG_SCAN_THREAD) && zio->io_bp != NULL &&
3287 zio->io_bookmark.zb_objset != DMU_META_OBJSET &&
3288 zio->io_txg != spa_syncing_txg(spa)) {
3296 if (!(zio->io_flags & ZIO_FLAG_PHYSICAL) &&
3297 P2PHASE(zio->io_size, align) != 0) {
3299 uint64_t asize = P2ROUNDUP(zio->io_size, align);
3301 if (zio->io_type == ZIO_TYPE_READ ||
3302 zio->io_type == ZIO_TYPE_WRITE)
3303 abuf = abd_alloc_sametype(zio->io_abd, asize);
3305 if (zio->io_type == ZIO_TYPE_WRITE) {
3306 abd_copy(abuf, zio->io_abd, zio->io_size);
3307 abd_zero_off(abuf, zio->io_size, asize - zio->io_size);
3309 zio_push_transform(zio, abuf, asize, abuf ? asize : 0,
3317 if (!(zio->io_flags & ZIO_FLAG_PHYSICAL)) {
3318 ASSERT0(P2PHASE(zio->io_offset, align));
3319 ASSERT0(P2PHASE(zio->io_size, align));
3327 ASSERT0(P2PHASE(zio->io_offset, log_align));
3328 ASSERT0(P2PHASE(zio->io_size, log_align));
3331 VERIFY(zio->io_type == ZIO_TYPE_READ || spa_writeable(spa));
3336 * then don't do the I/O unless zio's txg is actually in vd's DTL.
3364 if ((zio->io_flags & ZIO_FLAG_IO_REPAIR) &&
3365 !(zio->io_flags & ZIO_FLAG_SELF_HEAL) &&
3366 zio->io_txg != 0 && /* not a delegated i/o */
3368 !vdev_dtl_contains(vd, DTL_PARTIAL, zio->io_txg, 1)) {
3369 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
3370 zio_vdev_io_bypass(zio);
3371 return (zio);
3375 switch (zio->io_type) {
3377 if (vdev_cache_read(zio))
3378 return (zio);
3382 if ((zio = vdev_queue_io(zio)) == NULL)
3385 if (!vdev_accessible(vd, zio)) {
3386 zio->io_error = SET_ERROR(ENXIO);
3387 zio_interrupt(zio);
3397 if (zio->io_type == ZIO_TYPE_WRITE &&
3398 !(zio->io_flags & ZIO_FLAG_IO_REPAIR) &&
3399 !trim_map_write_start(zio))
3403 vd->vdev_ops->vdev_op_io_start(zio);
3408 zio_vdev_io_done(zio_t *zio)
3410 vdev_t *vd = zio->io_vd;
3414 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV_BIT, ZIO_WAIT_DONE)) {
3418 ASSERT(zio->io_type == ZIO_TYPE_READ ||
3419 zio->io_type == ZIO_TYPE_WRITE || zio->io_type == ZIO_TYPE_FREE);
3422 (zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE ||
3423 zio->io_type == ZIO_TYPE_FREE)) {
3425 if (zio->io_type == ZIO_TYPE_WRITE &&
3426 !(zio->io_flags & ZIO_FLAG_IO_REPAIR))
3427 trim_map_write_done(zio);
3429 vdev_queue_io_done(zio);
3431 if (zio->io_type == ZIO_TYPE_WRITE)
3432 vdev_cache_write(zio);
3434 if (zio_injection_enabled && zio->io_error == 0)
3435 zio->io_error = zio_handle_device_injection(vd,
3436 zio, EIO);
3438 if (zio_injection_enabled && zio->io_error == 0)
3439 zio->io_error = zio_handle_label_injection(zio, EIO);
3441 if (zio->io_error) {
3442 if (zio->io_error == ENOTSUP &&
3443 zio->io_type == ZIO_TYPE_FREE) {
3445 } else if (!vdev_accessible(vd, zio)) {
3446 zio->io_error = SET_ERROR(ENXIO);
3453 ops->vdev_op_io_done(zio);
3456 VERIFY(vdev_probe(vd, zio) == NULL);
3458 return (zio);
3462 * This function is used to change the priority of an existing zio that is
3504 zio_vsd_default_cksum_report(zio_t *zio, zio_cksum_report_t *zcr, void *ignored)
3506 void *buf = zio_buf_alloc(zio->io_size);
3508 abd_copy_to_buf(buf, zio->io_abd, zio->io_size);
3510 zcr->zcr_cbinfo = zio->io_size;
3517 zio_vdev_io_assess(zio_t *zio)
3519 vdev_t *vd = zio->io_vd;
3521 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV_BIT, ZIO_WAIT_DONE)) {
3525 if (vd == NULL && !(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
3526 spa_config_exit(zio->io_spa, SCL_ZIO, zio);
3528 if (zio->io_vsd != NULL) {
3529 zio->io_vsd_ops->vsd_free(zio);
3530 zio->io_vsd = NULL;
3533 if (zio_injection_enabled && zio->io_error == 0)
3534 zio->io_error = zio_handle_fault_injection(zio, EIO);
3536 if (zio->io_type == ZIO_TYPE_FREE &&
3537 zio->io_priority != ZIO_PRIORITY_NOW) {
3538 switch (zio->io_error) {
3540 ZIO_TRIM_STAT_INCR(bytes, zio->io_size);
3558 if (zio->io_error && vd == NULL &&
3559 !(zio->io_flags & (ZIO_FLAG_DONT_RETRY | ZIO_FLAG_IO_RETRY))) {
3560 ASSERT(!(zio->io_flags & ZIO_FLAG_DONT_QUEUE)); /* not a leaf */
3561 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_BYPASS)); /* not a leaf */
3562 zio->io_error = 0;
3563 zio->io_flags |= ZIO_FLAG_IO_RETRY |
3565 zio->io_stage = ZIO_STAGE_VDEV_IO_START >> 1;
3566 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE,
3575 if (zio->io_error && vd != NULL && vd->vdev_ops->vdev_op_leaf &&
3576 !vdev_accessible(vd, zio))
3577 zio->io_error = SET_ERROR(ENXIO);
3583 if (zio->io_error == ENXIO && zio->io_type == ZIO_TYPE_WRITE &&
3593 if ((zio->io_error == ENOTSUP || zio->io_error == ENOTTY) &&
3594 zio->io_type == ZIO_TYPE_IOCTL &&
3595 zio->io_cmd == DKIOCFLUSHWRITECACHE && vd != NULL)
3598 if (zio->io_error)
3599 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
3602 zio->io_physdone != NULL) {
3603 ASSERT(!(zio->io_flags & ZIO_FLAG_DELEGATED));
3604 ASSERT(zio->io_child_type == ZIO_CHILD_VDEV);
3605 zio->io_physdone(zio->io_logical);
3608 return (zio);
3612 zio_vdev_io_reissue(zio_t *zio)
3614 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START);
3615 ASSERT(zio->io_error == 0);
3617 zio->io_stage >>= 1;
3621 zio_vdev_io_redone(zio_t *zio)
3623 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_DONE);
3625 zio->io_stage >>= 1;
3629 zio_vdev_io_bypass(zio_t *zio)
3631 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START);
3632 ASSERT(zio->io_error == 0);
3634 zio->io_flags |= ZIO_FLAG_IO_BYPASS;
3635 zio->io_stage = ZIO_STAGE_VDEV_IO_ASSESS >> 1;
3644 zio_checksum_generate(zio_t *zio)
3646 blkptr_t *bp = zio->io_bp;
3654 checksum = zio->io_prop.zp_checksum;
3657 return (zio);
3661 if (BP_IS_GANG(bp) && zio->io_child_type == ZIO_CHILD_GANG) {
3662 ASSERT(!IO_IS_ALLOCATING(zio));
3669 zio_checksum_compute(zio, checksum, zio->io_abd, zio->io_size);
3671 return (zio);
3675 zio_checksum_verify(zio_t *zio)
3678 blkptr_t *bp = zio->io_bp;
3681 ASSERT(zio->io_vd != NULL);
3688 if (zio->io_prop.zp_checksum == ZIO_CHECKSUM_OFF)
3689 return (zio);
3691 ASSERT(zio->io_prop.zp_checksum == ZIO_CHECKSUM_LABEL);
3694 if ((error = zio_checksum_error(zio, &info)) != 0) {
3695 zio->io_error = error;
3697 !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
3698 zfs_ereport_start_checksum(zio->io_spa,
3699 zio->io_vd, zio, zio->io_offset,
3700 zio->io_size, NULL, &info);
3704 return (zio);
3711 zio_checksum_verified(zio_t *zio)
3713 zio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY;
3748 zio_ready(zio_t *zio)
3750 blkptr_t *bp = zio->io_bp;
3754 if (zio_wait_for_children(zio, ZIO_CHILD_GANG_BIT | ZIO_CHILD_DDT_BIT,
3759 if (zio->io_ready) {
3760 ASSERT(IO_IS_ALLOCATING(zio));
3761 ASSERT(bp->blk_birth == zio->io_txg || BP_IS_HOLE(bp) ||
3762 (zio->io_flags & ZIO_FLAG_NOPWRITE));
3763 ASSERT(zio->io_children[ZIO_CHILD_GANG][ZIO_WAIT_READY] == 0);
3765 zio->io_ready(zio);
3768 if (bp != NULL && bp != &zio->io_bp_copy)
3769 zio->io_bp_copy = *bp;
3771 if (zio->io_error != 0) {
3772 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
3774 if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
3775 ASSERT(IO_IS_ALLOCATING(zio));
3776 ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
3777 ASSERT(zio->io_metaslab_class != NULL);
3784 zio->io_metaslab_class, zio->io_prop.zp_copies,
3785 zio->io_allocator, zio);
3786 zio_allocate_dispatch(zio->io_spa, zio->io_allocator);
3790 mutex_enter(&zio->io_lock);
3791 zio->io_state[ZIO_WAIT_READY] = 1;
3792 pio = zio_walk_parents(zio, &zl);
3793 mutex_exit(&zio->io_lock);
3796 * As we notify zio's parents, new parents could be added.
3797 * New parents go to the head of zio's io_parent_list, however,
3798 * so we will (correctly) not notify them. The remainder of zio's
3803 pio_next = zio_walk_parents(zio, &zl);
3804 zio_notify_parent(pio, zio, ZIO_WAIT_READY, NULL);
3807 if (zio->io_flags & ZIO_FLAG_NODATA) {
3809 zio->io_flags &= ~ZIO_FLAG_NODATA;
3811 ASSERT((uintptr_t)zio->io_abd < SPA_MAXBLOCKSIZE);
3812 zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
3817 zio->io_spa->spa_syncing_txg == zio->io_txg)
3818 zio_handle_ignored_writes(zio);
3820 return (zio);
3827 zio_dva_throttle_done(zio_t *zio)
3829 zio_t *lio = zio->io_logical;
3830 zio_t *pio = zio_unique_parent(zio);
3831 vdev_t *vd = zio->io_vd;
3834 ASSERT3P(zio->io_bp, !=, NULL);
3835 ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
3836 ASSERT3U(zio->io_priority, ==, ZIO_PRIORITY_ASYNC_WRITE);
3837 ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
3840 ASSERT(!(zio->io_flags & (ZIO_FLAG_IO_REPAIR | ZIO_FLAG_IO_RETRY)));
3841 ASSERT(zio->io_flags & ZIO_FLAG_IO_ALLOCATING);
3849 * throttle needs to know the allocating parent zio so we must find
3863 ASSERT3P(zio, !=, zio->io_logical);
3864 ASSERT(zio->io_logical != NULL);
3865 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REPAIR));
3866 ASSERT0(zio->io_flags & ZIO_FLAG_NOPWRITE);
3867 ASSERT(zio->io_metaslab_class != NULL);
3870 metaslab_group_alloc_decrement(zio->io_spa, vd->vdev_id, pio, flags,
3874 metaslab_class_throttle_unreserve(zio->io_metaslab_class, 1,
3882 zio_allocate_dispatch(zio->io_spa, pio->io_allocator);
3886 zio_done(zio_t *zio)
3888 spa_t *spa = zio->io_spa;
3889 zio_t *lio = zio->io_logical;
3890 blkptr_t *bp = zio->io_bp;
3891 vdev_t *vd = zio->io_vd;
3892 uint64_t psize = zio->io_size;
3900 if (zio_wait_for_children(zio, ZIO_CHILD_ALL_BITS, ZIO_WAIT_DONE)) {
3910 if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING &&
3911 zio->io_child_type == ZIO_CHILD_VDEV) {
3912 ASSERT(zio->io_metaslab_class != NULL);
3913 ASSERT(zio->io_metaslab_class->mc_alloc_throttle_enabled);
3914 zio_dva_throttle_done(zio);
3921 if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
3922 ASSERT(zio->io_type == ZIO_TYPE_WRITE);
3923 ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
3926 metaslab_group_alloc_verify(spa, zio->io_bp, zio,
3927 zio->io_allocator);
3929 &zio->io_metaslab_class->mc_alloc_slots[zio->io_allocator],
3930 zio));
3935 ASSERT(zio->io_children[c][w] == 0);
3940 ASSERT(bcmp(bp, &zio->io_bp_copy, sizeof (blkptr_t)) == 0 ||
3941 (bp == zio_unique_parent(zio)->io_bp));
3942 if (zio->io_type == ZIO_TYPE_WRITE && !BP_IS_HOLE(bp) &&
3943 zio->io_bp_override == NULL &&
3944 !(zio->io_flags & ZIO_FLAG_IO_REPAIR)) {
3946 ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(bp));
3950 if (zio->io_flags & ZIO_FLAG_NOPWRITE)
3951 VERIFY(BP_EQUAL(bp, &zio->io_bp_orig));
3957 zio_inherit_child_errors(zio, ZIO_CHILD_VDEV);
3958 zio_inherit_child_errors(zio, ZIO_CHILD_GANG);
3959 zio_inherit_child_errors(zio, ZIO_CHILD_DDT);
3965 if (zio->io_error == 0) {
3966 while (zio->io_cksum_report != NULL) {
3967 zio_cksum_report_t *zcr = zio->io_cksum_report;
3971 abd_t *adata = zio->io_abd;
3975 abd_copy(adata, zio->io_abd, psize);
3982 zio->io_cksum_report = zcr->zcr_next;
3995 zio_pop_transforms(zio); /* note: may set zio->io_error */
3997 vdev_stat_update(zio, psize);
3999 if (zio->io_error) {
4006 if (zio->io_error != ECKSUM && vd != NULL && !vdev_is_dead(vd))
4007 zfs_ereport_post(FM_EREPORT_ZFS_IO, spa, vd, zio, 0, 0);
4009 if ((zio->io_error == EIO || !(zio->io_flags &
4011 zio == lio) {
4016 spa_log_error(spa, zio);
4017 zfs_ereport_post(FM_EREPORT_ZFS_DATA, spa, NULL, zio,
4022 if (zio->io_error && zio == lio) {
4024 * Determine whether zio should be reexecuted. This will
4028 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
4030 if (IO_IS_ALLOCATING(zio) &&
4031 !(zio->io_flags & ZIO_FLAG_CANFAIL)) {
4032 if (zio->io_error != ENOSPC)
4033 zio->io_reexecute |= ZIO_REEXECUTE_NOW;
4035 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
4038 if ((zio->io_type == ZIO_TYPE_READ ||
4039 zio->io_type == ZIO_TYPE_FREE) &&
4040 !(zio->io_flags & ZIO_FLAG_SCAN_THREAD) &&
4041 zio->io_error == ENXIO &&
4044 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
4046 if (!(zio->io_flags & ZIO_FLAG_CANFAIL) && !zio->io_reexecute)
4047 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
4061 * errors with errors that happened to the zio itself when
4064 zio_inherit_child_errors(zio, ZIO_CHILD_LOGICAL);
4066 if ((zio->io_error || zio->io_reexecute) &&
4067 IO_IS_ALLOCATING(zio) && zio->io_gang_leader == zio &&
4068 !(zio->io_flags & (ZIO_FLAG_IO_REWRITE | ZIO_FLAG_NOPWRITE)))
4069 zio_dva_unallocate(zio, zio->io_gang_tree, bp);
4071 zio_gang_tree_free(&zio->io_gang_tree);
4076 if ((zio->io_flags & ZIO_FLAG_GODFATHER) &&
4077 (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND))
4078 zio->io_reexecute = 0;
4080 if (zio->io_reexecute) {
4094 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
4096 zio->io_gang_leader = NULL;
4098 mutex_enter(&zio->io_lock);
4099 zio->io_state[ZIO_WAIT_DONE] = 1;
4100 mutex_exit(&zio->io_lock);
4110 for (pio = zio_walk_parents(zio, &zl); pio != NULL;
4113 pio_next = zio_walk_parents(zio, &zl);
4116 (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND)) {
4117 zio_remove_child(pio, zio, remove_zl);
4122 zio_notify_parent(pio, zio, ZIO_WAIT_DONE,
4127 if ((pio = zio_unique_parent(zio)) != NULL) {
4133 ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
4134 zio->io_flags |= ZIO_FLAG_DONT_PROPAGATE;
4139 zio_notify_parent(pio, zio, ZIO_WAIT_DONE, NULL);
4140 } else if (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND) {
4145 zio_suspend(zio->io_spa, zio, ZIO_SUSPEND_IOERR);
4152 ASSERT(zio->io_tqent.tqent_next == NULL);
4154 ASSERT(zio->io_tqent.tqent_task.ta_pending == 0);
4157 ZIO_TASKQ_ISSUE, (task_func_t *)zio_reexecute, zio,
4158 0, &zio->io_tqent);
4163 ASSERT(zio->io_child_count == 0);
4164 ASSERT(zio->io_reexecute == 0);
4165 ASSERT(zio->io_error == 0 || (zio->io_flags & ZIO_FLAG_CANFAIL));
4170 while (zio->io_cksum_report != NULL) {
4171 zio_cksum_report_t *zcr = zio->io_cksum_report;
4172 zio->io_cksum_report = zcr->zcr_next;
4180 * particular zio is no longer discoverable for adoption, and as
4183 if (zio->io_done)
4184 zio->io_done(zio);
4186 mutex_enter(&zio->io_lock);
4187 zio->io_state[ZIO_WAIT_DONE] = 1;
4188 mutex_exit(&zio->io_lock);
4191 * We are done executing this zio. We may want to execute a parent
4196 for (pio = zio_walk_parents(zio, &zl); pio != NULL; pio = pio_next) {
4198 pio_next = zio_walk_parents(zio, &zl);
4199 zio_remove_child(pio, zio, remove_zl);
4200 zio_notify_parent(pio, zio, ZIO_WAIT_DONE, &next_to_execute);
4203 if (zio->io_waiter != NULL) {
4204 mutex_enter(&zio->io_lock);
4205 zio->io_executor = NULL;
4206 cv_broadcast(&zio->io_cv);
4207 mutex_exit(&zio->io_lock);
4209 zio_destroy(zio);