mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2025-01-29 16:44:03 +00:00
Code Issues Releases Activity

Don't return ZIO_PIPELINE_CONTINUE from vdev_op_io_start methods

Browse Source 
This prevents recursion of vdev_queue_io_done as per r265321 but
using a different method as recommended on the openzfs list.

We now use zio_interrupt(zio) and return ZIO_PIPELINE_STOP instead
of returning ZIO_PIPELINE_CONTINUE from vdev_*_io_start methods.

zio_vdev_io_start now ASSERTS the that vdev_op_io_start returns
ZIO_PIPELINE_STOP to ensure future changes don't reintroduce
ZIO_PIPELINE_CONTINUE returns.

Cleanup flow in vdev_geom_io_start while I'm here.

Also fix some cases not using SET_ERROR(..)

MFC after:	2 weeks
X-MFC-With:	r265321
This commit is contained in:
Steven Hartland 2014-08-01 23:16:48 +00:00
parent eaa4e27642
commit 6a369c018c
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=269407
9 changed files with 78 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/zio.h
View File

@ -208,7 +208,6 @@ enum zio_flag {
ZIO_FLAG_NOPWRITE = 1 << 26,
ZIO_FLAG_REEXECUTED = 1 << 27,
ZIO_FLAG_DELEGATED = 1 << 28,
ZIO_FLAG_QUEUE_IO_DONE = 1 << 29,
};
#define ZIO_FLAG_MUSTSUCCEED 0
@ -363,7 +362,7 @@ typedef struct zio_transform {
struct zio_transform *zt_next;
} zio_transform_t;
typedef int zio_pipe_stage_t(zio_t **ziop);
typedef int zio_pipe_stage_t(zio_t *zio);
/*
* The io_reexecute flags are distinct from io_flags because the child must

13
sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev_disk.c
View File

@ -684,7 +684,7 @@ vdev_disk_io_intr(buf_t *bp)
* Rather than teach the rest of the stack about other error
* possibilities (EFAULT, etc), we normalize the error value here.
*/
zio->io_error = (geterror(bp) != 0 ? EIO : 0);
zio->io_error = (geterror(bp) != 0 ? SET_ERROR(EIO) : 0);
if (zio->io_error == 0 && bp->b_resid != 0)
zio->io_error = SET_ERROR(EIO);
@ -730,15 +730,17 @@ vdev_disk_io_start(zio_t *zio)
* Nothing to be done here but return failure.
*/
if (dvd == NULL || (dvd->vd_ldi_offline && dvd->vd_lh == NULL)) {
zio->io_error = ENXIO;
return (ZIO_PIPELINE_CONTINUE);
zio->io_error = SET_ERROR(ENXIO);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
if (zio->io_type == ZIO_TYPE_IOCTL) {
/* XXPOLICY */
if (!vdev_readable(vd)) {
zio->io_error = SET_ERROR(ENXIO);
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
switch (zio->io_cmd) {
@ -790,7 +792,8 @@ vdev_disk_io_start(zio_t *zio)
zio->io_error = SET_ERROR(ENOTSUP);
}
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
vb = kmem_alloc(sizeof (vdev_buf_t), KM_SLEEP);

6
sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev_file.c
View File

@ -164,7 +164,8 @@ vdev_file_io_start(zio_t *zio)
if (!vdev_readable(vd)) {
zio->io_error = SET_ERROR(ENXIO);
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
vf = vd->vdev_tsd;
@ -180,7 +181,8 @@ vdev_file_io_start(zio_t *zio)
zio->io_error = SET_ERROR(ENOTSUP);
}
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
zio->io_error = vn_rdwr(zio->io_type == ZIO_TYPE_READ ?

52
sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev_geom.c
View File

@ -749,7 +749,7 @@ vdev_geom_io_intr(struct bio *bp)
vd = zio->io_vd;
zio->io_error = bp->bio_error;
if (zio->io_error == 0 && bp->bio_resid != 0)
zio->io_error = EIO;
zio->io_error = SET_ERROR(EIO);
switch(zio->io_error) {
case ENOTSUP:
@ -803,37 +803,38 @@ vdev_geom_io_start(zio_t *zio)
/* XXPOLICY */
if (!vdev_readable(vd)) {
zio->io_error = SET_ERROR(ENXIO);
return (ZIO_PIPELINE_CONTINUE);
}
switch (zio->io_cmd) {
case DKIOCFLUSHWRITECACHE:
if (zfs_nocacheflush || vdev_geom_bio_flush_disable)
break;
if (vd->vdev_nowritecache) {
} else {
switch (zio->io_cmd) {
case DKIOCFLUSHWRITECACHE:
if (zfs_nocacheflush || vdev_geom_bio_flush_disable)
break;
if (vd->vdev_nowritecache) {
zio->io_error = SET_ERROR(ENOTSUP);
break;
}
goto sendreq;
default:
zio->io_error = SET_ERROR(ENOTSUP);
break;
}
goto sendreq;
default:
zio->io_error = SET_ERROR(ENOTSUP);
}
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
case ZIO_TYPE_FREE:
if (vdev_geom_bio_delete_disable)
return (ZIO_PIPELINE_CONTINUE);
if (vd->vdev_notrim) {
zio->io_error = SET_ERROR(ENOTSUP);
return (ZIO_PIPELINE_CONTINUE);
} else if (!vdev_geom_bio_delete_disable) {
goto sendreq;
}
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
sendreq:
cp = vd->vdev_tsd;
if (cp == NULL) {
zio->io_error = SET_ERROR(ENXIO);
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
bp = g_alloc_bio();
bp->bio_caller1 = zio;
@ -852,14 +853,11 @@ vdev_geom_io_start(zio_t *zio)
bp->bio_length = zio->io_size;
break;
case ZIO_TYPE_IOCTL:
if (zio->io_cmd == DKIOCFLUSHWRITECACHE) {
bp->bio_cmd = BIO_FLUSH;
bp->bio_flags |= BIO_ORDERED;
bp->bio_data = NULL;
bp->bio_offset = cp->provider->mediasize;
bp->bio_length = 0;
break;
}
bp->bio_cmd = BIO_FLUSH;
bp->bio_flags |= BIO_ORDERED;
bp->bio_data = NULL;
bp->bio_offset = cp->provider->mediasize;
bp->bio_length = 0;
break;
}
bp->bio_done = vdev_geom_io_intr;

6
sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev_mirror.c
View File

@ -450,7 +450,8 @@ vdev_mirror_io_start(zio_t *zio)
zio->io_type, zio->io_priority, 0,
vdev_mirror_scrub_done, mc));
}
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
/*
* For normal reads just pick one child.
@ -477,7 +478,8 @@ vdev_mirror_io_start(zio_t *zio)
c++;
}
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
static int

3
sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev_missing.c
View File

@ -71,7 +71,8 @@ static int
vdev_missing_io_start(zio_t *zio)
{
zio->io_error = SET_ERROR(ENOTSUP);
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
/* ARGSUSED */

11
sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev_queue.c
View File

@ -796,25 +796,14 @@ vdev_queue_io_done(zio_t *zio)
vq->vq_io_complete_ts = gethrtime();
if (zio->io_flags & ZIO_FLAG_QUEUE_IO_DONE) {
/*
* Executing from a previous vdev_queue_io_done so
* to avoid recursion we just unlock and return.
*/
mutex_exit(&vq->vq_lock);
return;
}
while ((nio = vdev_queue_io_to_issue(vq)) != NULL) {
mutex_exit(&vq->vq_lock);
nio->io_flags |= ZIO_FLAG_QUEUE_IO_DONE;
if (nio->io_done == vdev_queue_agg_io_done) {
zio_nowait(nio);
} else {
zio_vdev_io_reissue(nio);
zio_execute(nio);
}
nio->io_flags &= ~ZIO_FLAG_QUEUE_IO_DONE;
mutex_enter(&vq->vq_lock);
}

10
sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev_raidz.c
View File

@ -1755,7 +1755,9 @@ vdev_raidz_io_start(zio_t *zio)
zio->io_type, zio->io_priority, 0,
vdev_raidz_child_done, rc));
}
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
if (zio->io_type == ZIO_TYPE_WRITE) {
@ -1787,7 +1789,8 @@ vdev_raidz_io_start(zio_t *zio)
ZIO_FLAG_NODATA | ZIO_FLAG_OPTIONAL, NULL, NULL));
}
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
ASSERT(zio->io_type == ZIO_TYPE_READ);
@ -1827,7 +1830,8 @@ vdev_raidz_io_start(zio_t *zio)
}
}
return (ZIO_PIPELINE_CONTINUE);
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}

74
sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zio.c
View File

@ -1038,9 +1038,8 @@ zio_shrink(zio_t *zio, uint64_t size)
*/
static int
zio_read_bp_init(zio_t **ziop)
zio_read_bp_init(zio_t *zio)
{
zio_t *zio = *ziop;
blkptr_t *bp = zio->io_bp;
if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_OFF &&
@ -1073,9 +1072,8 @@ zio_read_bp_init(zio_t **ziop)
}
static int
zio_write_bp_init(zio_t **ziop)
zio_write_bp_init(zio_t *zio)
{
zio_t *zio = *ziop;
spa_t *spa = zio->io_spa;
zio_prop_t *zp = &zio->io_prop;
enum zio_compress compress = zp->zp_compress;
@ -1255,9 +1253,8 @@ zio_write_bp_init(zio_t **ziop)
}
static int
zio_free_bp_init(zio_t **ziop)
zio_free_bp_init(zio_t *zio)
{
zio_t *zio = *ziop;
blkptr_t *bp = zio->io_bp;
if (zio->io_child_type == ZIO_CHILD_LOGICAL) {
@ -1340,10 +1337,8 @@ zio_taskq_member(zio_t *zio, zio_taskq_type_t q)
}
static int
zio_issue_async(zio_t **ziop)
zio_issue_async(zio_t *zio)
{
zio_t *zio = *ziop;
zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
return (ZIO_PIPELINE_STOP);
@ -1411,7 +1406,7 @@ zio_execute(zio_t *zio)
}
zio->io_stage = stage;
rv = zio_pipeline[highbit64(stage) - 1](&zio);
rv = zio_pipeline[highbit64(stage) - 1](zio);
if (rv == ZIO_PIPELINE_STOP)
return;
@ -1845,9 +1840,8 @@ zio_gang_tree_issue(zio_t *pio, zio_gang_node_t *gn, blkptr_t *bp, void *data)
}
static int
zio_gang_assemble(zio_t **ziop)
zio_gang_assemble(zio_t *zio)
{
zio_t *zio = *ziop;
blkptr_t *bp = zio->io_bp;
ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == NULL);
@ -1861,9 +1855,8 @@ zio_gang_assemble(zio_t **ziop)
}
static int
zio_gang_issue(zio_t **ziop)
zio_gang_issue(zio_t *zio)
{
zio_t *zio = *ziop;
blkptr_t *bp = zio->io_bp;
if (zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_DONE))
@ -1997,9 +1990,8 @@ zio_write_gang_block(zio_t *pio)
* writes) and as a result is mutually exclusive with dedup.
*/
static int
zio_nop_write(zio_t **ziop)
zio_nop_write(zio_t *zio)
{
zio_t *zio = *ziop;
blkptr_t *bp = zio->io_bp;
blkptr_t *bp_orig = &zio->io_bp_orig;
zio_prop_t *zp = &zio->io_prop;
@ -2070,9 +2062,8 @@ zio_ddt_child_read_done(zio_t *zio)
}
static int
zio_ddt_read_start(zio_t **ziop)
zio_ddt_read_start(zio_t *zio)
{
zio_t *zio = *ziop;
blkptr_t *bp = zio->io_bp;
ASSERT(BP_GET_DEDUP(bp));
@ -2114,9 +2105,8 @@ zio_ddt_read_start(zio_t **ziop)
}
static int
zio_ddt_read_done(zio_t **ziop)
zio_ddt_read_done(zio_t *zio)
{
zio_t *zio = *ziop;
blkptr_t *bp = zio->io_bp;
if (zio_wait_for_children(zio, ZIO_CHILD_DDT, ZIO_WAIT_DONE))
@ -2284,9 +2274,8 @@ zio_ddt_ditto_write_done(zio_t *zio)
}
static int
zio_ddt_write(zio_t **ziop)
zio_ddt_write(zio_t *zio)
{
zio_t *zio = *ziop;
spa_t *spa = zio->io_spa;
blkptr_t *bp = zio->io_bp;
uint64_t txg = zio->io_txg;
@ -2397,9 +2386,8 @@ zio_ddt_write(zio_t **ziop)
ddt_entry_t *freedde; /* for debugging */
static int
zio_ddt_free(zio_t **ziop)
zio_ddt_free(zio_t *zio)
{
zio_t *zio = *ziop;
spa_t *spa = zio->io_spa;
blkptr_t *bp = zio->io_bp;
ddt_t *ddt = ddt_select(spa, bp);
@ -2424,9 +2412,8 @@ zio_ddt_free(zio_t **ziop)
* ==========================================================================
*/
static int
zio_dva_allocate(zio_t **ziop)
zio_dva_allocate(zio_t *zio)
{
zio_t *zio = *ziop;
spa_t *spa = zio->io_spa;
metaslab_class_t *mc = spa_normal_class(spa);
blkptr_t *bp = zio->io_bp;
@ -2468,19 +2455,16 @@ zio_dva_allocate(zio_t **ziop)
}
static int
zio_dva_free(zio_t **ziop)
zio_dva_free(zio_t *zio)
{
zio_t *zio = *ziop;
metaslab_free(zio->io_spa, zio->io_bp, zio->io_txg, B_FALSE);
return (ZIO_PIPELINE_CONTINUE);
}
static int
zio_dva_claim(zio_t **ziop)
zio_dva_claim(zio_t *zio)
{
zio_t *zio = *ziop;
int error;
error = metaslab_claim(zio->io_spa, zio->io_bp, zio->io_txg);
@ -2574,12 +2558,12 @@ zio_free_zil(spa_t *spa, uint64_t txg, blkptr_t *bp)
* ==========================================================================
*/
static int
zio_vdev_io_start(zio_t **ziop)
zio_vdev_io_start(zio_t *zio)
{
zio_t *zio = *ziop;
vdev_t *vd = zio->io_vd;
uint64_t align;
spa_t *spa = zio->io_spa;
int ret;
ASSERT(zio->io_error == 0);
ASSERT(zio->io_child_error[ZIO_CHILD_VDEV] == 0);
@ -2690,7 +2674,6 @@ zio_vdev_io_start(zio_t **ziop)
case ZIO_TYPE_FREE:
if ((zio = vdev_queue_io(zio)) == NULL)
return (ZIO_PIPELINE_STOP);
*ziop = zio;
if (!vdev_accessible(vd, zio)) {
zio->io_error = SET_ERROR(ENXIO);
@ -2710,13 +2693,15 @@ zio_vdev_io_start(zio_t **ziop)
return (ZIO_PIPELINE_STOP);
}
return (vd->vdev_ops->vdev_op_io_start(zio));
ret = vd->vdev_ops->vdev_op_io_start(zio);
ASSERT(ret == ZIO_PIPELINE_STOP);
return (ret);
}
static int
zio_vdev_io_done(zio_t **ziop)
zio_vdev_io_done(zio_t *zio)
{
zio_t *zio = *ziop;
vdev_t *vd = zio->io_vd;
vdev_ops_t *ops = vd ? vd->vdev_ops : &vdev_mirror_ops;
boolean_t unexpected_error = B_FALSE;
@ -2794,9 +2779,8 @@ zio_vsd_default_cksum_report(zio_t *zio, zio_cksum_report_t *zcr, void *ignored)
}
static int
zio_vdev_io_assess(zio_t **ziop)
zio_vdev_io_assess(zio_t *zio)
{
zio_t *zio = *ziop;
vdev_t *vd = zio->io_vd;
if (zio_wait_for_children(zio, ZIO_CHILD_VDEV, ZIO_WAIT_DONE))
@ -2911,9 +2895,8 @@ zio_vdev_io_bypass(zio_t *zio)
* ==========================================================================
*/
static int
zio_checksum_generate(zio_t **ziop)
zio_checksum_generate(zio_t *zio)
{
zio_t *zio = *ziop;
blkptr_t *bp = zio->io_bp;
enum zio_checksum checksum;
@ -2943,9 +2926,8 @@ zio_checksum_generate(zio_t **ziop)
}
static int
zio_checksum_verify(zio_t **ziop)
zio_checksum_verify(zio_t *zio)
{
zio_t *zio = *ziop;
zio_bad_cksum_t info;
blkptr_t *bp = zio->io_bp;
int error;
@ -3016,9 +2998,8 @@ zio_worst_error(int e1, int e2)
* ==========================================================================
*/
static int
zio_ready(zio_t **ziop)
zio_ready(zio_t *zio)
{
zio_t *zio = *ziop;
blkptr_t *bp = zio->io_bp;
zio_t *pio, *pio_next;
@ -3075,9 +3056,8 @@ zio_ready(zio_t **ziop)
}
static int
zio_done(zio_t **ziop)
zio_done(zio_t *zio)
{
zio_t *zio = *ziop;
spa_t *spa = zio->io_spa;
zio_t *lio = zio->io_logical;
blkptr_t *bp = zio->io_bp;