/* get lvp's parent, if possible, even if it isn't set.
lvp is expected to have an iocount before and after this call.
if a dvpp is populated the returned vnode has an iocount. */
static int
null_get_lowerparent(vnode_t lvp, vnode_t * dvpp, vfs_context_t ctx)
{
int error = 0;
struct vnode_attr va;
mount_t mp = vnode_mount(lvp);
vnode_t dvp = vnode_parent(lvp);
if (dvp) {
error = vnode_get(dvp);
goto end;
}
error = ENOENT;
if (!(mp->mnt_kern_flag & MNTK_PATH_FROM_ID)) {
goto end;
}
VATTR_INIT(&va);
VATTR_WANTED(&va, va_parentid);
error = vnode_getattr(lvp, &va, ctx);
if (error || !VATTR_IS_SUPPORTED(&va, va_parentid)) {
goto end;
}
error = VFS_VGET(mp, (ino64_t)va.va_parentid, &dvp, ctx);
end:
if (error == 0) {
*dvpp = dvp;
}
return error;
}
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;
}
/*
* Comes in iocount on ni_vp. May overwrite ni_dvp, but doesn't interpret incoming value.
*/
int
lookup_handle_emptyname(struct nameidata *ndp, struct componentname *cnp, int wantparent)
{
vnode_t dp;
int error = 0;
dp = ndp->ni_vp;
cnp->cn_namelen = 0;
/*
* A degenerate name (e.g. / or "") which is a way of
* talking about a directory, e.g. like "/." or ".".
*/
if (dp->v_type != VDIR) {
error = ENOTDIR;
goto out;
}
if (cnp->cn_nameiop != LOOKUP) {
error = EISDIR;
goto out;
}
if (wantparent) {
/*
* note that we already hold a reference
* on dp, but for some reason can't
* get another one... in this case we
* need to do vnode_put on dp in 'bad'
*/
if ( (vnode_get(dp)) ) {
error = ENOENT;
goto out;
}
ndp->ni_dvp = dp;
}
cnp->cn_flags &= ~ISDOTDOT;
cnp->cn_flags |= ISLASTCN;
ndp->ni_next = cnp->cn_nameptr;
ndp->ni_vp = dp;
if (cnp->cn_flags & AUDITVNPATH1)
AUDIT_ARG(vnpath, dp, ARG_VNODE1);
else if (cnp->cn_flags & AUDITVNPATH2)
AUDIT_ARG(vnpath, dp, ARG_VNODE2);
if (cnp->cn_flags & SAVESTART)
panic("lookup: SAVESTART");
return 0;
out:
return error;
}
int do_readvnode (uufsd_t *ufs, const char *path, ino_t *ino, struct ufs_vnode **vnode)
{
int rc;
rc = ufs_namei(ufs, ROOTINO, ROOTINO, path, ino);
if (rc || !*ino) {
debugf("ufs_namei(ufs, ROOTINO, ROOTINO, %s, ino); failed", path);
return -ENOENT;
}
*vnode = vnode_get(ufs, *ino);
if (*vnode==NULL) {
debugf("vnode_get(ufs, *ino); failed");
return -EIO;
}
return 0;
}
static int
vfs_root_9p(mount_t mp, vnode_t *vpp, vfs_context_t ctx)
{
#pragma unused(ctx)
vnode_t vp;
int e;
TRACE();
vp = MTO9P(mp)->root;
*vpp = NULL;
if ((e = vnode_get(vp)))
return e;
*vpp = vp;
return 0;
}
static int
nullfs_root(struct mount * mp, struct vnode ** vpp, __unused vfs_context_t ctx)
{
struct vnode * vp;
int error;
NULLFSDEBUG("nullfs_root(mp = %p, vp = %p)\n", (void *)mp, (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
/*
* Return locked reference to root.
*/
vp = MOUNTTONULLMOUNT(mp)->nullm_rootvp;
error = vnode_get(vp);
if (error)
return error;
*vpp = vp;
return 0;
}
static int
vfs_vget_9p(struct mount *mp, ino64_t ino, vnode_t *vpp, vfs_context_t ctx)
{
vnode_t vp;
qid_9p qid;
int e;
TRACE();
qid.path = ITOP(ino);
qid.type = ITOT(ino);
*vpp = NULL;
if ((e=nget_9p(MTO9P(mp), NOFID, qid, NULL, &vp, NULL, ctx)))
return e;
nunlock_9p(NTO9P(vp));
if ((e=vnode_get(vp)))
return e;
*vpp = vp;
return 0;
}
/*
* iocounts in:
* --One on ni_vp. One on ni_dvp if there is more path, or we didn't come through the
* cache, or we came through the cache and the caller doesn't want the parent.
*
* iocounts out:
* --Leaves us in the correct state for the next step, whatever that might be.
* --If we find a symlink, returns with iocounts on both ni_vp and ni_dvp.
* --If we are to look up another component, then we have an iocount on ni_vp and
* nothing else.
* --If we are done, returns an iocount on ni_vp, and possibly on ni_dvp depending on nameidata flags.
* --In the event of an error, may return with ni_dvp NULL'ed out (in which case, iocount
* was dropped).
*/
int
lookup_handle_found_vnode(struct nameidata *ndp, struct componentname *cnp, int rdonly,
int vbusyflags, int *keep_going, int nc_generation,
int wantparent, int atroot, vfs_context_t ctx)
{
vnode_t dp;
int error;
char *cp;
dp = ndp->ni_vp;
*keep_going = 0;
if (ndp->ni_vp == NULLVP) {
panic("NULL ni_vp in %s\n", __FUNCTION__);
}
if (atroot) {
goto nextname;
}
#if CONFIG_TRIGGERS
if (dp->v_resolve) {
error = vnode_trigger_resolve(dp, ndp, ctx);
if (error) {
goto out;
}
}
#endif /* CONFIG_TRIGGERS */
/*
* Take into account any additional components consumed by
* the underlying filesystem.
*/
if (cnp->cn_consume > 0) {
cnp->cn_nameptr += cnp->cn_consume;
ndp->ni_next += cnp->cn_consume;
ndp->ni_pathlen -= cnp->cn_consume;
cnp->cn_consume = 0;
} else {
lookup_consider_update_cache(ndp->ni_dvp, dp, cnp, nc_generation);
}
/*
* Check to see if the vnode has been mounted on...
* if so find the root of the mounted file system.
* Updates ndp->ni_vp.
*/
error = lookup_traverse_mountpoints(ndp, cnp, dp, vbusyflags, ctx);
dp = ndp->ni_vp;
if (error) {
goto out;
}
#if CONFIG_MACF
if (vfs_flags(vnode_mount(dp)) & MNT_MULTILABEL) {
error = vnode_label(vnode_mount(dp), NULL, dp, NULL, 0, ctx);
if (error)
goto out;
}
#endif
/*
* Check for symbolic link
*/
if ((dp->v_type == VLNK) &&
((cnp->cn_flags & FOLLOW) || (ndp->ni_flag & NAMEI_TRAILINGSLASH) || *ndp->ni_next == '/')) {
cnp->cn_flags |= ISSYMLINK;
*keep_going = 1;
return (0);
}
/*
* Check for bogus trailing slashes.
*/
if ((ndp->ni_flag & NAMEI_TRAILINGSLASH)) {
if (dp->v_type != VDIR) {
error = ENOTDIR;
goto out;
}
ndp->ni_flag &= ~(NAMEI_TRAILINGSLASH);
}
nextname:
/*
* Not a symbolic link. If more pathname,
* continue at next component, else return.
*
* Definitely have a dvp if there's another slash
*/
if (*ndp->ni_next == '/') {
cnp->cn_nameptr = ndp->ni_next + 1;
ndp->ni_pathlen--;
while (*cnp->cn_nameptr == '/') {
cnp->cn_nameptr++;
ndp->ni_pathlen--;
}
cp = cnp->cn_nameptr;
vnode_put(ndp->ni_dvp);
ndp->ni_dvp = NULLVP;
if (*cp == '\0') {
goto emptyname;
}
*keep_going = 1;
return 0;
}
/*
* Disallow directory write attempts on read-only file systems.
*/
if (rdonly &&
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
error = EROFS;
goto out;
}
/* If SAVESTART is set, we should have a dvp */
if (cnp->cn_flags & SAVESTART) {
/*
* note that we already hold a reference
* on both dp and ni_dvp, but for some reason
* can't get another one... in this case we
* need to do vnode_put on dp in 'bad2'
*/
if ( (vnode_get(ndp->ni_dvp)) ) {
error = ENOENT;
goto out;
}
ndp->ni_startdir = ndp->ni_dvp;
}
if (!wantparent && ndp->ni_dvp) {
vnode_put(ndp->ni_dvp);
ndp->ni_dvp = NULLVP;
}
if (cnp->cn_flags & AUDITVNPATH1)
AUDIT_ARG(vnpath, dp, ARG_VNODE1);
else if (cnp->cn_flags & AUDITVNPATH2)
AUDIT_ARG(vnpath, dp, ARG_VNODE2);
#if NAMEDRSRCFORK
/*
* Caller wants the resource fork.
*/
if ((cnp->cn_flags & CN_WANTSRSRCFORK) && (dp != NULLVP)) {
error = lookup_handle_rsrc_fork(dp, ndp, cnp, wantparent, ctx);
if (error != 0)
goto out;
dp = ndp->ni_vp;
}
#endif
if (kdebug_enable)
kdebug_lookup(dp, cnp);
return 0;
emptyname:
error = lookup_handle_emptyname(ndp, cnp, wantparent);
if (error != 0)
goto out;
return 0;
out:
return error;
}
/*
* relookup - lookup a path name component
* Used by lookup to re-aquire things.
*/
int
relookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp)
{
struct vnode *dp = NULL; /* the directory we are searching */
int wantparent; /* 1 => wantparent or lockparent flag */
int rdonly; /* lookup read-only flag bit */
int error = 0;
#ifdef NAMEI_DIAGNOSTIC
int i, newhash; /* DEBUG: check name hash */
char *cp; /* DEBUG: check name ptr/len */
#endif
vfs_context_t ctx = cnp->cn_context;;
/*
* Setup: break out flag bits into variables.
*/
wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT);
rdonly = cnp->cn_flags & RDONLY;
cnp->cn_flags &= ~ISSYMLINK;
if (cnp->cn_flags & NOCACHE)
cnp->cn_flags &= ~MAKEENTRY;
else
cnp->cn_flags |= MAKEENTRY;
dp = dvp;
/*
* Check for degenerate name (e.g. / or "")
* which is a way of talking about a directory,
* e.g. like "/." or ".".
*/
if (cnp->cn_nameptr[0] == '\0') {
if (cnp->cn_nameiop != LOOKUP || wantparent) {
error = EISDIR;
goto bad;
}
if (dp->v_type != VDIR) {
error = ENOTDIR;
goto bad;
}
if ( (vnode_get(dp)) ) {
error = ENOENT;
goto bad;
}
*vpp = dp;
if (cnp->cn_flags & SAVESTART)
panic("lookup: SAVESTART");
return (0);
}
/*
* We now have a segment name to search for, and a directory to search.
*/
if ( (error = VNOP_LOOKUP(dp, vpp, cnp, ctx)) ) {
if (error != EJUSTRETURN)
goto bad;
#if DIAGNOSTIC
if (*vpp != NULL)
panic("leaf should be empty");
#endif
/*
* If creating and at end of pathname, then can consider
* allowing file to be created.
*/
if (rdonly) {
error = EROFS;
goto bad;
}
/*
* We return with ni_vp NULL to indicate that the entry
* doesn't currently exist, leaving a pointer to the
* (possibly locked) directory inode in ndp->ni_dvp.
*/
return (0);
}
dp = *vpp;
#if DIAGNOSTIC
/*
* Check for symbolic link
*/
if (dp->v_type == VLNK && (cnp->cn_flags & FOLLOW))
panic ("relookup: symlink found.\n");
#endif
/*
* Disallow directory write attempts on read-only file systems.
*/
if (rdonly &&
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
error = EROFS;
goto bad2;
}
/* ASSERT(dvp == ndp->ni_startdir) */
return (0);
bad2:
vnode_put(dp);
bad:
*vpp = NULL;
return (error);
}
/*
* Convert a component of a pathname into a pointer to a locked inode.
* This is a very central and rather complicated routine.
* If the file system is not maintained in a strict tree hierarchy,
* this can result in a deadlock situation (see comments in code below).
*
* The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
* whether the name is to be looked up, created, renamed, or deleted.
* When CREATE, RENAME, or DELETE is specified, information usable in
* creating, renaming, or deleting a directory entry may be calculated.
* If flag has LOCKPARENT or'ed into it and the target of the pathname
* exists, lookup returns both the target and its parent directory locked.
* When creating or renaming and LOCKPARENT is specified, the target may
* not be ".". When deleting and LOCKPARENT is specified, the target may
* be "."., but the caller must check to ensure it does an vrele and iput
* instead of two iputs.
*
* Overall outline of ufs_lookup:
*
* check accessibility of directory
* look for name in cache, if found, then if at end of path
* and deleting or creating, drop it, else return name
* search for name in directory, to found or notfound
* notfound:
* if creating, return locked directory, leaving info on available slots
* else return error
* found:
* if at end of path and deleting, return information to allow delete
* if at end of path and rewriting (RENAME and LOCKPARENT), lock target
* inode and return info to allow rewrite
* if not at end, add name to cache; if at end and neither creating
* nor deleting, add name to cache
*
* NOTE: (LOOKUP | LOCKPARENT) currently returns the parent inode unlocked.
*/
int
cd9660_lookup(struct vnop_lookup_args *ap)
{
register struct vnode *vdp; /* vnode for directory being searched */
register struct iso_node *dp; /* inode for directory being searched */
register struct iso_mnt *imp; /* file system that directory is in */
struct buf *bp; /* a buffer of directory entries */
struct iso_directory_record *ep = NULL;/* the current directory entry */
int entryoffsetinblock; /* offset of ep in bp's buffer */
int saveoffset = 0; /* offset of last directory entry in dir */
int numdirpasses; /* strategy for directory search */
doff_t endsearch; /* offset to end directory search */
struct vnode *pdp; /* saved dp during symlink work */
struct vnode *tdp; /* returned by cd9660_vget_internal */
u_long bmask; /* block offset mask */
int lockparent; /* 1 => lockparent flag is set */
int wantparent; /* 1 => wantparent or lockparent flag */
int wantassoc;
int error;
ino_t ino = 0;
int reclen;
u_short namelen;
int isoflags;
char altname[ISO_RRIP_NAMEMAX];
int res;
int len;
char *name;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
int flags = cnp->cn_flags;
int nameiop = cnp->cn_nameiop;
vfs_context_t ctx = cnp->cn_context;
size_t altlen;
bp = NULL;
*vpp = NULL;
vdp = ap->a_dvp;
dp = VTOI(vdp);
imp = dp->i_mnt;
lockparent = flags & LOCKPARENT;
wantparent = flags & (LOCKPARENT|WANTPARENT);
wantassoc = 0;
/*
* We now have a segment name to search for, and a directory to search.
*
* Before tediously performing a linear scan of the directory,
* check the name cache to see if the directory/name pair
* we are looking for is known already.
*/
if ((error = cache_lookup(vdp, vpp, cnp))) {
if (error == ENOENT)
return (error);
return (0);
}
len = cnp->cn_namelen;
name = cnp->cn_nameptr;
altname[0] = '\0';
/*
* A "._" prefix means, we are looking for an associated file
*/
if (imp->iso_ftype != ISO_FTYPE_RRIP &&
*name == ASSOCCHAR1 && *(name+1) == ASSOCCHAR2) {
wantassoc = 1;
len -= 2;
name += 2;
}
/*
* Decode search name into UCS-2 (Unicode)
*/
if ((imp->iso_ftype == ISO_FTYPE_JOLIET) &&
!((len == 1 && *name == '.') || (flags & ISDOTDOT))) {
int flags1 = UTF_PRECOMPOSED;
(void) utf8_decodestr(name, len, (u_int16_t*) altname, &altlen,
sizeof(altname), 0, flags1);
name = altname;
len = altlen;
}
/*
* If there is cached information on a previous search of
* this directory, pick up where we last left off.
* We cache only lookups as these are the most common
* and have the greatest payoff. Caching CREATE has little
* benefit as it usually must search the entire directory
* to determine that the entry does not exist. Caching the
* location of the last DELETE or RENAME has not reduced
* profiling time and hence has been removed in the interest
* of simplicity.
*/
bmask = imp->im_sector_size - 1;
if (nameiop != LOOKUP || dp->i_diroff == 0 ||
dp->i_diroff > dp->i_size) {
entryoffsetinblock = 0;
dp->i_offset = 0;
numdirpasses = 1;
} else {
dp->i_offset = dp->i_diroff;
if ((entryoffsetinblock = dp->i_offset & bmask) &&
(error = cd9660_blkatoff(vdp, SECTOFF(imp, dp->i_offset), NULL, &bp)))
return (error);
numdirpasses = 2;
iso_nchstats.ncs_2passes++;
}
endsearch = dp->i_size;
searchloop:
while (dp->i_offset < endsearch) {
/*
* If offset is on a block boundary,
* read the next directory block.
* Release previous if it exists.
*/
if ((dp->i_offset & bmask) == 0) {
if (bp != NULL)
buf_brelse(bp);
if ( (error = cd9660_blkatoff(vdp, SECTOFF(imp,dp->i_offset), NULL, &bp)) )
return (error);
entryoffsetinblock = 0;
}
/*
* Get pointer to next entry.
*/
ep = (struct iso_directory_record *)
((char *)0 + buf_dataptr(bp) + entryoffsetinblock);
reclen = isonum_711(ep->length);
if (reclen == 0) {
/* skip to next block, if any */
dp->i_offset =
(dp->i_offset & ~bmask) + imp->im_sector_size;
continue;
}
if (reclen < ISO_DIRECTORY_RECORD_SIZE) {
/* illegal entry, stop */
break;
}
if (entryoffsetinblock + reclen > imp->im_sector_size) {
/* entries are not allowed to cross sector boundaries */
break;
}
namelen = isonum_711(ep->name_len);
isoflags = isonum_711(ep->flags);
if (reclen < ISO_DIRECTORY_RECORD_SIZE + namelen)
/* illegal entry, stop */
break;
/*
* Check for a name match.
*/
if (imp->iso_ftype == ISO_FTYPE_RRIP) {
if (isoflags & directoryBit)
ino = isodirino(ep, imp);
else
ino = ((daddr_t)buf_blkno(bp) << imp->im_bshift) + entryoffsetinblock;
dp->i_ino = ino;
cd9660_rrip_getname(ep,altname,&namelen,&dp->i_ino,imp);
if (namelen == cnp->cn_namelen
&& !bcmp(name,altname,namelen))
goto found;
ino = 0;
} else {
if ((!(isoflags & associatedBit)) == !wantassoc) {
if ((len == 1
&& *name == '.')
|| (flags & ISDOTDOT)) {
if (namelen == 1
&& ep->name[0] == ((flags & ISDOTDOT) ? 1 : 0)) {
/*
* Save directory entry's inode number and
* release directory buffer.
*/
dp->i_ino = isodirino(ep, imp);
goto found;
}
if (namelen != 1
|| ep->name[0] != 0)
goto notfound;
} else if (imp->iso_ftype != ISO_FTYPE_JOLIET && !(res = isofncmp(name, len, ep->name, namelen))) {
if ( isoflags & directoryBit )
ino = isodirino(ep, imp);
else
ino = ((daddr_t)buf_blkno(bp) << imp->im_bshift) + entryoffsetinblock;
saveoffset = dp->i_offset;
} else if (imp->iso_ftype == ISO_FTYPE_JOLIET && !(res = ucsfncmp((u_int16_t*)name, len,
(u_int16_t*) ep->name, namelen))) {
if ( isoflags & directoryBit )
ino = isodirino(ep, imp);
else
ino = ((daddr_t)buf_blkno(bp) << imp->im_bshift) + entryoffsetinblock;
saveoffset = dp->i_offset;
} else if (ino)
goto foundino;
#ifdef NOSORTBUG /* On some CDs directory entries are not sorted correctly */
else if (res < 0)
goto notfound;
else if (res > 0 && numdirpasses == 2)
numdirpasses++;
#endif
}
}
dp->i_offset += reclen;
entryoffsetinblock += reclen;
} /* endwhile */
if (ino) {
foundino:
dp->i_ino = ino;
if (saveoffset != dp->i_offset) {
if (lblkno(imp, dp->i_offset) !=
lblkno(imp, saveoffset)) {
if (bp != NULL)
buf_brelse(bp);
if ( (error = cd9660_blkatoff(vdp, SECTOFF(imp, saveoffset), NULL, &bp)) )
return (error);
}
entryoffsetinblock = saveoffset & bmask;
ep = (struct iso_directory_record *)
((char *)0 + buf_dataptr(bp) + entryoffsetinblock);
dp->i_offset = saveoffset;
}
goto found;
}
notfound:
/*
* If we started in the middle of the directory and failed
* to find our target, we must check the beginning as well.
*/
if (numdirpasses == 2) {
numdirpasses--;
dp->i_offset = 0;
endsearch = dp->i_diroff;
goto searchloop;
}
if (bp != NULL)
buf_brelse(bp);
/*
* Insert name into cache (as non-existent) if appropriate.
*/
if (cnp->cn_flags & MAKEENTRY)
cache_enter(vdp, *vpp, cnp);
return (ENOENT);
found:
if (numdirpasses == 2)
iso_nchstats.ncs_pass2++;
/*
* Found component in pathname.
* If the final component of path name, save information
* in the cache as to where the entry was found.
*/
if ((flags & ISLASTCN) && nameiop == LOOKUP)
dp->i_diroff = dp->i_offset;
/*
* Step through the translation in the name. We do not `iput' the
* directory because we may need it again if a symbolic link
* is relative to the current directory. Instead we save it
* unlocked as "pdp". We must get the target inode before unlocking
* the directory to insure that the inode will not be removed
* before we get it. We prevent deadlock by always fetching
* inodes from the root, moving down the directory tree. Thus
* when following backward pointers ".." we must unlock the
* parent directory before getting the requested directory.
* There is a potential race condition here if both the current
* and parent directories are removed before the `iget' for the
* inode associated with ".." returns. We hope that this occurs
* infrequently since we cannot avoid this race condition without
* implementing a sophisticated deadlock detection algorithm.
* Note also that this simple deadlock detection scheme will not
* work if the file system has any hard links other than ".."
* that point backwards in the directory structure.
*/
pdp = vdp;
/*
* If ino is different from dp->i_ino,
* it's a relocated directory.
*/
if (flags & ISDOTDOT) {
error = cd9660_vget_internal(vnode_mount(vdp), dp->i_ino, &tdp, NULL, NULL,
dp->i_ino != ino, ep,
vfs_context_proc(ctx));
VTOI(tdp)->i_parent = VTOI(pdp)->i_number;
buf_brelse(bp);
*vpp = tdp;
} else if (dp->i_number == dp->i_ino) {
buf_brelse(bp);
vnode_get(vdp); /* we want ourself, ie "." */
*vpp = vdp;
} else {
error = cd9660_vget_internal(vnode_mount(vdp), dp->i_ino, &tdp, vdp, cnp,
dp->i_ino != ino, ep, vfs_context_proc(ctx));
/* save parent inode number */
VTOI(tdp)->i_parent = VTOI(pdp)->i_number;
buf_brelse(bp);
if (error)
return (error);
*vpp = tdp;
}
return (0);
}
/* Note that we don't set CDirty here, this is OK because the unlink
* RPC is called synchronously */
int
afs_remove(OSI_VC_DECL(adp), char *aname, afs_ucred_t *acred)
{
struct vrequest treq;
register struct dcache *tdc;
struct VenusFid unlinkFid;
register afs_int32 code;
register struct vcache *tvc;
afs_size_t offset, len;
struct afs_fakestat_state fakestate;
OSI_VC_CONVERT(adp);
AFS_STATCNT(afs_remove);
afs_Trace2(afs_iclSetp, CM_TRACE_REMOVE, ICL_TYPE_POINTER, adp,
ICL_TYPE_STRING, aname);
if ((code = afs_InitReq(&treq, acred))) {
return code;
}
afs_InitFakeStat(&fakestate);
AFS_DISCON_LOCK();
code = afs_EvalFakeStat(&adp, &fakestate, &treq);
if (code)
goto done;
/* Check if this is dynroot */
if (afs_IsDynroot(adp)) {
code = afs_DynrootVOPRemove(adp, acred, aname);
goto done;
}
if (afs_IsDynrootMount(adp)) {
code = ENOENT;
goto done;
}
if (strlen(aname) > AFSNAMEMAX) {
code = ENAMETOOLONG;
goto done;
}
tagain:
code = afs_VerifyVCache(adp, &treq);
tvc = NULL;
if (code) {
code = afs_CheckCode(code, &treq, 23);
goto done;
}
/** If the volume is read-only, return error without making an RPC to the
* fileserver
*/
if (adp->f.states & CRO) {
code = EROFS;
goto done;
}
/* If we're running disconnected without logging, go no further... */
if (AFS_IS_DISCONNECTED && !AFS_IS_DISCON_RW) {
code = ENETDOWN;
goto done;
}
tdc = afs_GetDCache(adp, (afs_size_t) 0, &treq, &offset, &len, 1); /* test for error below */
ObtainWriteLock(&adp->lock, 142);
if (tdc)
ObtainSharedLock(&tdc->lock, 638);
/*
* Make sure that the data in the cache is current. We may have
* received a callback while we were waiting for the write lock.
*/
if (!(adp->f.states & CStatd)
|| (tdc && !hsame(adp->f.m.DataVersion, tdc->f.versionNo))) {
ReleaseWriteLock(&adp->lock);
if (tdc) {
ReleaseSharedLock(&tdc->lock);
afs_PutDCache(tdc);
}
goto tagain;
}
unlinkFid.Fid.Vnode = 0;
if (!tvc) {
tvc = osi_dnlc_lookup(adp, aname, WRITE_LOCK);
}
/* This should not be necessary since afs_lookup() has already
* done the work.
*/
if (!tvc)
if (tdc) {
code = afs_dir_Lookup(tdc, aname, &unlinkFid.Fid);
if (code == 0) {
afs_int32 cached = 0;
unlinkFid.Cell = adp->f.fid.Cell;
unlinkFid.Fid.Volume = adp->f.fid.Fid.Volume;
if (unlinkFid.Fid.Unique == 0) {
tvc =
afs_LookupVCache(&unlinkFid, &treq, &cached, adp,
aname);
} else {
ObtainReadLock(&afs_xvcache);
tvc = afs_FindVCache(&unlinkFid, 0, DO_STATS);
ReleaseReadLock(&afs_xvcache);
}
}
}
if (AFS_IS_DISCON_RW) {
if (!adp->f.shadow.vnode && !(adp->f.ddirty_flags & VDisconCreate)) {
/* Make shadow copy of parent dir. */
afs_MakeShadowDir(adp, tdc);
}
/* Can't hold a dcache lock whilst we're getting a vcache one */
if (tdc)
ReleaseSharedLock(&tdc->lock);
/* XXX - We're holding adp->lock still, and we've got no
* guarantee about whether the ordering matches the lock hierarchy */
ObtainWriteLock(&tvc->lock, 713);
/* If we were locally created, then we don't need to do very
* much beyond ensuring that we don't exist anymore */
if (tvc->f.ddirty_flags & VDisconCreate) {
afs_DisconRemoveDirty(tvc);
} else {
/* Add removed file vcache to dirty list. */
afs_DisconAddDirty(tvc, VDisconRemove, 1);
}
adp->f.m.LinkCount--;
ReleaseWriteLock(&tvc->lock);
if (tdc)
ObtainSharedLock(&tdc->lock, 714);
}
if (tvc && osi_Active(tvc)) {
/* about to delete whole file, prefetch it first */
ReleaseWriteLock(&adp->lock);
if (tdc)
ReleaseSharedLock(&tdc->lock);
ObtainWriteLock(&tvc->lock, 143);
FetchWholeEnchilada(tvc, &treq);
ReleaseWriteLock(&tvc->lock);
ObtainWriteLock(&adp->lock, 144);
/* Technically I don't think we need this back, but let's hold it
anyway; The "got" reference should actually be sufficient. */
if (tdc)
ObtainSharedLock(&tdc->lock, 640);
}
osi_dnlc_remove(adp, aname, tvc);
Tadp1 = adp;
#ifndef AFS_DARWIN80_ENV
Tadpr = VREFCOUNT(adp);
#endif
Ttvc = tvc;
Tnam = aname;
Tnam1 = 0;
#ifndef AFS_DARWIN80_ENV
if (tvc)
Ttvcr = VREFCOUNT(tvc);
#endif
#ifdef AFS_AIX_ENV
if (tvc && VREFCOUNT_GT(tvc, 2) && tvc->opens > 0
&& !(tvc->f.states & CUnlinked)) {
#else
if (tvc && VREFCOUNT_GT(tvc, 1) && tvc->opens > 0
&& !(tvc->f.states & CUnlinked)) {
#endif
char *unlname = afs_newname();
ReleaseWriteLock(&adp->lock);
if (tdc)
ReleaseSharedLock(&tdc->lock);
code = afsrename(adp, aname, adp, unlname, acred, &treq);
Tnam1 = unlname;
if (!code) {
struct VenusFid *oldmvid = NULL;
if (tvc->mvid)
oldmvid = tvc->mvid;
tvc->mvid = (struct VenusFid *)unlname;
if (oldmvid)
osi_FreeSmallSpace(oldmvid);
crhold(acred);
if (tvc->uncred) {
crfree(tvc->uncred);
}
tvc->uncred = acred;
tvc->f.states |= CUnlinked;
/* if rename succeeded, remove should not */
ObtainWriteLock(&tvc->lock, 715);
if (tvc->f.ddirty_flags & VDisconRemove) {
tvc->f.ddirty_flags &= ~VDisconRemove;
}
ReleaseWriteLock(&tvc->lock);
} else {
osi_FreeSmallSpace(unlname);
}
if (tdc)
afs_PutDCache(tdc);
afs_PutVCache(tvc);
} else {
code = afsremove(adp, tdc, tvc, aname, acred, &treq);
}
done:
afs_PutFakeStat(&fakestate);
#ifndef AFS_DARWIN80_ENV
/* we can't track by thread, it's not exported in the KPI; only do
this on !macos */
osi_Assert(!WriteLocked(&adp->lock) || (adp->lock.pid_writer != MyPidxx));
#endif
AFS_DISCON_UNLOCK();
return code;
}
/* afs_remunlink -- This tries to delete the file at the server after it has
* been renamed when unlinked locally but now has been finally released.
*
* CAUTION -- may be called with avc unheld. */
int
afs_remunlink(register struct vcache *avc, register int doit)
{
afs_ucred_t *cred;
char *unlname;
struct vcache *adp;
struct vrequest treq;
struct VenusFid dirFid;
register struct dcache *tdc;
afs_int32 code = 0;
if (NBObtainWriteLock(&avc->lock, 423))
return 0;
#if defined(AFS_DARWIN80_ENV)
if (vnode_get(AFSTOV(avc))) {
ReleaseWriteLock(&avc->lock);
return 0;
}
#endif
if (avc->mvid && (doit || (avc->f.states & CUnlinkedDel))) {
if ((code = afs_InitReq(&treq, avc->uncred))) {
ReleaseWriteLock(&avc->lock);
} else {
/* Must bump the refCount because GetVCache may block.
* Also clear mvid so no other thread comes here if we block.
*/
unlname = (char *)avc->mvid;
avc->mvid = NULL;
cred = avc->uncred;
avc->uncred = NULL;
#if defined(AFS_DARWIN_ENV) && !defined(AFS_DARWIN80_ENV)
VREF(AFSTOV(avc));
#else
AFS_FAST_HOLD(avc);
#endif
/* We'll only try this once. If it fails, just release the vnode.
* Clear after doing hold so that NewVCache doesn't find us yet.
*/
avc->f.states &= ~(CUnlinked | CUnlinkedDel);
ReleaseWriteLock(&avc->lock);
dirFid.Cell = avc->f.fid.Cell;
dirFid.Fid.Volume = avc->f.fid.Fid.Volume;
dirFid.Fid.Vnode = avc->f.parent.vnode;
dirFid.Fid.Unique = avc->f.parent.unique;
adp = afs_GetVCache(&dirFid, &treq, NULL, NULL);
if (adp) {
tdc = afs_FindDCache(adp, (afs_size_t) 0);
ObtainWriteLock(&adp->lock, 159);
if (tdc)
ObtainSharedLock(&tdc->lock, 639);
/* afsremove releases the adp & tdc locks, and does vn_rele(avc) */
code = afsremove(adp, tdc, avc, unlname, cred, &treq);
afs_PutVCache(adp);
} else {
/* we failed - and won't be back to try again. */
afs_PutVCache(avc);
}
osi_FreeSmallSpace(unlname);
crfree(cred);
}
} else {
#if defined(AFS_DARWIN80_ENV)
vnode_put(AFSTOV(avc));
#endif
ReleaseWriteLock(&avc->lock);
}
return code;
}
/*ARGSUSED*/
static int
zfs_vfs_unmount(struct mount *mp, int mntflags, vfs_context_t context)
{
zfsvfs_t *zfsvfs = vfs_fsprivate(mp);
objset_t *os = zfsvfs->z_os;
znode_t *zp, *nextzp;
int ret, i;
int flags;
/*XXX NOEL: delegation admin stuffs, add back if we use delg. admin */
#if 0
ret = 0; /* UNDEFINED: secpolicy_fs_unmount(cr, vfsp); */
if (ret) {
ret = dsl_deleg_access((char *)refstr_value(vfsp->vfs_resource),
ZFS_DELEG_PERM_MOUNT, cr);
if (ret)
return (ret);
}
/*
* We purge the parent filesystem's vfsp as the parent filesystem
* and all of its snapshots have their vnode's v_vfsp set to the
* parent's filesystem's vfsp. Note, 'z_parent' is self
* referential for non-snapshots.
*/
(void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
#endif
/*
* Unmount any snapshots mounted under .zfs before unmounting the
* dataset itself.
*/
#if 0
if (zfsvfs->z_ctldir != NULL &&
(ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0) {
return (ret);
#endif
flags = SKIPSYSTEM;
if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
ret = vflush(mp, NULLVP, flags);
/*
* Mac OS X needs a file system modify time
*
* We use the mtime of the "com.apple.system.mtime"
* extended attribute, which is associated with the
* file system root directory.
*
* Here we need to release the ref we took on z_mtime_vp during mount.
*/
if ((ret == 0) || (mntflags & MNT_FORCE)) {
if (zfsvfs->z_mtime_vp != NULL) {
struct vnode *mvp;
mvp = zfsvfs->z_mtime_vp;
zfsvfs->z_mtime_vp = NULL;
if (vnode_get(mvp) == 0) {
vnode_rele(mvp);
vnode_recycle(mvp);
vnode_put(mvp);
}
}
}
if (!(mntflags & MNT_FORCE)) {
/*
* Check the number of active vnodes in the file system.
* Our count is maintained in the vfs structure, but the
* number is off by 1 to indicate a hold on the vfs
* structure itself.
*
* The '.zfs' directory maintains a reference of its
* own, and any active references underneath are
* reflected in the vnode count.
*/
if (ret)
return (EBUSY);
#if 0
if (zfsvfs->z_ctldir == NULL) {
if (vfsp->vfs_count > 1)
return (EBUSY);
} else {
if (vfsp->vfs_count > 2 ||
zfsvfs->z_ctldir->v_count > 1) {
return (EBUSY);
}
}
#endif
}
rw_enter(&zfsvfs->z_unmount_lock, RW_WRITER);
rw_enter(&zfsvfs->z_unmount_inactive_lock, RW_WRITER);
/*
* At this point there are no vops active, and any new vops will
* fail with EIO since we have z_unmount_lock for writer (only
* relavent for forced unmount).
*
* Release all holds on dbufs.
* Note, the dmu can still callback via znode_pageout_func()
* which can zfs_znode_free() the znode. So we lock
* z_all_znodes; search the list for a held dbuf; drop the lock
* (we know zp can't disappear if we hold a dbuf lock) then
* regrab the lock and restart.
*/
mutex_enter(&zfsvfs->z_znodes_lock);
for (zp = list_head(&zfsvfs->z_all_znodes); zp; zp = nextzp) {
nextzp = list_next(&zfsvfs->z_all_znodes, zp);
if (zp->z_dbuf_held) {
/* dbufs should only be held when force unmounting */
zp->z_dbuf_held = 0;
mutex_exit(&zfsvfs->z_znodes_lock);
dmu_buf_rele(zp->z_dbuf, NULL);
/* Start again */
mutex_enter(&zfsvfs->z_znodes_lock);
nextzp = list_head(&zfsvfs->z_all_znodes);
}
}
mutex_exit(&zfsvfs->z_znodes_lock);
/*
* Set the unmounted flag and let new vops unblock.
* zfs_inactive will have the unmounted behavior, and all other
* vops will fail with EIO.
*/
zfsvfs->z_unmounted = B_TRUE;
rw_exit(&zfsvfs->z_unmount_lock);
rw_exit(&zfsvfs->z_unmount_inactive_lock);
/*
* Unregister properties.
*/
#ifndef __APPLE__
if (!dmu_objset_is_snapshot(os))
zfs_unregister_callbacks(zfsvfs);
#endif
/*
* Close the zil. NB: Can't close the zil while zfs_inactive
* threads are blocked as zil_close can call zfs_inactive.
*/
if (zfsvfs->z_log) {
zil_close(zfsvfs->z_log);
zfsvfs->z_log = NULL;
}
/*
* Evict all dbufs so that cached znodes will be freed
*/
if (dmu_objset_evict_dbufs(os, B_TRUE)) {
txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
(void) dmu_objset_evict_dbufs(os, B_FALSE);
}
/*
* Finally close the objset
*/
dmu_objset_close(os);
/*
* We can now safely destroy the '.zfs' directory node.
*/
#if 0
if (zfsvfs->z_ctldir != NULL)
zfsctl_destroy(zfsvfs);
#endif
/*
* Note that this work is normally done in zfs_freevfs, but since
* there is no VOP_FREEVFS in OSX, we free VFS items here
*/
OSDecrementAtomic((SInt32 *)&zfs_active_fs_count);
for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
mutex_destroy(&zfsvfs->z_hold_mtx[i]);
mutex_destroy(&zfsvfs->z_znodes_lock);
list_destroy(&zfsvfs->z_all_znodes);
rw_destroy(&zfsvfs->z_unmount_lock);
rw_destroy(&zfsvfs->z_unmount_inactive_lock);
return (0);
}
struct vnode* vnode_getparent(struct vnode *vp); /* sys/vnode_internal.h */
static int
zfs_vget_internal(zfsvfs_t *zfsvfs, ino64_t ino, struct vnode **vpp)
{
struct vnode *vp;
struct vnode *dvp = NULL;
znode_t *zp;
int error;
*vpp = NULL;
/*
* On Mac OS X we always export the root directory id as 2
* and its parent as 1
*/
if (ino == 2 || ino == 1)
ino = zfsvfs->z_root;
if ((error = zfs_zget(zfsvfs, ino, &zp)))
goto out;
/* Don't expose EA objects! */
if (zp->z_phys->zp_flags & ZFS_XATTR) {
vnode_put(ZTOV(zp));
error = ENOENT;
goto out;
}
*vpp = vp = ZTOV(zp);
if (vnode_isvroot(vp))
goto out;
/*
* If this znode didn't just come from the cache then
* it won't have a valid identity (parent and name).
*
* Manually fix its identity here (normally done by namei lookup).
*/
if ((dvp = vnode_getparent(vp)) == NULL) {
if (zp->z_phys->zp_parent != 0 &&
zfs_vget_internal(zfsvfs, zp->z_phys->zp_parent, &dvp)) {
goto out;
}
if ( vnode_isdir(dvp) ) {
char objname[ZAP_MAXNAMELEN]; /* 256 bytes */
int flags = VNODE_UPDATE_PARENT;
/* Look for znode's name in its parent's zap */
if ( zap_value_search(zfsvfs->z_os,
zp->z_phys->zp_parent,
zp->z_id,
ZFS_DIRENT_OBJ(-1ULL),
objname) == 0 ) {
flags |= VNODE_UPDATE_NAME;
}
/* Update the znode's parent and name */
vnode_update_identity(vp, dvp, objname, 0, 0, flags);
}
}
/* All done with znode's parent */
vnode_put(dvp);
out:
return (error);
}
/*
* Get a vnode from a file id (ignoring the generation)
*
* Use by NFS Server (readdirplus) and VFS (build_path)
*/
static int
zfs_vfs_vget(struct mount *mp, ino64_t ino, struct vnode **vpp, __unused vfs_context_t context)
{
zfsvfs_t *zfsvfs = vfs_fsprivate(mp);
int error;
ZFS_ENTER(zfsvfs);
/*
* On Mac OS X we always export the root directory id as 2.
* So we don't expect to see the real root directory id
* from zfs_vfs_vget KPI (unless of course the real id was
* already 2).
*/
if ((ino == zfsvfs->z_root) && (zfsvfs->z_root != 2)) {
ZFS_EXIT(zfsvfs);
return (ENOENT);
}
error = zfs_vget_internal(zfsvfs, ino, vpp);
ZFS_EXIT(zfsvfs);
return (error);
}
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;
}
/**
* Reset volume name to volume id mapping cache.
* @param flags
*/
void
afs_CheckVolumeNames(int flags)
{
afs_int32 i, j;
struct volume *tv;
unsigned int now;
struct vcache *tvc;
afs_int32 *volumeID, *cellID, vsize, nvols;
#ifdef AFS_DARWIN80_ENV
vnode_t tvp;
#endif
AFS_STATCNT(afs_CheckVolumeNames);
nvols = 0;
volumeID = cellID = NULL;
vsize = 0;
ObtainReadLock(&afs_xvolume);
if (flags & AFS_VOLCHECK_EXPIRED) {
/*
* allocate space to hold the volumeIDs and cellIDs, only if
* we will be invalidating the mountpoints later on
*/
for (i = 0; i < NVOLS; i++)
for (tv = afs_volumes[i]; tv; tv = tv->next)
++vsize;
volumeID = afs_osi_Alloc(2 * vsize * sizeof(*volumeID));
cellID = (volumeID) ? volumeID + vsize : 0;
}
now = osi_Time();
for (i = 0; i < NVOLS; i++) {
for (tv = afs_volumes[i]; tv; tv = tv->next) {
if (flags & AFS_VOLCHECK_EXPIRED) {
if (((tv->expireTime < (now + 10)) && (tv->states & VRO))
|| (flags & AFS_VOLCHECK_FORCE)) {
afs_ResetVolumeInfo(tv); /* also resets status */
if (volumeID) {
volumeID[nvols] = tv->volume;
cellID[nvols] = tv->cell;
}
++nvols;
continue;
}
}
/* ??? */
if (flags & (AFS_VOLCHECK_BUSY | AFS_VOLCHECK_FORCE)) {
for (j = 0; j < AFS_MAXHOSTS; j++)
tv->status[j] = not_busy;
}
}
}
ReleaseReadLock(&afs_xvolume);
/* next ensure all mt points are re-evaluated */
if (nvols || (flags & (AFS_VOLCHECK_FORCE | AFS_VOLCHECK_MTPTS))) {
loop:
ObtainReadLock(&afs_xvcache);
for (i = 0; i < VCSIZE; i++) {
for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
/* if the volume of "mvid" of the vcache entry is among the
* ones we found earlier, then we re-evaluate it. Also, if the
* force bit is set or we explicitly asked to reevaluate the
* mt-pts, we clean the cmvalid bit */
if ((flags & (AFS_VOLCHECK_FORCE | AFS_VOLCHECK_MTPTS))
|| (tvc->mvid
&& inVolList(tvc->mvid, nvols, volumeID, cellID)))
tvc->f.states &= ~CMValid;
/* If the volume that this file belongs to was reset earlier,
* then we should remove its callback.
* Again, if forced, always do it.
*/
if ((tvc->f.states & CRO)
&& (inVolList(&tvc->f.fid, nvols, volumeID, cellID)
|| (flags & AFS_VOLCHECK_FORCE))) {
if (tvc->f.states & CVInit) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop;
}
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop;
}
tvp = AFSTOV(tvc);
if (vnode_get(tvp))
continue;
if (vnode_ref(tvp)) {
AFS_GUNLOCK();
/* AFSTOV(tvc) may be NULL */
vnode_put(tvp);
AFS_GLOCK();
continue;
}
#else
AFS_FAST_HOLD(tvc);
#endif
ReleaseReadLock(&afs_xvcache);
ObtainWriteLock(&afs_xcbhash, 485);
/* LOCKXXX: We aren't holding tvc write lock? */
afs_DequeueCallback(tvc);
tvc->f.states &= ~CStatd;
ReleaseWriteLock(&afs_xcbhash);
if (tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR))
osi_dnlc_purgedp(tvc);
#ifdef AFS_DARWIN80_ENV
vnode_put(AFSTOV(tvc));
/* our tvc ptr is still good until now */
AFS_FAST_RELE(tvc);
ObtainReadLock(&afs_xvcache);
#else
ObtainReadLock(&afs_xvcache);
/* our tvc ptr is still good until now */
AFS_FAST_RELE(tvc);
#endif
}
}
}
osi_dnlc_purge(); /* definitely overkill, but it's safer this way. */
ReleaseReadLock(&afs_xvcache);
}
if (volumeID)
afs_osi_Free(volumeID, 2 * vsize * sizeof(*volumeID));
} /*afs_CheckVolumeNames */
/*
* Search a pathname.
* This is a very central and rather complicated routine.
*
* The pathname is pointed to by ni_ptr and is of length ni_pathlen.
* The starting directory is taken from ni_startdir. The pathname is
* descended until done, or a symbolic link is encountered. The variable
* ni_more is clear if the path is completed; it is set to one if a
* symbolic link needing interpretation is encountered.
*
* The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
* whether the name is to be looked up, created, renamed, or deleted.
* When CREATE, RENAME, or DELETE is specified, information usable in
* creating, renaming, or deleting a directory entry may be calculated.
* If flag has LOCKPARENT or'ed into it, the parent directory is returned
* locked. If flag has WANTPARENT or'ed into it, the parent directory is
* returned unlocked. Otherwise the parent directory is not returned. If
* the target of the pathname exists and LOCKLEAF is or'ed into the flag
* the target is returned locked, otherwise it is returned unlocked.
* When creating or renaming and LOCKPARENT is specified, the target may not
* be ".". When deleting and LOCKPARENT is specified, the target may be ".".
*
* Overall outline of lookup:
*
* dirloop:
* identify next component of name at ndp->ni_ptr
* handle degenerate case where name is null string
* if .. and crossing mount points and on mounted filesys, find parent
* call VNOP_LOOKUP routine for next component name
* directory vnode returned in ni_dvp, unlocked unless LOCKPARENT set
* component vnode returned in ni_vp (if it exists), locked.
* if result vnode is mounted on and crossing mount points,
* find mounted on vnode
* if more components of name, do next level at dirloop
* return the answer in ni_vp, locked if LOCKLEAF set
* if LOCKPARENT set, return locked parent in ni_dvp
* if WANTPARENT set, return unlocked parent in ni_dvp
*
* Returns: 0 Success
* ENOENT No such file or directory
* EBADF Bad file descriptor
* ENOTDIR Not a directory
* EROFS Read-only file system [CREATE]
* EISDIR Is a directory [CREATE]
* cache_lookup_path:ERECYCLE (vnode was recycled from underneath us, redrive lookup again)
* vnode_authorize:EROFS
* vnode_authorize:EACCES
* vnode_authorize:EPERM
* vnode_authorize:???
* VNOP_LOOKUP:ENOENT No such file or directory
* VNOP_LOOKUP:EJUSTRETURN Restart system call (INTERNAL)
* VNOP_LOOKUP:???
* VFS_ROOT:ENOTSUP
* VFS_ROOT:ENOENT
* VFS_ROOT:???
*/
int
lookup(struct nameidata *ndp)
{
char *cp; /* pointer into pathname argument */
vnode_t tdp; /* saved dp */
vnode_t dp; /* the directory we are searching */
mount_t mp; /* mount table entry */
int docache = 1; /* == 0 do not cache last component */
int wantparent; /* 1 => wantparent or lockparent flag */
int rdonly; /* lookup read-only flag bit */
int trailing_slash = 0;
int dp_authorized = 0;
int error = 0;
struct componentname *cnp = &ndp->ni_cnd;
vfs_context_t ctx = cnp->cn_context;
int mounted_on_depth = 0;
int dont_cache_mp = 0;
vnode_t mounted_on_dp = NULLVP;
int current_mount_generation = 0;
int vbusyflags = 0;
int nc_generation = 0;
vnode_t last_dp = NULLVP;
/*
* Setup: break out flag bits into variables.
*/
if (cnp->cn_flags & (NOCACHE | DOWHITEOUT)) {
if ((cnp->cn_flags & NOCACHE) || (cnp->cn_nameiop == DELETE))
docache = 0;
}
wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT);
rdonly = cnp->cn_flags & RDONLY;
cnp->cn_flags &= ~ISSYMLINK;
cnp->cn_consume = 0;
dp = ndp->ni_startdir;
ndp->ni_startdir = NULLVP;
if ((cnp->cn_flags & CN_NBMOUNTLOOK) != 0)
vbusyflags = LK_NOWAIT;
cp = cnp->cn_nameptr;
if (*cp == '\0') {
if ( (vnode_getwithref(dp)) ) {
dp = NULLVP;
error = ENOENT;
goto bad;
}
goto emptyname;
}
dirloop:
ndp->ni_vp = NULLVP;
if ( (error = cache_lookup_path(ndp, cnp, dp, ctx, &trailing_slash, &dp_authorized, last_dp)) ) {
dp = NULLVP;
goto bad;
}
if ((cnp->cn_flags & ISLASTCN)) {
if (docache)
cnp->cn_flags |= MAKEENTRY;
} else
cnp->cn_flags |= MAKEENTRY;
dp = ndp->ni_dvp;
if (ndp->ni_vp != NULLVP) {
/*
* cache_lookup_path returned a non-NULL ni_vp then,
* we're guaranteed that the dp is a VDIR, it's
* been authorized, and vp is not ".."
*
* make sure we don't try to enter the name back into
* the cache if this vp is purged before we get to that
* check since we won't have serialized behind whatever
* activity is occurring in the FS that caused the purge
*/
if (dp != NULLVP)
nc_generation = dp->v_nc_generation - 1;
goto returned_from_lookup_path;
}
/*
* Handle "..": two special cases.
* 1. If at root directory (e.g. after chroot)
* or at absolute root directory
* then ignore it so can't get out.
* 2. If this vnode is the root of a mounted
* filesystem, then replace it with the
* vnode which was mounted on so we take the
* .. in the other file system.
*/
if ( (cnp->cn_flags & ISDOTDOT) ) {
for (;;) {
if (dp == ndp->ni_rootdir || dp == rootvnode) {
ndp->ni_dvp = dp;
ndp->ni_vp = dp;
/*
* we're pinned at the root
* we've already got one reference on 'dp'
* courtesy of cache_lookup_path... take
* another one for the ".."
* if we fail to get the new reference, we'll
* drop our original down in 'bad'
*/
if ( (vnode_get(dp)) ) {
error = ENOENT;
goto bad;
}
goto nextname;
}
if ((dp->v_flag & VROOT) == 0 ||
(cnp->cn_flags & NOCROSSMOUNT))
break;
if (dp->v_mount == NULL) { /* forced umount */
error = EBADF;
goto bad;
}
tdp = dp;
dp = tdp->v_mount->mnt_vnodecovered;
vnode_put(tdp);
if ( (vnode_getwithref(dp)) ) {
dp = NULLVP;
error = ENOENT;
goto bad;
}
ndp->ni_dvp = dp;
dp_authorized = 0;
}
}
/*
* We now have a segment name to search for, and a directory to search.
*/
unionlookup:
ndp->ni_vp = NULLVP;
if (dp->v_type != VDIR) {
error = ENOTDIR;
goto lookup_error;
}
if ( (cnp->cn_flags & DONOTAUTH) != DONOTAUTH ) {
if (!dp_authorized) {
error = vnode_authorize(dp, NULL, KAUTH_VNODE_SEARCH, ctx);
if (error)
goto lookup_error;
}
#if CONFIG_MACF
error = mac_vnode_check_lookup(ctx, dp, cnp);
if (error)
goto lookup_error;
#endif /* CONFIG_MACF */
}
nc_generation = dp->v_nc_generation;
if ( (error = VNOP_LOOKUP(dp, &ndp->ni_vp, cnp, ctx)) ) {
lookup_error:
if ((error == ENOENT) &&
(dp->v_flag & VROOT) && (dp->v_mount != NULL) &&
(dp->v_mount->mnt_flag & MNT_UNION)) {
if ((cnp->cn_flags & FSNODELOCKHELD)) {
cnp->cn_flags &= ~FSNODELOCKHELD;
unlock_fsnode(dp, NULL);
}
tdp = dp;
dp = tdp->v_mount->mnt_vnodecovered;
vnode_put(tdp);
if ( (vnode_getwithref(dp)) ) {
dp = NULLVP;
error = ENOENT;
goto bad;
}
ndp->ni_dvp = dp;
dp_authorized = 0;
goto unionlookup;
}
if (error != EJUSTRETURN)
goto bad;
if (ndp->ni_vp != NULLVP)
panic("leaf should be empty");
/*
* If creating and at end of pathname, then can consider
* allowing file to be created.
*/
if (rdonly) {
error = EROFS;
goto bad;
}
if ((cnp->cn_flags & ISLASTCN) && trailing_slash && !(cnp->cn_flags & WILLBEDIR)) {
error = ENOENT;
goto bad;
}
/*
* We return with ni_vp NULL to indicate that the entry
* doesn't currently exist, leaving a pointer to the
* referenced directory vnode in ndp->ni_dvp.
*/
if (cnp->cn_flags & SAVESTART) {
if ( (vnode_get(ndp->ni_dvp)) ) {
error = ENOENT;
goto bad;
}
ndp->ni_startdir = ndp->ni_dvp;
}
if (!wantparent)
vnode_put(ndp->ni_dvp);
if (kdebug_enable)
kdebug_lookup(ndp->ni_dvp, cnp);
return (0);
}
returned_from_lookup_path:
dp = ndp->ni_vp;
/*
* Take into account any additional components consumed by
* the underlying filesystem.
*/
if (cnp->cn_consume > 0) {
cnp->cn_nameptr += cnp->cn_consume;
ndp->ni_next += cnp->cn_consume;
ndp->ni_pathlen -= cnp->cn_consume;
cnp->cn_consume = 0;
} else {
if (dp->v_name == NULL || dp->v_parent == NULLVP) {
int isdot_or_dotdot;
int update_flags = 0;
isdot_or_dotdot = (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') || (cnp->cn_flags & ISDOTDOT);
if (isdot_or_dotdot == 0) {
if (dp->v_name == NULL)
update_flags |= VNODE_UPDATE_NAME;
if (ndp->ni_dvp != NULLVP && dp->v_parent == NULLVP)
update_flags |= VNODE_UPDATE_PARENT;
if (update_flags)
vnode_update_identity(dp, ndp->ni_dvp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_hash, update_flags);
}
}
if ( (cnp->cn_flags & MAKEENTRY) && (dp->v_flag & VNCACHEABLE) && LIST_FIRST(&dp->v_nclinks) == NULL) {
/*
* missing from name cache, but should
* be in it... this can happen if volfs
* causes the vnode to be created or the
* name cache entry got recycled but the
* vnode didn't...
* check to make sure that ni_dvp is valid
* cache_lookup_path may return a NULL
* do a quick check to see if the generation of the
* directory matches our snapshot... this will get
* rechecked behind the name cache lock, but if it
* already fails to match, no need to go any further
*/
if (ndp->ni_dvp != NULLVP && (nc_generation == ndp->ni_dvp->v_nc_generation))
cache_enter_with_gen(ndp->ni_dvp, dp, cnp, nc_generation);
}
}
mounted_on_dp = dp;
mounted_on_depth = 0;
dont_cache_mp = 0;
current_mount_generation = mount_generation;
/*
* Check to see if the vnode has been mounted on...
* if so find the root of the mounted file system.
*/
check_mounted_on:
if ((dp->v_type == VDIR) && dp->v_mountedhere &&
((cnp->cn_flags & NOCROSSMOUNT) == 0)) {
vnode_lock(dp);
if ((dp->v_type == VDIR) && (mp = dp->v_mountedhere)) {
struct uthread *uth = (struct uthread *)get_bsdthread_info(current_thread());
mp->mnt_crossref++;
vnode_unlock(dp);
if (vfs_busy(mp, vbusyflags)) {
mount_dropcrossref(mp, dp, 0);
if (vbusyflags == LK_NOWAIT) {
error = ENOENT;
goto bad2;
}
goto check_mounted_on;
}
/*
* XXX - if this is the last component of the
* pathname, and it's either not a lookup operation
* or the NOTRIGGER flag is set for the operation,
* set a uthread flag to let VFS_ROOT() for autofs
* know it shouldn't trigger a mount.
*/
if ((cnp->cn_flags & ISLASTCN) &&
(cnp->cn_nameiop != LOOKUP ||
(cnp->cn_flags & NOTRIGGER))) {
uth->uu_notrigger = 1;
dont_cache_mp = 1;
}
error = VFS_ROOT(mp, &tdp, ctx);
/* XXX - clear the uthread flag */
uth->uu_notrigger = 0;
/*
* mount_dropcrossref does a vnode_put
* on dp if the 3rd arg is non-zero
*/
mount_dropcrossref(mp, dp, 1);
dp = NULL;
vfs_unbusy(mp);
if (error) {
goto bad2;
}
ndp->ni_vp = dp = tdp;
mounted_on_depth++;
goto check_mounted_on;
}
vnode_unlock(dp);
}
#if CONFIG_MACF
if (vfs_flags(vnode_mount(dp)) & MNT_MULTILABEL) {
error = vnode_label(vnode_mount(dp), NULL, dp, NULL,
VNODE_LABEL_NEEDREF, ctx);
if (error)
goto bad2;
}
#endif
if (mounted_on_depth && !dont_cache_mp) {
mp = mounted_on_dp->v_mountedhere;
if (mp) {
mount_lock(mp);
mp->mnt_realrootvp_vid = dp->v_id;
mp->mnt_realrootvp = dp;
mp->mnt_generation = current_mount_generation;
mount_unlock(mp);
}
}
/*
* Check for symbolic link
*/
if ((dp->v_type == VLNK) &&
((cnp->cn_flags & FOLLOW) || trailing_slash || *ndp->ni_next == '/')) {
cnp->cn_flags |= ISSYMLINK;
return (0);
}
/*
* Check for bogus trailing slashes.
*/
if (trailing_slash) {
if (dp->v_type != VDIR) {
error = ENOTDIR;
goto bad2;
}
trailing_slash = 0;
}
nextname:
/*
* Not a symbolic link. If more pathname,
* continue at next component, else return.
*/
if (*ndp->ni_next == '/') {
cnp->cn_nameptr = ndp->ni_next + 1;
ndp->ni_pathlen--;
while (*cnp->cn_nameptr == '/') {
cnp->cn_nameptr++;
ndp->ni_pathlen--;
}
vnode_put(ndp->ni_dvp);
cp = cnp->cn_nameptr;
if (*cp == '\0')
goto emptyname;
/*
* cache_lookup_path is now responsible for dropping io ref on dp
* when it is called again in the dirloop. This ensures we hold
* a ref on dp until we complete the next round of lookup.
*/
last_dp = dp;
goto dirloop;
}
/*
* Disallow directory write attempts on read-only file systems.
*/
if (rdonly &&
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
error = EROFS;
goto bad2;
}
if (cnp->cn_flags & SAVESTART) {
/*
* note that we already hold a reference
* on both dp and ni_dvp, but for some reason
* can't get another one... in this case we
* need to do vnode_put on dp in 'bad2'
*/
if ( (vnode_get(ndp->ni_dvp)) ) {
error = ENOENT;
goto bad2;
}
ndp->ni_startdir = ndp->ni_dvp;
}
if (!wantparent && ndp->ni_dvp) {
vnode_put(ndp->ni_dvp);
ndp->ni_dvp = NULLVP;
}
if (cnp->cn_flags & AUDITVNPATH1)
AUDIT_ARG(vnpath, dp, ARG_VNODE1);
else if (cnp->cn_flags & AUDITVNPATH2)
AUDIT_ARG(vnpath, dp, ARG_VNODE2);
#if NAMEDRSRCFORK
/*
* Caller wants the resource fork.
*/
if ((cnp->cn_flags & CN_WANTSRSRCFORK) && (dp != NULLVP)) {
vnode_t svp = NULLVP;
enum nsoperation nsop;
if (dp->v_type != VREG) {
error = ENOENT;
goto bad2;
}
switch (cnp->cn_nameiop) {
case DELETE:
nsop = NS_DELETE;
break;
case CREATE:
nsop = NS_CREATE;
break;
case LOOKUP:
/* Make sure our lookup of "/..namedfork/rsrc" is allowed. */
if (cnp->cn_flags & CN_ALLOWRSRCFORK) {
nsop = NS_OPEN;
} else {
error = EPERM;
goto bad2;
}
break;
default:
error = EPERM;
goto bad2;
}
/* Ask the file system for the resource fork. */
error = vnode_getnamedstream(dp, &svp, XATTR_RESOURCEFORK_NAME, nsop, 0, ctx);
/* During a create, it OK for stream vnode to be missing. */
if (error == ENOATTR || error == ENOENT) {
error = (nsop == NS_CREATE) ? 0 : ENOENT;
}
if (error) {
goto bad2;
}
/* The "parent" of the stream is the file. */
if (wantparent) {
if (ndp->ni_dvp) {
if (ndp->ni_cnd.cn_flags & FSNODELOCKHELD) {
ndp->ni_cnd.cn_flags &= ~FSNODELOCKHELD;
unlock_fsnode(ndp->ni_dvp, NULL);
}
vnode_put(ndp->ni_dvp);
}
ndp->ni_dvp = dp;
} else {
vnode_put(dp);
}
ndp->ni_vp = dp = svp; /* on create this may be null */
/* Restore the truncated pathname buffer (for audits). */
if (ndp->ni_pathlen == 1 && ndp->ni_next[0] == '\0') {
ndp->ni_next[0] = '/';
}
cnp->cn_flags &= ~MAKEENTRY;
}
#endif
if (kdebug_enable)
kdebug_lookup(dp, cnp);
return (0);
emptyname:
cnp->cn_namelen = 0;
/*
* A degenerate name (e.g. / or "") which is a way of
* talking about a directory, e.g. like "/." or ".".
*/
if (dp->v_type != VDIR) {
error = ENOTDIR;
goto bad;
}
if (cnp->cn_nameiop != LOOKUP) {
error = EISDIR;
goto bad;
}
if (wantparent) {
/*
* note that we already hold a reference
* on dp, but for some reason can't
* get another one... in this case we
* need to do vnode_put on dp in 'bad'
*/
if ( (vnode_get(dp)) ) {
error = ENOENT;
goto bad;
}
ndp->ni_dvp = dp;
}
cnp->cn_flags &= ~ISDOTDOT;
cnp->cn_flags |= ISLASTCN;
ndp->ni_next = cp;
ndp->ni_vp = dp;
if (cnp->cn_flags & AUDITVNPATH1)
AUDIT_ARG(vnpath, dp, ARG_VNODE1);
else if (cnp->cn_flags & AUDITVNPATH2)
AUDIT_ARG(vnpath, dp, ARG_VNODE2);
if (cnp->cn_flags & SAVESTART)
panic("lookup: SAVESTART");
return (0);
bad2:
if ((cnp->cn_flags & FSNODELOCKHELD)) {
cnp->cn_flags &= ~FSNODELOCKHELD;
unlock_fsnode(ndp->ni_dvp, NULL);
}
if (ndp->ni_dvp)
vnode_put(ndp->ni_dvp);
if (dp)
vnode_put(dp);
ndp->ni_vp = NULLVP;
if (kdebug_enable)
kdebug_lookup(dp, cnp);
return (error);
bad:
if ((cnp->cn_flags & FSNODELOCKHELD)) {
cnp->cn_flags &= ~FSNODELOCKHELD;
unlock_fsnode(ndp->ni_dvp, NULL);
}
if (dp)
vnode_put(dp);
ndp->ni_vp = NULLVP;
if (kdebug_enable)
kdebug_lookup(dp, cnp);
return (error);
}
/*
* Look up a vnode/nfsnode by file handle.
* Callers must check for mount points!!
* In all cases, a pointer to a
* nfsnode structure is returned.
*/
int
nfs_nget(
mount_t mp,
nfsnode_t dnp,
struct componentname *cnp,
u_char *fhp,
int fhsize,
struct nfs_vattr *nvap,
u_int64_t *xidp,
uint32_t auth,
int flags,
nfsnode_t *npp)
{
nfsnode_t np;
struct nfsnodehashhead *nhpp;
vnode_t vp;
int error, nfsvers;
mount_t mp2;
struct vnode_fsparam vfsp;
uint32_t vid;
FSDBG_TOP(263, mp, dnp, flags, npp);
/* Check for unmount in progress */
if (!mp || vfs_isforce(mp)) {
*npp = NULL;
error = ENXIO;
FSDBG_BOT(263, mp, dnp, 0xd1e, error);
return (error);
}
nfsvers = VFSTONFS(mp)->nm_vers;
nhpp = NFSNOHASH(nfs_hash(fhp, fhsize));
loop:
lck_mtx_lock(nfs_node_hash_mutex);
for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) {
mp2 = (np->n_hflag & NHINIT) ? np->n_mount : NFSTOMP(np);
if (mp != mp2 || np->n_fhsize != fhsize ||
bcmp(fhp, np->n_fhp, fhsize))
continue;
if (nvap && (nvap->nva_flags & NFS_FFLAG_TRIGGER_REFERRAL) &&
cnp && (cnp->cn_namelen > (fhsize - (int)sizeof(dnp)))) {
/* The name was too long to fit in the file handle. Check it against the node's name. */
int namecmp = 0;
const char *vname = vnode_getname(NFSTOV(np));
if (vname) {
if (cnp->cn_namelen != (int)strlen(vname))
namecmp = 1;
else
namecmp = strncmp(vname, cnp->cn_nameptr, cnp->cn_namelen);
vnode_putname(vname);
}
if (namecmp) /* full name didn't match */
continue;
}
FSDBG(263, dnp, np, np->n_flag, 0xcace0000);
/* if the node is locked, sleep on it */
if ((np->n_hflag & NHLOCKED) && !(flags & NG_NOCREATE)) {
np->n_hflag |= NHLOCKWANT;
FSDBG(263, dnp, np, np->n_flag, 0xcace2222);
msleep(np, nfs_node_hash_mutex, PDROP | PINOD, "nfs_nget", NULL);
FSDBG(263, dnp, np, np->n_flag, 0xcace3333);
goto loop;
}
vp = NFSTOV(np);
vid = vnode_vid(vp);
lck_mtx_unlock(nfs_node_hash_mutex);
if ((error = vnode_getwithvid(vp, vid))) {
/*
* If vnode is being reclaimed or has already
* changed identity, no need to wait.
*/
FSDBG_BOT(263, dnp, *npp, 0xcace0d1e, error);
return (error);
}
if ((error = nfs_node_lock(np))) {
/* this only fails if the node is now unhashed */
/* so let's see if we can find/create it again */
FSDBG(263, dnp, *npp, 0xcaced1e2, error);
vnode_put(vp);
if (flags & NG_NOCREATE) {
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0xcaced1e0, ENOENT);
return (ENOENT);
}
goto loop;
}
/* update attributes */
if (nvap)
error = nfs_loadattrcache(np, nvap, xidp, 0);
if (error) {
nfs_node_unlock(np);
vnode_put(vp);
} else {
if (dnp && cnp && (flags & NG_MAKEENTRY))
cache_enter(NFSTOV(dnp), vp, cnp);
/*
* Update the vnode if the name/and or the parent has
* changed. We need to do this so that if getattrlist is
* called asking for ATTR_CMN_NAME, that the "most"
* correct name is being returned. In addition for
* monitored vnodes we need to kick the vnode out of the
* name cache. We do this so that if there are hard
* links in the same directory the link will not be
* found and a lookup will get us here to return the
* name of the current link. In addition by removing the
* name from the name cache the old name will not be
* found after a rename done on another client or the
* server. The principle reason to do this is because
* Finder is asking for notifications on a directory.
* The directory changes, Finder gets notified, reads
* the directory (which we have purged) and for each
* entry returned calls getattrlist with the name
* returned from readdir. gettattrlist has to call
* namei/lookup to resolve the name, because its not in
* the cache we end up here. We need to update the name
* so Finder will get the name it called us with.
*
* We had an imperfect solution with respect to case
* sensitivity. There is a test that is run in
* FileBuster that does renames from some name to
* another name differing only in case. It then reads
* the directory looking for the new name, after it
* finds that new name, it ask gettattrlist to verify
* that the name is the new name. Usually that works,
* but renames generate fsevents and fseventsd will do a
* lookup on the name via lstat. Since that test renames
* old name to new name back and forth there is a race
* that an fsevent will be behind and will access the
* file by the old name, on a case insensitive file
* system that will work. Problem is if we do a case
* sensitive compare, we're going to change the name,
* which the test's getattrlist verification step is
* going to fail. So we will check the case sensitivity
* of the file system and do the appropriate compare. In
* a rare instance for non homogeneous file systems
* w.r.t. pathconf we will use case sensitive compares.
* That could break if the file system is actually case
* insensitive.
*
* Note that V2 does not know the case, so we just
* assume case sensitivity.
*
* This is clearly not perfect due to races, but this is
* as good as its going to get. You can defeat the
* handling of hard links simply by doing:
*
* while :; do ls -l > /dev/null; done
*
* in a terminal window. Even a single ls -l can cause a
* race.
*
* <rant>What we really need is for the caller, that
* knows the name being used is valid since it got it
* from a readdir to use that name and not ask for the
* ATTR_CMN_NAME</rant>
*/
if (dnp && cnp && (vp != NFSTOV(dnp))) {
int update_flags = (vnode_ismonitored((NFSTOV(dnp)))) ? VNODE_UPDATE_CACHE : 0;
int (*cmp)(const char *s1, const char *s2, size_t n);
cmp = nfs_case_insensitive(mp) ? strncasecmp : strncmp;
if (vp->v_name && cnp->cn_namelen && (*cmp)(cnp->cn_nameptr, vp->v_name, cnp->cn_namelen))
update_flags |= VNODE_UPDATE_NAME;
if ((vp->v_name == NULL && cnp->cn_namelen != 0) || (vp->v_name != NULL && cnp->cn_namelen == 0))
update_flags |= VNODE_UPDATE_NAME;
if (vnode_parent(vp) != NFSTOV(dnp))
update_flags |= VNODE_UPDATE_PARENT;
if (update_flags) {
NFS_NODE_DBG("vnode_update_identity old name %s new name %.*s update flags = %x\n",
vp->v_name, cnp->cn_namelen, cnp->cn_nameptr ? cnp->cn_nameptr : "", update_flags);
vnode_update_identity(vp, NFSTOV(dnp), cnp->cn_nameptr, cnp->cn_namelen, 0, update_flags);
}
}
*npp = np;
}
FSDBG_BOT(263, dnp, *npp, 0xcace0000, error);
return(error);
}
FSDBG(263, mp, dnp, npp, 0xaaaaaaaa);
if (flags & NG_NOCREATE) {
lck_mtx_unlock(nfs_node_hash_mutex);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000001, ENOENT);
return (ENOENT);
}
/*
* allocate and initialize nfsnode and stick it in the hash
* before calling getnewvnode(). Anyone finding it in the
* hash before initialization is complete will wait for it.
*/
MALLOC_ZONE(np, nfsnode_t, sizeof *np, M_NFSNODE, M_WAITOK);
if (!np) {
lck_mtx_unlock(nfs_node_hash_mutex);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000001, ENOMEM);
return (ENOMEM);
}
bzero(np, sizeof *np);
np->n_hflag |= (NHINIT | NHLOCKED);
np->n_mount = mp;
np->n_auth = auth;
TAILQ_INIT(&np->n_opens);
TAILQ_INIT(&np->n_lock_owners);
TAILQ_INIT(&np->n_locks);
np->n_dlink.tqe_next = NFSNOLIST;
np->n_dreturn.tqe_next = NFSNOLIST;
np->n_monlink.le_next = NFSNOLIST;
/* ugh... need to keep track of ".zfs" directories to workaround server bugs */
if ((nvap->nva_type == VDIR) && cnp && (cnp->cn_namelen == 4) &&
(cnp->cn_nameptr[0] == '.') && (cnp->cn_nameptr[1] == 'z') &&
(cnp->cn_nameptr[2] == 'f') && (cnp->cn_nameptr[3] == 's'))
np->n_flag |= NISDOTZFS;
if (dnp && (dnp->n_flag & NISDOTZFS))
np->n_flag |= NISDOTZFSCHILD;
if (dnp && cnp && ((cnp->cn_namelen != 2) ||
(cnp->cn_nameptr[0] != '.') || (cnp->cn_nameptr[1] != '.'))) {
vnode_t dvp = NFSTOV(dnp);
if (!vnode_get(dvp)) {
if (!vnode_ref(dvp))
np->n_parent = dvp;
vnode_put(dvp);
}
}
/* setup node's file handle */
if (fhsize > NFS_SMALLFH) {
MALLOC_ZONE(np->n_fhp, u_char *,
fhsize, M_NFSBIGFH, M_WAITOK);
if (!np->n_fhp) {
lck_mtx_unlock(nfs_node_hash_mutex);
FREE_ZONE(np, sizeof *np, M_NFSNODE);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000002, ENOMEM);
return (ENOMEM);
}
} else {
static int ufs_mkdir(uufsd_t *ufs, ino_t parent, ino_t inum, char *name)
{
int retval;
struct ufs_vnode *parent_vnode = NULL, *vnode = NULL;
struct inode *parent_inode, *inode;
ino_t ino = inum;
ino_t scratch_ino;
ufs2_daddr_t blk;
char *block = 0;
struct fs *fs = &ufs->d_fs;
int dirsize = DIRBLKSIZ;
int blocksize = fragroundup(fs, dirsize);
parent_vnode = vnode_get(ufs, parent);
if (!parent_vnode) {
return ENOENT;
}
parent_inode = vnode2inode(parent_vnode);
/*
* Allocate an inode, if necessary
*/
if (!ino) {
retval = ufs_valloc(parent_vnode, DTTOIF(DT_DIR), &vnode);
if (retval)
goto cleanup;
ino = vnode->inode.i_number;
inode = vnode2inode(vnode);
}
/*
* Allocate a data block for the directory
*/
retval = ufs_block_alloc(ufs, inode, fragroundup(fs, dirsize), &blk);
if (retval)
goto cleanup;
/*
* Create a scratch template for the directory
*/
retval = ufs_new_dir_block(ufs, vnode->inode.i_number, parent_vnode, &block);
if (retval)
goto cleanup;
/*
* Get the parent's inode, if necessary
if (parent != ino) {
parent_vnode = vnode_get(ufs, parent);
if (retval)
goto cleanup;
} else
memset(&parent_inode, 0, sizeof(parent_inode));
*/
/*
* Create the inode structure....
*/
inode->i_mode = DT_DIR | (0777);
inode->i_uid = inode->i_gid = 0;
UFS_DINODE(inode)->di_db[0] = blk;
inode->i_nlink = 1;
inode->i_size = dirsize;
/*
* Write out the inode and inode data block
*/
retval = blkwrite(ufs, fsbtodb(fs, blk), block, blocksize);
if (retval == -1)
goto cleanup;
/*
* Link the directory into the filesystem hierarchy
*/
if (name) {
retval = ufs_lookup(ufs, parent, name, strlen(name),
&scratch_ino);
if (!retval) {
retval = EEXIST;
name = 0;
goto cleanup;
}
if (retval != ENOENT)
goto cleanup;
retval = ufs_link(ufs, parent, name, vnode, DTTOIF(DT_DIR));
if (retval)
goto cleanup;
}
/*
* Update parent inode's counts
*/
if (parent != ino) {
parent_inode->i_nlink++;
}
cleanup:
if (vnode)
vnode_put(vnode, 1);
if (parent_vnode)
vnode_put(parent_vnode, 1);
if (block)
ufs_free_mem(&block);
return retval;
}
/*
* We have to carry on the locking protocol on the null layer vnodes
* as we progress through the tree. We also have to enforce read-only
* if this layer is mounted read-only.
*/
static int
null_lookup(struct vnop_lookup_args * ap)
{
struct componentname * cnp = ap->a_cnp;
struct vnode * dvp = ap->a_dvp;
struct vnode *vp, *ldvp, *lvp;
struct mount * mp;
struct null_mount * null_mp;
int error;
NULLFSDEBUG("%s parent: %p component: %.*s\n", __FUNCTION__, ap->a_dvp, cnp->cn_namelen, cnp->cn_nameptr);
mp = vnode_mount(dvp);
/* rename and delete are not allowed. this is a read only file system */
if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME || cnp->cn_nameiop == CREATE) {
return (EROFS);
}
null_mp = MOUNTTONULLMOUNT(mp);
lck_mtx_lock(&null_mp->nullm_lock);
if (nullfs_isspecialvp(dvp)) {
error = null_special_lookup(ap);
lck_mtx_unlock(&null_mp->nullm_lock);
return error;
}
lck_mtx_unlock(&null_mp->nullm_lock);
// . and .. handling
if (cnp->cn_nameptr[0] == '.') {
if (cnp->cn_namelen == 1) {
vp = dvp;
} else if (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.') {
/* mount point crossing is handled in null_special_lookup */
vp = vnode_parent(dvp);
} else {
goto notdot;
}
error = vp ? vnode_get(vp) : ENOENT;
if (error == 0) {
*ap->a_vpp = vp;
}
return error;
}
notdot:
ldvp = NULLVPTOLOWERVP(dvp);
vp = lvp = NULL;
/*
* Hold ldvp. The reference on it, owned by dvp, is lost in
* case of dvp reclamation.
*/
error = vnode_getwithref(ldvp);
if (error) {
return error;
}
error = VNOP_LOOKUP(ldvp, &lvp, cnp, ap->a_context);
vnode_put(ldvp);
if ((error == 0 || error == EJUSTRETURN) && lvp != NULL) {
if (ldvp == lvp) {
vp = dvp;
error = vnode_get(vp);
} else {
error = null_nodeget(mp, lvp, dvp, &vp, cnp, 0);
}
if (error == 0) {
*ap->a_vpp = vp;
}
}
/* if we got lvp, drop the iocount from VNOP_LOOKUP */
if (lvp != NULL) {
vnode_put(lvp);
}
return (error);
}
/* the mountpoint lock should be held going into this function */
static int
null_special_lookup(struct vnop_lookup_args * ap)
{
struct componentname * cnp = ap->a_cnp;
struct vnode * dvp = ap->a_dvp;
struct vnode * ldvp = NULL;
struct vnode * lvp = NULL;
struct vnode * vp = NULL;
struct mount * mp = vnode_mount(dvp);
struct null_mount * null_mp = MOUNTTONULLMOUNT(mp);
int error = ENOENT;
if (dvp == null_mp->nullm_rootvp) {
/* handle . and .. */
if (cnp->cn_nameptr[0] == '.') {
if (cnp->cn_namelen == 1 || (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.')) {
/* this is the root so both . and .. give back the root */
vp = dvp;
error = vnode_get(vp);
goto end;
}
}
/* our virtual wrapper directory should be d but D is acceptable if the
* lower file system is case insensitive */
if (cnp->cn_namelen == 1 &&
(cnp->cn_nameptr[0] == 'd' || (null_mp->nullm_flags & NULLM_CASEINSENSITIVE ? cnp->cn_nameptr[0] == 'D' : 0))) {
error = 0;
if (null_mp->nullm_secondvp == NULL) {
error = null_getnewvnode(mp, NULL, dvp, &vp, cnp, 0);
if (error) {
goto end;
}
null_mp->nullm_secondvp = vp;
} else {
vp = null_mp->nullm_secondvp;
error = vnode_get(vp);
}
}
} else if (dvp == null_mp->nullm_secondvp) {
/* handle . and .. */
if (cnp->cn_nameptr[0] == '.') {
if (cnp->cn_namelen == 1) {
vp = dvp;
error = vnode_get(vp);
goto end;
} else if (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.') {
/* parent here is the root vp */
vp = null_mp->nullm_rootvp;
error = vnode_get(vp);
goto end;
}
}
/* nullmp->nullm_lowerrootvp was set at mount time so don't need to lock to
* access it */
/* v_name should be null terminated but cn_nameptr is not necessarily.
cn_namelen is the number of characters before the null in either case */
error = vnode_getwithvid(null_mp->nullm_lowerrootvp, null_mp->nullm_lowerrootvid);
if (error) {
goto end;
}
/* We don't want to mess with case insensitivity and unicode, so the plan to
check here is
1. try to get the lower root's parent
2. If we get a parent, then perform a lookup on the lower file system
using the parent and the passed in cnp
3. If that worked and we got a vp, then see if the vp is lowerrootvp. If
so we got a match
4. Anything else results in ENOENT.
*/
error = null_get_lowerparent(null_mp->nullm_lowerrootvp, &ldvp, ap->a_context);
if (error == 0) {
error = VNOP_LOOKUP(ldvp, &lvp, cnp, ap->a_context);
vnode_put(ldvp);
if (error == 0) {
if (lvp == null_mp->nullm_lowerrootvp) {
/* always check the hashmap for a vnode for this, the root of the
* mirrored system */
error = null_nodeget(mp, lvp, dvp, &vp, cnp, 0);
if (error == 0 && null_mp->nullm_thirdcovervp == NULL) {
/* if nodeget succeeded then vp has an iocount*/
null_mp->nullm_thirdcovervp = vp;
}
} else {
error = ENOENT;
}
vnode_put(lvp);
}
}
vnode_put(null_mp->nullm_lowerrootvp);
}
end:
if (error == 0) {
*ap->a_vpp = vp;
}
return error;
}
/* works like PFlushVolumeData */
void
darwin_notify_perms(struct unixuser *auser, int event)
{
int i;
struct afs_q *tq, *uq = NULL;
struct vcache *tvc, *hnext;
int isglock = ISAFS_GLOCK();
struct vnode *vp;
struct vnode_attr va;
int isctxtowner = 0;
if (!afs_darwin_fsevents)
return;
VATTR_INIT(&va);
VATTR_SET(&va, va_mode, 0777);
if (event & UTokensObtained)
VATTR_SET(&va, va_uid, auser->uid);
else
VATTR_SET(&va, va_uid, -2); /* nobody */
if (!isglock)
AFS_GLOCK();
if (!(vfs_context_owner == current_thread())) {
get_vfs_context();
isctxtowner = 1;
}
loop:
ObtainReadLock(&afs_xvcache);
for (i = 0; i < VCSIZE; i++) {
for (tq = afs_vhashTV[i].prev; tq != &afs_vhashTV[i]; tq = uq) {
uq = QPrev(tq);
tvc = QTOVH(tq);
if (tvc->f.states & CDeadVnode) {
/* we can afford to be best-effort */
continue;
}
/* no per-file acls, so only notify on directories */
if (!(vp = AFSTOV(tvc)) || !vnode_isdir(AFSTOV(tvc)))
continue;
/* dynroot object. no callbacks. anonymous ACL. just no. */
if (afs_IsDynrootFid(&tvc->f.fid))
continue;
/* no fake fsevents on mount point sources. leaks refs */
if (tvc->mvstat == 1)
continue;
/* if it's being reclaimed, just pass */
if (vnode_get(vp))
continue;
if (vnode_ref(vp)) {
AFS_GUNLOCK();
vnode_put(vp);
AFS_GLOCK();
continue;
}
ReleaseReadLock(&afs_xvcache);
/* Avoid potentially re-entering on this lock */
if (0 == NBObtainWriteLock(&tvc->lock, 234)) {
tvc->f.states |= CEvent;
AFS_GUNLOCK();
vnode_setattr(vp, &va, afs_osi_ctxtp);
tvc->f.states &= ~CEvent;
vnode_put(vp);
AFS_GLOCK();
ReleaseWriteLock(&tvc->lock);
}
ObtainReadLock(&afs_xvcache);
uq = QPrev(tq);
/* our tvc ptr is still good until now */
AFS_FAST_RELE(tvc);
}
}
ReleaseReadLock(&afs_xvcache);
if (isctxtowner)
put_vfs_context();
if (!isglock)
AFS_GUNLOCK();
}
struct vcache *
osi_dnlc_lookup(struct vcache *adp, char *aname, int locktype)
{
struct vcache *tvc;
int LRUme;
unsigned int key, skey;
char *ts = aname;
struct nc *tnc, *tnc1 = 0;
int safety;
#ifdef AFS_DARWIN80_ENV
vnode_t tvp;
#endif
ma_critical_enter();
if (!afs_usednlc) {
ma_critical_exit();
return 0;
}
dnlcHash(ts, key); /* leaves ts pointing at the NULL */
if (ts - aname >= AFSNCNAMESIZE) {
ma_critical_exit();
return 0;
}
skey = key & (NHSIZE - 1);
TRACE(osi_dnlc_lookupT, skey);
dnlcstats.lookups++;
ObtainReadLock(&afs_xvcache);
ObtainReadLock(&afs_xdnlc);
for (tvc = NULL, tnc = nameHash[skey], safety = 0; tnc;
tnc = tnc->next, safety++) {
if ( /* (tnc->key == key) && */ (tnc->dirp == adp)
&& (!strcmp((char *)tnc->name, aname))) {
tvc = tnc->vp;
tnc1 = tnc;
break;
} else if (tnc->next == nameHash[skey]) { /* end of list */
break;
} else if (safety > NCSIZE) {
afs_warn("DNLC cycle");
dnlcstats.cycles++;
ReleaseReadLock(&afs_xdnlc);
ReleaseReadLock(&afs_xvcache);
osi_dnlc_purge();
ma_critical_exit();
return (0);
}
}
LRUme = 0; /* (tnc != nameHash[skey]); */
ReleaseReadLock(&afs_xdnlc);
if (!tvc) {
ReleaseReadLock(&afs_xvcache);
dnlcstats.misses++;
} else {
if ((tvc->f.states & CVInit)
#ifdef AFS_DARWIN80_ENV
||(tvc->f.states & CDeadVnode)
#endif
)
{
ReleaseReadLock(&afs_xvcache);
dnlcstats.misses++;
osi_dnlc_remove(adp, aname, tvc);
ma_critical_exit();
return 0;
}
#if defined(AFS_DARWIN80_ENV)
tvp = AFSTOV(tvc);
if (vnode_get(tvp)) {
ReleaseReadLock(&afs_xvcache);
dnlcstats.misses++;
osi_dnlc_remove(adp, aname, tvc);
ma_critical_exit();
return 0;
}
if (vnode_ref(tvp)) {
ReleaseReadLock(&afs_xvcache);
AFS_GUNLOCK();
vnode_put(tvp);
AFS_GLOCK();
dnlcstats.misses++;
osi_dnlc_remove(adp, aname, tvc);
ma_critical_exit();
return 0;
}
#elif defined(AFS_FBSD_ENV)
/* can't sleep in a critical section */
ma_critical_exit();
osi_vnhold(tvc, 0);
ma_critical_enter();
#else
osi_vnhold(tvc, 0);
#endif
ReleaseReadLock(&afs_xvcache);
#ifdef notdef
/*
* XX If LRUme ever is non-zero change the if statement around because
* aix's cc with optimizer on won't necessarily check things in order XX
*/
if (LRUme && (0 == NBObtainWriteLock(&afs_xdnlc))) {
/* don't block to do this */
/* tnc might have been moved during race condition, */
/* but it's always in a legit hash chain when a lock is granted,
* or else it's on the freelist so prev == NULL,
* so at worst this is redundant */
/* Now that we've got it held, and a lock on the dnlc, we
* should check to be sure that there was no race, and
* bail out if there was. */
if (tnc->prev) {
/* special case for only two elements on list - relative ordering
* doesn't change */
if (tnc->prev != tnc->next) {
/* remove from old location */
tnc->prev->next = tnc->next;
tnc->next->prev = tnc->prev;
/* insert into new location */
tnc->next = nameHash[skey];
tnc->prev = tnc->next->prev;
tnc->next->prev = tnc;
tnc->prev->next = tnc;
}
nameHash[skey] = tnc;
}
ReleaseWriteLock(&afs_xdnlc);
}
#endif
}
ma_critical_exit();
return tvc;
}
struct vcache *
osi_dnlc_lookup(struct vcache *adp, char *aname, int locktype)
{
struct vcache *tvc;
unsigned int key, skey;
char *ts = aname;
struct nc *tnc;
int safety;
#ifdef AFS_DARWIN80_ENV
vnode_t tvp;
#endif
if (!afs_usednlc)
return 0;
dnlcHash(ts, key); /* leaves ts pointing at the NULL */
if (ts - aname >= AFSNCNAMESIZE)
return 0;
skey = key & (NHSIZE - 1);
TRACE(osi_dnlc_lookupT, skey);
dnlcstats.lookups++;
ObtainReadLock(&afs_xvcache);
ObtainReadLock(&afs_xdnlc);
for (tvc = NULL, tnc = nameHash[skey], safety = 0; tnc;
tnc = tnc->next, safety++) {
if ( /* (tnc->key == key) && */ (tnc->dirp == adp)
&& (!strcmp((char *)tnc->name, aname))) {
tvc = tnc->vp;
break;
} else if (tnc->next == nameHash[skey]) { /* end of list */
break;
} else if (safety > NCSIZE) {
afs_warn("DNLC cycle");
dnlcstats.cycles++;
ReleaseReadLock(&afs_xdnlc);
ReleaseReadLock(&afs_xvcache);
osi_dnlc_purge();
return (0);
}
}
ReleaseReadLock(&afs_xdnlc);
if (!tvc) {
ReleaseReadLock(&afs_xvcache);
dnlcstats.misses++;
} else {
if ((tvc->f.states & CVInit)
#ifdef AFS_DARWIN80_ENV
||(tvc->f.states & CDeadVnode)
#endif
)
{
ReleaseReadLock(&afs_xvcache);
dnlcstats.misses++;
osi_dnlc_remove(adp, aname, tvc);
return 0;
}
#if defined(AFS_DARWIN80_ENV)
tvp = AFSTOV(tvc);
if (vnode_get(tvp)) {
ReleaseReadLock(&afs_xvcache);
dnlcstats.misses++;
osi_dnlc_remove(adp, aname, tvc);
return 0;
}
if (vnode_ref(tvp)) {
ReleaseReadLock(&afs_xvcache);
AFS_GUNLOCK();
vnode_put(tvp);
AFS_GLOCK();
dnlcstats.misses++;
osi_dnlc_remove(adp, aname, tvc);
return 0;
}
#else
osi_vnhold(tvc, 0);
#endif
ReleaseReadLock(&afs_xvcache);
}
return tvc;
}
/*
* Search a pathname.
* This is a very central and rather complicated routine.
*
* The pathname is pointed to by ni_ptr and is of length ni_pathlen.
* The starting directory is taken from ni_startdir. The pathname is
* descended until done, or a symbolic link is encountered. The variable
* ni_more is clear if the path is completed; it is set to one if a
* symbolic link needing interpretation is encountered.
*
* The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
* whether the name is to be looked up, created, renamed, or deleted.
* When CREATE, RENAME, or DELETE is specified, information usable in
* creating, renaming, or deleting a directory entry may be calculated.
* If flag has LOCKPARENT or'ed into it, the parent directory is returned
* locked. If flag has WANTPARENT or'ed into it, the parent directory is
* returned unlocked. Otherwise the parent directory is not returned. If
* the target of the pathname exists and LOCKLEAF is or'ed into the flag
* the target is returned locked, otherwise it is returned unlocked.
* When creating or renaming and LOCKPARENT is specified, the target may not
* be ".". When deleting and LOCKPARENT is specified, the target may be ".".
*
* Overall outline of lookup:
*
* dirloop:
* identify next component of name at ndp->ni_ptr
* handle degenerate case where name is null string
* if .. and crossing mount points and on mounted filesys, find parent
* call VNOP_LOOKUP routine for next component name
* directory vnode returned in ni_dvp, unlocked unless LOCKPARENT set
* component vnode returned in ni_vp (if it exists), locked.
* if result vnode is mounted on and crossing mount points,
* find mounted on vnode
* if more components of name, do next level at dirloop
* return the answer in ni_vp, locked if LOCKLEAF set
* if LOCKPARENT set, return locked parent in ni_dvp
* if WANTPARENT set, return unlocked parent in ni_dvp
*
* Returns: 0 Success
* ENOENT No such file or directory
* EBADF Bad file descriptor
* ENOTDIR Not a directory
* EROFS Read-only file system [CREATE]
* EISDIR Is a directory [CREATE]
* cache_lookup_path:ERECYCLE (vnode was recycled from underneath us, redrive lookup again)
* vnode_authorize:EROFS
* vnode_authorize:EACCES
* vnode_authorize:EPERM
* vnode_authorize:???
* VNOP_LOOKUP:ENOENT No such file or directory
* VNOP_LOOKUP:EJUSTRETURN Restart system call (INTERNAL)
* VNOP_LOOKUP:???
* VFS_ROOT:ENOTSUP
* VFS_ROOT:ENOENT
* VFS_ROOT:???
*/
int
lookup(struct nameidata *ndp)
{
char *cp; /* pointer into pathname argument */
vnode_t tdp; /* saved dp */
vnode_t dp; /* the directory we are searching */
int docache = 1; /* == 0 do not cache last component */
int wantparent; /* 1 => wantparent or lockparent flag */
int rdonly; /* lookup read-only flag bit */
int dp_authorized = 0;
int error = 0;
struct componentname *cnp = &ndp->ni_cnd;
vfs_context_t ctx = cnp->cn_context;
int vbusyflags = 0;
int nc_generation = 0;
vnode_t last_dp = NULLVP;
int keep_going;
int atroot;
/*
* Setup: break out flag bits into variables.
*/
if (cnp->cn_flags & (NOCACHE | DOWHITEOUT)) {
if ((cnp->cn_flags & NOCACHE) || (cnp->cn_nameiop == DELETE))
docache = 0;
}
wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT);
rdonly = cnp->cn_flags & RDONLY;
cnp->cn_flags &= ~ISSYMLINK;
cnp->cn_consume = 0;
dp = ndp->ni_startdir;
ndp->ni_startdir = NULLVP;
if ((cnp->cn_flags & CN_NBMOUNTLOOK) != 0)
vbusyflags = LK_NOWAIT;
cp = cnp->cn_nameptr;
if (*cp == '\0') {
if ( (vnode_getwithref(dp)) ) {
dp = NULLVP;
error = ENOENT;
goto bad;
}
ndp->ni_vp = dp;
error = lookup_handle_emptyname(ndp, cnp, wantparent);
if (error) {
goto bad;
}
return 0;
}
dirloop:
atroot = 0;
ndp->ni_vp = NULLVP;
if ( (error = cache_lookup_path(ndp, cnp, dp, ctx, &dp_authorized, last_dp)) ) {
dp = NULLVP;
goto bad;
}
if ((cnp->cn_flags & ISLASTCN)) {
if (docache)
cnp->cn_flags |= MAKEENTRY;
} else
cnp->cn_flags |= MAKEENTRY;
dp = ndp->ni_dvp;
if (ndp->ni_vp != NULLVP) {
/*
* cache_lookup_path returned a non-NULL ni_vp then,
* we're guaranteed that the dp is a VDIR, it's
* been authorized, and vp is not ".."
*
* make sure we don't try to enter the name back into
* the cache if this vp is purged before we get to that
* check since we won't have serialized behind whatever
* activity is occurring in the FS that caused the purge
*/
if (dp != NULLVP)
nc_generation = dp->v_nc_generation - 1;
goto returned_from_lookup_path;
}
/*
* Handle "..": two special cases.
* 1. If at root directory (e.g. after chroot)
* or at absolute root directory
* then ignore it so can't get out.
* 2. If this vnode is the root of a mounted
* filesystem, then replace it with the
* vnode which was mounted on so we take the
* .. in the other file system.
*/
if ( (cnp->cn_flags & ISDOTDOT) ) {
for (;;) {
if (dp == ndp->ni_rootdir || dp == rootvnode) {
ndp->ni_dvp = dp;
ndp->ni_vp = dp;
/*
* we're pinned at the root
* we've already got one reference on 'dp'
* courtesy of cache_lookup_path... take
* another one for the ".."
* if we fail to get the new reference, we'll
* drop our original down in 'bad'
*/
if ( (vnode_get(dp)) ) {
error = ENOENT;
goto bad;
}
atroot = 1;
goto returned_from_lookup_path;
}
if ((dp->v_flag & VROOT) == 0 ||
(cnp->cn_flags & NOCROSSMOUNT))
break;
if (dp->v_mount == NULL) { /* forced umount */
error = EBADF;
goto bad;
}
tdp = dp;
dp = tdp->v_mount->mnt_vnodecovered;
vnode_put(tdp);
if ( (vnode_getwithref(dp)) ) {
dp = NULLVP;
error = ENOENT;
goto bad;
}
ndp->ni_dvp = dp;
dp_authorized = 0;
}
}
/*
* We now have a segment name to search for, and a directory to search.
*/
unionlookup:
ndp->ni_vp = NULLVP;
if (dp->v_type != VDIR) {
error = ENOTDIR;
goto lookup_error;
}
if ( (cnp->cn_flags & DONOTAUTH) != DONOTAUTH ) {
error = lookup_authorize_search(dp, cnp, dp_authorized, ctx);
if (error) {
goto lookup_error;
}
}
/*
* Now that we've authorized a lookup, can bail out if the filesystem
* will be doing a batched operation. Return an iocount on dvp.
*/
#if NAMEDRSRCFORK
if ((cnp->cn_flags & ISLASTCN) && namei_compound_available(dp, ndp) && !(cnp->cn_flags & CN_WANTSRSRCFORK)) {
#else
if ((cnp->cn_flags & ISLASTCN) && namei_compound_available(dp, ndp)) {
#endif /* NAMEDRSRCFORK */
ndp->ni_flag |= NAMEI_UNFINISHED;
ndp->ni_ncgeneration = dp->v_nc_generation;
return 0;
}
nc_generation = dp->v_nc_generation;
error = VNOP_LOOKUP(dp, &ndp->ni_vp, cnp, ctx);
if ( error ) {
lookup_error:
if ((error == ENOENT) &&
(dp->v_flag & VROOT) && (dp->v_mount != NULL) &&
(dp->v_mount->mnt_flag & MNT_UNION)) {
#if CONFIG_VFS_FUNNEL
if ((cnp->cn_flags & FSNODELOCKHELD)) {
cnp->cn_flags &= ~FSNODELOCKHELD;
unlock_fsnode(dp, NULL);
}
#endif /* CONFIG_VFS_FUNNEL */
tdp = dp;
dp = tdp->v_mount->mnt_vnodecovered;
vnode_put(tdp);
if ( (vnode_getwithref(dp)) ) {
dp = NULLVP;
error = ENOENT;
goto bad;
}
ndp->ni_dvp = dp;
dp_authorized = 0;
goto unionlookup;
}
if (error != EJUSTRETURN)
goto bad;
if (ndp->ni_vp != NULLVP)
panic("leaf should be empty");
error = lookup_validate_creation_path(ndp);
if (error)
goto bad;
/*
* We return with ni_vp NULL to indicate that the entry
* doesn't currently exist, leaving a pointer to the
* referenced directory vnode in ndp->ni_dvp.
*/
if (cnp->cn_flags & SAVESTART) {
if ( (vnode_get(ndp->ni_dvp)) ) {
error = ENOENT;
goto bad;
}
ndp->ni_startdir = ndp->ni_dvp;
}
if (!wantparent)
vnode_put(ndp->ni_dvp);
if (kdebug_enable)
kdebug_lookup(ndp->ni_dvp, cnp);
return (0);
}
returned_from_lookup_path:
/* We'll always have an iocount on ni_vp when this finishes. */
error = lookup_handle_found_vnode(ndp, cnp, rdonly, vbusyflags, &keep_going, nc_generation, wantparent, atroot, ctx);
if (error != 0) {
goto bad2;
}
if (keep_going) {
dp = ndp->ni_vp;
/* namei() will handle symlinks */
if ((dp->v_type == VLNK) &&
((cnp->cn_flags & FOLLOW) || (ndp->ni_flag & NAMEI_TRAILINGSLASH) || *ndp->ni_next == '/')) {
return 0;
}
/*
* Otherwise, there's more path to process.
* cache_lookup_path is now responsible for dropping io ref on dp
* when it is called again in the dirloop. This ensures we hold
* a ref on dp until we complete the next round of lookup.
*/
last_dp = dp;
goto dirloop;
}
return (0);
bad2:
#if CONFIG_VFS_FUNNEL
if ((cnp->cn_flags & FSNODELOCKHELD)) {
cnp->cn_flags &= ~FSNODELOCKHELD;
unlock_fsnode(ndp->ni_dvp, NULL);
}
#endif /* CONFIG_VFS_FUNNEL */
if (ndp->ni_dvp)
vnode_put(ndp->ni_dvp);
vnode_put(ndp->ni_vp);
ndp->ni_vp = NULLVP;
if (kdebug_enable)
kdebug_lookup(dp, cnp);
return (error);
bad:
#if CONFIG_VFS_FUNNEL
if ((cnp->cn_flags & FSNODELOCKHELD)) {
cnp->cn_flags &= ~FSNODELOCKHELD;
unlock_fsnode(ndp->ni_dvp, NULL);
}
#endif /* CONFIG_VFS_FUNNEL */
if (dp)
vnode_put(dp);
ndp->ni_vp = NULLVP;
if (kdebug_enable)
kdebug_lookup(dp, cnp);
return (error);
}
int
lookup_validate_creation_path(struct nameidata *ndp)
{
struct componentname *cnp = &ndp->ni_cnd;
/*
* If creating and at end of pathname, then can consider
* allowing file to be created.
*/
if (cnp->cn_flags & RDONLY) {
return EROFS;
}
if ((cnp->cn_flags & ISLASTCN) && (ndp->ni_flag & NAMEI_TRAILINGSLASH) && !(cnp->cn_flags & WILLBEDIR)) {
return ENOENT;
}
return 0;
}
/*
* Modifies only ni_vp. Always returns with ni_vp still valid (iocount held).
*/
int
lookup_traverse_mountpoints(struct nameidata *ndp, struct componentname *cnp, vnode_t dp,
int vbusyflags, vfs_context_t ctx)
{
mount_t mp;
vnode_t tdp;
int error = 0;
uthread_t uth;
uint32_t depth = 0;
int dont_cache_mp = 0;
vnode_t mounted_on_dp;
int current_mount_generation = 0;
mounted_on_dp = dp;
current_mount_generation = mount_generation;
while ((dp->v_type == VDIR) && dp->v_mountedhere &&
((cnp->cn_flags & NOCROSSMOUNT) == 0)) {
#if CONFIG_TRIGGERS
/*
* For a trigger vnode, call its resolver when crossing its mount (if requested)
*/
if (dp->v_resolve) {
(void) vnode_trigger_resolve(dp, ndp, ctx);
}
#endif
vnode_lock(dp);
if ((dp->v_type == VDIR) && (mp = dp->v_mountedhere)) {
mp->mnt_crossref++;
vnode_unlock(dp);
if (vfs_busy(mp, vbusyflags)) {
mount_dropcrossref(mp, dp, 0);
if (vbusyflags == LK_NOWAIT) {
error = ENOENT;
goto out;
}
continue;
}
/*
* XXX - if this is the last component of the
* pathname, and it's either not a lookup operation
* or the NOTRIGGER flag is set for the operation,
* set a uthread flag to let VFS_ROOT() for autofs
* know it shouldn't trigger a mount.
*/
uth = (struct uthread *)get_bsdthread_info(current_thread());
if ((cnp->cn_flags & ISLASTCN) &&
(cnp->cn_nameiop != LOOKUP ||
(cnp->cn_flags & NOTRIGGER))) {
uth->uu_notrigger = 1;
dont_cache_mp = 1;
}
error = VFS_ROOT(mp, &tdp, ctx);
/* XXX - clear the uthread flag */
uth->uu_notrigger = 0;
mount_dropcrossref(mp, dp, 0);
vfs_unbusy(mp);
if (error) {
goto out;
}
vnode_put(dp);
ndp->ni_vp = dp = tdp;
depth++;
#if CONFIG_TRIGGERS
/*
* Check if root dir is a trigger vnode
*/
if (dp->v_resolve) {
error = vnode_trigger_resolve(dp, ndp, ctx);
if (error) {
goto out;
}
}
#endif
} else {
vnode_unlock(dp);
break;
}
}
if (depth && !dont_cache_mp) {
mp = mounted_on_dp->v_mountedhere;
if (mp) {
mount_lock_spin(mp);
mp->mnt_realrootvp_vid = dp->v_id;
mp->mnt_realrootvp = dp;
mp->mnt_generation = current_mount_generation;
mount_unlock(mp);
}
}
return 0;
out:
return error;
}
static int
vnop_lookup_9p(struct vnop_lookup_args *ap)
{
struct componentname *cnp;
node_9p *dnp;
vnode_t *vpp, dvp;
fid_9p fid;
qid_9p qid;
int e;
TRACE();
dvp = ap->a_dvp;
vpp = ap->a_vpp;
cnp = ap->a_cnp;
dnp = NTO9P(dvp);
if(!vnode_isdir(dvp))
return ENOTDIR;
if (isdotdot(cnp) && vnode_isvroot(dvp))
return EIO;
if (islastcn(cnp) && !isop(cnp, LOOKUP) && vnode_vfsisrdonly(dvp))
return EROFS;
if (isdot(cnp)) {
if (islastcn(cnp) && isop(cnp, RENAME))
return EISDIR;
if ((e=vnode_get(dvp)))
return e;
*vpp = dvp;
return 0;
}
if (isdotdot(cnp)) {
*vpp = vnode_getparent(dvp);
if (*vpp == NULL)
return ENOENT;
return 0;
}
e = cache_lookup(dvp, vpp, cnp);
if (e == -1) /* found */
return 0;
if (e != 0) /* errno */
return e;
/* not in cache */
nlock_9p(dnp, NODE_LCK_EXCLUSIVE);
e = walk_9p(dnp->nmp, dnp->fid, cnp->cn_nameptr, cnp->cn_namelen, &fid, &qid);
if (e) {
if (islastcn(cnp)) {
if (isop(cnp, CREATE) || isop(cnp, RENAME))
e = EJUSTRETURN;
else if (ismkentry(cnp) && dnp->dir.qid.vers!=0)
cache_enter(dvp, NULL, cnp);
}
goto error;
}
e = nget_9p(dnp->nmp, fid, qid, dvp, vpp, cnp, ap->a_context);
if (e || *vpp==NULL || NTO9P(*vpp)->fid!=fid)
clunk_9p(dnp->nmp, fid);
if (*vpp)
nunlock_9p(NTO9P(*vpp));
error:
nunlock_9p(dnp);
return e;
}
int ufs_dir_iterate(uufsd_t *ufs, ino_t dirino,
int (*func)(
struct direct *dirent,
int n,
char *buf,
void *priv_data),
void *priv_data)
{
int i, ret = 0;
ufs2_daddr_t ndb;
ufs2_daddr_t blkno;
int blksize = ufs->d_fs.fs_bsize;
u_int64_t dir_size;
char *dirbuf = NULL;
struct ufs_vnode *vnode;
vnode = vnode_get(ufs, dirino);
if (vnode == NULL) {
ret = -ENOMEM;
goto out;
}
dir_size = vnode2inode(vnode)->i_size;
dirbuf = malloc(blksize);
if (!dirbuf) {
ret = -ENOMEM;
goto out;
}
ndb = howmany(dir_size, ufs->d_fs.fs_bsize);
int offset, pos = 0;
for (i = 0; i < ndb ; i++) {
ret = ufs_bmap(ufs, vnode, i, &blkno);
if (ret) {
ret = -EIO;
goto out;
}
blksize = ufs_inode_io_size(vnode2inode(vnode), pos, 0);
if (blkread(ufs, fsbtodb(&ufs->d_fs, blkno), dirbuf, blksize) == -1) {
debugf("Unable to read block %d\n",blkno);
ret = -EIO;
goto out;
}
offset = 0;
while (offset < blksize && pos + offset < dir_size) {
struct direct *de = (struct direct *)(dirbuf + offset);
/* HACK: Restrict frame for func() operations
* to blocks of DIRBLKSIZ bytes
*/
int blockoff = offset % DIRBLKSIZ;
char * dirblock = dirbuf + (offset-blockoff);
ret = (*func)(de, blockoff, dirblock, priv_data);
if (ret & DIRENT_CHANGED) {
if (blkwrite(ufs, fsbtodb(&ufs->d_fs, blkno), dirbuf, blksize) == -1) {
debugf("Unable to write block %d\n",blkno);
ret = -EIO;
goto out;
}
}
if (ret & DIRENT_ABORT) {
ret = 0;
goto out;
}
offset += de->d_reclen;
}
pos += blksize;
}
out:
if (vnode) {
vnode_put(vnode, 0);
}
if (dirbuf) {
free(dirbuf);
}
return ret;
}
/*
* Lookup *cnp in directory *dvp, return it in *vpp.
* **vpp is held on exit.
* We create a cnode for the file, but we do NOT open the file here.
#% lookup dvp L ? ?
#% lookup vpp - L -
IN struct vnode *dvp - Parent node of file;
INOUT struct vnode **vpp - node of target file, its a new node if
the target vnode did not exist;
IN struct componentname *cnp - Name of file;
* When should we lock parent_hp in here ??
*/
static int
hfs_lookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, int *cnode_locked, int force_casesensitive_lookup)
{
struct cnode *dcp; /* cnode for directory being searched */
struct vnode *tvp; /* target vnode */
struct hfsmount *hfsmp;
int flags;
int nameiop;
int retval = 0;
int isDot;
struct cat_desc desc;
struct cat_desc cndesc;
struct cat_attr attr;
struct cat_fork fork;
int lockflags;
int newvnode_flags;
retry:
newvnode_flags = 0;
dcp = NULL;
hfsmp = VTOHFS(dvp);
*vpp = NULL;
*cnode_locked = 0;
isDot = FALSE;
tvp = NULL;
nameiop = cnp->cn_nameiop;
flags = cnp->cn_flags;
bzero(&desc, sizeof(desc));
/*
* First check to see if it is a . or .., else look it up.
*/
if (flags & ISDOTDOT) { /* Wanting the parent */
cnp->cn_flags &= ~MAKEENTRY;
goto found; /* .. is always defined */
} else if ((cnp->cn_nameptr[0] == '.') && (cnp->cn_namelen == 1)) {
isDot = TRUE;
cnp->cn_flags &= ~MAKEENTRY;
goto found; /* We always know who we are */
} else {
if (hfs_lock(VTOC(dvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {
retval = ENOENT; /* The parent no longer exists ? */
goto exit;
}
dcp = VTOC(dvp);
if (dcp->c_flag & C_DIR_MODIFICATION) {
// XXXdbg - if we could msleep on a lck_rw_t then we would do that
// but since we can't we have to unlock, delay for a bit
// and then retry...
// msleep((caddr_t)&dcp->c_flag, &dcp->c_rwlock, PINOD, "hfs_vnop_lookup", 0);
hfs_unlock(dcp);
tsleep((caddr_t)dvp, PRIBIO, "hfs_lookup", 1);
goto retry;
}
/*
* We shouldn't need to go to the catalog if there are no children.
* However, in the face of a minor disk corruption where the valence of
* the directory is off, we could infinite loop here if we return ENOENT
* even though there are actually items in the directory. (create will
* see the ENOENT, try to create something, which will return with
* EEXIST over and over again). As a result, always check the catalog.
*/
bzero(&cndesc, sizeof(cndesc));
cndesc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;
cndesc.cd_namelen = cnp->cn_namelen;
cndesc.cd_parentcnid = dcp->c_fileid;
cndesc.cd_hint = dcp->c_childhint;
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
retval = cat_lookup(hfsmp, &cndesc, 0, force_casesensitive_lookup, &desc, &attr, &fork, NULL);
hfs_systemfile_unlock(hfsmp, lockflags);
if (retval == 0) {
dcp->c_childhint = desc.cd_hint;
/*
* Note: We must drop the parent lock here before calling
* hfs_getnewvnode (which takes the child lock).
*/
hfs_unlock(dcp);
dcp = NULL;
/* Verify that the item just looked up isn't one of the hidden directories. */
if (desc.cd_cnid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||
desc.cd_cnid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {
retval = ENOENT;
goto exit;
}
goto found;
}
/*
* ENAMETOOLONG supersedes other errors
*
* For a CREATE or RENAME operation on the last component
* the ENAMETOOLONG will be handled in the next VNOP.
*/
if ((retval != ENAMETOOLONG) &&
(cnp->cn_namelen > kHFSPlusMaxFileNameChars) &&
(((flags & ISLASTCN) == 0) || ((nameiop != CREATE) && (nameiop != RENAME)))) {
retval = ENAMETOOLONG;
} else if (retval == 0) {
retval = ENOENT;
} else if (retval == ERESERVEDNAME) {
/*
* We found the name in the catalog, but it is unavailable
* to us. The exact error to return to our caller depends
* on the operation, and whether we've already reached the
* last path component. In all cases, avoid a negative
* cache entry, since someone else may be able to access
* the name if their lookup is configured differently.
*/
cnp->cn_flags &= ~MAKEENTRY;
if (((flags & ISLASTCN) == 0) || ((nameiop == LOOKUP) || (nameiop == DELETE))) {
/* A reserved name for a pure lookup is the same as the path not being present */
retval = ENOENT;
} else {
/* A reserved name with intent to create must be rejected as impossible */
retval = EEXIST;
}
}
if (retval != ENOENT)
goto exit;
/*
* This is a non-existing entry
*
* If creating, and at end of pathname and current
* directory has not been removed, then can consider
* allowing file to be created.
*/
if ((nameiop == CREATE || nameiop == RENAME ||
(nameiop == DELETE &&
(cnp->cn_flags & DOWHITEOUT) &&
(cnp->cn_flags & ISWHITEOUT))) &&
(flags & ISLASTCN) &&
!(ISSET(dcp->c_flag, C_DELETED | C_NOEXISTS))) {
retval = EJUSTRETURN;
goto exit;
}
/*
* Insert name into the name cache (as non-existent).
*/
if ((hfsmp->hfs_flags & HFS_STANDARD) == 0 &&
(cnp->cn_flags & MAKEENTRY) &&
(nameiop != CREATE)) {
cache_enter(dvp, NULL, cnp);
dcp->c_flag |= C_NEG_ENTRIES;
}
goto exit;
}
found:
if (flags & ISLASTCN) {
switch(nameiop) {
case DELETE:
cnp->cn_flags &= ~MAKEENTRY;
break;
case RENAME:
cnp->cn_flags &= ~MAKEENTRY;
if (isDot) {
retval = EISDIR;
goto exit;
}
break;
}
}
if (isDot) {
if ((retval = vnode_get(dvp)))
goto exit;
*vpp = dvp;
} else if (flags & ISDOTDOT) {
/*
* Directory hard links can have multiple parents so
* find the appropriate parent for the current thread.
*/
if ((retval = hfs_vget(hfsmp, hfs_currentparent(VTOC(dvp)), &tvp, 0, 0))) {
goto exit;
}
*cnode_locked = 1;
*vpp = tvp;
} else {
int type = (attr.ca_mode & S_IFMT);
if (!(flags & ISLASTCN) && (type != S_IFDIR) && (type != S_IFLNK)) {
retval = ENOTDIR;
goto exit;
}
/* Don't cache directory hardlink names. */
if (attr.ca_recflags & kHFSHasLinkChainMask) {
cnp->cn_flags &= ~MAKEENTRY;
}
/* Names with composed chars are not cached. */
if (cnp->cn_namelen != desc.cd_namelen)
cnp->cn_flags &= ~MAKEENTRY;
retval = hfs_getnewvnode(hfsmp, dvp, cnp, &desc, 0, &attr, &fork, &tvp, &newvnode_flags);
if (retval) {
/*
* If this was a create/rename operation lookup, then by this point
* we expected to see the item returned from hfs_getnewvnode above.
* In the create case, it would probably eventually bubble out an EEXIST
* because the item existed when we were trying to create it. In the
* rename case, it would let us know that we need to go ahead and
* delete it as part of the rename. However, if we hit the condition below
* then it means that we found the element during cat_lookup above, but
* it is now no longer there. We simply behave as though we never found
* the element at all and return EJUSTRETURN.
*/
if ((retval == ENOENT) &&
((cnp->cn_nameiop == CREATE) || (cnp->cn_nameiop == RENAME)) &&
(flags & ISLASTCN)) {
retval = EJUSTRETURN;
}
/*
* If this was a straight lookup operation, we may need to redrive the entire
* lookup starting from cat_lookup if the element was deleted as the result of
* a rename operation. Since rename is supposed to guarantee atomicity, then
* lookups cannot fail because the underlying element is deleted as a result of
* the rename call -- either they returned the looked up element prior to rename
* or return the newer element. If we are in this region, then all we can do is add
* workarounds to guarantee the latter case. The element has already been deleted, so
* we just re-try the lookup to ensure the caller gets the most recent element.
*/
if ((retval == ENOENT) && (cnp->cn_nameiop == LOOKUP) &&
(newvnode_flags & (GNV_CHASH_RENAMED | GNV_CAT_DELETED))) {
if (dcp) {
hfs_unlock (dcp);
}
/* get rid of any name buffers that may have lingered from the cat_lookup call */
cat_releasedesc (&desc);
goto retry;
}
/* Also, re-drive the lookup if the item we looked up was a hardlink, and the number
* or name of hardlinks has changed in the interim between the cat_lookup above, and
* our call to hfs_getnewvnode. hfs_getnewvnode will validate the cattr we passed it
* against what is actually in the catalog after the cnode is created. If there were
* any issues, it will bubble out ERECYCLE, which we need to swallow and use as the
* key to redrive as well. We need to special case this below because in this case,
* it needs to occur regardless of the type of lookup we're doing here.
*/
if ((retval == ERECYCLE) && (newvnode_flags & GNV_CAT_ATTRCHANGED)) {
if (dcp) {
hfs_unlock (dcp);
}
/* get rid of any name buffers that may have lingered from the cat_lookup call */
cat_releasedesc (&desc);
retval = 0;
goto retry;
}
/* skip to the error-handling code if we can't retry */
goto exit;
}
/*
* Save the origin info for file and directory hardlinks. Directory hardlinks
* need the origin for '..' lookups, and file hardlinks need it to ensure that
* competing lookups do not cause us to vend different hardlinks than the ones requested.
* We want to restrict saving the cache entries to LOOKUP namei operations, since
* we're really doing this to protect getattr.
*/
if ((nameiop == LOOKUP) && (VTOC(tvp)->c_flag & C_HARDLINK)) {
hfs_savelinkorigin(VTOC(tvp), VTOC(dvp)->c_fileid);
}
*cnode_locked = 1;
*vpp = tvp;
}
exit:
if (dcp) {
hfs_unlock(dcp);
}
cat_releasedesc(&desc);
return (retval);
}
/*
* Convert a component of a pathname into a pointer to a locked node.
* This is a very central and rather complicated routine.
* If the file system is not maintained in a strict tree hierarchy,
* this can result in a deadlock situation (see comments in code below).
*
* The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
* whether the name is to be looked up, created, renamed, or deleted.
* When CREATE, RENAME, or DELETE is specified, information usable in
* creating, renaming, or deleting a directory entry may be calculated.
* If flag has LOCKPARENT or'ed into it and the target of the pathname
* exists, lookup returns both the target and its parent directory locked.
* When creating or renaming and LOCKPARENT is specified, the target may
* not be ".". When deleting and LOCKPARENT is specified, the target may
* be "."., but the caller must check to ensure it does an vrele and DNUNLOCK
* instead of two DNUNLOCKs.
*
* Overall outline of devfs_lookup:
*
* check accessibility of directory
* null terminate the component (lookup leaves the whole string alone)
* look for name in cache, if found, then if at end of path
* and deleting or creating, drop it, else return name
* search for name in directory, to found or notfound
* notfound:
* if creating, return locked directory,
* else return error
* found:
* if at end of path and deleting, return information to allow delete
* if at end of path and rewriting (RENAME and LOCKPARENT), lock target
* node and return info to allow rewrite
* if not at end, add name to cache; if at end and neither creating
* nor deleting, add name to cache
* On return to lookup, remove the null termination we put in at the start.
*
* NOTE: (LOOKUP | LOCKPARENT) currently returns the parent node unlocked.
*/
static int
devfs_lookup(struct vnop_lookup_args *ap)
/*struct vnop_lookup_args {
struct vnode * a_dvp; directory vnode ptr
struct vnode ** a_vpp; where to put the result
struct componentname * a_cnp; the name we want
vfs_context_t a_context;
};*/
{
struct componentname *cnp = ap->a_cnp;
vfs_context_t ctx = cnp->cn_context;
struct proc *p = vfs_context_proc(ctx);
struct vnode *dir_vnode = ap->a_dvp;
struct vnode **result_vnode = ap->a_vpp;
devnode_t * dir_node; /* the directory we are searching */
devnode_t * node = NULL; /* the node we are searching for */
devdirent_t * nodename;
int flags = cnp->cn_flags;
int op = cnp->cn_nameiop; /* LOOKUP, CREATE, RENAME, or DELETE */
int wantparent = flags & (LOCKPARENT|WANTPARENT);
int error = 0;
char heldchar; /* the char at the end of the name componet */
retry:
*result_vnode = NULL; /* safe not sorry */ /*XXX*/
/* okay to look at directory vnodes ourside devfs lock as they are not aliased */
dir_node = VTODN(dir_vnode);
/*
* Make sure that our node is a directory as well.
*/
if (dir_node->dn_type != DEV_DIR) {
return (ENOTDIR);
}
DEVFS_LOCK();
/*
* temporarily terminate string component
*/
heldchar = cnp->cn_nameptr[cnp->cn_namelen];
cnp->cn_nameptr[cnp->cn_namelen] = '\0';
nodename = dev_findname(dir_node, cnp->cn_nameptr);
/*
* restore saved character
*/
cnp->cn_nameptr[cnp->cn_namelen] = heldchar;
if (nodename) {
/* entry exists */
node = nodename->de_dnp;
/* Do potential vnode allocation here inside the lock
* to make sure that our device node has a non-NULL dn_vn
* associated with it. The device node might otherwise
* get deleted out from under us (see devfs_dn_free()).
*/
error = devfs_dntovn(node, result_vnode, p);
}
DEVFS_UNLOCK();
if (error) {
if (error == EAGAIN)
goto retry;
return error;
}
if (!nodename) {
/*
* we haven't called devfs_dntovn if we get here
* we have not taken a reference on the node.. no
* vnode_put is necessary on these error returns
*
* If it doesn't exist and we're not the last component,
* or we're at the last component, but we're not creating
* or renaming, return ENOENT.
*/
if (!(flags & ISLASTCN) || !(op == CREATE || op == RENAME)) {
return ENOENT;
}
/*
* We return with the directory locked, so that
* the parameters we set up above will still be
* valid if we actually decide to add a new entry.
* We return ni_vp == NULL to indicate that the entry
* does not currently exist; we leave a pointer to
* the (locked) directory vnode in namei_data->ni_dvp.
*
* NB - if the directory is unlocked, then this
* information cannot be used.
*/
return (EJUSTRETURN);
}
/*
* from this point forward, we need to vnode_put the reference
* picked up in devfs_dntovn if we decide to return an error
*/
/*
* If deleting, and at end of pathname, return
* parameters which can be used to remove file.
* If the wantparent flag isn't set, we return only
* the directory (in namei_data->ni_dvp), otherwise we go
* on and lock the node, being careful with ".".
*/
if (op == DELETE && (flags & ISLASTCN)) {
/*
* we are trying to delete '.'. What does this mean? XXX
*/
if (dir_node == node) {
if (*result_vnode) {
vnode_put(*result_vnode);
*result_vnode = NULL;
}
if ( ((error = vnode_get(dir_vnode)) == 0) ) {
*result_vnode = dir_vnode;
}
return (error);
}
return (0);
}
/*
* If rewriting (RENAME), return the vnode and the
* information required to rewrite the present directory
* Must get node of directory entry to verify it's a
* regular file, or empty directory.
*/
if (op == RENAME && wantparent && (flags & ISLASTCN)) {
/*
* Careful about locking second node.
* This can only occur if the target is ".".
*/
if (dir_node == node) {
error = EISDIR;
goto drop_ref;
}
return (0);
}
/*
* Step through the translation in the name. We do not unlock the
* directory because we may need it again if a symbolic link
* is relative to the current directory. Instead we save it
* unlocked as "saved_dir_node" XXX. We must get the target
* node before unlocking
* the directory to insure that the node will not be removed
* before we get it. We prevent deadlock by always fetching
* nodes from the root, moving down the directory tree. Thus
* when following backward pointers ".." we must unlock the
* parent directory before getting the requested directory.
* There is a potential race condition here if both the current
* and parent directories are removed before the lock for the
* node associated with ".." returns. We hope that this occurs
* infrequently since we cannot avoid this race condition without
* implementing a sophisticated deadlock detection algorithm.
* Note also that this simple deadlock detection scheme will not
* work if the file system has any hard links other than ".."
* that point backwards in the directory structure.
*/
if ((flags & ISDOTDOT) == 0 && dir_node == node) {
if (*result_vnode) {
vnode_put(*result_vnode);
*result_vnode = NULL;
}
if ( (error = vnode_get(dir_vnode)) ) {
return (error);
}
*result_vnode = dir_vnode;
}
return (0);
drop_ref:
if (*result_vnode) {
vnode_put(*result_vnode);
*result_vnode = NULL;
}
return (error);
}
static int
ClearCallBack(struct rx_connection *a_conn,
struct AFSFid *a_fid)
{
struct vcache *tvc;
int i;
struct VenusFid localFid;
struct volume *tv;
#ifdef AFS_DARWIN80_ENV
vnode_t vp;
#endif
AFS_STATCNT(ClearCallBack);
AFS_ASSERT_GLOCK();
/*
* XXXX Don't hold any server locks here because of callback protocol XXX
*/
localFid.Cell = 0;
localFid.Fid.Volume = a_fid->Volume;
localFid.Fid.Vnode = a_fid->Vnode;
localFid.Fid.Unique = a_fid->Unique;
/*
* Volume ID of zero means don't do anything.
*/
if (a_fid->Volume != 0) {
if (a_fid->Vnode == 0) {
struct afs_q *tq, *uq;
/*
* Clear callback for the whole volume. Zip through the
* hash chain, nullifying entries whose volume ID matches.
*/
loop1:
ObtainReadLock(&afs_xvcache);
i = VCHashV(&localFid);
for (tq = afs_vhashTV[i].prev; tq != &afs_vhashTV[i]; tq = uq) {
uq = QPrev(tq);
tvc = QTOVH(tq);
if (tvc->f.fid.Fid.Volume == a_fid->Volume) {
tvc->callback = NULL;
if (!localFid.Cell)
localFid.Cell = tvc->f.fid.Cell;
tvc->dchint = NULL; /* invalidate hints */
if (tvc->f.states & CVInit) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop1;
}
#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
AFS_FAST_HOLD(tvc);
#else
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
if (!(tvc->f.states & CBulkFetching)) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop1;
}
}
vp = AFSTOV(tvc);
if (vnode_get(vp))
continue;
if (vnode_ref(vp)) {
AFS_GUNLOCK();
vnode_put(vp);
AFS_GLOCK();
continue;
}
if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
AFS_GUNLOCK();
vnode_recycle(AFSTOV(tvc));
AFS_GLOCK();
}
#else
AFS_FAST_HOLD(tvc);
#endif
#endif
ReleaseReadLock(&afs_xvcache);
ObtainWriteLock(&afs_xcbhash, 449);
afs_DequeueCallback(tvc);
tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
afs_allCBs++;
if (tvc->f.fid.Fid.Vnode & 1)
afs_oddCBs++;
else
afs_evenCBs++;
ReleaseWriteLock(&afs_xcbhash);
if ((tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
osi_dnlc_purgedp(tvc);
afs_Trace3(afs_iclSetp, CM_TRACE_CALLBACK,
ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
tvc->f.states, ICL_TYPE_INT32,
a_fid->Volume);
#ifdef AFS_DARWIN80_ENV
vnode_put(AFSTOV(tvc));
#endif
ObtainReadLock(&afs_xvcache);
uq = QPrev(tq);
AFS_FAST_RELE(tvc);
} else if ((tvc->f.states & CMValid)
&& (tvc->mvid->Fid.Volume == a_fid->Volume)) {
tvc->f.states &= ~CMValid;
if (!localFid.Cell)
localFid.Cell = tvc->mvid->Cell;
}
}
ReleaseReadLock(&afs_xvcache);
/*
* XXXX Don't hold any locks here XXXX
*/
tv = afs_FindVolume(&localFid, 0);
if (tv) {
afs_ResetVolumeInfo(tv);
afs_PutVolume(tv, 0);
/* invalidate mtpoint? */
}
} /*Clear callbacks for whole volume */
else {
/*
* Clear callbacks just for the one file.
*/
struct vcache *uvc;
afs_allCBs++;
if (a_fid->Vnode & 1)
afs_oddCBs++; /*Could do this on volume basis, too */
else
afs_evenCBs++; /*A particular fid was specified */
loop2:
ObtainReadLock(&afs_xvcache);
i = VCHash(&localFid);
for (tvc = afs_vhashT[i]; tvc; tvc = uvc) {
uvc = tvc->hnext;
if (tvc->f.fid.Fid.Vnode == a_fid->Vnode
&& tvc->f.fid.Fid.Volume == a_fid->Volume
&& tvc->f.fid.Fid.Unique == a_fid->Unique) {
tvc->callback = NULL;
tvc->dchint = NULL; /* invalidate hints */
if (tvc->f.states & CVInit) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop2;
}
#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
AFS_FAST_HOLD(tvc);
#else
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
if (!(tvc->f.states & CBulkFetching)) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop2;
}
}
vp = AFSTOV(tvc);
if (vnode_get(vp))
continue;
if (vnode_ref(vp)) {
AFS_GUNLOCK();
vnode_put(vp);
AFS_GLOCK();
continue;
}
if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
AFS_GUNLOCK();
vnode_recycle(AFSTOV(tvc));
AFS_GLOCK();
}
#else
AFS_FAST_HOLD(tvc);
#endif
#endif
ReleaseReadLock(&afs_xvcache);
ObtainWriteLock(&afs_xcbhash, 450);
afs_DequeueCallback(tvc);
tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
ReleaseWriteLock(&afs_xcbhash);
if ((tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
osi_dnlc_purgedp(tvc);
afs_Trace3(afs_iclSetp, CM_TRACE_CALLBACK,
ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
tvc->f.states, ICL_TYPE_LONG, 0);
#ifdef CBDEBUG
lastCallBack_vnode = afid->Vnode;
lastCallBack_dv = tvc->mstat.DataVersion.low;
osi_GetuTime(&lastCallBack_time);
#endif /* CBDEBUG */
#ifdef AFS_DARWIN80_ENV
vnode_put(AFSTOV(tvc));
#endif
ObtainReadLock(&afs_xvcache);
uvc = tvc->hnext;
AFS_FAST_RELE(tvc);
}
} /*Walk through hash table */
ReleaseReadLock(&afs_xvcache);
} /*Clear callbacks for one file */
}
/*Fid has non-zero volume ID */
/*
* Always return a predictable value.
*/
return (0);
} /*ClearCallBack */
