static int
vn_readwrite_io(struct vn_softc * vn, struct buf * bp, vfs_context_t ctx)
{
int error = 0;
char * iov_base;
caddr_t vaddr;
if (buf_map(bp, &vaddr))
panic("vn device: buf_map failed");
iov_base = (char *)vaddr;
if (vn->sc_shadow_vp == NULL) {
user_ssize_t temp_resid;
error = file_io(vn->sc_vp, ctx,
buf_flags(bp) & B_READ ? UIO_READ : UIO_WRITE,
iov_base,
(off_t)buf_blkno(bp) * vn->sc_secsize,
buf_resid(bp), &temp_resid);
buf_setresid(bp, temp_resid);
}
else {
if (buf_flags(bp) & B_READ)
error = shadow_read(vn, bp, iov_base, ctx);
else
error = shadow_write(vn, bp, iov_base, ctx);
}
buf_unmap(bp);
return (error);
}
static void
vdev_disk_io_intr(struct buf *bp, void *arg)
{
zio_t *zio = (zio_t *)arg;
zio->io_error = buf_error(bp);
if (zio->io_error == 0 && buf_resid(bp) != 0) {
zio->io_error = EIO;
}
buf_free(bp);
//zio_next_stage_async(zio);
zio_interrupt(zio);
}
static int
shadow_write(struct vn_softc * vn, struct buf * bp, char * base,
vfs_context_t ctx)
{
u_int32_t blocksize = vn->sc_secsize;
int error = 0;
u_int32_t offset;
boolean_t shadow_grew;
u_int32_t resid;
u_int32_t start = 0;
offset = buf_blkno(bp);
resid = buf_resid(bp) / blocksize;
while (resid > 0) {
user_ssize_t temp_resid;
u_int32_t this_offset;
u_int32_t this_resid;
shadow_grew = shadow_map_write(vn->sc_shadow_map,
offset, resid,
&this_offset, &this_resid);
if (shadow_grew) {
#if 0
off_t size;
/* truncate the file to its new length before write */
size = (off_t)shadow_map_shadow_size(vn->sc_shadow_map)
* blocksize;
vnode_setsize(vn->sc_shadow_vp, size, IO_SYNC, ctx);
#endif
}
error = file_io(vn->sc_shadow_vp, ctx, UIO_WRITE,
base + start,
(off_t)this_offset * blocksize,
(user_ssize_t)this_resid * blocksize,
&temp_resid);
if (error) {
break;
}
this_resid -= (temp_resid / blocksize);
if (this_resid == 0) {
printf("vn device: shadow_write zero length write\n");
break;
}
resid -= this_resid;
offset += this_resid;
start += this_resid * blocksize;
}
buf_setresid(bp, resid * blocksize);
return (error);
}
static int
shadow_read(struct vn_softc * vn, struct buf * bp, char * base,
vfs_context_t ctx)
{
u_int32_t blocksize = vn->sc_secsize;
int error = 0;
u_int32_t offset;
boolean_t read_shadow;
u_int32_t resid;
u_int32_t start = 0;
offset = buf_blkno(bp);
resid = buf_resid(bp) / blocksize;
while (resid > 0) {
user_ssize_t temp_resid;
u_int32_t this_offset;
u_int32_t this_resid;
struct vnode * vp;
read_shadow = shadow_map_read(vn->sc_shadow_map,
offset, resid,
&this_offset, &this_resid);
if (read_shadow) {
vp = vn->sc_shadow_vp;
}
else {
vp = vn->sc_vp;
}
error = file_io(vp, ctx, UIO_READ, base + start,
(off_t)this_offset * blocksize,
(user_ssize_t)this_resid * blocksize,
&temp_resid);
if (error) {
break;
}
this_resid -= (temp_resid / blocksize);
if (this_resid == 0) {
printf("vn device: shadow_read zero length read\n");
break;
}
resid -= this_resid;
offset += this_resid;
start += this_resid * blocksize;
}
buf_setresid(bp, resid * blocksize);
return (error);
}
static void
vdev_disk_io_intr(struct buf *bp, void *arg)
{
zio_t *zio = (zio_t *)arg;
/*
* The rest of the zio stack only deals with EIO, ECKSUM, and ENXIO.
* Rather than teach the rest of the stack about other error
* possibilities (EFAULT, etc), we normalize the error value here.
*/
int error;
error=buf_error(bp);
zio->io_error = (error != 0 ? EIO : 0);
if (zio->io_error == 0 && buf_resid(bp) != 0) {
zio->io_error = EIO;
}
buf_free(bp);
zio_delay_interrupt(zio);
}
/*
* Vnode op for write
*/
int
spec_write(struct vnop_write_args *ap)
{
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
struct buf *bp;
daddr64_t bn;
int bsize, blkmask, bscale;
int io_sync;
int devBlockSize=0;
int n, on;
int error = 0;
dev_t dev;
#if DIAGNOSTIC
if (uio->uio_rw != UIO_WRITE)
panic("spec_write mode");
if (UIO_SEG_IS_USER_SPACE(uio->uio_segflg))
panic("spec_write proc");
#endif
switch (vp->v_type) {
case VCHR:
error = (*cdevsw[major(vp->v_rdev)].d_write)
(vp->v_rdev, uio, ap->a_ioflag);
return (error);
case VBLK:
if (uio_resid(uio) == 0)
return (0);
if (uio->uio_offset < 0)
return (EINVAL);
io_sync = (ap->a_ioflag & IO_SYNC);
dev = (vp->v_rdev);
devBlockSize = vp->v_specsize;
if (devBlockSize > PAGE_SIZE)
return(EINVAL);
bscale = PAGE_SIZE / devBlockSize;
blkmask = bscale - 1;
bsize = bscale * devBlockSize;
do {
bn = (daddr64_t)((uio->uio_offset / devBlockSize) &~ blkmask);
on = uio->uio_offset % bsize;
n = min((unsigned)(bsize - on), uio_resid(uio));
/*
* Use buf_getblk() as an optimization IFF:
*
* 1) We are reading exactly a block on a block
* aligned boundary
* 2) We know the size of the device from spec_open
* 3) The read doesn't span the end of the device
*
* Otherwise, we fall back on buf_bread().
*/
if (n == bsize &&
vp->v_specdevsize != (u_int64_t)0 &&
(uio->uio_offset + (u_int64_t)n) > vp->v_specdevsize) {
/* reduce the size of the read to what is there */
n = (uio->uio_offset + (u_int64_t)n) - vp->v_specdevsize;
}
if (n == bsize)
bp = buf_getblk(vp, bn, bsize, 0, 0, BLK_WRITE);
else
error = (int)buf_bread(vp, bn, bsize, NOCRED, &bp);
/* Translate downstream error for upstream, if needed */
if (!error)
error = (int)buf_error(bp);
if (error) {
buf_brelse(bp);
return (error);
}
n = min(n, bsize - buf_resid(bp));
error = uiomove((char *)0 + buf_dataptr(bp) + on, n, uio);
if (error) {
buf_brelse(bp);
return (error);
}
buf_markaged(bp);
if (io_sync)
error = buf_bwrite(bp);
else {
if ((n + on) == bsize)
error = buf_bawrite(bp);
else
error = buf_bdwrite(bp);
}
} while (error == 0 && uio_resid(uio) > 0 && n != 0);
return (error);
default:
panic("spec_write type");
}
/* NOTREACHED */
return (0);
}
/*
* Vnode op for read
*/
int
spec_read(struct vnop_read_args *ap)
{
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
struct buf *bp;
daddr64_t bn, nextbn;
long bsize, bscale;
int devBlockSize=0;
int n, on;
int error = 0;
dev_t dev;
#if DIAGNOSTIC
if (uio->uio_rw != UIO_READ)
panic("spec_read mode");
if (UIO_SEG_IS_USER_SPACE(uio->uio_segflg))
panic("spec_read proc");
#endif
if (uio_resid(uio) == 0)
return (0);
switch (vp->v_type) {
case VCHR:
error = (*cdevsw[major(vp->v_rdev)].d_read)
(vp->v_rdev, uio, ap->a_ioflag);
return (error);
case VBLK:
if (uio->uio_offset < 0)
return (EINVAL);
dev = vp->v_rdev;
devBlockSize = vp->v_specsize;
if (devBlockSize > PAGE_SIZE)
return (EINVAL);
bscale = PAGE_SIZE / devBlockSize;
bsize = bscale * devBlockSize;
do {
on = uio->uio_offset % bsize;
bn = (daddr64_t)((uio->uio_offset / devBlockSize) &~ (bscale - 1));
if (vp->v_speclastr + bscale == bn) {
nextbn = bn + bscale;
error = buf_breadn(vp, bn, (int)bsize, &nextbn,
(int *)&bsize, 1, NOCRED, &bp);
} else
error = buf_bread(vp, bn, (int)bsize, NOCRED, &bp);
vnode_lock(vp);
vp->v_speclastr = bn;
vnode_unlock(vp);
n = bsize - buf_resid(bp);
if ((on > n) || error) {
if (!error)
error = EINVAL;
buf_brelse(bp);
return (error);
}
n = min((unsigned)(n - on), uio_resid(uio));
error = uiomove((char *)0 + buf_dataptr(bp) + on, n, uio);
if (n + on == bsize)
buf_markaged(bp);
buf_brelse(bp);
} while (error == 0 && uio_resid(uio) > 0 && n != 0);
return (error);
default:
panic("spec_read type");
}
/* NOTREACHED */
return (0);
}
int
physio( void (*f_strategy)(buf_t),
buf_t bp,
dev_t dev,
int flags,
u_int (*f_minphys)(buf_t),
struct uio *uio,
int blocksize)
{
struct proc *p = current_proc();
int error, i, buf_allocated, todo, iosize;
int orig_bflags = 0;
int64_t done;
error = 0;
flags &= B_READ | B_WRITE;
buf_allocated = 0;
/*
* [check user read/write access to the data buffer]
*
* Check each iov one by one. Note that we know if we're reading or
* writing, so we ignore the uio's rw parameter. Also note that if
* we're doing a read, that's a *write* to user-space.
*/
for (i = 0; i < uio->uio_iovcnt; i++) {
if (UIO_SEG_IS_USER_SPACE(uio->uio_segflg)) {
user_addr_t base;
user_size_t len;
if (uio_getiov(uio, i, &base, &len) ||
!useracc(base,
len,
(flags == B_READ) ? B_WRITE : B_READ))
return (EFAULT);
}
}
/*
* Make sure we have a buffer, creating one if necessary.
*/
if (bp == NULL) {
bp = buf_alloc((vnode_t)0);
buf_allocated = 1;
} else
orig_bflags = buf_flags(bp);
/*
* at this point we should have a buffer
* that is marked BL_BUSY... we either
* acquired it via buf_alloc, or it was
* passed into us... if it was passed
* in, it needs to already be owned by
* the caller (i.e. BL_BUSY is set)
*/
assert(bp->b_lflags & BL_BUSY);
/*
* [set up the fixed part of the buffer for a transfer]
*/
bp->b_dev = dev;
bp->b_proc = p;
/*
* [mark the buffer busy for physical I/O]
* (i.e. set B_PHYS (because it's an I/O to user
* memory, and B_RAW, because B_RAW is to be
* "Set by physio for raw transfers.", in addition
* to the read/write flag.)
*/
buf_setflags(bp, B_PHYS | B_RAW);
/*
* [while there is data to transfer and no I/O error]
* Note that I/O errors are handled with a 'goto' at the bottom
* of the 'while' loop.
*/
while (uio_resid(uio) > 0) {
if ( (iosize = uio_curriovlen(uio)) > MAXPHYSIO_WIRED)
iosize = MAXPHYSIO_WIRED;
/*
* make sure we're set to issue a fresh I/O
* in the right direction
*/
buf_reset(bp, flags);
/* [set up the buffer for a maximum-sized transfer] */
buf_setblkno(bp, uio_offset(uio) / blocksize);
buf_setcount(bp, iosize);
buf_setdataptr(bp, (uintptr_t)CAST_DOWN(caddr_t, uio_curriovbase(uio)));
/*
* [call f_minphys to bound the tranfer size]
* and remember the amount of data to transfer,
* for later comparison.
*/
(*f_minphys)(bp);
todo = buf_count(bp);
/*
* [lock the part of the user address space involved
* in the transfer]
*/
if(UIO_SEG_IS_USER_SPACE(uio->uio_segflg)) {
error = vslock(CAST_USER_ADDR_T(buf_dataptr(bp)),
(user_size_t)todo);
if (error)
goto done;
}
/* [call f_strategy to start the transfer] */
(*f_strategy)(bp);
/* [wait for the transfer to complete] */
error = (int)buf_biowait(bp);
/*
* [unlock the part of the address space previously
* locked]
*/
if(UIO_SEG_IS_USER_SPACE(uio->uio_segflg))
vsunlock(CAST_USER_ADDR_T(buf_dataptr(bp)),
(user_size_t)todo,
(flags & B_READ));
/*
* [deduct the transfer size from the total number
* of data to transfer]
*/
done = buf_count(bp) - buf_resid(bp);
uio_update(uio, done);
/*
* Now, check for an error.
* Also, handle weird end-of-disk semantics.
*/
if (error || done < todo)
goto done;
}
done:
if (buf_allocated)
buf_free(bp);
else
buf_setflags(bp, orig_bflags);
return (error);
}
__private_extern__
int
fuse_internal_strategy(vnode_t vp, buf_t bp)
{
size_t biosize;
size_t chunksize;
size_t respsize;
int mapped = FALSE;
int mode;
int op;
int vtype = vnode_vtype(vp);
int err = 0;
caddr_t bufdat;
off_t left;
off_t offset;
int32_t bflags = buf_flags(bp);
fufh_type_t fufh_type;
struct fuse_dispatcher fdi;
struct fuse_data *data;
struct fuse_vnode_data *fvdat = VTOFUD(vp);
struct fuse_filehandle *fufh = NULL;
mount_t mp = vnode_mount(vp);
data = fuse_get_mpdata(mp);
biosize = data->blocksize;
if (!(vtype == VREG || vtype == VDIR)) {
return ENOTSUP;
}
if (bflags & B_READ) {
mode = FREAD;
fufh_type = FUFH_RDONLY; /* FUFH_RDWR will also do */
} else {
mode = FWRITE;
fufh_type = FUFH_WRONLY; /* FUFH_RDWR will also do */
}
if (fvdat->flag & FN_CREATING) {
fuse_lck_mtx_lock(fvdat->createlock);
if (fvdat->flag & FN_CREATING) {
(void)fuse_msleep(fvdat->creator, fvdat->createlock,
PDROP | PINOD | PCATCH, "fuse_internal_strategy",
NULL);
} else {
fuse_lck_mtx_unlock(fvdat->createlock);
}
}
fufh = &(fvdat->fufh[fufh_type]);
if (!FUFH_IS_VALID(fufh)) {
fufh_type = FUFH_RDWR;
fufh = &(fvdat->fufh[fufh_type]);
if (!FUFH_IS_VALID(fufh)) {
fufh = NULL;
} else {
/* We've successfully fallen back to FUFH_RDWR. */
}
}
if (!fufh) {
if (mode == FREAD) {
fufh_type = FUFH_RDONLY;
} else {
fufh_type = FUFH_RDWR;
}
/*
* Lets NOT do the filehandle preflight check here.
*/
err = fuse_filehandle_get(vp, NULL, fufh_type, 0 /* mode */);
if (!err) {
fufh = &(fvdat->fufh[fufh_type]);
FUFH_AUX_INC(fufh);
/* We've created a NEW fufh of type fufh_type. open_count is 1. */
}
} else { /* good fufh */
FUSE_OSAddAtomic(1, (SInt32 *)&fuse_fh_reuse_count);
/* We're using an existing fufh of type fufh_type. */
}
if (err) {
/* A more typical error case. */
if ((err == ENOTCONN) || fuse_isdeadfs(vp)) {
buf_seterror(bp, EIO);
buf_biodone(bp);
return EIO;
}
IOLog("MacFUSE: strategy failed to get fh "
"(vtype=%d, fufh_type=%d, err=%d)\n", vtype, fufh_type, err);
if (!vfs_issynchronous(mp)) {
IOLog("MacFUSE: asynchronous write failed!\n");
}
buf_seterror(bp, EIO);
buf_biodone(bp);
return EIO;
}
if (!fufh) {
panic("MacFUSE: tried everything but still no fufh");
/* NOTREACHED */
}
#define B_INVAL 0x00040000 /* Does not contain valid info. */
#define B_ERROR 0x00080000 /* I/O error occurred. */
if (bflags & B_INVAL) {
IOLog("MacFUSE: buffer does not contain valid information\n");
}
if (bflags & B_ERROR) {
IOLog("MacFUSE: an I/O error has occured\n");
}
if (buf_count(bp) == 0) {
return 0;
}
fdisp_init(&fdi, 0);
if (mode == FREAD) {
struct fuse_read_in *fri;
buf_setresid(bp, buf_count(bp));
offset = (off_t)((off_t)buf_blkno(bp) * biosize);
if (offset >= fvdat->filesize) {
/* Trying to read at/after EOF? */
if (offset != fvdat->filesize) {
/* Trying to read after EOF? */
buf_seterror(bp, EINVAL);
}
buf_biodone(bp);
return 0;
}
/* Note that we just made sure that offset < fvdat->filesize. */
if ((offset + buf_count(bp)) > fvdat->filesize) {
/* Trimming read */
buf_setcount(bp, (uint32_t)(fvdat->filesize - offset));
}
if (buf_map(bp, &bufdat)) {
IOLog("MacFUSE: failed to map buffer in strategy\n");
return EFAULT;
} else {
mapped = TRUE;
}
while (buf_resid(bp) > 0) {
chunksize = min((size_t)buf_resid(bp), data->iosize);
fdi.iosize = sizeof(*fri);
op = FUSE_READ;
if (vtype == VDIR) {
op = FUSE_READDIR;
}
fdisp_make_vp(&fdi, op, vp, (vfs_context_t)0);
fri = fdi.indata;
fri->fh = fufh->fh_id;
/*
* Historical note:
*
* fri->offset = ((off_t)(buf_blkno(bp))) * biosize;
*
* This wasn't being incremented!?
*/
fri->offset = offset;
fri->size = (typeof(fri->size))chunksize;
fdi.tick->tk_aw_type = FT_A_BUF;
fdi.tick->tk_aw_bufdata = bufdat;
if ((err = fdisp_wait_answ(&fdi))) {
/* There was a problem with reading. */
goto out;
}
respsize = fdi.tick->tk_aw_bufsize;
if (respsize < 0) { /* Cannot really happen... */
err = EIO;
goto out;
}
buf_setresid(bp, (uint32_t)(buf_resid(bp) - respsize));
bufdat += respsize;
offset += respsize;
/* Did we hit EOF before being done? */
if ((respsize == 0) && (buf_resid(bp) > 0)) {
/*
* Historical note:
* If we don't get enough data, just fill the rest with zeros.
* In NFS context, this would mean a hole in the file.
*/
/* Zero-pad the incomplete buffer. */
bzero(bufdat, buf_resid(bp));
buf_setresid(bp, 0);
break;
}
} /* while (buf_resid(bp) > 0) */
} else {
/* write */
struct fuse_write_in *fwi;
struct fuse_write_out *fwo;
int merr = 0;
off_t diff;
if (buf_map(bp, &bufdat)) {
IOLog("MacFUSE: failed to map buffer in strategy\n");
return EFAULT;
} else {
mapped = TRUE;
}
/* Write begin */
buf_setresid(bp, buf_count(bp));
offset = (off_t)((off_t)buf_blkno(bp) * biosize);
/* XXX: TBD -- Check here for extension (writing past end) */
left = buf_count(bp);
while (left) {
fdi.iosize = sizeof(*fwi);
op = FUSE_WRITE;
fdisp_make_vp(&fdi, op, vp, (vfs_context_t)0);
chunksize = min((size_t)left, data->iosize);
fwi = fdi.indata;
fwi->fh = fufh->fh_id;
fwi->offset = offset;
fwi->size = (typeof(fwi->size))chunksize;
fdi.tick->tk_ms_type = FT_M_BUF;
fdi.tick->tk_ms_bufdata = bufdat;
fdi.tick->tk_ms_bufsize = chunksize;
/* About to write <chunksize> at <offset> */
if ((err = fdisp_wait_answ(&fdi))) {
merr = 1;
break;
}
fwo = fdi.answ;
diff = chunksize - fwo->size;
if (diff < 0) {
err = EINVAL;
break;
}
left -= fwo->size;
bufdat += fwo->size;
offset += fwo->size;
buf_setresid(bp, buf_resid(bp) - fwo->size);
}
if (merr) {
goto out;
}
}
if (fdi.tick) {
fuse_ticket_drop(fdi.tick);
} else {
/* No ticket upon leaving */
}
out:
if (err) {
buf_seterror(bp, err);
}
if (mapped == TRUE) {
buf_unmap(bp);
}
buf_biodone(bp);
return err;
}