int
fuse_filehandle_getrw(struct vnode *vp, fufh_type_t fufh_type,
struct fuse_filehandle **fufhp)
{
struct fuse_vnode_data *fvdat = VTOFUD(vp);
struct fuse_filehandle *fufh;
fufh = &(fvdat->fufh[fufh_type]);
if (!FUFH_IS_VALID(fufh)) {
fufh_type = FUFH_RDWR;
}
return fuse_filehandle_get(vp, fufh_type, fufhp);
}
/*
struct vnop_readdir_args {
struct vnode *a_vp;
struct uio *a_uio;
struct ucred *a_cred;
int *a_eofflag;
int *ncookies;
u_long **a_cookies;
};
*/
static int
fuse_vnop_readdir(struct vop_readdir_args *ap)
{
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
struct ucred *cred = ap->a_cred;
struct fuse_filehandle *fufh = NULL;
struct fuse_vnode_data *fvdat;
struct fuse_iov cookediov;
int err = 0;
int freefufh = 0;
FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp));
if (fuse_isdeadfs(vp)) {
return ENXIO;
}
if ( /* XXXIP ((uio_iovcnt(uio) > 1)) || */
(uio_resid(uio) < sizeof(struct dirent))) {
return EINVAL;
}
fvdat = VTOFUD(vp);
if (!fuse_filehandle_valid(vp, FUFH_RDONLY)) {
FS_DEBUG("calling readdir() before open()");
err = fuse_filehandle_open(vp, FUFH_RDONLY, &fufh, NULL, cred);
freefufh = 1;
} else {
err = fuse_filehandle_get(vp, FUFH_RDONLY, &fufh);
}
if (err) {
return (err);
}
#define DIRCOOKEDSIZE FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + MAXNAMLEN + 1)
fiov_init(&cookediov, DIRCOOKEDSIZE);
err = fuse_internal_readdir(vp, uio, fufh, &cookediov);
fiov_teardown(&cookediov);
if (freefufh) {
fuse_filehandle_close(vp, FUFH_RDONLY, NULL, cred);
}
return err;
}
__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;
}
