/*
struct vnop_readlink_args {
struct vnode *a_vp;
struct uio *a_uio;
struct ucred *a_cred;
};
*/
static int
fuse_vnop_readlink(struct vop_readlink_args *ap)
{
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
struct ucred *cred = ap->a_cred;
struct fuse_dispatcher fdi;
int err;
FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp));
if (fuse_isdeadfs(vp)) {
return ENXIO;
}
if (!vnode_islnk(vp)) {
return EINVAL;
}
fdisp_init(&fdi, 0);
err = fdisp_simple_putget_vp(&fdi, FUSE_READLINK, vp, curthread, cred);
if (err) {
goto out;
}
if (((char *)fdi.answ)[0] == '/' &&
fuse_get_mpdata(vnode_mount(vp))->dataflags & FSESS_PUSH_SYMLINKS_IN) {
char *mpth = vnode_mount(vp)->mnt_stat.f_mntonname;
err = uiomove(mpth, strlen(mpth), uio);
}
if (!err) {
err = uiomove(fdi.answ, fdi.iosize, uio);
}
out:
fdisp_destroy(&fdi);
return err;
}
/*
struct vnop_getattr_args {
struct vnode *a_vp;
struct vattr *a_vap;
struct ucred *a_cred;
struct thread *a_td;
};
*/
static int
fuse_vnop_getattr(struct vop_getattr_args *ap)
{
struct vnode *vp = ap->a_vp;
struct vattr *vap = ap->a_vap;
struct ucred *cred = ap->a_cred;
struct thread *td = curthread;
struct fuse_vnode_data *fvdat = VTOFUD(vp);
int err = 0;
int dataflags;
struct fuse_dispatcher fdi;
FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp));
dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags;
/* Note that we are not bailing out on a dead file system just yet. */
if (!(dataflags & FSESS_INITED)) {
if (!vnode_isvroot(vp)) {
fdata_set_dead(fuse_get_mpdata(vnode_mount(vp)));
err = ENOTCONN;
debug_printf("fuse_getattr b: returning ENOTCONN\n");
return err;
} else {
goto fake;
}
}
fdisp_init(&fdi, 0);
if ((err = fdisp_simple_putget_vp(&fdi, FUSE_GETATTR, vp, td, cred))) {
if ((err == ENOTCONN) && vnode_isvroot(vp)) {
/* see comment at similar place in fuse_statfs() */
fdisp_destroy(&fdi);
goto fake;
}
if (err == ENOENT) {
fuse_internal_vnode_disappear(vp);
}
goto out;
}
cache_attrs(vp, (struct fuse_attr_out *)fdi.answ);
if (vap != VTOVA(vp)) {
memcpy(vap, VTOVA(vp), sizeof(*vap));
}
if (vap->va_type != vnode_vtype(vp)) {
fuse_internal_vnode_disappear(vp);
err = ENOENT;
goto out;
}
if ((fvdat->flag & FN_SIZECHANGE) != 0)
vap->va_size = fvdat->filesize;
if (vnode_isreg(vp) && (fvdat->flag & FN_SIZECHANGE) == 0) {
/*
* This is for those cases when the file size changed without us
* knowing, and we want to catch up.
*/
off_t new_filesize = ((struct fuse_attr_out *)
fdi.answ)->attr.size;
if (fvdat->filesize != new_filesize) {
fuse_vnode_setsize(vp, cred, new_filesize);
}
}
debug_printf("fuse_getattr e: returning 0\n");
out:
fdisp_destroy(&fdi);
return err;
fake:
bzero(vap, sizeof(*vap));
vap->va_type = vnode_vtype(vp);
return 0;
}
/* getattr sidekicks */
__private_extern__
int
fuse_internal_loadxtimes(vnode_t vp, struct vnode_attr *out_vap,
vfs_context_t context)
{
struct vnode_attr *in_vap = VTOVA(vp);
struct fuse_data *data = fuse_get_mpdata(vnode_mount(vp));
struct fuse_dispatcher fdi;
struct fuse_getxtimes_out *fgxo = NULL;
int isvroot = vnode_isvroot(vp);
struct timespec t = { 0, 0 };
const struct timespec kZeroTime = { 0, 0 };
int err = 0;
if (!(data->dataflags & FSESS_XTIMES)) {
/* We don't return anything. */
goto out;
}
if (VTOFUD(vp)->c_flag & C_XTIMES_VALID) {
VATTR_RETURN(out_vap, va_backup_time, in_vap->va_backup_time);
VATTR_RETURN(out_vap, va_create_time, in_vap->va_create_time);
goto out;
}
if (!fuse_implemented(data, FSESS_NOIMPLBIT(GETXTIMES))) {
goto fake;
}
if (fuse_isdeadfs(vp) && isvroot) {
goto fake;
}
if (!(data->dataflags & FSESS_INITED) && isvroot) {
goto fake;
}
err = fdisp_simple_putget_vp(&fdi, FUSE_GETXTIMES, vp, context);
if (err) {
/* We don't ever treat this as a hard error. */
err = 0;
goto fake;
}
fgxo = (struct fuse_getxtimes_out *)fdi.answ;
t.tv_sec = (time_t)fgxo->bkuptime; /* XXX: truncation */
t.tv_nsec = fgxo->bkuptimensec;
VATTR_RETURN(in_vap, va_backup_time, t);
VATTR_RETURN(out_vap, va_backup_time, t);
t.tv_sec = (time_t)fgxo->crtime; /* XXX: truncation */
t.tv_nsec = fgxo->crtimensec;
VATTR_RETURN(in_vap, va_create_time, t);
VATTR_RETURN(out_vap, va_create_time, t);
fuse_ticket_drop(fdi.tick);
VTOFUD(vp)->c_flag |= C_XTIMES_VALID;
goto out;
fake:
VATTR_RETURN(out_vap, va_backup_time, kZeroTime);
VATTR_RETURN(out_vap, va_create_time, kZeroTime);
out:
return err;
}
