1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1982, 1986, 1989, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
* (c) UNIX System Laboratories, Inc.
|
|
|
|
* All or some portions of this file are derived from material licensed
|
|
|
|
* to the University of California by American Telephone and Telegraph
|
|
|
|
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
|
|
|
|
* the permission of UNIX System Laboratories, Inc.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)vfs_lookup.c 8.4 (Berkeley) 2/16/94
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1996-01-03 21:42:35 +00:00
|
|
|
#include "opt_ktrace.h"
|
2002-08-01 01:21:40 +00:00
|
|
|
#include "opt_mac.h"
|
1996-01-03 21:42:35 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
1994-08-18 22:36:09 +00:00
|
|
|
#include <sys/systm.h>
|
2000-12-06 07:09:08 +00:00
|
|
|
#include <sys/kernel.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/lock.h>
|
2002-08-01 01:21:40 +00:00
|
|
|
#include <sys/mac.h>
|
2002-01-13 21:37:49 +00:00
|
|
|
#include <sys/mutex.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/namei.h>
|
|
|
|
#include <sys/vnode.h>
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#include <sys/filedesc.h>
|
|
|
|
#include <sys/proc.h>
|
|
|
|
#ifdef KTRACE
|
|
|
|
#include <sys/ktrace.h>
|
|
|
|
#endif
|
|
|
|
|
2002-03-20 04:09:59 +00:00
|
|
|
#include <vm/uma.h>
|
1997-12-27 02:56:39 +00:00
|
|
|
|
2004-12-03 12:15:39 +00:00
|
|
|
#define NAMEI_DIAGNOSTIC 1
|
|
|
|
#undef NAMEI_DIAGNOSTIC
|
|
|
|
|
2000-12-06 07:09:08 +00:00
|
|
|
/*
|
|
|
|
* Allocation zone for namei
|
|
|
|
*/
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zone_t namei_zone;
|
2000-12-06 07:09:08 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
nameiinit(void *dummy __unused)
|
|
|
|
{
|
2002-03-19 09:11:49 +00:00
|
|
|
namei_zone = uma_zcreate("NAMEI", MAXPATHLEN, NULL, NULL, NULL, NULL,
|
|
|
|
UMA_ALIGN_PTR, 0);
|
2000-12-06 07:09:08 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_SECOND, nameiinit, NULL)
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Convert a pathname into a pointer to a locked inode.
|
|
|
|
*
|
|
|
|
* The FOLLOW flag is set when symbolic links are to be followed
|
|
|
|
* when they occur at the end of the name translation process.
|
|
|
|
* Symbolic links are always followed for all other pathname
|
|
|
|
* components other than the last.
|
|
|
|
*
|
|
|
|
* The segflg defines whether the name is to be copied from user
|
|
|
|
* space or kernel space.
|
|
|
|
*
|
|
|
|
* Overall outline of namei:
|
|
|
|
*
|
|
|
|
* copy in name
|
|
|
|
* get starting directory
|
|
|
|
* while (!done && !error) {
|
|
|
|
* call lookup to search path.
|
|
|
|
* if symbolic link, massage name in buffer and continue
|
|
|
|
* }
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
namei(ndp)
|
|
|
|
register struct nameidata *ndp;
|
|
|
|
{
|
|
|
|
register struct filedesc *fdp; /* pointer to file descriptor state */
|
|
|
|
register char *cp; /* pointer into pathname argument */
|
|
|
|
register struct vnode *dp; /* the directory we are searching */
|
|
|
|
struct iovec aiov; /* uio for reading symbolic links */
|
|
|
|
struct uio auio;
|
|
|
|
int error, linklen;
|
|
|
|
struct componentname *cnp = &ndp->ni_cnd;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = cnp->cn_thread;
|
|
|
|
struct proc *p = td->td_proc;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-08-04 18:39:07 +00:00
|
|
|
GIANT_REQUIRED;
|
|
|
|
|
2002-02-27 19:15:29 +00:00
|
|
|
ndp->ni_cnd.cn_cred = ndp->ni_cnd.cn_thread->td_ucred;
|
2001-09-12 08:38:13 +00:00
|
|
|
KASSERT(cnp->cn_cred && p, ("namei: bad cred/proc"));
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT((cnp->cn_nameiop & (~OPMASK)) == 0,
|
1999-01-10 01:58:29 +00:00
|
|
|
("namei: nameiop contaminated with flags"));
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT((cnp->cn_flags & OPMASK) == 0,
|
1999-01-10 01:58:29 +00:00
|
|
|
("namei: flags contaminated with nameiops"));
|
2001-09-12 08:38:13 +00:00
|
|
|
fdp = p->p_fd;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a buffer for the name to be translated, and copy the
|
|
|
|
* name into the buffer.
|
|
|
|
*/
|
|
|
|
if ((cnp->cn_flags & HASBUF) == 0)
|
2003-02-19 05:47:46 +00:00
|
|
|
cnp->cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ndp->ni_segflg == UIO_SYSSPACE)
|
|
|
|
error = copystr(ndp->ni_dirp, cnp->cn_pnbuf,
|
1998-06-07 17:13:14 +00:00
|
|
|
MAXPATHLEN, (size_t *)&ndp->ni_pathlen);
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
|
|
|
error = copyinstr(ndp->ni_dirp, cnp->cn_pnbuf,
|
1998-06-07 17:13:14 +00:00
|
|
|
MAXPATHLEN, (size_t *)&ndp->ni_pathlen);
|
1996-12-01 16:05:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't allow empty pathnames.
|
|
|
|
*/
|
|
|
|
if (!error && *cnp->cn_pnbuf == '\0')
|
|
|
|
error = ENOENT;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error) {
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zfree(namei_zone, cnp->cn_pnbuf);
|
2002-07-24 15:42:22 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
cnp->cn_pnbuf = NULL;
|
|
|
|
cnp->cn_nameptr = NULL;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
ndp->ni_vp = NULL;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
ndp->ni_loopcnt = 0;
|
|
|
|
#ifdef KTRACE
|
2002-06-07 05:37:18 +00:00
|
|
|
if (KTRPOINT(td, KTR_NAMEI)) {
|
|
|
|
KASSERT(cnp->cn_thread == curthread,
|
|
|
|
("namei not using curthread"));
|
|
|
|
ktrnamei(cnp->cn_pnbuf);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get starting point for the translation.
|
|
|
|
*/
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
1998-02-15 04:17:09 +00:00
|
|
|
ndp->ni_rootdir = fdp->fd_rdir;
|
1999-09-25 14:14:21 +00:00
|
|
|
ndp->ni_topdir = fdp->fd_jdir;
|
1998-02-15 04:17:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
dp = fdp->fd_cdir;
|
|
|
|
VREF(dp);
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
1994-05-24 10:09:53 +00:00
|
|
|
for (;;) {
|
|
|
|
/*
|
|
|
|
* Check if root directory should replace current directory.
|
|
|
|
* Done at start of translation and after symbolic link.
|
|
|
|
*/
|
|
|
|
cnp->cn_nameptr = cnp->cn_pnbuf;
|
|
|
|
if (*(cnp->cn_nameptr) == '/') {
|
|
|
|
vrele(dp);
|
|
|
|
while (*(cnp->cn_nameptr) == '/') {
|
|
|
|
cnp->cn_nameptr++;
|
|
|
|
ndp->ni_pathlen--;
|
|
|
|
}
|
|
|
|
dp = ndp->ni_rootdir;
|
|
|
|
VREF(dp);
|
|
|
|
}
|
|
|
|
ndp->ni_startdir = dp;
|
1994-09-27 20:33:41 +00:00
|
|
|
error = lookup(ndp);
|
|
|
|
if (error) {
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zfree(namei_zone, cnp->cn_pnbuf);
|
2002-07-24 15:42:22 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
cnp->cn_pnbuf = NULL;
|
|
|
|
cnp->cn_nameptr = NULL;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Check for symbolic link
|
|
|
|
*/
|
|
|
|
if ((cnp->cn_flags & ISSYMLINK) == 0) {
|
2002-07-24 15:42:22 +00:00
|
|
|
if ((cnp->cn_flags & (SAVENAME | SAVESTART)) == 0) {
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zfree(namei_zone, cnp->cn_pnbuf);
|
2002-07-24 15:42:22 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
cnp->cn_pnbuf = NULL;
|
|
|
|
cnp->cn_nameptr = NULL;
|
|
|
|
#endif
|
|
|
|
} else
|
1994-05-24 10:09:53 +00:00
|
|
|
cnp->cn_flags |= HASBUF;
|
Make our v_usecount vnode reference count work identically to the
original BSD code. The association between the vnode and the vm_object
no longer includes reference counts. The major difference is that
vm_object's are no longer freed gratuitiously from the vnode, and so
once an object is created for the vnode, it will last as long as the
vnode does.
When a vnode object reference count is incremented, then the underlying
vnode reference count is incremented also. The two "objects" are now
more intimately related, and so the interactions are now much less
complex.
When vnodes are now normally placed onto the free queue with an object still
attached. The rundown of the object happens at vnode rundown time, and
happens with exactly the same filesystem semantics of the original VFS
code. There is absolutely no need for vnode_pager_uncache and other
travesties like that anymore.
A side-effect of these changes is that SMP locking should be much simpler,
the I/O copyin/copyout optimizations work, NFS should be more ponderable,
and further work on layered filesystems should be less frustrating, because
of the totally coherent management of the vnode objects and vnodes.
Please be careful with your system while running this code, but I would
greatly appreciate feedback as soon a reasonably possible.
1998-01-06 05:26:17 +00:00
|
|
|
|
1999-07-26 06:25:53 +00:00
|
|
|
if (vn_canvmio(ndp->ni_vp) == TRUE &&
|
Make our v_usecount vnode reference count work identically to the
original BSD code. The association between the vnode and the vm_object
no longer includes reference counts. The major difference is that
vm_object's are no longer freed gratuitiously from the vnode, and so
once an object is created for the vnode, it will last as long as the
vnode does.
When a vnode object reference count is incremented, then the underlying
vnode reference count is incremented also. The two "objects" are now
more intimately related, and so the interactions are now much less
complex.
When vnodes are now normally placed onto the free queue with an object still
attached. The rundown of the object happens at vnode rundown time, and
happens with exactly the same filesystem semantics of the original VFS
code. There is absolutely no need for vnode_pager_uncache and other
travesties like that anymore.
A side-effect of these changes is that SMP locking should be much simpler,
the I/O copyin/copyout optimizations work, NFS should be more ponderable,
and further work on layered filesystems should be less frustrating, because
of the totally coherent management of the vnode objects and vnodes.
Please be careful with your system while running this code, but I would
greatly appreciate feedback as soon a reasonably possible.
1998-01-06 05:26:17 +00:00
|
|
|
(cnp->cn_nameiop != DELETE) &&
|
1999-01-05 18:50:03 +00:00
|
|
|
((cnp->cn_flags & (NOOBJ|LOCKLEAF)) ==
|
|
|
|
LOCKLEAF))
|
2001-09-12 08:38:13 +00:00
|
|
|
vfs_object_create(ndp->ni_vp, td,
|
1999-01-05 18:50:03 +00:00
|
|
|
ndp->ni_cnd.cn_cred);
|
Make our v_usecount vnode reference count work identically to the
original BSD code. The association between the vnode and the vm_object
no longer includes reference counts. The major difference is that
vm_object's are no longer freed gratuitiously from the vnode, and so
once an object is created for the vnode, it will last as long as the
vnode does.
When a vnode object reference count is incremented, then the underlying
vnode reference count is incremented also. The two "objects" are now
more intimately related, and so the interactions are now much less
complex.
When vnodes are now normally placed onto the free queue with an object still
attached. The rundown of the object happens at vnode rundown time, and
happens with exactly the same filesystem semantics of the original VFS
code. There is absolutely no need for vnode_pager_uncache and other
travesties like that anymore.
A side-effect of these changes is that SMP locking should be much simpler,
the I/O copyin/copyout optimizations work, NFS should be more ponderable,
and further work on layered filesystems should be less frustrating, because
of the totally coherent management of the vnode objects and vnodes.
Please be careful with your system while running this code, but I would
greatly appreciate feedback as soon a reasonably possible.
1998-01-06 05:26:17 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1)
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(ndp->ni_dvp, 0, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
|
|
|
|
error = ELOOP;
|
|
|
|
break;
|
|
|
|
}
|
2002-08-01 01:21:40 +00:00
|
|
|
#ifdef MAC
|
2002-10-19 21:25:51 +00:00
|
|
|
if ((cnp->cn_flags & NOMACCHECK) == 0) {
|
|
|
|
error = mac_check_vnode_readlink(td->td_ucred,
|
|
|
|
ndp->ni_vp);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
}
|
2002-08-01 01:21:40 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ndp->ni_pathlen > 1)
|
2003-02-19 05:47:46 +00:00
|
|
|
cp = uma_zalloc(namei_zone, M_WAITOK);
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
|
|
|
cp = cnp->cn_pnbuf;
|
|
|
|
aiov.iov_base = cp;
|
|
|
|
aiov.iov_len = MAXPATHLEN;
|
|
|
|
auio.uio_iov = &aiov;
|
|
|
|
auio.uio_iovcnt = 1;
|
|
|
|
auio.uio_offset = 0;
|
|
|
|
auio.uio_rw = UIO_READ;
|
|
|
|
auio.uio_segflg = UIO_SYSSPACE;
|
2001-09-12 08:38:13 +00:00
|
|
|
auio.uio_td = (struct thread *)0;
|
1994-05-24 10:09:53 +00:00
|
|
|
auio.uio_resid = MAXPATHLEN;
|
1994-09-27 20:33:41 +00:00
|
|
|
error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
|
|
|
|
if (error) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ndp->ni_pathlen > 1)
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zfree(namei_zone, cp);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
linklen = MAXPATHLEN - auio.uio_resid;
|
2001-06-24 05:24:41 +00:00
|
|
|
if (linklen == 0) {
|
|
|
|
if (ndp->ni_pathlen > 1)
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zfree(namei_zone, cp);
|
2001-06-24 05:24:41 +00:00
|
|
|
error = ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
|
|
|
|
if (ndp->ni_pathlen > 1)
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zfree(namei_zone, cp);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = ENAMETOOLONG;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ndp->ni_pathlen > 1) {
|
|
|
|
bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen);
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zfree(namei_zone, cnp->cn_pnbuf);
|
1994-05-24 10:09:53 +00:00
|
|
|
cnp->cn_pnbuf = cp;
|
|
|
|
} else
|
|
|
|
cnp->cn_pnbuf[linklen] = '\0';
|
|
|
|
ndp->ni_pathlen += linklen;
|
|
|
|
vput(ndp->ni_vp);
|
|
|
|
dp = ndp->ni_dvp;
|
|
|
|
}
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zfree(namei_zone, cnp->cn_pnbuf);
|
2002-07-24 15:42:22 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
cnp->cn_pnbuf = NULL;
|
|
|
|
cnp->cn_nameptr = NULL;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
vrele(ndp->ni_dvp);
|
|
|
|
vput(ndp->ni_vp);
|
|
|
|
ndp->ni_vp = NULL;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 ".".
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* 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 VOP_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
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
lookup(ndp)
|
|
|
|
register struct nameidata *ndp;
|
|
|
|
{
|
|
|
|
register char *cp; /* pointer into pathname argument */
|
|
|
|
register struct vnode *dp = 0; /* the directory we are searching */
|
|
|
|
struct vnode *tdp; /* saved dp */
|
|
|
|
struct mount *mp; /* mount table entry */
|
|
|
|
int docache; /* == 0 do not cache last component */
|
|
|
|
int wantparent; /* 1 => wantparent or lockparent flag */
|
|
|
|
int rdonly; /* lookup read-only flag bit */
|
1995-07-31 00:35:58 +00:00
|
|
|
int trailing_slash;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error = 0;
|
2000-09-13 08:57:56 +00:00
|
|
|
int dpunlocked = 0; /* dp has already been unlocked */
|
1994-05-24 10:09:53 +00:00
|
|
|
struct componentname *cnp = &ndp->ni_cnd;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = cnp->cn_thread;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Setup: break out flag bits into variables.
|
|
|
|
*/
|
|
|
|
wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT);
|
|
|
|
docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE;
|
|
|
|
if (cnp->cn_nameiop == DELETE ||
|
1997-02-18 06:46:41 +00:00
|
|
|
(wantparent && cnp->cn_nameiop != CREATE &&
|
|
|
|
cnp->cn_nameiop != LOOKUP))
|
1994-05-24 10:09:53 +00:00
|
|
|
docache = 0;
|
|
|
|
rdonly = cnp->cn_flags & RDONLY;
|
|
|
|
ndp->ni_dvp = NULL;
|
|
|
|
cnp->cn_flags &= ~ISSYMLINK;
|
|
|
|
dp = ndp->ni_startdir;
|
|
|
|
ndp->ni_startdir = NULLVP;
|
2001-09-12 08:38:13 +00:00
|
|
|
vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
dirloop:
|
|
|
|
/*
|
|
|
|
* Search a new directory.
|
|
|
|
*
|
|
|
|
* The last component of the filename is left accessible via
|
|
|
|
* cnp->cn_nameptr for callers that need the name. Callers needing
|
|
|
|
* the name set the SAVENAME flag. When done, they assume
|
|
|
|
* responsibility for freeing the pathname buffer.
|
|
|
|
*/
|
|
|
|
cnp->cn_consume = 0;
|
|
|
|
for (cp = cnp->cn_nameptr; *cp != 0 && *cp != '/'; cp++)
|
1999-10-03 12:18:29 +00:00
|
|
|
continue;
|
1994-05-24 10:09:53 +00:00
|
|
|
cnp->cn_namelen = cp - cnp->cn_nameptr;
|
|
|
|
if (cnp->cn_namelen > NAME_MAX) {
|
|
|
|
error = ENAMETOOLONG;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
#ifdef NAMEI_DIAGNOSTIC
|
|
|
|
{ char c = *cp;
|
|
|
|
*cp = '\0';
|
|
|
|
printf("{%s}: ", cnp->cn_nameptr);
|
|
|
|
*cp = c; }
|
|
|
|
#endif
|
|
|
|
ndp->ni_pathlen -= cnp->cn_namelen;
|
|
|
|
ndp->ni_next = cp;
|
1995-07-31 00:35:58 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Replace multiple slashes by a single slash and trailing slashes
|
|
|
|
* by a null. This must be done before VOP_LOOKUP() because some
|
|
|
|
* fs's don't know about trailing slashes. Remember if there were
|
|
|
|
* trailing slashes to handle symlinks, existing non-directories
|
|
|
|
* and non-existing files that won't be directories specially later.
|
|
|
|
*/
|
|
|
|
trailing_slash = 0;
|
|
|
|
while (*cp == '/' && (cp[1] == '/' || cp[1] == '\0')) {
|
|
|
|
cp++;
|
|
|
|
ndp->ni_pathlen--;
|
|
|
|
if (*cp == '\0') {
|
|
|
|
trailing_slash = 1;
|
|
|
|
*ndp->ni_next = '\0'; /* XXX for direnter() ... */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ndp->ni_next = cp;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
cnp->cn_flags |= MAKEENTRY;
|
|
|
|
if (*cp == '\0' && docache == 0)
|
|
|
|
cnp->cn_flags &= ~MAKEENTRY;
|
|
|
|
if (cnp->cn_namelen == 2 &&
|
|
|
|
cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
|
|
|
|
cnp->cn_flags |= ISDOTDOT;
|
|
|
|
else
|
|
|
|
cnp->cn_flags &= ~ISDOTDOT;
|
|
|
|
if (*ndp->ni_next == 0)
|
|
|
|
cnp->cn_flags |= ISLASTCN;
|
|
|
|
else
|
|
|
|
cnp->cn_flags &= ~ISLASTCN;
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 (dp->v_type != VDIR) {
|
|
|
|
error = ENOTDIR;
|
|
|
|
goto bad;
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
if (cnp->cn_nameiop != LOOKUP) {
|
|
|
|
error = EISDIR;
|
|
|
|
goto bad;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if (wantparent) {
|
|
|
|
ndp->ni_dvp = dp;
|
|
|
|
VREF(dp);
|
|
|
|
}
|
|
|
|
ndp->ni_vp = dp;
|
|
|
|
if (!(cnp->cn_flags & (LOCKPARENT | LOCKLEAF)))
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(dp, 0, td);
|
1999-12-15 23:02:35 +00:00
|
|
|
/* XXX This should probably move to the top of function. */
|
1994-05-24 10:09:53 +00:00
|
|
|
if (cnp->cn_flags & SAVESTART)
|
|
|
|
panic("lookup: SAVESTART");
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
2002-05-16 21:28:32 +00:00
|
|
|
* .. in the other filesystem.
|
1999-09-25 14:14:21 +00:00
|
|
|
* 3. If the vnode is the top directory of
|
|
|
|
* the jail or chroot, don't let them out.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
if (cnp->cn_flags & ISDOTDOT) {
|
|
|
|
for (;;) {
|
1999-09-25 14:14:21 +00:00
|
|
|
if (dp == ndp->ni_rootdir ||
|
|
|
|
dp == ndp->ni_topdir ||
|
|
|
|
dp == rootvnode) {
|
1994-05-24 10:09:53 +00:00
|
|
|
ndp->ni_dvp = dp;
|
|
|
|
ndp->ni_vp = dp;
|
|
|
|
VREF(dp);
|
|
|
|
goto nextname;
|
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
if ((dp->v_vflag & VV_ROOT) == 0 ||
|
1994-05-24 10:09:53 +00:00
|
|
|
(cnp->cn_flags & NOCROSSMOUNT))
|
|
|
|
break;
|
2000-11-30 20:04:44 +00:00
|
|
|
if (dp->v_mount == NULL) { /* forced unmount */
|
|
|
|
error = EBADF;
|
|
|
|
goto bad;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
tdp = dp;
|
|
|
|
dp = dp->v_mount->mnt_vnodecovered;
|
|
|
|
vput(tdp);
|
|
|
|
VREF(dp);
|
2001-09-12 08:38:13 +00:00
|
|
|
vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We now have a segment name to search for, and a directory to search.
|
|
|
|
*/
|
|
|
|
unionlookup:
|
2002-08-01 01:21:40 +00:00
|
|
|
#ifdef MAC
|
2002-10-19 21:25:51 +00:00
|
|
|
if ((cnp->cn_flags & NOMACCHECK) == 0) {
|
|
|
|
error = mac_check_vnode_lookup(td->td_ucred, dp, cnp);
|
|
|
|
if (error)
|
|
|
|
goto bad;
|
|
|
|
}
|
2002-08-01 01:21:40 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
ndp->ni_dvp = dp;
|
1997-02-10 02:22:35 +00:00
|
|
|
ndp->ni_vp = NULL;
|
2000-09-17 07:26:42 +00:00
|
|
|
cnp->cn_flags &= ~PDIRUNLOCK;
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_LOCKED(dp, "lookup");
|
2004-12-03 12:15:39 +00:00
|
|
|
#ifdef NAMEI_DIAGNOSTIC
|
|
|
|
vprint("lookup in", dp);
|
|
|
|
#endif
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = VOP_LOOKUP(dp, &ndp->ni_vp, cnp)) != 0) {
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(ndp->ni_vp == NULL, ("leaf should be empty"));
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef NAMEI_DIAGNOSTIC
|
|
|
|
printf("not found\n");
|
|
|
|
#endif
|
|
|
|
if ((error == ENOENT) &&
|
2002-08-04 10:29:36 +00:00
|
|
|
(dp->v_vflag & VV_ROOT) && (dp->v_mount != NULL) &&
|
1994-05-24 10:09:53 +00:00
|
|
|
(dp->v_mount->mnt_flag & MNT_UNION)) {
|
|
|
|
tdp = dp;
|
|
|
|
dp = dp->v_mount->mnt_vnodecovered;
|
2000-09-17 07:26:42 +00:00
|
|
|
if (cnp->cn_flags & PDIRUNLOCK)
|
|
|
|
vrele(tdp);
|
|
|
|
else
|
|
|
|
vput(tdp);
|
1994-05-24 10:09:53 +00:00
|
|
|
VREF(dp);
|
2001-09-12 08:38:13 +00:00
|
|
|
vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
goto unionlookup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (error != EJUSTRETURN)
|
|
|
|
goto bad;
|
|
|
|
/*
|
|
|
|
* If creating and at end of pathname, then can consider
|
|
|
|
* allowing file to be created.
|
|
|
|
*/
|
1995-10-22 09:32:48 +00:00
|
|
|
if (rdonly) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EROFS;
|
|
|
|
goto bad;
|
|
|
|
}
|
1995-07-31 00:35:58 +00:00
|
|
|
if (*cp == '\0' && trailing_slash &&
|
|
|
|
!(cnp->cn_flags & WILLBEDIR)) {
|
|
|
|
error = ENOENT;
|
|
|
|
goto bad;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
if (cnp->cn_flags & SAVESTART) {
|
|
|
|
ndp->ni_startdir = ndp->ni_dvp;
|
|
|
|
VREF(ndp->ni_startdir);
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
#ifdef NAMEI_DIAGNOSTIC
|
|
|
|
printf("found\n");
|
|
|
|
#endif
|
|
|
|
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_LOCKED(ndp->ni_vp, "lookup");
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
dp = ndp->ni_vp;
|
1995-07-31 00:35:58 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Check to see if the vnode has been mounted on;
|
2002-05-16 21:28:32 +00:00
|
|
|
* if so find the root of the mounted filesystem.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
while (dp->v_type == VDIR && (mp = dp->v_mountedhere) &&
|
|
|
|
(cnp->cn_flags & NOCROSSMOUNT) == 0) {
|
2001-09-12 08:38:13 +00:00
|
|
|
if (vfs_busy(mp, 0, 0, td))
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(dp, 0, td);
|
2004-07-12 08:14:09 +00:00
|
|
|
error = VFS_ROOT(mp, &tdp, td);
|
2001-09-12 08:38:13 +00:00
|
|
|
vfs_unbusy(mp, td);
|
2000-09-13 08:57:56 +00:00
|
|
|
if (error) {
|
|
|
|
dpunlocked = 1;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad2;
|
2000-09-13 08:57:56 +00:00
|
|
|
}
|
|
|
|
vrele(dp);
|
1994-05-24 10:09:53 +00:00
|
|
|
ndp->ni_vp = dp = tdp;
|
|
|
|
}
|
|
|
|
|
1995-08-24 10:17:39 +00:00
|
|
|
/*
|
|
|
|
* Check for symbolic link
|
|
|
|
*/
|
|
|
|
if ((dp->v_type == VLNK) &&
|
|
|
|
((cnp->cn_flags & FOLLOW) || trailing_slash ||
|
|
|
|
*ndp->ni_next == '/')) {
|
|
|
|
cnp->cn_flags |= ISSYMLINK;
|
2000-11-30 20:04:44 +00:00
|
|
|
if (dp->v_mount == NULL) {
|
|
|
|
/* We can't know whether the directory was mounted with
|
|
|
|
* NOSYMFOLLOW, so we can't follow safely. */
|
|
|
|
error = EBADF;
|
|
|
|
goto bad2;
|
|
|
|
}
|
1998-04-08 18:31:59 +00:00
|
|
|
if (dp->v_mount->mnt_flag & MNT_NOSYMFOLLOW) {
|
|
|
|
error = EACCES;
|
|
|
|
goto bad2;
|
|
|
|
}
|
1995-08-24 10:17:39 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for bogus trailing slashes.
|
|
|
|
*/
|
|
|
|
if (trailing_slash && dp->v_type != VDIR) {
|
|
|
|
error = ENOTDIR;
|
|
|
|
goto bad2;
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
nextname:
|
|
|
|
/*
|
|
|
|
* Not a symbolic link. If more pathname,
|
|
|
|
* continue at next component, else return.
|
|
|
|
*/
|
|
|
|
if (*ndp->ni_next == '/') {
|
|
|
|
cnp->cn_nameptr = ndp->ni_next;
|
|
|
|
while (*cnp->cn_nameptr == '/') {
|
|
|
|
cnp->cn_nameptr++;
|
|
|
|
ndp->ni_pathlen--;
|
|
|
|
}
|
1999-12-15 23:02:35 +00:00
|
|
|
if (ndp->ni_dvp != ndp->ni_vp)
|
|
|
|
ASSERT_VOP_UNLOCKED(ndp->ni_dvp, "lookup");
|
1994-05-24 10:09:53 +00:00
|
|
|
vrele(ndp->ni_dvp);
|
|
|
|
goto dirloop;
|
|
|
|
}
|
|
|
|
/*
|
2002-05-16 21:28:32 +00:00
|
|
|
* Disallow directory write attempts on read-only filesystems.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-10-22 09:32:48 +00:00
|
|
|
if (rdonly &&
|
|
|
|
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
|
|
|
|
error = EROFS;
|
|
|
|
goto bad2;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if (cnp->cn_flags & SAVESTART) {
|
|
|
|
ndp->ni_startdir = ndp->ni_dvp;
|
|
|
|
VREF(ndp->ni_startdir);
|
|
|
|
}
|
|
|
|
if (!wantparent)
|
|
|
|
vrele(ndp->ni_dvp);
|
1997-12-29 00:25:11 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((cnp->cn_flags & LOCKLEAF) == 0)
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(dp, 0, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
bad2:
|
2000-09-17 07:26:42 +00:00
|
|
|
if ((cnp->cn_flags & (LOCKPARENT | PDIRUNLOCK)) == LOCKPARENT &&
|
|
|
|
*ndp->ni_next == '\0')
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(ndp->ni_dvp, 0, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
vrele(ndp->ni_dvp);
|
|
|
|
bad:
|
2000-09-13 08:57:56 +00:00
|
|
|
if (dpunlocked)
|
|
|
|
vrele(dp);
|
|
|
|
else
|
|
|
|
vput(dp);
|
1994-05-24 10:09:53 +00:00
|
|
|
ndp->ni_vp = NULL;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-09-27 20:33:41 +00:00
|
|
|
/*
|
|
|
|
* relookup - lookup a path name component
|
|
|
|
* Used by lookup to re-aquire things.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
relookup(dvp, vpp, cnp)
|
|
|
|
struct vnode *dvp, **vpp;
|
|
|
|
struct componentname *cnp;
|
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = cnp->cn_thread;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct vnode *dp = 0; /* the directory we are searching */
|
1994-09-27 20:33:41 +00:00
|
|
|
int docache; /* == 0 do not cache last component */
|
|
|
|
int wantparent; /* 1 => wantparent or lockparent flag */
|
|
|
|
int rdonly; /* lookup read-only flag bit */
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Setup: break out flag bits into variables.
|
|
|
|
*/
|
|
|
|
wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT);
|
|
|
|
docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE;
|
|
|
|
if (cnp->cn_nameiop == DELETE ||
|
|
|
|
(wantparent && cnp->cn_nameiop != CREATE))
|
|
|
|
docache = 0;
|
|
|
|
rdonly = cnp->cn_flags & RDONLY;
|
|
|
|
cnp->cn_flags &= ~ISSYMLINK;
|
|
|
|
dp = dvp;
|
2001-09-12 08:38:13 +00:00
|
|
|
vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td);
|
1994-09-27 20:33:41 +00:00
|
|
|
|
|
|
|
/* dirloop: */
|
|
|
|
/*
|
|
|
|
* Search a new directory.
|
|
|
|
*
|
|
|
|
* The last component of the filename is left accessible via
|
|
|
|
* cnp->cn_nameptr for callers that need the name. Callers needing
|
|
|
|
* the name set the SAVENAME flag. When done, they assume
|
|
|
|
* responsibility for freeing the pathname buffer.
|
|
|
|
*/
|
|
|
|
#ifdef NAMEI_DIAGNOSTIC
|
|
|
|
printf("{%s}: ", cnp->cn_nameptr);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 (!(cnp->cn_flags & LOCKLEAF))
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(dp, 0, td);
|
1994-09-27 20:33:41 +00:00
|
|
|
*vpp = dp;
|
1999-12-15 23:02:35 +00:00
|
|
|
/* XXX This should probably move to the top of function. */
|
1994-09-27 20:33:41 +00:00
|
|
|
if (cnp->cn_flags & SAVESTART)
|
|
|
|
panic("lookup: SAVESTART");
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cnp->cn_flags & ISDOTDOT)
|
|
|
|
panic ("relookup: lookup on dot-dot");
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1994-09-27 20:33:41 +00:00
|
|
|
/*
|
|
|
|
* We now have a segment name to search for, and a directory to search.
|
|
|
|
*/
|
2004-12-03 12:15:39 +00:00
|
|
|
#ifdef NAMEI_DIAGNOSTIC
|
|
|
|
vprint("search in:", dp);
|
|
|
|
#endif
|
1999-01-28 00:57:57 +00:00
|
|
|
if ((error = VOP_LOOKUP(dp, vpp, cnp)) != 0) {
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(*vpp == NULL, ("leaf should be empty"));
|
1994-09-27 20:33:41 +00:00
|
|
|
if (error != EJUSTRETURN)
|
|
|
|
goto bad;
|
|
|
|
/*
|
|
|
|
* If creating and at end of pathname, then can consider
|
|
|
|
* allowing file to be created.
|
|
|
|
*/
|
1995-10-22 09:32:48 +00:00
|
|
|
if (rdonly) {
|
1994-09-27 20:33:41 +00:00
|
|
|
error = EROFS;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
/* ASSERT(dvp == ndp->ni_startdir) */
|
|
|
|
if (cnp->cn_flags & SAVESTART)
|
|
|
|
VREF(dvp);
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for symbolic link
|
|
|
|
*/
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(dp->v_type != VLNK || !(cnp->cn_flags & FOLLOW),
|
1999-01-10 01:58:29 +00:00
|
|
|
("relookup: symlink found.\n"));
|
1994-09-27 20:33:41 +00:00
|
|
|
|
|
|
|
/*
|
2002-05-16 21:28:32 +00:00
|
|
|
* Disallow directory write attempts on read-only filesystems.
|
1994-09-27 20:33:41 +00:00
|
|
|
*/
|
1995-10-22 09:32:48 +00:00
|
|
|
if (rdonly &&
|
|
|
|
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
|
|
|
|
error = EROFS;
|
|
|
|
goto bad2;
|
1994-09-27 20:33:41 +00:00
|
|
|
}
|
|
|
|
/* ASSERT(dvp == ndp->ni_startdir) */
|
|
|
|
if (cnp->cn_flags & SAVESTART)
|
|
|
|
VREF(dvp);
|
1997-02-10 02:22:35 +00:00
|
|
|
|
1994-09-27 20:33:41 +00:00
|
|
|
if (!wantparent)
|
|
|
|
vrele(dvp);
|
1997-12-29 00:25:11 +00:00
|
|
|
|
1999-07-26 06:25:53 +00:00
|
|
|
if (vn_canvmio(dp) == TRUE &&
|
Make our v_usecount vnode reference count work identically to the
original BSD code. The association between the vnode and the vm_object
no longer includes reference counts. The major difference is that
vm_object's are no longer freed gratuitiously from the vnode, and so
once an object is created for the vnode, it will last as long as the
vnode does.
When a vnode object reference count is incremented, then the underlying
vnode reference count is incremented also. The two "objects" are now
more intimately related, and so the interactions are now much less
complex.
When vnodes are now normally placed onto the free queue with an object still
attached. The rundown of the object happens at vnode rundown time, and
happens with exactly the same filesystem semantics of the original VFS
code. There is absolutely no need for vnode_pager_uncache and other
travesties like that anymore.
A side-effect of these changes is that SMP locking should be much simpler,
the I/O copyin/copyout optimizations work, NFS should be more ponderable,
and further work on layered filesystems should be less frustrating, because
of the totally coherent management of the vnode objects and vnodes.
Please be careful with your system while running this code, but I would
greatly appreciate feedback as soon a reasonably possible.
1998-01-06 05:26:17 +00:00
|
|
|
((cnp->cn_flags & (NOOBJ|LOCKLEAF)) == LOCKLEAF))
|
2001-09-12 08:38:13 +00:00
|
|
|
vfs_object_create(dp, td, cnp->cn_cred);
|
1997-12-29 00:25:11 +00:00
|
|
|
|
1994-09-27 20:33:41 +00:00
|
|
|
if ((cnp->cn_flags & LOCKLEAF) == 0)
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(dp, 0, td);
|
1994-09-27 20:33:41 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
bad2:
|
|
|
|
if ((cnp->cn_flags & LOCKPARENT) && (cnp->cn_flags & ISLASTCN))
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(dvp, 0, td);
|
1994-09-27 20:33:41 +00:00
|
|
|
vrele(dvp);
|
|
|
|
bad:
|
|
|
|
vput(dp);
|
|
|
|
*vpp = NULL;
|
|
|
|
return (error);
|
|
|
|
}
|