static int
vdev_disk_io_start(zio_t *zio)
{
vdev_t *vd = zio->io_vd;
vdev_disk_t *dvd = vd->vdev_tsd;
struct buf *bp;
vfs_context_t context;
int flags, error = 0;
if (zio->io_type == ZIO_TYPE_IOCTL) {
zio_vdev_io_bypass(zio);
/* XXPOLICY */
if (vdev_is_dead(vd)) {
zio->io_error = ENXIO;
//zio_next_stage_async(zio);
return (ZIO_PIPELINE_CONTINUE);
//return;
}
switch (zio->io_cmd) {
case DKIOCFLUSHWRITECACHE:
if (zfs_nocacheflush)
break;
if (vd->vdev_nowritecache) {
zio->io_error = SET_ERROR(ENOTSUP);
break;
}
context = vfs_context_create((vfs_context_t)0);
error = VNOP_IOCTL(dvd->vd_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, context);
(void) vfs_context_rele(context);
if (error == 0)
vdev_disk_ioctl_done(zio, error);
else
error = ENOTSUP;
if (error == 0) {
/*
* The ioctl will be done asychronously,
* and will call vdev_disk_ioctl_done()
* upon completion.
*/
return ZIO_PIPELINE_STOP;
} else if (error == ENOTSUP || error == ENOTTY) {
/*
* If we get ENOTSUP or ENOTTY, we know that
* no future attempts will ever succeed.
* In this case we set a persistent bit so
* that we don't bother with the ioctl in the
* future.
*/
vd->vdev_nowritecache = B_TRUE;
}
zio->io_error = error;
break;
default:
zio->io_error = SET_ERROR(ENOTSUP);
}
//zio_next_stage_async(zio);
return (ZIO_PIPELINE_CONTINUE);
}
if (zio->io_type == ZIO_TYPE_READ && vdev_cache_read(zio) == 0)
return (ZIO_PIPELINE_STOP);
// return;
if ((zio = vdev_queue_io(zio)) == NULL)
return (ZIO_PIPELINE_CONTINUE);
// return;
flags = (zio->io_type == ZIO_TYPE_READ ? B_READ : B_WRITE);
//flags |= B_NOCACHE;
if (zio->io_flags & ZIO_FLAG_FAILFAST)
flags |= B_FAILFAST;
/*
* Check the state of this device to see if it has been offlined or
* is in an error state. If the device was offlined or closed,
* dvd will be NULL and buf_alloc below will fail
*/
//error = vdev_is_dead(vd) ? ENXIO : vdev_error_inject(vd, zio);
if (vdev_is_dead(vd)) {
error = ENXIO;
}
if (error) {
zio->io_error = error;
//zio_next_stage_async(zio);
return (ZIO_PIPELINE_CONTINUE);
}
bp = buf_alloc(dvd->vd_devvp);
ASSERT(bp != NULL);
ASSERT(zio->io_data != NULL);
ASSERT(zio->io_size != 0);
buf_setflags(bp, flags);
buf_setcount(bp, zio->io_size);
buf_setdataptr(bp, (uintptr_t)zio->io_data);
if (dvd->vd_ashift) {
buf_setlblkno(bp, zio->io_offset>>dvd->vd_ashift);
buf_setblkno(bp, zio->io_offset>>dvd->vd_ashift);
} else {
static int
vdev_file_io_start(zio_t *zio)
{
vdev_t *vd = zio->io_vd;
vdev_file_t *vf = vd->vdev_tsd;
#ifdef LINUX_AIO
struct iocb *iocbp = &zio->io_aio;
#endif
ssize_t resid;
int error;
if (zio->io_type == ZIO_TYPE_IOCTL) {
zio_vdev_io_bypass(zio);
/* XXPOLICY */
if (!vdev_readable(vd)) {
zio->io_error = ENXIO;
return (ZIO_PIPELINE_CONTINUE);
}
switch (zio->io_cmd) {
case DKIOCFLUSHWRITECACHE:
if (zfs_nocacheflush)
break;
/* This doesn't actually do much with O_DIRECT... */
zio->io_error = VOP_FSYNC(vf->vf_vnode, FSYNC | FDSYNC,
kcred, NULL);
dprintf("fsync(%s) = %d\n", vdev_description(vd),
zio->io_error);
if (vd->vdev_nowritecache) {
zio->io_error = ENOTSUP;
break;
}
/* Flush the write cache */
error = flushwc(vf->vf_vnode);
dprintf("flushwc(%s) = %d\n", vdev_description(vd),
error);
if (error) {
#ifdef _KERNEL
cmn_err(CE_WARN, "Failed to flush write cache "
"on device '%s'. Data on pool '%s' may be lost "
"if power fails. No further warnings will "
"be given.", vdev_description(vd),
spa_name(vd->vdev_spa));
#endif
vd->vdev_nowritecache = B_TRUE;
zio->io_error = error;
}
break;
default:
zio->io_error = ENOTSUP;
}
return (ZIO_PIPELINE_CONTINUE);
}
/*
* In the kernel, don't bother double-caching, but in userland,
* we want to test the vdev_cache code.
*/
if (zio->io_type == ZIO_TYPE_READ && vdev_cache_read(zio) == 0)
return (ZIO_PIPELINE_STOP);
if ((zio = vdev_queue_io(zio)) == NULL)
return (ZIO_PIPELINE_STOP);
/* XXPOLICY */
if (zio->io_type == ZIO_TYPE_WRITE)
error = vdev_writeable(vd) ? vdev_error_inject(vd, zio) : ENXIO;
else
error = vdev_readable(vd) ? vdev_error_inject(vd, zio) : ENXIO;
error = (vd->vdev_remove_wanted || vd->vdev_is_failing) ? ENXIO : error;
if (error) {
zio->io_error = error;
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
#ifdef LINUX_AIO
if (zio->io_aio_ctx && zio->io_aio_ctx->zac_enabled) {
if (zio->io_type == ZIO_TYPE_READ)
io_prep_pread(&zio->io_aio, vf->vf_vnode->v_fd,
zio->io_data, zio->io_size, zio->io_offset);
else
io_prep_pwrite(&zio->io_aio, vf->vf_vnode->v_fd,
zio->io_data, zio->io_size, zio->io_offset);
zio->io_aio.data = zio;
do {
error = io_submit(zio->io_aio_ctx->zac_ctx, 1, &iocbp);
} while (error == -EINTR);
if (error < 0) {
zio->io_error = -error;
zio_interrupt(zio);
} else
VERIFY(error == 1);
return (ZIO_PIPELINE_STOP);
}
#endif
zio->io_error = vn_rdwr(zio->io_type == ZIO_TYPE_READ ?
UIO_READ : UIO_WRITE, vf->vf_vnode, zio->io_data,
zio->io_size, zio->io_offset, UIO_SYSSPACE,
0, RLIM64_INFINITY, kcred, &resid);
if (resid != 0 && zio->io_error == 0)
zio->io_error = ENOSPC;
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
static void
vdev_file_io_start(zio_t *zio)
{
vdev_t *vd = zio->io_vd;
vdev_file_t *vf = vd->vdev_tsd;
ssize_t resid;
int error;
if (zio->io_type == ZIO_TYPE_IOCTL) {
zio_vdev_io_bypass(zio);
/* XXPOLICY */
if (vdev_is_dead(vd)) {
zio->io_error = ENXIO;
zio_next_stage_async(zio);
return;
}
switch (zio->io_cmd) {
case DKIOCFLUSHWRITECACHE:
zio->io_error = VOP_FSYNC(vf->vf_vnode, FSYNC | FDSYNC,
kcred);
dprintf("fsync(%s) = %d\n", vdev_description(vd),
zio->io_error);
break;
default:
zio->io_error = ENOTSUP;
}
zio_next_stage_async(zio);
return;
}
/*
* In the kernel, don't bother double-caching, but in userland,
* we want to test the vdev_cache code.
*/
#ifndef _KERNEL
if (zio->io_type == ZIO_TYPE_READ && vdev_cache_read(zio) == 0)
return;
#endif
if ((zio = vdev_queue_io(zio)) == NULL)
return;
/* XXPOLICY */
error = vdev_is_dead(vd) ? ENXIO : vdev_error_inject(vd, zio);
if (error) {
zio->io_error = error;
zio_next_stage_async(zio);
return;
}
#ifdef ZFS_READONLY_KEXT
if (zio->io_type == ZIO_TYPE_WRITE) {
zio->io_error = 0;
zio_next_stage_async(zio);
return;
}
#endif /* ZFS_READONLY_KEXT */
zio->io_error = vn_rdwr(zio->io_type == ZIO_TYPE_READ ?
UIO_READ : UIO_WRITE, vf->vf_vnode, zio->io_data,
zio->io_size, zio->io_offset, UIO_SYSSPACE,
0, RLIM64_INFINITY, kcred, &resid);
if (resid != 0 && zio->io_error == 0)
zio->io_error = ENOSPC;
zio_next_stage_async(zio);
}