/*
* gfs_get_parent_ino: used to obtain a parent inode number and the
* inode number of the given vnode in preparation for calling gfs_readdir_init.
*/
int
gfs_get_parent_ino(struct vnode *dvp, cred_t *cr, caller_context_t *ct,
ino64_t *pino, ino64_t *ino)
{
struct vnode *parent;
gfs_dir_t *dp = vnode_fsnode(dvp);
*ino = dp->gfsd_file.gfs_ino;
parent = dp->gfsd_file.gfs_parent;
if (parent == NULL) {
*pino = *ino; /* root of filesystem */
#ifdef TODO
// vnode_isnamedstream()
} else if (dvp->v_flag & V_XATTRDIR) {
vattr_t va;
va.va_mask = AT_NODEID;
error = VOP_GETATTR(parent, &va, 0, cr, ct);
if (error)
return (error);
*pino = va.va_nodeid;
panic("%s:%u: not implemented", __func__, __LINE__);
#endif
} else {
*pino = ((gfs_file_t *)vnode_fsnode(parent))->gfs_ino;
}
return (0);
}
static int
vboxvfs_vnode_close(struct vnop_close_args *args)
{
vnode_t vnode;
mount_t mp;
vboxvfs_vnode_t *pVnodeData;
vboxvfs_mount_t *pMount;
int rc;
PDEBUG("Closing vnode...");
AssertReturn(args, EINVAL);
vnode = args->a_vp; AssertReturn(vnode, EINVAL);
pVnodeData = (vboxvfs_vnode_t *)vnode_fsnode(vnode); AssertReturn(pVnodeData, EINVAL);
mp = vnode_mount(vnode); AssertReturn(mp, EINVAL);
pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp); AssertReturn(pMount, EINVAL);
lck_rw_lock_exclusive(pVnodeData->pLock);
if (vnode_isinuse(vnode, 0))
{
PDEBUG("vnode '%s' (handle 0x%X) is still in use, just return ok",
(char *)pVnodeData->pPath->String.utf8,
(int)pVnodeData->pHandle);
lck_rw_unlock_exclusive(pVnodeData->pLock);
return 0;
}
/* At this point we must make sure that vnode has VBoxVFS object handle assigned */
if (pVnodeData->pHandle == SHFL_HANDLE_NIL)
{
PDEBUG("vnode has no active VBoxVFS object handle set, aborting");
lck_rw_unlock_exclusive(pVnodeData->pLock);
return EINVAL;
}
rc = vboxvfs_close_internal(pMount, pVnodeData->pHandle);
if (rc == 0)
{
PDEBUG("Close success: '%s' (handle 0x%X)",
(char *)pVnodeData->pPath->String.utf8,
(int)pVnodeData->pHandle);
/* Forget about previously assigned VBoxVFS object handle */
pVnodeData->pHandle = SHFL_HANDLE_NIL;
}
else
{
PDEBUG("Unable to close: '%s' (handle 0x%X): %d",
(char *)pVnodeData->pPath->String.utf8,
(int)pVnodeData->pHandle, rc);
}
lck_rw_unlock_exclusive(pVnodeData->pLock);
return rc;
}
static int
gfs_dir_lookup_dynamic(gfs_lookup_cb callback, gfs_dir_t *dp,
const char *nm, struct vnode *dvp, struct vnode **vpp, cred_t *cr, int flags,
int *direntflags, pathname_t *realpnp)
{
gfs_file_t *fp;
ino64_t ino;
int ret;
ASSERT(GFS_DIR_LOCKED(dp));
/*
* Drop the directory lock, as the lookup routine
* will need to allocate memory, or otherwise deadlock on this
* directory.
*/
gfs_dir_unlock(dp);
ret = callback(dvp, nm, vpp, &ino, cr, flags, direntflags, realpnp);
gfs_dir_lock(dp);
/*
* The callback for extended attributes returns a vnode
* with v_data from an underlying fs.
*/
if (ret == 0 /*&& !IS_XATTRDIR(dvp)*/) {
fp = (gfs_file_t *)((vnode_fsnode(*vpp)));
fp->gfs_index = -1;
fp->gfs_ino = ino;
}
return (ret);
}
/*
* gfs_dir_readdir: does a readdir() on the given directory
*
* dvp - directory vnode
* uiop - uio structure
* eofp - eof pointer
* data - arbitrary data passed to readdir callback
*
* This routine does all the readdir() dirty work. Even so, the caller must
* supply two callbacks in order to get full compatibility.
*
* If the directory contains static entries, an inode callback must be
* specified. This avoids having to create every vnode and call VOP_GETATTR()
* when reading the directory. This function has the following arguments:
*
* ino_t gfs_inode_cb(struct vnode *vp, int index);
*
* vp - vnode for the directory
* index - index in original gfs_dirent_t array
*
* Returns the inode number for the given entry.
*
* For directories with dynamic entries, a readdir callback must be provided.
* This is significantly more complex, thanks to the particulars of
* VOP_READDIR().
*
* int gfs_readdir_cb(struct vnode *vp, void *dp, int *eofp,
* offset_t *off, offset_t *nextoff, void *data, int flags)
*
* vp - directory vnode
* dp - directory entry, sized according to maxlen given to
* gfs_dir_create(). callback must fill in d_name and
* d_ino (if a dirent64_t), or ed_name, ed_ino, and ed_eflags
* (if an edirent_t). edirent_t is used if V_RDDIR_ENTFLAGS
* is set in 'flags'.
* eofp - callback must set to 1 when EOF has been reached
* off - on entry, the last offset read from the directory. Callback
* must set to the offset of the current entry, typically left
* untouched.
* nextoff - callback must set to offset of next entry. Typically
* (off + 1)
* data - caller-supplied data
* flags - VOP_READDIR flags
*
* Return 0 on success, or error on failure.
*/
int
gfs_dir_readdir(struct vnode *dvp, uio_t *uiop, int *eofp, int *ncookies,
u_long **cookies, void *data, cred_t *cr, int flags)
{
gfs_readdir_state_t gstate;
int error, eof = 0;
ino64_t ino, pino;
offset_t off, next;
gfs_dir_t *dp = vnode_fsnode(dvp);
error = gfs_get_parent_ino(dvp, cr, NULL, &pino, &ino);
if (error)
return (error);
if ((error = gfs_readdir_init(&gstate, dp->gfsd_maxlen, 1, uiop,
pino, ino, flags)) != 0)
return (error);
while ((error = gfs_readdir_pred(&gstate, uiop, &off, ncookies,
cookies)) == 0 && !eof) {
if (off >= 0 && off < dp->gfsd_nstatic) {
ino = dp->gfsd_inode(dvp, off);
if ((error = gfs_readdir_emit(&gstate, uiop,
off, ino, dp->gfsd_static[off].gfse_name, 0,
ncookies, cookies)) != 0)
break;
} else if (dp->gfsd_readdir) {
off -= dp->gfsd_nstatic;
if ((error = dp->gfsd_readdir(dvp,
gstate.grd_dirent, &eof, &off, &next,
data, flags)) != 0 || eof)
break;
off += dp->gfsd_nstatic + 2;
next += dp->gfsd_nstatic + 2;
if ((error = gfs_readdir_emit_int(&gstate, uiop,
next, ncookies, cookies)) != 0)
break;
} else {
/*
* Offset is beyond the end of the static entries, and
* we have no dynamic entries. Set EOF.
*/
eof = 1;
}
}
return (gfs_readdir_fini(&gstate, error, eofp, eof));
}
/*
* gfs_root_create_file(): create a root vnode for a GFS file as a filesystem
*
* Similar to gfs_root_create(), this creates a root vnode for a file to
* be the pseudo-filesystem.
*/
struct vnode *
gfs_root_create_file(size_t size, vfs_t *vfsp, vnodeops_t *ops, ino64_t ino)
{
struct vnode *vp = gfs_file_create(size, NULL, ops, VREG);
((gfs_file_t *)vnode_fsnode(vp))->gfs_ino = ino;
VFS_HOLD(vfsp);
VN_SET_VFS_TYPE_DEV(vp, vfsp, VREG, 0);
vp->v_flag |= VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT;
return (vp);
}
/*
* gfs_root_create(): create a root vnode for a GFS filesystem
*
* Similar to gfs_dir_create(), this creates a root vnode for a filesystem. The
* only difference is that it takes a vfs_t instead of a struct vnode as its parent.
*/
struct vnode *
gfs_root_create(size_t size, vfs_t *vfsp, vnodeops_t *ops, ino64_t ino,
gfs_dirent_t *entries, gfs_inode_cb inode_cb, int maxlen,
gfs_readdir_cb readdir_cb, gfs_lookup_cb lookup_cb)
{
struct vnode *vp;
VFS_HOLD(vfsp);
vp = gfs_dir_create(size, NULL, vfsp, ops, entries, inode_cb,
maxlen, readdir_cb, lookup_cb,
ZFS_VNODE_SYSTEM);
/* Manually set the inode */
((gfs_file_t *)vnode_fsnode(vp))->gfs_ino = ino;
dprintf(".zfs created returning %p; ino %d\n", vp, ino);
/*
* Since we created the .zfs node as VSYSTEM, we have to manually
* call vnode_recycle() as done in zfsctl_destroy().
*/
return (vp);
}
/**
* VBoxVFS reclaim callback.
* Called when vnode is going to be deallocated. Should release
* all the VBoxVFS resources that correspond to current vnode object.
*
* @param pArgs Operation arguments passed from VFS layer.
*
* @return 0 on success, BSD error code otherwise.
*/
static int
vboxvfs_vnode_reclaim(struct vnop_reclaim_args *pArgs)
{
PDEBUG("Releasing vnode resources...");
AssertReturn(pArgs, EINVAL);
vnode_t pVnode;
vboxvfs_vnode_t *pVnodeData;
vboxvfs_mount_t *pMount;
mount_t mp;
pVnode = pArgs->a_vp;
AssertReturn(pVnode, EINVAL);
mp = vnode_mount(pVnode);
AssertReturn(mp, EINVAL);
pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp);
AssertReturn(pMount, EINVAL);
pVnodeData = (vboxvfs_vnode_t *)vnode_fsnode(pVnode);
AssertReturn(pVnodeData, EINVAL);
AssertReturn(pVnodeData->pPath, EINVAL);
AssertReturn(pVnodeData->pLockAttr, EINVAL);
AssertReturn(pVnodeData->pLock, EINVAL);
RTMemFree(pVnodeData->pPath);
pVnodeData->pPath = NULL;
lck_rw_free(pVnodeData->pLock, pMount->pLockGroup);
pVnodeData->pLock = NULL;
lck_attr_free(pVnodeData->pLockAttr);
pVnodeData->pLockAttr = NULL;
return 0;
}
/*
* gfs_dir_create: creates a new directory in the parent
*
* size - size of private data structure (v_data)
* pvp - parent vnode (GFS directory)
* ops - vnode operations vector
* entries - NULL-terminated list of static entries (if any)
* maxlen - maximum length of a directory entry
* readdir_cb - readdir callback (see gfs_dir_readdir)
* inode_cb - inode callback (see gfs_dir_readdir)
* lookup_cb - lookup callback (see gfs_dir_lookup)
*
* In order to use this function, the first member of the private vnode
* structure (v_data) must be a gfs_dir_t. For each directory, there are
* static entries, defined when the structure is initialized, and dynamic
* entries, retrieved through callbacks.
*
* If a directory has static entries, then it must supply a inode callback,
* which will compute the inode number based on the parent and the index.
* For a directory with dynamic entries, the caller must supply a readdir
* callback and a lookup callback. If a static lookup fails, we fall back to
* the supplied lookup callback, if any.
*
* This function also performs the same initialization as gfs_file_create().
*/
struct vnode *
gfs_dir_create(size_t struct_size, struct vnode *pvp, vfs_t *vfsp, vnodeops_t *ops,
gfs_dirent_t *entries, gfs_inode_cb inode_cb, int maxlen,
gfs_readdir_cb readdir_cb, gfs_lookup_cb lookup_cb, int flags)
{
struct vnode *vp;
gfs_dir_t *dp;
gfs_dirent_t *de;
dprintf("gfs_dir_create\n");
vp = gfs_file_create(struct_size, pvp, vfsp, ops, VDIR, flags);
//vp->v_type = VDIR; // Can only be set at create FIXME
dp = vnode_fsnode(vp);
dp->gfsd_file.gfs_type = GFS_DIR;
dp->gfsd_maxlen = maxlen;
if (entries != NULL) {
for (de = entries; de->gfse_name != NULL; de++)
dp->gfsd_nstatic++;
dp->gfsd_static = kmem_alloc(
dp->gfsd_nstatic * sizeof (gfs_dirent_t), KM_SLEEP);
bcopy(entries, dp->gfsd_static,
dp->gfsd_nstatic * sizeof (gfs_dirent_t));
}
dp->gfsd_readdir = readdir_cb;
dp->gfsd_lookup = lookup_cb;
dp->gfsd_inode = inode_cb;
mutex_init(&dp->gfsd_lock, NULL, MUTEX_DEFAULT, NULL);
return (vp);
}
static int
vboxvfs_vnode_readdir(struct vnop_readdir_args *args)
{
vboxvfs_mount_t *pMount;
vboxvfs_vnode_t *pVnodeData;
SHFLDIRINFO *Info;
uint32_t cbInfo;
mount_t mp;
vnode_t vnode;
struct uio *uio;
int rc = 0, rc2;
PDEBUG("Reading directory...");
AssertReturn(args, EINVAL);
AssertReturn(args->a_eofflag, EINVAL);
AssertReturn(args->a_numdirent, EINVAL);
uio = args->a_uio; AssertReturn(uio, EINVAL);
vnode = args->a_vp; AssertReturn(vnode, EINVAL); AssertReturn(vnode_isdir(vnode), EINVAL);
pVnodeData = (vboxvfs_vnode_t *)vnode_fsnode(vnode); AssertReturn(pVnodeData, EINVAL);
mp = vnode_mount(vnode); AssertReturn(mp, EINVAL);
pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp); AssertReturn(pMount, EINVAL);
lck_rw_lock_shared(pVnodeData->pLock);
cbInfo = sizeof(Info) + MAXPATHLEN;
Info = (SHFLDIRINFO *)RTMemAllocZ(cbInfo);
if (!Info)
{
PDEBUG("No memory to allocate internal data");
lck_rw_unlock_shared(pVnodeData->pLock);
return ENOMEM;
}
uint32_t index = (uint32_t)uio_offset(uio) / (uint32_t)sizeof(struct dirent);
uint32_t cFiles = 0;
PDEBUG("Exploring VBoxVFS directory (%s), handle (0x%.8X), offset (0x%X), count (%d)", (char *)pVnodeData->pPath->String.utf8, (int)pVnodeData->pHandle, index, uio_iovcnt(uio));
/* Currently, there is a problem when VbglR0SfDirInfo() is not able to
* continue retrieve directory content if the same VBoxVFS handle is used.
* This macro forces to use a new handle in readdir() callback. If enabled,
* the original handle (obtained in open() callback is ignored). */
SHFLHANDLE Handle;
rc = vboxvfs_open_internal(pMount,
pVnodeData->pPath,
SHFL_CF_DIRECTORY | SHFL_CF_ACCESS_READ | SHFL_CF_ACT_OPEN_IF_EXISTS | SHFL_CF_ACT_FAIL_IF_NEW,
&Handle);
if (rc != 0)
{
PDEBUG("Unable to open dir: %d", rc);
RTMemFree(Info);
lck_rw_unlock_shared(pVnodeData->pLock);
return rc;
}
#if 0
rc = VbglR0SfDirInfo(&g_vboxSFClient, &pMount->pMap, Handle, 0, 0, index, &cbInfo, (PSHFLDIRINFO)Info, &cFiles);
#else
SHFLSTRING *pMask = vboxvfs_construct_shflstring("*", strlen("*"));
if (pMask)
{
for (uint32_t cSkip = 0; (cSkip < index + 1) && (rc == VINF_SUCCESS); cSkip++)
{
//rc = VbglR0SfDirInfo(&g_vboxSFClient, &pMount->pMap, Handle, 0 /* pMask */, 0 /* SHFL_LIST_RETURN_ONE */, 0, &cbInfo, (PSHFLDIRINFO)Info, &cFiles);
uint32_t cbReturned = cbInfo;
//rc = VbglR0SfDirInfo(&g_vboxSFClient, &pMount->pMap, Handle, pMask, SHFL_LIST_RETURN_ONE, 0, &cbReturned, (PSHFLDIRINFO)Info, &cFiles);
rc = VbglR0SfDirInfo(&g_vboxSFClient, &pMount->pMap, Handle, 0, SHFL_LIST_RETURN_ONE, 0,
&cbReturned, (PSHFLDIRINFO)Info, &cFiles);
}
PDEBUG("read %d files", cFiles);
RTMemFree(pMask);
}
else
{
PDEBUG("Can't alloc mask");
rc = ENOMEM;
}
#endif
rc2 = vboxvfs_close_internal(pMount, Handle);
if (rc2 != 0)
{
PDEBUG("Unable to close directory: %s: %d",
pVnodeData->pPath->String.utf8,
rc2);
}
switch (rc)
{
case VINF_SUCCESS:
{
rc = vboxvfs_vnode_readdir_copy_data((ino_t)(index + 1), Info, uio, args->a_numdirent);
break;
}
case VERR_NO_MORE_FILES:
{
PDEBUG("No more entries in directory");
*(args->a_eofflag) = 1;
break;
}
default:
{
PDEBUG("VbglR0SfDirInfo() for item #%d has failed: %d", (int)index, (int)rc);
rc = EINVAL;
break;
}
}
RTMemFree(Info);
lck_rw_unlock_shared(pVnodeData->pLock);
return rc;
}
static int
vboxvfs_vnode_getattr(struct vnop_getattr_args *args)
{
vboxvfs_mount_t *pMount;
struct vnode_attr *vnode_args;
vboxvfs_vnode_t *pVnodeData;
struct timespec timespec;
SHFLFSOBJINFO Info;
mount_t mp;
vnode_t vnode;
int rc;
PDEBUG("Getting vnode attribute...");
AssertReturn(args, EINVAL);
vnode = args->a_vp; AssertReturn(vnode, EINVAL);
vnode_args = args->a_vap; AssertReturn(vnode_args, EINVAL);
mp = vnode_mount(vnode); AssertReturn(mp, EINVAL);
pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp); AssertReturn(pMount, EINVAL);
pVnodeData = (vboxvfs_vnode_t *)vnode_fsnode(vnode); AssertReturn(pVnodeData, EINVAL);
lck_rw_lock_shared(pVnodeData->pLock);
rc = vboxvfs_get_info_internal(mp, pVnodeData->pPath, &Info);
if (rc == 0)
{
/* Set timestamps */
RTTimeSpecGetTimespec(&Info.BirthTime, ×pec); VATTR_RETURN(vnode_args, va_create_time, timespec);
RTTimeSpecGetTimespec(&Info.AccessTime, ×pec); VATTR_RETURN(vnode_args, va_access_time, timespec);
RTTimeSpecGetTimespec(&Info.ModificationTime, ×pec); VATTR_RETURN(vnode_args, va_modify_time, timespec);
RTTimeSpecGetTimespec(&Info.ChangeTime, ×pec); VATTR_RETURN(vnode_args, va_change_time, timespec);
VATTR_CLEAR_ACTIVE(vnode_args, va_backup_time);
/* Set owner info. */
VATTR_RETURN(vnode_args, va_uid, pMount->owner);
VATTR_CLEAR_ACTIVE(vnode_args, va_gid);
/* Access mode and flags */
VATTR_RETURN(vnode_args, va_mode, vboxvfs_h2g_mode_inernal(Info.Attr.fMode));
VATTR_RETURN(vnode_args, va_flags, Info.Attr.u.Unix.fFlags);
/* The current generation number (0 if this information is not available) */
VATTR_RETURN(vnode_args, va_gen, Info.Attr.u.Unix.GenerationId);
VATTR_RETURN(vnode_args, va_rdev, 0);
VATTR_RETURN(vnode_args, va_nlink, 2);
VATTR_RETURN(vnode_args, va_data_size, sizeof(struct dirent)); /* Size of data returned per each readdir() request */
/* Hope, when it overflows nothing catastrophical will heppen! If we will not assign
* a uniq va_fileid to each vnode, `ls`, 'find' (and simmilar tools that uses fts_read() calls) will think that
* each sub-directory is self-cycled. */
VATTR_RETURN(vnode_args, va_fileid, (pMount->cFileIdCounter++));
/* Not supported */
VATTR_CLEAR_ACTIVE(vnode_args, va_linkid);
VATTR_CLEAR_ACTIVE(vnode_args, va_parentid);
VATTR_CLEAR_ACTIVE(vnode_args, va_fsid);
VATTR_CLEAR_ACTIVE(vnode_args, va_filerev);
/* Not present on 10.6 */
//VATTR_CLEAR_ACTIVE(vnode_args, va_addedtime);
/* todo: take care about va_encoding (file name encoding) */
VATTR_CLEAR_ACTIVE(vnode_args, va_encoding);
/* todo: take care about: va_acl */
VATTR_CLEAR_ACTIVE(vnode_args, va_acl);
VATTR_CLEAR_ACTIVE(vnode_args, va_name);
VATTR_CLEAR_ACTIVE(vnode_args, va_uuuid);
VATTR_CLEAR_ACTIVE(vnode_args, va_guuid);
VATTR_CLEAR_ACTIVE(vnode_args, va_total_size);
VATTR_CLEAR_ACTIVE(vnode_args, va_total_alloc);
VATTR_CLEAR_ACTIVE(vnode_args, va_data_alloc);
VATTR_CLEAR_ACTIVE(vnode_args, va_iosize);
VATTR_CLEAR_ACTIVE(vnode_args, va_nchildren);
VATTR_CLEAR_ACTIVE(vnode_args, va_dirlinkcount);
}
else
{
PDEBUG("getattr: unable to get VBoxVFS object info");
}
lck_rw_unlock_shared(pVnodeData->pLock);
return rc;
}
static int
vboxvfs_vnode_open(struct vnop_open_args *args)
{
vnode_t vnode;
vboxvfs_vnode_t *pVnodeData;
uint32_t fHostFlags;
mount_t mp;
vboxvfs_mount_t *pMount;
int rc;
PDEBUG("Opening vnode...");
AssertReturn(args, EINVAL);
vnode = args->a_vp; AssertReturn(vnode, EINVAL);
pVnodeData = (vboxvfs_vnode_t *)vnode_fsnode(vnode); AssertReturn(pVnodeData, EINVAL);
mp = vnode_mount(vnode); AssertReturn(mp, EINVAL);
pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp); AssertReturn(pMount, EINVAL);
lck_rw_lock_exclusive(pVnodeData->pLock);
if (vnode_isinuse(vnode, 0))
{
PDEBUG("vnode '%s' (handle 0x%X) already has VBoxVFS object handle assigned, just return ok",
(char *)pVnodeData->pPath->String.utf8,
(int)pVnodeData->pHandle);
lck_rw_unlock_exclusive(pVnodeData->pLock);
return 0;
}
/* At this point we must make sure that nobody is using VBoxVFS object handle */
//if (pVnodeData->Handle != SHFL_HANDLE_NIL)
//{
// PDEBUG("vnode has active VBoxVFS object handle set, aborting");
// lck_rw_unlock_exclusive(pVnodeData->pLock);
// return EINVAL;
//}
fHostFlags = vboxvfs_g2h_mode_inernal(args->a_mode);
fHostFlags |= (vnode_isdir(vnode) ? SHFL_CF_DIRECTORY : 0);
SHFLHANDLE Handle;
rc = vboxvfs_open_internal(pMount, pVnodeData->pPath, fHostFlags, &Handle);
if (rc == 0)
{
PDEBUG("Open success: '%s' (handle 0x%X)",
(char *)pVnodeData->pPath->String.utf8,
(int)Handle);
pVnodeData->pHandle = Handle;
}
else
{
PDEBUG("Unable to open: '%s': %d",
(char *)pVnodeData->pPath->String.utf8,
rc);
}
lck_rw_unlock_exclusive(pVnodeData->pLock);
return rc;
}
static int
vboxvfs_vnode_lookup(struct vnop_lookup_args *args)
{
int rc;
vnode_t vnode;
vboxvfs_vnode_t *pVnodeData;
PDEBUG("Looking up for vnode...");
AssertReturn(args, EINVAL);
AssertReturn(args->a_dvp, EINVAL);
AssertReturn(vnode_isdir(args->a_dvp), EINVAL);
AssertReturn(args->a_cnp, EINVAL);
AssertReturn(args->a_cnp->cn_nameptr, EINVAL);
AssertReturn(args->a_vpp, EINVAL);
pVnodeData = (vboxvfs_vnode_t *)vnode_fsnode(args->a_dvp);
AssertReturn(pVnodeData, EINVAL);
AssertReturn(pVnodeData->pLock, EINVAL);
/*
todo: take care about args->a_cnp->cn_nameiop
*/
if (args->a_cnp->cn_nameiop == LOOKUP) PDEBUG("LOOKUP");
else if (args->a_cnp->cn_nameiop == CREATE) PDEBUG("CREATE");
else if (args->a_cnp->cn_nameiop == RENAME) PDEBUG("RENAME");
else if (args->a_cnp->cn_nameiop == DELETE) PDEBUG("DELETE");
else PDEBUG("Unknown cn_nameiop: 0x%X", (int)args->a_cnp->cn_nameiop);
lck_rw_lock_exclusive(pVnodeData->pLock);
/* Take care about '.' and '..' entries */
if (vboxvfs_vnode_lookup_dot_handler(args, &vnode) == 0)
{
vnode_get(vnode);
*args->a_vpp = vnode;
lck_rw_unlock_exclusive(pVnodeData->pLock);
return 0;
}
/* Look into VFS cache and attempt to find previously allocated vnode there. */
rc = cache_lookup(args->a_dvp, &vnode, args->a_cnp);
if (rc == -1) /* Record found */
{
PDEBUG("Found record in VFS cache");
/* Check if VFS object still exist on a host side */
if (vboxvfs_exist_internal(vnode))
{
/* Prepare & return cached vnode */
vnode_get(vnode);
*args->a_vpp = vnode;
rc = 0;
}
else
{
/* If vnode exist in guets VFS cache, but not exist on a host -- just forget it. */
cache_purge(vnode);
/* todo: free vnode data here */
rc = ENOENT;
}
}
else
{
PDEBUG("cache_lookup() returned %d, create new VFS vnode", rc);
rc = vboxvfs_vnode_lookup_instantinate_vnode(args->a_dvp, args->a_cnp->cn_nameptr, &vnode);
if (rc == 0)
{
cache_enter(args->a_dvp, vnode, args->a_cnp);
*args->a_vpp = vnode;
}
else
{
rc = ENOENT;
}
}
lck_rw_unlock_exclusive(pVnodeData->pLock);
return rc;
}
/*
* gfs_dir_lookup()
*
* Looks up the given name in the directory and returns the corresponding
* vnode, if found.
*
* First, we search statically defined entries, if any, with a call to
* gfs_dir_lookup_static(). If no static entry is found, and we have
* a callback function we try a dynamic lookup via gfs_dir_lookup_dynamic().
*
* This function returns 0 on success, non-zero on error.
*/
int
gfs_dir_lookup(struct vnode *dvp, const char *nm, struct vnode **vpp, cred_t *cr,
int flags, int *direntflags, pathname_t *realpnp)
{
gfs_dir_t *dp = vnode_fsnode(dvp);
boolean_t casecheck;
struct vnode *dynvp = NULL;
struct vnode *vp = NULL;
int (*compare)(const char *, const char *);
int error, idx;
dprintf("gfs_dir_lookup\n");
ASSERT(dvp->v_type == VDIR);
if (gfs_lookup_dot(vpp, dvp, dp->gfsd_file.gfs_parent, nm) == 0)
return (0);
casecheck = (flags & FIGNORECASE) != 0 && direntflags != NULL;
#if 1 //FIXME
if (/*vfs_has_feature(vnode_mount(dvp), VFSFT_NOCASESENSITIVE) ||*/
(flags & FIGNORECASE))
compare = strcasecmp;
else
#endif
compare = strcmp;
gfs_dir_lock(dp);
error = gfs_dir_lookup_static(compare, dp, nm, dvp, &idx, &vp, realpnp);
if (vp && casecheck) {
gfs_dirent_t *ge;
int i;
for (i = idx + 1; i < dp->gfsd_nstatic; i++) {
ge = &dp->gfsd_static[i];
if (strcasecmp(ge->gfse_name, nm) == 0) {
*direntflags |= ED_CASE_CONFLICT;
goto out;
}
}
}
#if 0
if ((error || casecheck) && dp->gfsd_lookup)
error = gfs_dir_lookup_dynamic(dp->gfsd_lookup, dp, nm, dvp,
&dynvp, cr, flags, direntflags, vp ? NULL : realpnp);
#endif
if (vp && dynvp) {
/* static and dynamic entries are case-insensitive conflict */
ASSERT(casecheck);
*direntflags |= ED_CASE_CONFLICT;
VN_RELE(dynvp);
} else if (vp == NULL) {
vp = dynvp;
} else if (error == ENOENT) {
error = 0;
} else if (error) {
VN_RELE(vp);
vp = NULL;
}
out:
gfs_dir_unlock(dp);
*vpp = vp;
return (error);
}
/*
* gfs_dir_lookup_static()
*
* This routine looks up the provided name amongst the static entries
* in the gfs directory and returns the corresponding vnode, if found.
* The first argument to the function is a pointer to the comparison
* function this function should use to decide if names are a match.
*
* If a match is found, and GFS_CACHE_VNODE is set and the vnode
* exists, we simply return the existing vnode. Otherwise, we call
* the static entry's callback routine, caching the result if
* necessary. If the idx pointer argument is non-NULL, we use it to
* return the index of the matching static entry.
*
* The gfs directory is expected to be locked by the caller prior to calling
* this function. The directory may be unlocked during the execution of
* this function, but will be locked upon return from the function.
*
* This function returns 0 if a match is found, ENOENT if not.
*/
static int
gfs_dir_lookup_static(int (*compare)(const char *, const char *),
gfs_dir_t *dp, const char *nm, struct vnode *dvp, int *idx,
struct vnode **vpp, pathname_t *rpnp)
{
gfs_dirent_t *ge;
struct vnode *vp = NULL;
int i;
ASSERT(GFS_DIR_LOCKED(dp));
/*
* Search static entries.
*/
for (i = 0; i < dp->gfsd_nstatic; i++) {
ge = &dp->gfsd_static[i];
if (compare(ge->gfse_name, nm) == 0) {
if (rpnp)
(void) strlcpy(rpnp->pn_buf, ge->gfse_name,
rpnp->pn_bufsize);
if (ge->gfse_vnode) {
ASSERT(ge->gfse_flags & GFS_CACHE_VNODE);
vp = ge->gfse_vnode;
VN_HOLD(vp);
break;
}
/*
* We drop the directory lock, as the constructor will
* need to do KM_SLEEP allocations. If we return from
* the constructor only to find that a parallel
* operation has completed, and GFS_CACHE_VNODE is set
* for this entry, we discard the result in favor of
* the cached vnode.
*/
dprintf("lookup_static\n");
gfs_dir_unlock(dp);
vp = ge->gfse_ctor(dvp);
gfs_dir_lock(dp);
((gfs_file_t *)vnode_fsnode(vp))->gfs_index = i;
/* Set the inode according to the callback. */
((gfs_file_t *)vnode_fsnode(vp))->gfs_ino =
dp->gfsd_inode(dvp, i);
if (ge->gfse_flags & GFS_CACHE_VNODE) {
if (ge->gfse_vnode == NULL) {
ge->gfse_vnode = vp;
} else {
/*
* A parallel constructor beat us to it;
* return existing vnode. We have to be
* careful because we can't release the
* current vnode while holding the
* directory lock; its inactive routine
* will try to lock this directory.
*/
struct vnode *oldvp = vp;
vp = ge->gfse_vnode;
VN_HOLD(vp);
gfs_dir_unlock(dp);
VN_RELE(oldvp);
gfs_dir_lock(dp);
}
}
break;
}
}
if (vp == NULL)
return (ENOENT);
else if (idx)
*idx = i;
*vpp = vp;
return (0);
}
/*
* gfs_file_inactive()
*
* Called from the VOP_INACTIVE() routine. If necessary, this routine will
* remove the given vnode from the parent directory and clean up any references
* in the VFS layer.
*
* If the vnode was not removed (due to a race with vget), then NULL is
* returned. Otherwise, a pointer to the private data is returned.
*/
void *
gfs_file_inactive(struct vnode *vp)
{
int i;
gfs_dirent_t *ge = NULL;
gfs_file_t *fp = vnode_fsnode(vp);
gfs_dir_t *dp = NULL;
void *data;
if (!fp) return NULL;
if (fp->gfs_parent == NULL /*|| (vp->v_flag & V_XATTRDIR)*/)
goto found;
/*
* XXX cope with a FreeBSD-specific race wherein the parent's
* snapshot data can be freed before the parent is
*/
if ((dp = vnode_fsnode(fp->gfs_parent)) == NULL)
return (NULL);
/*
* First, see if this vnode is cached in the parent.
*/
gfs_dir_lock(dp);
/*
* Find it in the set of static entries.
*/
for (i = 0; i < dp->gfsd_nstatic; i++) {
ge = &dp->gfsd_static[i];
if (ge->gfse_vnode == vp)
goto found;
}
/*
* If 'ge' is NULL, then it is a dynamic entry.
*/
ge = NULL;
found:
#ifdef TODO
if (vp->v_flag & V_XATTRDIR)
VI_LOCK(fp->gfs_parent);
#endif
VN_HOLD(vp);
/*
* Really remove this vnode
*/
data = vnode_fsnode(vp);
if (ge != NULL) {
/*
* If this was a statically cached entry, simply set the
* cached vnode to NULL.
*/
ge->gfse_vnode = NULL;
}
VN_RELE(vp);
/*
* Free vnode and release parent
*/
dprintf("freeing vp %p and parent %p\n", vp, fp->gfs_parent);
if (fp->gfs_parent) {
if (dp)
gfs_dir_unlock(dp);
//VOP_UNLOCK(vp, 0);
VN_RELE(fp->gfs_parent);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
} else {
ASSERT(vp->v_vfsp != NULL);
VFS_RELE(vp->v_vfsp);
}
#ifdef TODO
if (vp->v_flag & V_XATTRDIR)
VI_UNLOCK(fp->gfs_parent);
#endif
return (data);
}
