/* ARGSUSED */
static int
zfsctl_shares_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp,
int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
int *direntflags, pathname_t *realpnp)
{
zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data;
znode_t *dzp;
int error;
ZFS_ENTER(zfsvfs);
if (gfs_lookup_dot(vpp, dvp, zfsvfs->z_ctldir, nm) == 0) {
ZFS_EXIT(zfsvfs);
return (0);
}
if (zfsvfs->z_shares_dir == 0) {
ZFS_EXIT(zfsvfs);
return (ENOTSUP);
}
if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0)
error = VOP_LOOKUP(ZTOV(dzp), nm, vpp, pnp,
flags, rdir, cr, ct, direntflags, realpnp);
VN_RELE(ZTOV(dzp));
ZFS_EXIT(zfsvfs);
return (error);
}
/* ARGSUSED */
static int
zfsctl_snapdir_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp,
int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
int *direntflags, pathname_t *realpnp)
{
zfsctl_snapdir_t *sdp = dvp->v_data;
objset_t *snap;
char snapname[MAXNAMELEN];
char real[MAXNAMELEN];
char *mountpoint;
zfs_snapentry_t *sep, search;
struct mounta margs;
vfs_t *vfsp;
size_t mountpoint_len;
avl_index_t where;
zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data;
int err;
/*
* No extended attributes allowed under .zfs
*/
if (flags & LOOKUP_XATTR)
return (EINVAL);
ASSERT(dvp->v_type == VDIR);
/*
* If we get a recursive call, that means we got called
* from the domount() code while it was trying to look up the
* spec (which looks like a local path for zfs). We need to
* add some flag to domount() to tell it not to do this lookup.
*/
if (MUTEX_HELD(&sdp->sd_lock))
return (ENOENT);
ZFS_ENTER(zfsvfs);
if (gfs_lookup_dot(vpp, dvp, zfsvfs->z_ctldir, nm) == 0) {
ZFS_EXIT(zfsvfs);
return (0);
}
if (flags & FIGNORECASE) {
boolean_t conflict = B_FALSE;
err = dmu_snapshot_realname(zfsvfs->z_os, nm, real,
MAXNAMELEN, &conflict);
if (err == 0) {
nm = real;
} else if (err != ENOTSUP) {
ZFS_EXIT(zfsvfs);
return (err);
}
if (realpnp)
(void) strlcpy(realpnp->pn_buf, nm,
realpnp->pn_bufsize);
if (conflict && direntflags)
*direntflags = ED_CASE_CONFLICT;
}
mutex_enter(&sdp->sd_lock);
search.se_name = (char *)nm;
if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) != NULL) {
*vpp = sep->se_root;
VN_HOLD(*vpp);
err = traverse(vpp);
if (err) {
VN_RELE(*vpp);
*vpp = NULL;
} else if (*vpp == sep->se_root) {
/*
* The snapshot was unmounted behind our backs,
* try to remount it.
*/
goto domount;
} else {
/*
* VROOT was set during the traverse call. We need
* to clear it since we're pretending to be part
* of our parent's vfs.
*/
(*vpp)->v_flag &= ~VROOT;
}
mutex_exit(&sdp->sd_lock);
ZFS_EXIT(zfsvfs);
return (err);
}
/*
* The requested snapshot is not currently mounted, look it up.
*/
err = zfsctl_snapshot_zname(dvp, nm, MAXNAMELEN, snapname);
if (err) {
mutex_exit(&sdp->sd_lock);
ZFS_EXIT(zfsvfs);
/*
* handle "ls *" or "?" in a graceful manner,
* forcing EILSEQ to ENOENT.
* Since shell ultimately passes "*" or "?" as name to lookup
*/
return (err == EILSEQ ? ENOENT : err);
}
if (dmu_objset_hold(snapname, FTAG, &snap) != 0) {
mutex_exit(&sdp->sd_lock);
ZFS_EXIT(zfsvfs);
return (ENOENT);
}
sep = kmem_alloc(sizeof (zfs_snapentry_t), KM_SLEEP);
sep->se_name = kmem_alloc(strlen(nm) + 1, KM_SLEEP);
(void) strcpy(sep->se_name, nm);
*vpp = sep->se_root = zfsctl_snapshot_mknode(dvp, dmu_objset_id(snap));
avl_insert(&sdp->sd_snaps, sep, where);
dmu_objset_rele(snap, FTAG);
domount:
mountpoint_len = strlen(refstr_value(dvp->v_vfsp->vfs_mntpt)) +
strlen("/.zfs/snapshot/") + strlen(nm) + 1;
mountpoint = kmem_alloc(mountpoint_len, KM_SLEEP);
(void) snprintf(mountpoint, mountpoint_len, "%s/.zfs/snapshot/%s",
refstr_value(dvp->v_vfsp->vfs_mntpt), nm);
margs.spec = snapname;
margs.dir = mountpoint;
margs.flags = MS_SYSSPACE | MS_NOMNTTAB;
margs.fstype = "zfs";
margs.dataptr = NULL;
margs.datalen = 0;
margs.optptr = NULL;
margs.optlen = 0;
err = domount("zfs", &margs, *vpp, kcred, &vfsp);
kmem_free(mountpoint, mountpoint_len);
if (err == 0) {
/*
* Return the mounted root rather than the covered mount point.
* Takes the GFS vnode at .zfs/snapshot/<snapname> and returns
* the ZFS vnode mounted on top of the GFS node. This ZFS
* vnode is the root of the newly created vfsp.
*/
VFS_RELE(vfsp);
err = traverse(vpp);
}
if (err == 0) {
/*
* Fix up the root vnode mounted on .zfs/snapshot/<snapname>.
*
* This is where we lie about our v_vfsp in order to
* make .zfs/snapshot/<snapname> accessible over NFS
* without requiring manual mounts of <snapname>.
*/
ASSERT(VTOZ(*vpp)->z_zfsvfs != zfsvfs);
VTOZ(*vpp)->z_zfsvfs->z_parent = zfsvfs;
(*vpp)->v_vfsp = zfsvfs->z_vfs;
(*vpp)->v_flag &= ~VROOT;
}
mutex_exit(&sdp->sd_lock);
ZFS_EXIT(zfsvfs);
/*
* If we had an error, drop our hold on the vnode and
* zfsctl_snapshot_inactive() will clean up.
*/
if (err) {
VN_RELE(*vpp);
*vpp = NULL;
}
return (err);
}
/*
* 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);
}
