/*
* Revalidate the Linux inode from the vattr.
* Note: i_size _not_ updated; we must hold the inode
* semaphore when doing that - callers responsibility.
*/
void
vn_revalidate_core(
struct vnode *vp,
vattr_t *vap)
{
struct inode *inode = LINVFS_GET_IP(vp);
inode->i_mode = VTTOIF(vap->va_type) | vap->va_mode;
inode->i_nlink = vap->va_nlink;
inode->i_uid = vap->va_uid;
inode->i_gid = vap->va_gid;
inode->i_blocks = vap->va_nblocks;
inode->i_mtime = vap->va_mtime;
inode->i_ctime = vap->va_ctime;
inode->i_atime = vap->va_atime;
if (vap->va_xflags & XFS_XFLAG_IMMUTABLE)
inode->i_flags |= S_IMMUTABLE;
else
inode->i_flags &= ~S_IMMUTABLE;
if (vap->va_xflags & XFS_XFLAG_APPEND)
inode->i_flags |= S_APPEND;
else
inode->i_flags &= ~S_APPEND;
if (vap->va_xflags & XFS_XFLAG_SYNC)
inode->i_flags |= S_SYNC;
else
inode->i_flags &= ~S_SYNC;
if (vap->va_xflags & XFS_XFLAG_NOATIME)
inode->i_flags |= S_NOATIME;
else
inode->i_flags &= ~S_NOATIME;
}
static errno_t
fuse_vfsop_root(mount_t mp, struct vnode **vpp, vfs_context_t context)
{
int err = 0;
vnode_t vp = NULLVP;
struct fuse_entry_out feo_root;
struct fuse_data *data = fuse_get_mpdata(mp);
fuse_trace_printf_vfsop();
if (data->rootvp != NULLVP) {
*vpp = data->rootvp;
return vnode_get(*vpp);
}
bzero(&feo_root, sizeof(feo_root));
feo_root.nodeid = FUSE_ROOT_ID;
feo_root.generation = 0;
feo_root.attr.ino = FUSE_ROOT_ID;
feo_root.attr.size = FUSE_ROOT_SIZE;
feo_root.attr.mode = VTTOIF(VDIR);
err = FSNodeGetOrCreateFileVNodeByID(&vp, FN_IS_ROOT, &feo_root, mp,
NULLVP /* dvp */, context,
NULL /* oflags */);
*vpp = vp;
if (!err) {
data->rootvp = *vpp;
}
return err;
}
/*
* au_to_attr
* returns:
* pointer to au_membuf chain containing an attribute token.
*/
token_t *
au_to_attr(struct vattr *attr)
{
token_t *m; /* local au_membuf */
adr_t adr; /* adr memory stream header */
#ifdef _LP64
char data_header = AUT_ATTR64; /* header for this token */
#else
char data_header = AUT_ATTR32;
#endif
int32_t value;
m = au_getclr();
adr_start(&adr, memtod(m, char *));
adr_char(&adr, &data_header, 1);
value = (int32_t)attr->va_mode;
value |= (int32_t)(VTTOIF(attr->va_type));
adr_int32(&adr, &value, 1);
value = (int32_t)attr->va_uid;
adr_int32(&adr, &value, 1);
value = (int32_t)attr->va_gid;
adr_int32(&adr, &value, 1);
adr_int32(&adr, (int32_t *)&(attr->va_fsid), 1);
adr_int64(&adr, (int64_t *)&(attr->va_nodeid), 1);
#ifdef _LP64
adr_int64(&adr, (int64_t *)&(attr->va_rdev), 1);
#else
adr_int32(&adr, (int32_t *)&(attr->va_rdev), 1);
#endif
m->len = adr_count(&adr);
return (m);
}
static int
_xfs_create(
struct vop_create_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
} */ *ap)
{
struct vnode *dvp = ap->a_dvp;
struct vattr *vap = ap->a_vap;
struct thread *td = curthread;
struct ucred *credp = td->td_ucred;
struct componentname *cnp = ap->a_cnp;
xfs_vnode_t *xvp;
xfs_vattr_t va;
int error;
memset(&va, 0, sizeof (va));
va.va_mask |= XFS_AT_MODE;
va.va_mode = vap->va_mode;
va.va_mask |= XFS_AT_TYPE;
va.va_mode |= VTTOIF(vap->va_type);
xvp = NULL;
XVOP_CREATE(VPTOXFSVP(dvp), cnp, &va, &xvp, credp, error);
if (error == 0) {
*ap->a_vpp = xvp->v_vnode;
VOP_LOCK(xvp->v_vnode, LK_EXCLUSIVE);
}
return (error);
}
static int zfsfuse_stat(vnode_t *vp, struct stat *stbuf, cred_t *cred)
{
ASSERT(vp != NULL);
ASSERT(stbuf != NULL);
vattr_t vattr;
vattr.va_mask = AT_STAT | AT_NBLOCKS | AT_BLKSIZE | AT_SIZE;
int error = VOP_GETATTR(vp, &vattr, 0, cred, NULL);
if(error)
return error;
memset(stbuf, 0, sizeof(struct stat));
stbuf->st_dev = vattr.va_fsid;
stbuf->st_ino = vattr.va_nodeid == 3 ? 1 : vattr.va_nodeid;
stbuf->st_mode = VTTOIF(vattr.va_type) | vattr.va_mode;
stbuf->st_nlink = vattr.va_nlink;
stbuf->st_uid = vattr.va_uid;
stbuf->st_gid = vattr.va_gid;
stbuf->st_rdev = vattr.va_rdev;
stbuf->st_size = vattr.va_size;
stbuf->st_blksize = vattr.va_blksize;
stbuf->st_blocks = vattr.va_nblocks;
TIMESTRUC_TO_TIME(vattr.va_atime, &stbuf->st_atime);
TIMESTRUC_TO_TIME(vattr.va_mtime, &stbuf->st_mtime);
TIMESTRUC_TO_TIME(vattr.va_ctime, &stbuf->st_ctime);
return 0;
}
STATIC __inline__ void
xfs_revalidate_inode(
xfs_mount_t *mp,
vnode_t *vp,
xfs_inode_t *ip)
{
struct inode *inode = LINVFS_GET_IP(vp);
inode->i_mode = (ip->i_d.di_mode & MODEMASK) | VTTOIF(vp->v_type);
inode->i_nlink = ip->i_d.di_nlink;
inode->i_uid = ip->i_d.di_uid;
inode->i_gid = ip->i_d.di_gid;
if (((1 << vp->v_type) & ((1<<VBLK) | (1<<VCHR))) == 0) {
inode->i_rdev = 0;
} else {
xfs_dev_t dev = ip->i_df.if_u2.if_rdev;
inode->i_rdev = MKDEV(sysv_major(dev) & 0x1ff, sysv_minor(dev));
}
inode->i_blksize = PAGE_CACHE_SIZE;
inode->i_generation = ip->i_d.di_gen;
i_size_write(inode, ip->i_d.di_size);
inode->i_blocks =
XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
inode->i_atime.tv_sec = ip->i_d.di_atime.t_sec;
inode->i_atime.tv_nsec = ip->i_d.di_atime.t_nsec;
inode->i_mtime.tv_sec = ip->i_d.di_mtime.t_sec;
inode->i_mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
inode->i_ctime.tv_sec = ip->i_d.di_ctime.t_sec;
inode->i_ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
inode->i_flags |= S_IMMUTABLE;
else
inode->i_flags &= ~S_IMMUTABLE;
if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
inode->i_flags |= S_APPEND;
else
inode->i_flags &= ~S_APPEND;
if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
inode->i_flags |= S_SYNC;
else
inode->i_flags &= ~S_SYNC;
if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
inode->i_flags |= S_NOATIME;
else
inode->i_flags &= ~S_NOATIME;
vp->v_flag &= ~VMODIFIED;
}
/*
* Revalidate the Linux inode from the vnode.
*/
int
vn_revalidate(
struct vnode *vp)
{
struct inode *inode;
vattr_t va;
int error;
vn_trace_entry(vp, "vn_revalidate", (inst_t *)__return_address);
ASSERT(vp->v_fbhv != NULL);
va.va_mask = XFS_AT_STAT|XFS_AT_XFLAGS;
VOP_GETATTR(vp, &va, 0, NULL, error);
if (!error) {
inode = LINVFS_GET_IP(vp);
inode->i_mode = VTTOIF(va.va_type) | va.va_mode;
inode->i_nlink = va.va_nlink;
inode->i_uid = va.va_uid;
inode->i_gid = va.va_gid;
inode->i_blocks = va.va_nblocks;
inode->i_mtime = va.va_mtime;
inode->i_ctime = va.va_ctime;
inode->i_atime = va.va_atime;
if (va.va_xflags & XFS_XFLAG_IMMUTABLE)
inode->i_flags |= S_IMMUTABLE;
else
inode->i_flags &= ~S_IMMUTABLE;
if (va.va_xflags & XFS_XFLAG_APPEND)
inode->i_flags |= S_APPEND;
else
inode->i_flags &= ~S_APPEND;
if (va.va_xflags & XFS_XFLAG_SYNC)
inode->i_flags |= S_SYNC;
else
inode->i_flags &= ~S_SYNC;
if (va.va_xflags & XFS_XFLAG_NOATIME)
inode->i_flags |= S_NOATIME;
else
inode->i_flags &= ~S_NOATIME;
VUNMODIFY(vp);
}
return -error;
}
