/*
* Return the lowermost vnode if this is a mountpoint.
*/
static vnode_t *
vn_under(vnode_t *vp)
{
vnode_t *uvp;
vfs_t *vfsp;
while (vp->v_flag & VROOT) {
vfsp = vp->v_vfsp;
vfs_rlock_wait(vfsp);
if ((uvp = vfsp->vfs_vnodecovered) == NULL ||
(vfsp->vfs_flag & VFS_UNMOUNTED)) {
vfs_unlock(vfsp);
break;
}
VN_HOLD(uvp);
vfs_unlock(vfsp);
VN_RELE(vp);
vp = uvp;
}
return (vp);
}
static int
auto_lookup(
vnode_t *dvp,
char *nm,
vnode_t **vpp,
pathname_t *pnp,
int flags,
vnode_t *rdir,
cred_t *cred,
caller_context_t *ct,
int *direntflags,
pathname_t *realpnp)
{
int error = 0;
vnode_t *newvp = NULL;
vfs_t *vfsp;
fninfo_t *dfnip;
fnnode_t *dfnp = NULL;
fnnode_t *fnp = NULL;
char *searchnm;
int operation; /* either AUTOFS_LOOKUP or AUTOFS_MOUNT */
dfnip = vfstofni(dvp->v_vfsp);
AUTOFS_DPRINT((3, "auto_lookup: dvp=%p (%s) name=%s\n",
(void *)dvp, dfnip->fi_map, nm));
if (nm[0] == 0) {
VN_HOLD(dvp);
*vpp = dvp;
return (0);
}
if (error = VOP_ACCESS(dvp, VEXEC, 0, cred, ct))
return (error);
if (nm[0] == '.' && nm[1] == 0) {
VN_HOLD(dvp);
*vpp = dvp;
return (0);
}
if (nm[0] == '.' && nm[1] == '.' && nm[2] == 0) {
fnnode_t *pdfnp;
pdfnp = (vntofn(dvp))->fn_parent;
ASSERT(pdfnp != NULL);
/*
* Since it is legitimate to have the VROOT flag set for the
* subdirectories of the indirect map in autofs filesystem,
* rootfnnodep is checked against fnnode of dvp instead of
* just checking whether VROOT flag is set in dvp
*/
if (pdfnp == pdfnp->fn_globals->fng_rootfnnodep) {
vnode_t *vp;
vfs_rlock_wait(dvp->v_vfsp);
if (dvp->v_vfsp->vfs_flag & VFS_UNMOUNTED) {
vfs_unlock(dvp->v_vfsp);
return (EIO);
}
vp = dvp->v_vfsp->vfs_vnodecovered;
VN_HOLD(vp);
vfs_unlock(dvp->v_vfsp);
error = VOP_LOOKUP(vp, nm, vpp, pnp, flags, rdir, cred,
ct, direntflags, realpnp);
VN_RELE(vp);
return (error);
} else {
*vpp = fntovn(pdfnp);
VN_HOLD(*vpp);
return (0);
}
}
top:
dfnp = vntofn(dvp);
searchnm = nm;
operation = 0;
ASSERT(vn_matchops(dvp, auto_vnodeops));
AUTOFS_DPRINT((3, "auto_lookup: dvp=%p dfnp=%p\n", (void *)dvp,
(void *)dfnp));
/*
* If a lookup or mount of this node is in progress, wait for it
* to finish, and return whatever result it got.
*/
mutex_enter(&dfnp->fn_lock);
if (dfnp->fn_flags & (MF_LOOKUP | MF_INPROG)) {
mutex_exit(&dfnp->fn_lock);
error = auto_wait4mount(dfnp);
if (error == AUTOFS_SHUTDOWN)
error = ENOENT;
if (error == EAGAIN)
goto top;
if (error)
return (error);
} else
mutex_exit(&dfnp->fn_lock);
error = vn_vfsrlock_wait(dvp);
if (error)
return (error);
vfsp = vn_mountedvfs(dvp);
if (vfsp != NULL) {
error = VFS_ROOT(vfsp, &newvp);
vn_vfsunlock(dvp);
if (!error) {
error = VOP_LOOKUP(newvp, nm, vpp, pnp,
flags, rdir, cred, ct, direntflags, realpnp);
VN_RELE(newvp);
}
return (error);
}
vn_vfsunlock(dvp);
rw_enter(&dfnp->fn_rwlock, RW_READER);
error = auto_search(dfnp, nm, &fnp, cred);
if (error) {
if (dfnip->fi_flags & MF_DIRECT) {
/*
* direct map.
*/
if (dfnp->fn_dirents) {
/*
* Mount previously triggered.
* 'nm' not found
*/
error = ENOENT;
} else {
/*
* I need to contact the daemon to trigger
* the mount. 'dfnp' will be the mountpoint.
*/
operation = AUTOFS_MOUNT;
VN_HOLD(fntovn(dfnp));
fnp = dfnp;
error = 0;
}
} else if (dvp == dfnip->fi_rootvp) {
/*
* 'dfnp' is the root of the indirect AUTOFS.
*/
if (rw_tryupgrade(&dfnp->fn_rwlock) == 0) {
/*
* Could not acquire writer lock, release
* reader, and wait until available. We
* need to search for 'nm' again, since we
* had to release the lock before reacquiring
* it.
*/
rw_exit(&dfnp->fn_rwlock);
rw_enter(&dfnp->fn_rwlock, RW_WRITER);
error = auto_search(dfnp, nm, &fnp, cred);
}
ASSERT(RW_WRITE_HELD(&dfnp->fn_rwlock));
if (error) {
/*
* create node being looked-up and request
* mount on it.
*/
error = auto_enter(dfnp, nm, &fnp, kcred);
if (!error)
operation = AUTOFS_LOOKUP;
}
} else if ((dfnp->fn_dirents == NULL) &&
((dvp->v_flag & VROOT) == 0) &&
((fntovn(dfnp->fn_parent))->v_flag & VROOT)) {
/*
* dfnp is the actual 'mountpoint' of indirect map,
* it is the equivalent of a direct mount,
* ie, /home/'user1'
*/
operation = AUTOFS_MOUNT;
VN_HOLD(fntovn(dfnp));
fnp = dfnp;
error = 0;
searchnm = dfnp->fn_name;
}
}
if (error == EAGAIN) {
rw_exit(&dfnp->fn_rwlock);
goto top;
}
if (error) {
rw_exit(&dfnp->fn_rwlock);
return (error);
}
/*
* We now have the actual fnnode we're interested in.
* The 'MF_LOOKUP' indicates another thread is currently
* performing a daemon lookup of this node, therefore we
* wait for its completion.
* The 'MF_INPROG' indicates another thread is currently
* performing a daemon mount of this node, we wait for it
* to be done if we are performing a MOUNT. We don't
* wait for it if we are performing a LOOKUP.
* We can release the reader/writer lock as soon as we acquire
* the mutex, since the state of the lock can only change by
* first acquiring the mutex.
*/
mutex_enter(&fnp->fn_lock);
rw_exit(&dfnp->fn_rwlock);
if ((fnp->fn_flags & MF_LOOKUP) ||
((operation == AUTOFS_MOUNT) && (fnp->fn_flags & MF_INPROG))) {
mutex_exit(&fnp->fn_lock);
error = auto_wait4mount(fnp);
VN_RELE(fntovn(fnp));
if (error == AUTOFS_SHUTDOWN)
error = ENOENT;
if (error && error != EAGAIN)
return (error);
goto top;
}
if (operation == 0) {
/*
* got the fnnode, check for any errors
* on the previous operation on that node.
*/
error = fnp->fn_error;
if ((error == EINTR) || (error == EAGAIN)) {
/*
* previous operation on this node was
* not completed, do a lookup now.
*/
operation = AUTOFS_LOOKUP;
} else {
/*
* previous operation completed. Return
* a pointer to the node only if there was
* no error.
*/
mutex_exit(&fnp->fn_lock);
if (!error)
*vpp = fntovn(fnp);
else
VN_RELE(fntovn(fnp));
return (error);
}
}
/*
* Since I got to this point, it means I'm the one
* responsible for triggering the mount/look-up of this node.
*/
switch (operation) {
case AUTOFS_LOOKUP:
AUTOFS_BLOCK_OTHERS(fnp, MF_LOOKUP);
fnp->fn_error = 0;
mutex_exit(&fnp->fn_lock);
error = auto_lookup_aux(fnp, searchnm, cred);
if (!error) {
/*
* Return this vnode
*/
*vpp = fntovn(fnp);
} else {
/*
* release our reference to this vnode
* and return error
*/
VN_RELE(fntovn(fnp));
}
break;
case AUTOFS_MOUNT:
AUTOFS_BLOCK_OTHERS(fnp, MF_INPROG);
fnp->fn_error = 0;
mutex_exit(&fnp->fn_lock);
/*
* auto_new_mount_thread fires up a new thread which
* calls automountd finishing up the work
*/
auto_new_mount_thread(fnp, searchnm, cred);
/*
* At this point, we are simply another thread
* waiting for the mount to complete
*/
error = auto_wait4mount(fnp);
if (error == AUTOFS_SHUTDOWN)
error = ENOENT;
/*
* now release our reference to this vnode
*/
VN_RELE(fntovn(fnp));
if (!error)
goto top;
break;
default:
auto_log(dfnp->fn_globals->fng_verbose,
dfnp->fn_globals->fng_zoneid, CE_WARN,
"auto_lookup: unknown operation %d",
operation);
}
AUTOFS_DPRINT((5, "auto_lookup: name=%s *vpp=%p return=%d\n",
nm, (void *)*vpp, error));
return (error);
}
/*
* Starting at current directory, translate pathname pnp to end.
* Leave pathname of final component in pnp, return the vnode
* for the final component in *compvpp, and return the vnode
* for the parent of the final component in dirvpp.
*
* This is the central routine in pathname translation and handles
* multiple components in pathnames, separating them at /'s. It also
* implements mounted file systems and processes symbolic links.
*
* vp is the vnode where the directory search should start.
*
* Reference counts: vp must be held prior to calling this function. rootvp
* should only be held if rootvp != rootdir.
*/
int
lookuppnvp(
struct pathname *pnp, /* pathname to lookup */
struct pathname *rpnp, /* if non-NULL, return resolved path */
int flags, /* follow symlinks */
vnode_t **dirvpp, /* ptr for parent vnode */
vnode_t **compvpp, /* ptr for entry vnode */
vnode_t *rootvp, /* rootvp */
vnode_t *vp, /* directory to start search at */
cred_t *cr) /* user's credential */
{
vnode_t *cvp; /* current component vp */
char component[MAXNAMELEN]; /* buffer for component (incl null) */
int error;
int nlink;
int lookup_flags;
struct pathname presrvd; /* case preserved name */
struct pathname *pp = NULL;
vnode_t *startvp;
vnode_t *zonevp = curproc->p_zone->zone_rootvp; /* zone root */
int must_be_directory = 0;
boolean_t retry_with_kcred;
uint32_t auditing = AU_AUDITING();
CPU_STATS_ADDQ(CPU, sys, namei, 1);
nlink = 0;
cvp = NULL;
if (rpnp)
rpnp->pn_pathlen = 0;
lookup_flags = dirvpp ? LOOKUP_DIR : 0;
if (flags & FIGNORECASE) {
lookup_flags |= FIGNORECASE;
pn_alloc(&presrvd);
pp = &presrvd;
}
if (auditing)
audit_anchorpath(pnp, vp == rootvp);
/*
* Eliminate any trailing slashes in the pathname.
* If there are any, we must follow all symlinks.
* Also, we must guarantee that the last component is a directory.
*/
if (pn_fixslash(pnp)) {
flags |= FOLLOW;
must_be_directory = 1;
}
startvp = vp;
next:
retry_with_kcred = B_FALSE;
/*
* Make sure we have a directory.
*/
if (vp->v_type != VDIR) {
error = ENOTDIR;
goto bad;
}
if (rpnp && VN_CMP(vp, rootvp))
(void) pn_set(rpnp, "/");
/*
* Process the next component of the pathname.
*/
if (error = pn_getcomponent(pnp, component)) {
goto bad;
}
/*
* Handle "..": two special cases.
* 1. If we're at the root directory (e.g. after chroot or
* zone_enter) then change ".." to "." so we can't get
* out of this subtree.
* 2. If this vnode is the root of a mounted file system,
* then replace it with the vnode that was mounted on
* so that we take the ".." in the other file system.
*/
if (component[0] == '.' && component[1] == '.' && component[2] == 0) {
checkforroot:
if (VN_CMP(vp, rootvp) || VN_CMP(vp, zonevp)) {
component[1] = '\0';
} else if (vp->v_flag & VROOT) {
vfs_t *vfsp;
cvp = vp;
/*
* While we deal with the vfs pointer from the vnode
* the filesystem could have been forcefully unmounted
* and the vnode's v_vfsp could have been invalidated
* by VFS_UNMOUNT. Hence, we cache v_vfsp and use it
* with vfs_rlock_wait/vfs_unlock.
* It is safe to use the v_vfsp even it is freed by
* VFS_UNMOUNT because vfs_rlock_wait/vfs_unlock
* do not dereference v_vfsp. It is just used as a
* magic cookie.
* One more corner case here is the memory getting
* reused for another vfs structure. In this case
* lookuppnvp's vfs_rlock_wait will succeed, domount's
* vfs_lock will fail and domount will bail out with an
* error (EBUSY).
*/
vfsp = cvp->v_vfsp;
/*
* This lock is used to synchronize
* mounts/unmounts and lookups.
* Threads doing mounts/unmounts hold the
* writers version vfs_lock_wait().
*/
vfs_rlock_wait(vfsp);
/*
* If this vnode is on a file system that
* has been forcibly unmounted,
* we can't proceed. Cancel this operation
* and return EIO.
*
* vfs_vnodecovered is NULL if unmounted.
* Currently, nfs uses VFS_UNMOUNTED to
* check if it's a forced-umount. Keep the
* same checking here as well even though it
* may not be needed.
*/
if (((vp = cvp->v_vfsp->vfs_vnodecovered) == NULL) ||
(cvp->v_vfsp->vfs_flag & VFS_UNMOUNTED)) {
vfs_unlock(vfsp);
VN_RELE(cvp);
if (pp)
pn_free(pp);
return (EIO);
}
VN_HOLD(vp);
vfs_unlock(vfsp);
VN_RELE(cvp);
cvp = NULL;
/*
* Crossing mount points. For eg: We are doing
* a lookup of ".." for file systems root vnode
* mounted here, and VOP_LOOKUP() (with covered vnode)
* will be on underlying file systems mount point
* vnode. Set retry_with_kcred flag as we might end
* up doing VOP_LOOKUP() with kcred if required.
*/
retry_with_kcred = B_TRUE;
goto checkforroot;
}
}
/*
* LOOKUP_CHECKREAD is a private flag used by vnodetopath() to indicate
* that we need to have read permission on every directory in the entire
* path. This is used to ensure that a forward-lookup of a cached value
* has the same effect as a reverse-lookup when the cached value cannot
* be found.
*/
if ((flags & LOOKUP_CHECKREAD) &&
(error = VOP_ACCESS(vp, VREAD, 0, cr, NULL)) != 0)
goto bad;
/*
* Perform a lookup in the current directory.
*/
error = VOP_LOOKUP(vp, component, &cvp, pnp, lookup_flags,
rootvp, cr, NULL, NULL, pp);
/*
* Retry with kcred - If crossing mount points & error is EACCES.
*
* If we are crossing mount points here and doing ".." lookup,
* VOP_LOOKUP() might fail if the underlying file systems
* mount point has no execute permission. In cases like these,
* we retry VOP_LOOKUP() by giving as much privilage as possible
* by passing kcred credentials.
*
* In case of hierarchical file systems, passing kcred still may
* or may not work.
* For eg: UFS FS --> Mount NFS FS --> Again mount UFS on some
* directory inside NFS FS.
*/
if ((error == EACCES) && retry_with_kcred)
error = VOP_LOOKUP(vp, component, &cvp, pnp, lookup_flags,
rootvp, zone_kcred(), NULL, NULL, pp);
if (error) {
cvp = NULL;
/*
* On error, return hard error if
* (a) we're not at the end of the pathname yet, or
* (b) the caller didn't want the parent directory, or
* (c) we failed for some reason other than a missing entry.
*/
if (pn_pathleft(pnp) || dirvpp == NULL || error != ENOENT)
goto bad;
if (auditing) { /* directory access */
if (error = audit_savepath(pnp, vp, vp, error, cr))
goto bad_noaudit;
}
pn_setlast(pnp);
/*
* We inform the caller that the desired entry must be
* a directory by adding a '/' to the component name.
*/
if (must_be_directory && (error = pn_addslash(pnp)) != 0)
goto bad;
*dirvpp = vp;
if (compvpp != NULL)
*compvpp = NULL;
if (rootvp != rootdir)
VN_RELE(rootvp);
if (pp)
pn_free(pp);
return (0);
}
/*
* Traverse mount points.
* XXX why don't we need to hold a read lock here (call vn_vfsrlock)?
* What prevents a concurrent update to v_vfsmountedhere?
* Possible answer: if mounting, we might not see the mount
* if it is concurrently coming into existence, but that's
* really not much different from the thread running a bit slower.
* If unmounting, we may get into traverse() when we shouldn't,
* but traverse() will catch this case for us.
* (For this to work, fetching v_vfsmountedhere had better
* be atomic!)
*/
if (vn_mountedvfs(cvp) != NULL) {
if ((error = traverse(&cvp)) != 0)
goto bad;
}
/*
* If we hit a symbolic link and there is more path to be
* translated or this operation does not wish to apply
* to a link, then place the contents of the link at the
* front of the remaining pathname.
*/
if (cvp->v_type == VLNK && ((flags & FOLLOW) || pn_pathleft(pnp))) {
struct pathname linkpath;
if (++nlink > MAXSYMLINKS) {
error = ELOOP;
goto bad;
}
pn_alloc(&linkpath);
if (error = pn_getsymlink(cvp, &linkpath, cr)) {
pn_free(&linkpath);
goto bad;
}
if (auditing)
audit_symlink(pnp, &linkpath);
if (pn_pathleft(&linkpath) == 0)
(void) pn_set(&linkpath, ".");
error = pn_insert(pnp, &linkpath, strlen(component));
pn_free(&linkpath);
if (error)
goto bad;
VN_RELE(cvp);
cvp = NULL;
if (pnp->pn_pathlen == 0) {
error = ENOENT;
goto bad;
}
if (pnp->pn_path[0] == '/') {
do {
pnp->pn_path++;
pnp->pn_pathlen--;
} while (pnp->pn_path[0] == '/');
VN_RELE(vp);
vp = rootvp;
VN_HOLD(vp);
}
if (auditing)
audit_anchorpath(pnp, vp == rootvp);
if (pn_fixslash(pnp)) {
flags |= FOLLOW;
must_be_directory = 1;
}
goto next;
}
/*
* If rpnp is non-NULL, remember the resolved path name therein.
* Do not include "." components. Collapse occurrences of
* "previous/..", so long as "previous" is not itself "..".
* Exhausting rpnp results in error ENAMETOOLONG.
*/
if (rpnp && strcmp(component, ".") != 0) {
size_t len;
if (strcmp(component, "..") == 0 &&
rpnp->pn_pathlen != 0 &&
!((rpnp->pn_pathlen > 2 &&
strncmp(rpnp->pn_path+rpnp->pn_pathlen-3, "/..", 3) == 0) ||
(rpnp->pn_pathlen == 2 &&
strncmp(rpnp->pn_path, "..", 2) == 0))) {
while (rpnp->pn_pathlen &&
rpnp->pn_path[rpnp->pn_pathlen-1] != '/')
rpnp->pn_pathlen--;
if (rpnp->pn_pathlen > 1)
rpnp->pn_pathlen--;
rpnp->pn_path[rpnp->pn_pathlen] = '\0';
} else {
if (rpnp->pn_pathlen != 0 &&
rpnp->pn_path[rpnp->pn_pathlen-1] != '/')
rpnp->pn_path[rpnp->pn_pathlen++] = '/';
if (flags & FIGNORECASE) {
/*
* Return the case-preserved name
* within the resolved path.
*/
error = copystr(pp->pn_buf,
rpnp->pn_path + rpnp->pn_pathlen,
rpnp->pn_bufsize - rpnp->pn_pathlen, &len);
} else {
error = copystr(component,
rpnp->pn_path + rpnp->pn_pathlen,
rpnp->pn_bufsize - rpnp->pn_pathlen, &len);
}
if (error) /* copystr() returns ENAMETOOLONG */
goto bad;
rpnp->pn_pathlen += (len - 1);
ASSERT(rpnp->pn_bufsize > rpnp->pn_pathlen);
}
}
/*
* If no more components, return last directory (if wanted) and
* last component (if wanted).
*/
if (pn_pathleft(pnp) == 0) {
/*
* If there was a trailing slash in the pathname,
* make sure the last component is a directory.
*/
if (must_be_directory && cvp->v_type != VDIR) {
error = ENOTDIR;
goto bad;
}
if (dirvpp != NULL) {
/*
* Check that we have the real parent and not
* an alias of the last component.
*/
if (vn_compare(vp, cvp)) {
if (auditing)
(void) audit_savepath(pnp, cvp, vp,
EINVAL, cr);
pn_setlast(pnp);
VN_RELE(vp);
VN_RELE(cvp);
if (rootvp != rootdir)
VN_RELE(rootvp);
if (pp)
pn_free(pp);
return (EINVAL);
}
*dirvpp = vp;
} else
VN_RELE(vp);
if (auditing)
(void) audit_savepath(pnp, cvp, vp, 0, cr);
if (pnp->pn_path == pnp->pn_buf)
(void) pn_set(pnp, ".");
else
pn_setlast(pnp);
if (rpnp) {
if (VN_CMP(cvp, rootvp))
(void) pn_set(rpnp, "/");
else if (rpnp->pn_pathlen == 0)
(void) pn_set(rpnp, ".");
}
if (compvpp != NULL)
*compvpp = cvp;
else
VN_RELE(cvp);
if (rootvp != rootdir)
VN_RELE(rootvp);
if (pp)
pn_free(pp);
return (0);
}
/*
* Skip over slashes from end of last component.
*/
while (pnp->pn_path[0] == '/') {
pnp->pn_path++;
pnp->pn_pathlen--;
}
/*
* Searched through another level of directory:
* release previous directory handle and save new (result
* of lookup) as current directory.
*/
VN_RELE(vp);
vp = cvp;
cvp = NULL;
goto next;
bad:
if (auditing) /* reached end of path */
(void) audit_savepath(pnp, cvp, vp, error, cr);
bad_noaudit:
/*
* Error. Release vnodes and return.
*/
if (cvp)
VN_RELE(cvp);
/*
* If the error was ESTALE and the current directory to look in
* was the root for this lookup, the root for a mounted file
* system, or the starting directory for lookups, then
* return ENOENT instead of ESTALE. In this case, no recovery
* is possible by the higher level. If ESTALE was returned for
* some intermediate directory along the path, then recovery
* is potentially possible and retrying from the higher level
* will either correct the situation by purging stale cache
* entries or eventually get back to the point where no recovery
* is possible.
*/
if (error == ESTALE &&
(VN_CMP(vp, rootvp) || (vp->v_flag & VROOT) || vp == startvp))
error = ENOENT;
VN_RELE(vp);
if (rootvp != rootdir)
VN_RELE(rootvp);
if (pp)
pn_free(pp);
return (error);
}
/*
* smb_vop_lookup
*
* dvp: directory vnode (in)
* name: name of file to be looked up (in)
* vpp: looked-up vnode (out)
* od_name: on-disk name of file (out).
* This parameter is optional. If a pointer is passed in, it
* must be allocated with MAXNAMELEN bytes
* rootvp: vnode of the tree root (in)
* This parameter is always passed in non-NULL except at the time
* of share set up.
* direntflags: dirent flags returned from VOP_LOOKUP
*/
int
smb_vop_lookup(
vnode_t *dvp,
char *name,
vnode_t **vpp,
char *od_name,
int flags,
int *direntflags,
vnode_t *rootvp,
cred_t *cr)
{
int error = 0;
int option_flags = 0;
pathname_t rpn;
char *np = name;
char namebuf[MAXNAMELEN];
if (*name == '\0')
return (EINVAL);
ASSERT(vpp);
*vpp = NULL;
*direntflags = 0;
if ((name[0] == '.') && (name[1] == '.') && (name[2] == 0)) {
if (rootvp && (dvp == rootvp)) {
VN_HOLD(dvp);
*vpp = dvp;
return (0);
}
if (dvp->v_flag & VROOT) {
vfs_t *vfsp;
vnode_t *cvp = dvp;
/*
* Set dvp and check for races with forced unmount
* (see lookuppnvp())
*/
vfsp = cvp->v_vfsp;
vfs_rlock_wait(vfsp);
if (((dvp = cvp->v_vfsp->vfs_vnodecovered) == NULL) ||
(cvp->v_vfsp->vfs_flag & VFS_UNMOUNTED)) {
vfs_unlock(vfsp);
return (EIO);
}
vfs_unlock(vfsp);
}
}
if (flags & SMB_IGNORE_CASE)
option_flags = FIGNORECASE;
if (flags & SMB_CATIA)
np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf));
pn_alloc(&rpn);
error = VOP_LOOKUP(dvp, np, vpp, NULL, option_flags, NULL, cr,
&smb_ct, direntflags, &rpn);
if ((error == 0) && od_name) {
bzero(od_name, MAXNAMELEN);
np = (option_flags == FIGNORECASE) ? rpn.pn_buf : name;
if (flags & SMB_CATIA)
smb_vop_catia_v4tov5(np, od_name, MAXNAMELEN);
else
(void) strlcpy(od_name, np, MAXNAMELEN);
}
pn_free(&rpn);
return (error);
}
