Lines Matching defs:pio
656 zio_walk_children(zio_t *pio, zio_link_t **zl)
658 list_t *cl = &pio->io_child_list;
660 ASSERT(MUTEX_HELD(&pio->io_lock));
666 ASSERT((*zl)->zl_parent == pio);
674 zio_t *pio = zio_walk_parents(cio, &zl);
677 return (pio);
681 zio_add_child(zio_t *pio, zio_t *cio)
689 ASSERT3S(cio->io_child_type, <=, pio->io_child_type);
694 (pio->io_pipeline & ZIO_STAGE_READY) == 0);
697 zl->zl_parent = pio;
700 mutex_enter(&pio->io_lock);
703 ASSERT(pio->io_state[ZIO_WAIT_DONE] == 0);
705 uint64_t *countp = pio->io_children[cio->io_child_type];
709 list_insert_head(&pio->io_child_list, zl);
713 mutex_exit(&pio->io_lock);
717 zio_add_child_first(zio_t *pio, zio_t *cio)
725 ASSERT3S(cio->io_child_type, <=, pio->io_child_type);
730 (pio->io_pipeline & ZIO_STAGE_READY) == 0);
733 zl->zl_parent = pio;
739 mutex_enter(&pio->io_lock);
741 ASSERT(pio->io_state[ZIO_WAIT_DONE] == 0);
743 uint64_t *countp = pio->io_children[cio->io_child_type];
747 list_insert_head(&pio->io_child_list, zl);
749 mutex_exit(&pio->io_lock);
753 zio_remove_child(zio_t *pio, zio_t *cio, zio_link_t *zl)
755 ASSERT(zl->zl_parent == pio);
758 mutex_enter(&pio->io_lock);
761 list_remove(&pio->io_child_list, zl);
765 mutex_exit(&pio->io_lock);
795 zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait,
798 uint64_t *countp = &pio->io_children[zio->io_child_type][wait];
799 int *errorp = &pio->io_child_error[zio->io_child_type];
801 mutex_enter(&pio->io_lock);
804 pio->io_reexecute |= zio->io_reexecute;
811 pio->io_flags |= ZIO_FLAG_DIO_CHKSUM_ERR;
815 if (*countp == 0 && pio->io_stall == countp) {
817 pio->io_stage < ZIO_STAGE_VDEV_IO_START ? ZIO_TASKQ_ISSUE :
819 pio->io_stall = NULL;
820 mutex_exit(&pio->io_lock);
847 (pio->io_type == zio->io_type ||
848 (pio->io_type == ZIO_TYPE_NULL && !pio->io_done))) {
849 *next_to_executep = pio;
851 zio_taskq_dispatch(pio, type, B_FALSE);
854 mutex_exit(&pio->io_lock);
905 zio_create(zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp,
984 if (pio != NULL) {
985 zio->io_metaslab_class = pio->io_metaslab_class;
987 zio->io_logical = pio->io_logical;
989 zio->io_gang_leader = pio->io_gang_leader;
990 zio_add_child_first(pio, zio);
1014 zio_null(zio_t *pio, spa_t *spa, vdev_t *vd, zio_done_func_t *done,
1019 zio = zio_create(pio, spa, 0, NULL, NULL, 0, 0, done, private,
1269 zio_read(zio_t *pio, spa_t *spa, const blkptr_t *bp,
1275 zio = zio_create(pio, spa, BP_GET_BIRTH(bp), bp,
1285 zio_write(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
1297 zio = zio_create(pio, spa, txg, bp, data, lsize, psize, done, private,
1322 zio_rewrite(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp, abd_t *data,
1328 zio = zio_create(pio, spa, txg, bp, data, size, size, done, private,
1400 zio_free_sync(zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp,
1424 return (zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp),
1435 zio_claim(zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp,
1444 return (zio_null(pio, spa, NULL, NULL, NULL, 0));
1463 zio = zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp),
1472 zio_trim(zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size,
1483 zio = zio_create(pio, vd->vdev_spa, 0, NULL, NULL, size, size, done,
1492 zio_read_phys(zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size,
1503 zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, size, done,
1513 zio_write_phys(zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size,
1524 zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, size, done,
1550 zio_vdev_child_io(zio_t *pio, blkptr_t *bp, vdev_t *vd, uint64_t offset,
1575 pio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY;
1583 ASSERT0(pio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR);
1585 pio->io_prop.zp_direct_write == B_TRUE) {
1595 ASSERT3U(pio->io_child_type, ==, ZIO_CHILD_LOGICAL);
1604 flags |= ZIO_VDEV_CHILD_FLAGS(pio);
1621 ASSERT(pio->io_metaslab_class != NULL);
1622 ASSERT(pio->io_metaslab_class->mc_alloc_throttle_enabled);
1626 ASSERT(!(pio->io_flags & ZIO_FLAG_IO_REWRITE) ||
1627 pio->io_child_type == ZIO_CHILD_GANG);
1632 zio = zio_create(pio, pio->io_spa, pio->io_txg, bp, data, size, size,
1633 done, private, type, priority, flags, vd, offset, &pio->io_bookmark,
1661 * the flush zios are issued immediately. You can wait on pio to pause until
1665 zio_flush(zio_t *pio, vdev_t *vd)
1674 zio_nowait(zio_create(pio, vd->vdev_spa, 0, NULL, NULL, 0, 0,
1679 zio_flush(pio, vd->vdev_child[c]);
2219 zio_deadman_impl(zio_t *pio, int ziodepth)
2223 vdev_t *vd = pio->io_vd;
2227 zbookmark_phys_t *zb = &pio->io_bookmark;
2228 uint64_t delta = gethrtime() - pio->io_timestamp;
2229 uint64_t failmode = spa_get_deadman_failmode(pio->io_spa);
2241 ziodepth, pio, pio->io_timestamp,
2242 (u_longlong_t)delta, pio->io_delta, pio->io_delay,
2244 vq ? vq->vq_io_complete_ts : 0, pio->io_type,
2245 pio->io_priority, (u_longlong_t)pio->io_flags,
2246 pio->io_stage, pio->io_pipeline, pio->io_pipeline_trace,
2249 (u_longlong_t)pio->io_offset, (u_longlong_t)pio->io_size,
2250 pio->io_error);
2252 pio->io_spa, vd, zb, pio, 0);
2255 taskq_empty_ent(&pio->io_tqent)) {
2256 zio_interrupt(pio);
2260 mutex_enter(&pio->io_lock);
2261 for (cio = zio_walk_children(pio, &zl); cio != NULL; cio = cio_next) {
2262 cio_next = zio_walk_children(pio, &zl);
2265 mutex_exit(&pio->io_lock);
2273 zio_deadman(zio_t *pio, const char *tag)
2275 spa_t *spa = pio->io_spa;
2281 zio_deadman_impl(pio, 0);
2491 zio_t *pio;
2499 pio = spa->spa_async_zio_root[CPU_SEQID_UNSTABLE];
2501 zio_add_child(pio, zio);
2521 zio_t *pio = arg;
2524 ASSERT(pio->io_child_type == ZIO_CHILD_LOGICAL);
2525 ASSERT(pio->io_orig_stage == ZIO_STAGE_OPEN);
2526 ASSERT(pio->io_gang_leader == NULL);
2527 ASSERT(pio->io_gang_tree == NULL);
2529 mutex_enter(&pio->io_lock);
2530 pio->io_flags = pio->io_orig_flags;
2531 pio->io_stage = pio->io_orig_stage;
2532 pio->io_pipeline = pio->io_orig_pipeline;
2533 pio->io_reexecute = 0;
2534 pio->io_flags |= ZIO_FLAG_REEXECUTED;
2535 pio->io_pipeline_trace = 0;
2536 pio->io_error = 0;
2537 pio->io_state[ZIO_WAIT_READY] = (pio->io_stage >= ZIO_STAGE_READY) ||
2538 (pio->io_pipeline & ZIO_STAGE_READY) == 0;
2539 pio->io_state[ZIO_WAIT_DONE] = (pio->io_stage >= ZIO_STAGE_DONE);
2541 while ((gio = zio_walk_parents(pio, &zl)) != NULL) {
2543 gio->io_children[pio->io_child_type][w] +=
2544 !pio->io_state[w];
2548 pio->io_child_error[c] = 0;
2550 if (IO_IS_ALLOCATING(pio))
2551 BP_ZERO(pio->io_bp);
2554 * As we reexecute pio's children, new children could be created.
2555 * New children go to the head of pio's io_child_list, however,
2557 * the remainder of pio's io_child_list, from 'cio_next' onward,
2561 for (cio = zio_walk_children(pio, &zl); cio != NULL; cio = cio_next) {
2562 cio_next = zio_walk_children(pio, &zl);
2563 mutex_exit(&pio->io_lock);
2565 mutex_enter(&pio->io_lock);
2567 mutex_exit(&pio->io_lock);
2574 if (!(pio->io_flags & ZIO_FLAG_GODFATHER)) {
2575 pio->io_queued_timestamp = gethrtime();
2576 __zio_execute(pio);
2620 zio_t *pio;
2632 pio = spa->spa_suspend_zio_root;
2636 if (pio == NULL)
2639 zio_reexecute(pio);
2640 return (zio_wait(pio));
2725 zio_read_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, abd_t *data,
2729 return (pio);
2731 return (zio_read(pio, pio->io_spa, bp, abd_get_offset(data, offset),
2733 NULL, pio->io_priority, ZIO_GANG_CHILD_FLAGS(pio),
2734 &pio->io_bookmark));
2738 zio_rewrite_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, abd_t *data,
2746 zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
2748 pio->io_priority, ZIO_GANG_CHILD_FLAGS(pio),
2749 &pio->io_bookmark);
2759 if (gn != pio->io_gang_leader->io_gang_tree) {
2771 if (pio->io_gang_leader->io_flags & ZIO_FLAG_INDUCE_DAMAGE)
2774 zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
2776 zio_gang_issue_func_done, NULL, pio->io_priority,
2777 ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark);
2784 zio_free_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, abd_t *data,
2789 zio_t *zio = zio_free_sync(pio, pio->io_spa, pio->io_txg, bp,
2790 ZIO_GANG_CHILD_FLAGS(pio));
2792 zio = zio_null(pio, pio->io_spa,
2793 NULL, NULL, NULL, ZIO_GANG_CHILD_FLAGS(pio));
2799 zio_claim_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, abd_t *data,
2803 return (zio_claim(pio, pio->io_spa, pio->io_txg, bp,
2804 NULL, NULL, ZIO_GANG_CHILD_FLAGS(pio)));
2905 zio_gang_tree_issue(zio_t *pio, zio_gang_node_t *gn, blkptr_t *bp, abd_t *data,
2908 zio_t *gio = pio->io_gang_leader;
2919 zio = zio_gang_issue_func[gio->io_type](pio, bp, gn, data, offset);
2937 if (zio != pio)
2980 zio_gang_inherit_allocator(zio_t *pio, zio_t *cio)
2982 cio->io_allocator = pio->io_allocator;
2988 zio_t *pio = zio_unique_parent(zio);
2990 dva_t *pdva = pio->io_bp->blk_dva;
3002 ASSERT3U(pio->io_prop.zp_copies, <=, BP_GET_NDVAS(pio->io_bp));
3003 VERIFY3U(BP_GET_NDVAS(zio->io_bp), <=, BP_GET_NDVAS(pio->io_bp));
3005 mutex_enter(&pio->io_lock);
3012 mutex_exit(&pio->io_lock);
3028 zio_write_gang_block(zio_t *pio, metaslab_class_t *mc)
3030 spa_t *spa = pio->io_spa;
3031 blkptr_t *bp = pio->io_bp;
3032 zio_t *gio = pio->io_gang_leader;
3037 uint64_t txg = pio->io_txg;
3038 uint64_t resid = pio->io_size;
3043 boolean_t has_data = !(pio->io_flags & ZIO_FLAG_NODATA);
3056 ASSERT(ZIO_HAS_ALLOCATOR(pio));
3058 if (pio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
3059 ASSERT(pio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
3063 VERIFY(zfs_refcount_held(&mc->mc_allocator[pio->io_allocator].
3064 mca_alloc_slots, pio));
3075 pio->io_allocator, pio, flags));
3079 bp, gbh_copies, txg, pio == gio ? NULL : gio->io_bp, flags,
3080 &pio->io_alloc_list, pio, pio->io_allocator);
3082 if (pio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
3083 ASSERT(pio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
3094 gbh_copies - copies, pio->io_allocator, pio);
3097 pio->io_error = error;
3098 return (pio);
3101 if (pio == gio) {
3104 gnpp = pio->io_private;
3105 ASSERT(pio->io_ready == zio_write_gang_member_ready);
3116 zio = zio_rewrite(pio, spa, txg, bp, gbh_abd, SPA_GANGBLOCKSIZE,
3117 zio_write_gang_done, NULL, pio->io_priority,
3118 ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark);
3120 zio_gang_inherit_allocator(pio, zio);
3147 has_data ? abd_get_offset(pio->io_abd, pio->io_size -
3150 zio_write_gang_done, &gn->gn_child[g], pio->io_priority,
3151 ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark);
3155 if (pio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
3156 ASSERT(pio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
3171 * Set pio's pipeline to just wait for zio to finish.
3173 pio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
3177 return (pio);
3305 zio_t *pio = zio_unique_parent(zio);
3307 mutex_enter(&pio->io_lock);
3320 mutex_exit(&pio->io_lock);
3562 zio_t *pio;
3564 while ((pio = zio_walk_parents(zio, &zl)) != NULL) {
3565 if (!(pio->io_flags & ZIO_FLAG_DDT_CHILD))
3591 zio_t *pio;
3593 while ((pio = zio_walk_parents(zio, &zl)) != NULL) {
3594 if (!(pio->io_flags & ZIO_FLAG_DDT_CHILD))
3595 ddt_bp_fill(dde->dde_phys, v, pio->io_bp, zio->io_txg);
3826 zio_t *pio =
3828 ASSERT(pio);
3829 uint8_t parent_dvas = pio->io_prop.zp_copies;
4491 zio_change_priority(zio_t *pio, zio_priority_t priority)
4498 if (pio->io_vd != NULL && pio->io_vd->vdev_ops->vdev_op_leaf) {
4499 vdev_queue_change_io_priority(pio, priority);
4501 pio->io_priority = priority;
4504 mutex_enter(&pio->io_lock);
4505 for (cio = zio_walk_children(pio, &zl); cio != NULL; cio = cio_next) {
4506 cio_next = zio_walk_children(pio, &zl);
4509 mutex_exit(&pio->io_lock);
4877 zio_t *pio = zio_unique_parent(zio);
4890 if (pio->io_child_type == ZIO_CHILD_LOGICAL) {
4910 zio_t *pio = zio_unique_parent(zio);
4917 ASSERT3B(pio->io_prop.zp_direct_write, ==, B_TRUE);
4918 ASSERT3U(pio->io_child_type, ==, ZIO_CHILD_LOGICAL);
5013 zio_t *pio, *pio_next;
5057 pio = zio_walk_parents(zio, &zl);
5067 for (; pio != NULL; pio = pio_next) {
5069 zio_notify_parent(pio, zio, ZIO_WAIT_READY, NULL);
5095 zio_t *pio = zio_unique_parent(zio);
5118 if (pio->io_child_type == ZIO_CHILD_GANG) {
5123 if (pio->io_flags & ZIO_FLAG_IO_REWRITE)
5124 pio = zio_unique_parent(pio);
5128 ASSERT(IO_IS_ALLOCATING(pio));
5129 ASSERT(ZIO_HAS_ALLOCATOR(pio));
5136 mutex_enter(&pio->io_lock);
5137 metaslab_group_alloc_decrement(zio->io_spa, vd->vdev_id, pio, flags,
5138 pio->io_allocator, B_TRUE);
5139 mutex_exit(&pio->io_lock);
5142 pio->io_allocator, pio);
5149 zio_allocate_dispatch(zio->io_spa, pio->io_allocator);
5160 zio_t *pio, *pio_next;
5424 for (pio = zio_walk_parents(zio, &zl); pio != NULL;
5425 pio = pio_next) {
5429 if ((pio->io_flags & ZIO_FLAG_GODFATHER) &&
5431 zio_remove_child(pio, zio, remove_zl);
5436 zio_notify_parent(pio, zio, ZIO_WAIT_DONE,
5441 if ((pio = zio_unique_parent(zio)) != NULL) {
5453 zio_notify_parent(pio, zio, ZIO_WAIT_DONE, NULL);
5505 for (pio = zio_walk_parents(zio, &zl); pio != NULL; pio = pio_next) {
5508 zio_remove_child(pio, zio, remove_zl);
5509 zio_notify_parent(pio, zio, ZIO_WAIT_DONE, &next_to_execute);