2005-01-06 23:35:40 +00:00
|
|
|
/*-
|
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$");
|
|
|
|
|
|
2011-08-11 12:30:23 +00:00
|
|
|
#include "opt_capsicum.h"
|
2009-04-06 10:32:40 +00:00
|
|
|
#include "opt_kdtrace.h"
|
1996-01-03 21:42:35 +00:00
|
|
|
#include "opt_ktrace.h"
|
|
|
|
|
|
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>
|
2011-08-11 12:30:23 +00:00
|
|
|
#include <sys/capability.h>
|
2008-03-31 12:01:21 +00:00
|
|
|
#include <sys/fcntl.h>
|
2009-05-27 14:11:23 +00:00
|
|
|
#include <sys/jail.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/lock.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>
|
2009-04-06 10:32:40 +00:00
|
|
|
#include <sys/sdt.h>
|
2005-02-07 18:44:55 +00:00
|
|
|
#include <sys/syscallsubr.h>
|
2005-04-03 23:50:20 +00:00
|
|
|
#include <sys/sysctl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
|
#include <sys/ktrace.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
2006-02-05 15:42:01 +00:00
|
|
|
#include <security/audit/audit.h>
|
2006-10-22 11:52:19 +00:00
|
|
|
#include <security/mac/mac_framework.h>
|
2006-02-05 15:42:01 +00:00
|
|
|
|
2002-03-20 04:09:59 +00:00
|
|
|
#include <vm/uma.h>
|
1997-12-27 02:56:39 +00:00
|
|
|
|
2006-02-01 09:34:32 +00:00
|
|
|
#define NAMEI_DIAGNOSTIC 1
|
2004-12-03 12:15:39 +00:00
|
|
|
#undef NAMEI_DIAGNOSTIC
|
|
|
|
|
|
2009-04-06 10:32:40 +00:00
|
|
|
SDT_PROVIDER_DECLARE(vfs);
|
2010-08-22 11:18:57 +00:00
|
|
|
SDT_PROBE_DEFINE3(vfs, namei, lookup, entry, entry, "struct vnode *", "char *",
|
2009-04-06 10:32:40 +00:00
|
|
|
"unsigned long");
|
2010-08-22 11:18:57 +00:00
|
|
|
SDT_PROBE_DEFINE2(vfs, namei, lookup, return, return, "int", "struct vnode *");
|
2009-04-06 10:32:40 +00:00
|
|
|
|
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;
|
Below is slightly edited description of the LOR by Tor Egge:
--------------------------
[Deadlock] is caused by a lock order reversal in vfs_lookup(), where
[some] process is trying to lock a directory vnode, that is the parent
directory of covered vnode) while holding an exclusive vnode lock on
covering vnode.
A simplified scenario:
root fs var fs
/ A / (/var) D
/var B /log (/var/log) E
vfs lock C vfs lock F
Within each file system, the lock order is clear: C->A->B and F->D->E
When traversing across mounts, the system can choose between two lock orders,
but everything must then follow that lock order:
L1: C->A->B
|
+->F->D->E
L2: F->D->E
|
+->C->A->B
The lookup() process for namei("/var") mixes those two lock orders:
VOP_LOOKUP() obtains B while A is held
vfs_busy() obtains a shared lock on F while A and B are held (follows L1,
violates L2)
vput() releases lock on B
VOP_UNLOCK() releases lock on A
VFS_ROOT() obtains lock on D while shared lock on F is held
vfs_unbusy() releases shared lock on F
vn_lock() obtains lock on A while D is held (violates L1, follows L2)
dounmount() follows L1 (B is locked while F is drained).
Without unmount activity, vfs_busy() will always succeed without blocking
and the deadlock isn't triggered (the system behaves as if L2 is followed).
With unmount, you can get 4 processes in a deadlock:
p1: holds D, want A (in lookup())
p2: holds shared lock on F, want D (in VFS_ROOT())
p3: holds B, want drain lock on F (in dounmount())
p4: holds A, want B (in VOP_LOOKUP())
You can have more than one instance of p2.
The reversal was introduced in revision 1.81 of src/sys/kern/vfs_lookup.c and
MFCed to revision 1.80.2.1, probably to avoid a cascade of vnode locks when nfs
servers are dead (VFS_ROOT() just hangs) spreading to the root fs root vnode.
- Tor Egge
To fix the LOR, ups@ noted that when crossing the mount point, ni_dvp
is actually not used by the callers of namei. Thus, placeholder deadfs
vnode vp_crossmp is introduced that is filled into ni_dvp.
Idea by: ups
Reviewed by: tegge, ups, jeff, rwatson (mac interaction)
Tested by: Peter Holm
MFC after: 2 weeks
2007-01-22 11:25:22 +00:00
|
|
|
/*
|
|
|
|
|
* Placeholder vnode for mp traversal
|
|
|
|
|
*/
|
|
|
|
|
static struct vnode *vp_crossmp;
|
2000-12-06 07:09:08 +00:00
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
nameiinit(void *dummy __unused)
|
|
|
|
|
{
|
2007-03-31 16:08:50 +00:00
|
|
|
|
2002-03-19 09:11:49 +00:00
|
|
|
namei_zone = uma_zcreate("NAMEI", MAXPATHLEN, NULL, NULL, NULL, NULL,
|
|
|
|
|
UMA_ALIGN_PTR, 0);
|
2010-08-20 19:46:50 +00:00
|
|
|
getnewvnode("crossmp", NULL, &dead_vnodeops, &vp_crossmp);
|
|
|
|
|
vn_lock(vp_crossmp, LK_EXCLUSIVE);
|
2008-02-24 16:38:58 +00:00
|
|
|
VN_LOCK_ASHARE(vp_crossmp);
|
2010-08-20 19:46:50 +00:00
|
|
|
VOP_UNLOCK(vp_crossmp, 0);
|
2000-12-06 07:09:08 +00:00
|
|
|
}
|
2008-03-16 10:58:09 +00:00
|
|
|
SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_SECOND, nameiinit, NULL);
|
2000-12-06 07:09:08 +00:00
|
|
|
|
2008-10-01 19:25:37 +00:00
|
|
|
static int lookup_shared = 1;
|
2005-04-03 23:50:20 +00:00
|
|
|
SYSCTL_INT(_vfs, OID_AUTO, lookup_shared, CTLFLAG_RW, &lookup_shared, 0,
|
|
|
|
|
"Enables/Disables shared locks for path name translation");
|
2008-10-01 19:24:16 +00:00
|
|
|
TUNABLE_INT("vfs.lookup_shared", &lookup_shared);
|
2005-04-03 23:50:20 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2006-08-05 21:08:47 +00:00
|
|
|
* Convert a pathname into a pointer to a locked vnode.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
|
|
|
|
* 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
|
2006-08-05 21:40:59 +00:00
|
|
|
namei(struct nameidata *ndp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2006-08-05 21:40:59 +00:00
|
|
|
struct filedesc *fdp; /* pointer to file descriptor state */
|
|
|
|
|
char *cp; /* pointer into pathname argument */
|
|
|
|
|
struct vnode *dp; /* the directory we are searching */
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
2005-01-24 10:27:05 +00:00
|
|
|
int vfslocked;
|
2004-08-04 18:39:07 +00:00
|
|
|
|
2005-09-15 15:03:48 +00:00
|
|
|
KASSERT((cnp->cn_flags & MPSAFE) != 0 || mtx_owned(&Giant) != 0,
|
|
|
|
|
("NOT MPSAFE and Giant not held"));
|
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"));
|
2005-04-03 23:50:20 +00:00
|
|
|
if (!lookup_shared)
|
|
|
|
|
cnp->cn_flags &= ~LOCKSHARED;
|
2001-09-12 08:38:13 +00:00
|
|
|
fdp = p->p_fd;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2009-05-29 10:02:44 +00:00
|
|
|
/* We will set this ourselves if we need it. */
|
|
|
|
|
cnp->cn_flags &= ~TRAILINGSLASH;
|
|
|
|
|
|
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
|
|
|
|
2010-02-02 23:10:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
|
/*
|
|
|
|
|
* If we are auditing the kernel pathname, save the user
|
|
|
|
|
* pathname.
|
|
|
|
|
*/
|
|
|
|
|
if (cnp->cn_flags & AUDITVNODE1)
|
|
|
|
|
AUDIT_ARG_UPATH1(td, cnp->cn_pnbuf);
|
|
|
|
|
if (cnp->cn_flags & AUDITVNODE2)
|
|
|
|
|
AUDIT_ARG_UPATH2(td, cnp->cn_pnbuf);
|
|
|
|
|
}
|
2006-02-05 15:42:01 +00:00
|
|
|
|
1996-12-01 16:05:44 +00:00
|
|
|
/*
|
|
|
|
|
* Don't allow empty pathnames.
|
|
|
|
|
*/
|
|
|
|
|
if (!error && *cnp->cn_pnbuf == '\0')
|
|
|
|
|
error = ENOENT;
|
|
|
|
|
|
2011-08-13 09:21:16 +00:00
|
|
|
#ifdef CAPABILITY_MODE
|
|
|
|
|
/*
|
|
|
|
|
* In capability mode, lookups must be "strictly relative" (i.e.
|
|
|
|
|
* not an absolute path, and not containing '..' components) to
|
|
|
|
|
* a real file descriptor, not the pseudo-descriptor AT_FDCWD.
|
|
|
|
|
*/
|
|
|
|
|
if (IN_CAPABILITY_MODE(td)) {
|
|
|
|
|
ndp->ni_strictrelative = 1;
|
2011-10-18 07:28:58 +00:00
|
|
|
if (ndp->ni_dirfd == AT_FDCWD) {
|
|
|
|
|
#ifdef KTRACE
|
|
|
|
|
if (KTRPOINT(td, KTR_CAPFAIL))
|
|
|
|
|
ktrcapfail(CAPFAIL_LOOKUP, 0, 0);
|
|
|
|
|
#endif
|
2011-08-13 09:21:16 +00:00
|
|
|
error = ECAPMODE;
|
2011-10-18 07:28:58 +00:00
|
|
|
}
|
2011-08-13 09:21:16 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
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.
|
|
|
|
|
*/
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SLOCK(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
|
|
|
|
Update ZFS from version 6 to 13 and bring some FreeBSD-specific changes.
This bring huge amount of changes, I'll enumerate only user-visible changes:
- Delegated Administration
Allows regular users to perform ZFS operations, like file system
creation, snapshot creation, etc.
- L2ARC
Level 2 cache for ZFS - allows to use additional disks for cache.
Huge performance improvements mostly for random read of mostly
static content.
- slog
Allow to use additional disks for ZFS Intent Log to speed up
operations like fsync(2).
- vfs.zfs.super_owner
Allows regular users to perform privileged operations on files stored
on ZFS file systems owned by him. Very careful with this one.
- chflags(2)
Not all the flags are supported. This still needs work.
- ZFSBoot
Support to boot off of ZFS pool. Not finished, AFAIK.
Submitted by: dfr
- Snapshot properties
- New failure modes
Before if write requested failed, system paniced. Now one
can select from one of three failure modes:
- panic - panic on write error
- wait - wait for disk to reappear
- continue - serve read requests if possible, block write requests
- Refquota, refreservation properties
Just quota and reservation properties, but don't count space consumed
by children file systems, clones and snapshots.
- Sparse volumes
ZVOLs that don't reserve space in the pool.
- External attributes
Compatible with extattr(2).
- NFSv4-ACLs
Not sure about the status, might not be complete yet.
Submitted by: trasz
- Creation-time properties
- Regression tests for zpool(8) command.
Obtained from: OpenSolaris
2008-11-17 20:49:29 +00:00
|
|
|
dp = NULL;
|
|
|
|
|
if (cnp->cn_pnbuf[0] != '/') {
|
|
|
|
|
if (ndp->ni_startdir != NULL) {
|
|
|
|
|
dp = ndp->ni_startdir;
|
|
|
|
|
error = 0;
|
2009-07-28 21:39:58 +00:00
|
|
|
} else if (ndp->ni_dirfd != AT_FDCWD) {
|
|
|
|
|
if (cnp->cn_flags & AUDITVNODE1)
|
|
|
|
|
AUDIT_ARG_ATFD1(ndp->ni_dirfd);
|
|
|
|
|
if (cnp->cn_flags & AUDITVNODE2)
|
|
|
|
|
AUDIT_ARG_ATFD2(ndp->ni_dirfd);
|
2011-08-13 09:21:16 +00:00
|
|
|
error = fgetvp_rights(td, ndp->ni_dirfd,
|
|
|
|
|
ndp->ni_rightsneeded | CAP_LOOKUP,
|
|
|
|
|
&(ndp->ni_baserights), &dp);
|
|
|
|
|
#ifdef CAPABILITIES
|
|
|
|
|
/*
|
|
|
|
|
* Lookups relative to a capability must also be
|
|
|
|
|
* strictly relative.
|
|
|
|
|
*
|
|
|
|
|
* Note that a capability with rights CAP_MASK_VALID
|
|
|
|
|
* is treated exactly like a regular file descriptor.
|
|
|
|
|
*/
|
|
|
|
|
if (ndp->ni_baserights != CAP_MASK_VALID)
|
|
|
|
|
ndp->ni_strictrelative = 1;
|
2011-08-11 12:30:23 +00:00
|
|
|
#endif
|
2009-07-28 21:39:58 +00:00
|
|
|
}
|
Update ZFS from version 6 to 13 and bring some FreeBSD-specific changes.
This bring huge amount of changes, I'll enumerate only user-visible changes:
- Delegated Administration
Allows regular users to perform ZFS operations, like file system
creation, snapshot creation, etc.
- L2ARC
Level 2 cache for ZFS - allows to use additional disks for cache.
Huge performance improvements mostly for random read of mostly
static content.
- slog
Allow to use additional disks for ZFS Intent Log to speed up
operations like fsync(2).
- vfs.zfs.super_owner
Allows regular users to perform privileged operations on files stored
on ZFS file systems owned by him. Very careful with this one.
- chflags(2)
Not all the flags are supported. This still needs work.
- ZFSBoot
Support to boot off of ZFS pool. Not finished, AFAIK.
Submitted by: dfr
- Snapshot properties
- New failure modes
Before if write requested failed, system paniced. Now one
can select from one of three failure modes:
- panic - panic on write error
- wait - wait for disk to reappear
- continue - serve read requests if possible, block write requests
- Refquota, refreservation properties
Just quota and reservation properties, but don't count space consumed
by children file systems, clones and snapshots.
- Sparse volumes
ZVOLs that don't reserve space in the pool.
- External attributes
Compatible with extattr(2).
- NFSv4-ACLs
Not sure about the status, might not be complete yet.
Submitted by: trasz
- Creation-time properties
- Regression tests for zpool(8) command.
Obtained from: OpenSolaris
2008-11-17 20:49:29 +00:00
|
|
|
if (error != 0 || dp != NULL) {
|
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
|
if (error == 0 && dp->v_type != VDIR) {
|
|
|
|
|
vfslocked = VFS_LOCK_GIANT(dp->v_mount);
|
|
|
|
|
vrele(dp);
|
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
|
error = ENOTDIR;
|
|
|
|
|
}
|
2008-03-31 12:01:21 +00:00
|
|
|
}
|
|
|
|
|
if (error) {
|
|
|
|
|
uma_zfree(namei_zone, cnp->cn_pnbuf);
|
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
|
cnp->cn_pnbuf = NULL;
|
|
|
|
|
cnp->cn_nameptr = NULL;
|
|
|
|
|
#endif
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
Update ZFS from version 6 to 13 and bring some FreeBSD-specific changes.
This bring huge amount of changes, I'll enumerate only user-visible changes:
- Delegated Administration
Allows regular users to perform ZFS operations, like file system
creation, snapshot creation, etc.
- L2ARC
Level 2 cache for ZFS - allows to use additional disks for cache.
Huge performance improvements mostly for random read of mostly
static content.
- slog
Allow to use additional disks for ZFS Intent Log to speed up
operations like fsync(2).
- vfs.zfs.super_owner
Allows regular users to perform privileged operations on files stored
on ZFS file systems owned by him. Very careful with this one.
- chflags(2)
Not all the flags are supported. This still needs work.
- ZFSBoot
Support to boot off of ZFS pool. Not finished, AFAIK.
Submitted by: dfr
- Snapshot properties
- New failure modes
Before if write requested failed, system paniced. Now one
can select from one of three failure modes:
- panic - panic on write error
- wait - wait for disk to reappear
- continue - serve read requests if possible, block write requests
- Refquota, refreservation properties
Just quota and reservation properties, but don't count space consumed
by children file systems, clones and snapshots.
- Sparse volumes
ZVOLs that don't reserve space in the pool.
- External attributes
Compatible with extattr(2).
- NFSv4-ACLs
Not sure about the status, might not be complete yet.
Submitted by: trasz
- Creation-time properties
- Regression tests for zpool(8) command.
Obtained from: OpenSolaris
2008-11-17 20:49:29 +00:00
|
|
|
}
|
|
|
|
|
if (dp == NULL) {
|
2008-03-31 12:01:21 +00:00
|
|
|
dp = fdp->fd_cdir;
|
|
|
|
|
VREF(dp);
|
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
Update ZFS from version 6 to 13 and bring some FreeBSD-specific changes.
This bring huge amount of changes, I'll enumerate only user-visible changes:
- Delegated Administration
Allows regular users to perform ZFS operations, like file system
creation, snapshot creation, etc.
- L2ARC
Level 2 cache for ZFS - allows to use additional disks for cache.
Huge performance improvements mostly for random read of mostly
static content.
- slog
Allow to use additional disks for ZFS Intent Log to speed up
operations like fsync(2).
- vfs.zfs.super_owner
Allows regular users to perform privileged operations on files stored
on ZFS file systems owned by him. Very careful with this one.
- chflags(2)
Not all the flags are supported. This still needs work.
- ZFSBoot
Support to boot off of ZFS pool. Not finished, AFAIK.
Submitted by: dfr
- Snapshot properties
- New failure modes
Before if write requested failed, system paniced. Now one
can select from one of three failure modes:
- panic - panic on write error
- wait - wait for disk to reappear
- continue - serve read requests if possible, block write requests
- Refquota, refreservation properties
Just quota and reservation properties, but don't count space consumed
by children file systems, clones and snapshots.
- Sparse volumes
ZVOLs that don't reserve space in the pool.
- External attributes
Compatible with extattr(2).
- NFSv4-ACLs
Not sure about the status, might not be complete yet.
Submitted by: trasz
- Creation-time properties
- Regression tests for zpool(8) command.
Obtained from: OpenSolaris
2008-11-17 20:49:29 +00:00
|
|
|
if (ndp->ni_startdir != NULL) {
|
|
|
|
|
vfslocked = VFS_LOCK_GIANT(ndp->ni_startdir->v_mount);
|
|
|
|
|
vrele(ndp->ni_startdir);
|
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
|
}
|
2008-03-31 12:01:21 +00:00
|
|
|
}
|
2009-04-06 10:32:40 +00:00
|
|
|
SDT_PROBE(vfs, namei, lookup, entry, dp, cnp->cn_pnbuf,
|
|
|
|
|
cnp->cn_flags, 0, 0);
|
2005-01-24 10:27:05 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(dp->v_mount);
|
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);
|
2005-01-24 10:27:05 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2011-10-18 07:28:58 +00:00
|
|
|
if (ndp->ni_strictrelative != 0) {
|
|
|
|
|
#ifdef KTRACE
|
|
|
|
|
if (KTRPOINT(curthread, KTR_CAPFAIL))
|
|
|
|
|
ktrcapfail(CAPFAIL_LOOKUP, 0, 0);
|
|
|
|
|
#endif
|
2011-08-13 09:21:16 +00:00
|
|
|
return (ENOTCAPABLE);
|
2011-10-18 07:28:58 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
while (*(cnp->cn_nameptr) == '/') {
|
|
|
|
|
cnp->cn_nameptr++;
|
|
|
|
|
ndp->ni_pathlen--;
|
|
|
|
|
}
|
|
|
|
|
dp = ndp->ni_rootdir;
|
2005-01-24 10:27:05 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(dp->v_mount);
|
1994-05-24 10:09:53 +00:00
|
|
|
VREF(dp);
|
|
|
|
|
}
|
2005-01-24 10:27:05 +00:00
|
|
|
if (vfslocked)
|
|
|
|
|
ndp->ni_cnd.cn_flags |= GIANTHELD;
|
1994-05-24 10:09:53 +00:00
|
|
|
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
|
2009-04-06 10:32:40 +00:00
|
|
|
SDT_PROBE(vfs, namei, lookup, return, error, NULL, 0,
|
|
|
|
|
0, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
|
}
|
2005-01-24 10:27:05 +00:00
|
|
|
vfslocked = (ndp->ni_cnd.cn_flags & GIANTHELD) != 0;
|
|
|
|
|
ndp->ni_cnd.cn_flags &= ~GIANTHELD;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2009-05-29 09:52:13 +00:00
|
|
|
* If not a symbolic link, we're done.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
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
|
|
|
|
2005-01-24 10:27:05 +00:00
|
|
|
if ((cnp->cn_flags & MPSAFE) == 0) {
|
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
|
} else if (vfslocked)
|
|
|
|
|
ndp->ni_cnd.cn_flags |= GIANTHELD;
|
2009-04-06 10:32:40 +00:00
|
|
|
SDT_PROBE(vfs, namei, lookup, return, 0, ndp->ni_vp,
|
|
|
|
|
0, 0, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
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) {
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_readlink(td->td_ucred,
|
2002-10-19 21:25:51 +00:00
|
|
|
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
|
|
|
vput(ndp->ni_vp);
|
|
|
|
|
ndp->ni_vp = NULL;
|
2005-04-09 11:53:16 +00:00
|
|
|
vrele(ndp->ni_dvp);
|
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2009-04-06 10:32:40 +00:00
|
|
|
SDT_PROBE(vfs, namei, lookup, return, error, NULL, 0, 0, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
|
}
|
|
|
|
|
|
2006-09-13 18:39:09 +00:00
|
|
|
static int
|
|
|
|
|
compute_cn_lkflags(struct mount *mp, int lkflags)
|
|
|
|
|
{
|
2008-11-03 19:33:20 +00:00
|
|
|
|
2006-09-14 17:57:02 +00:00
|
|
|
if (mp == NULL ||
|
|
|
|
|
((lkflags & LK_SHARED) && !(mp->mnt_kern_flag & MNTK_LOOKUP_SHARED))) {
|
2006-09-13 18:39:09 +00:00
|
|
|
lkflags &= ~LK_SHARED;
|
|
|
|
|
lkflags |= LK_EXCLUSIVE;
|
|
|
|
|
}
|
2008-11-03 19:33:20 +00:00
|
|
|
return (lkflags);
|
2006-09-13 18:39:09 +00:00
|
|
|
}
|
|
|
|
|
|
2009-03-11 14:13:47 +00:00
|
|
|
static __inline int
|
|
|
|
|
needs_exclusive_leaf(struct mount *mp, int flags)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Intermediate nodes can use shared locks, we only need to
|
|
|
|
|
* force an exclusive lock for leaf nodes.
|
|
|
|
|
*/
|
|
|
|
|
if ((flags & (ISLASTCN | LOCKLEAF)) != (ISLASTCN | LOCKLEAF))
|
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
|
|
/* Always use exclusive locks if LOCKSHARED isn't set. */
|
|
|
|
|
if (!(flags & LOCKSHARED))
|
|
|
|
|
return (1);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* For lookups during open(), if the mount point supports
|
|
|
|
|
* extended shared operations, then use a shared lock for the
|
|
|
|
|
* leaf node, otherwise use an exclusive lock.
|
|
|
|
|
*/
|
|
|
|
|
if (flags & ISOPEN) {
|
|
|
|
|
if (mp != NULL &&
|
|
|
|
|
(mp->mnt_kern_flag & MNTK_EXTENDED_SHARED))
|
|
|
|
|
return (0);
|
|
|
|
|
else
|
|
|
|
|
return (1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Lookup requests outside of open() that specify LOCKSHARED
|
|
|
|
|
* only need a shared lock on the leaf vnode.
|
|
|
|
|
*/
|
2009-03-11 14:39:55 +00:00
|
|
|
return (0);
|
2009-03-11 14:13:47 +00:00
|
|
|
}
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
|
* 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
|
2006-08-05 21:40:59 +00:00
|
|
|
lookup(struct nameidata *ndp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2006-08-05 21:40:59 +00:00
|
|
|
char *cp; /* pointer into pathname argument */
|
|
|
|
|
struct vnode *dp = 0; /* the directory we are searching */
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vnode *tdp; /* saved dp */
|
|
|
|
|
struct mount *mp; /* mount table entry */
|
2009-05-27 14:11:23 +00:00
|
|
|
struct prison *pr;
|
1994-05-24 10:09:53 +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;
|
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;
|
2006-04-28 00:59:48 +00:00
|
|
|
int vfslocked; /* VFS Giant state for child */
|
|
|
|
|
int dvfslocked; /* VFS Giant state for parent */
|
2005-01-24 10:27:05 +00:00
|
|
|
int tvfslocked;
|
2006-09-13 18:39:09 +00:00
|
|
|
int lkflags_save;
|
2012-01-01 18:45:59 +00:00
|
|
|
int ni_dvp_unlocked;
|
2006-09-13 18:39:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
|
* Setup: break out flag bits into variables.
|
|
|
|
|
*/
|
2006-04-28 00:59:48 +00:00
|
|
|
dvfslocked = (ndp->ni_cnd.cn_flags & GIANTHELD) != 0;
|
|
|
|
|
vfslocked = 0;
|
2012-01-01 18:45:59 +00:00
|
|
|
ni_dvp_unlocked = 0;
|
2005-01-24 10:27:05 +00:00
|
|
|
ndp->ni_cnd.cn_flags &= ~GIANTHELD;
|
1994-05-24 10:09:53 +00:00
|
|
|
wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT);
|
2005-03-28 13:56:56 +00:00
|
|
|
KASSERT(cnp->cn_nameiop == LOOKUP || wantparent,
|
|
|
|
|
("CREATE, DELETE, RENAME require LOCKPARENT or WANTPARENT."));
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
|
|
|
|
cnp->cn_flags &= ~ISSYMLINK;
|
2005-03-29 10:07:15 +00:00
|
|
|
ndp->ni_dvp = NULL;
|
|
|
|
|
/*
|
|
|
|
|
* We use shared locks until we hit the parent of the last cn then
|
|
|
|
|
* we adjust based on the requesting flags.
|
|
|
|
|
*/
|
2005-04-03 23:50:20 +00:00
|
|
|
if (lookup_shared)
|
|
|
|
|
cnp->cn_lkflags = LK_SHARED;
|
|
|
|
|
else
|
|
|
|
|
cnp->cn_lkflags = LK_EXCLUSIVE;
|
1994-05-24 10:09:53 +00:00
|
|
|
dp = ndp->ni_startdir;
|
|
|
|
|
ndp->ni_startdir = NULLVP;
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(dp,
|
|
|
|
|
compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags | LK_RETRY));
|
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.
|
|
|
|
|
*/
|
|
|
|
|
while (*cp == '/' && (cp[1] == '/' || cp[1] == '\0')) {
|
|
|
|
|
cp++;
|
|
|
|
|
ndp->ni_pathlen--;
|
|
|
|
|
if (*cp == '\0') {
|
2009-06-06 00:49:49 +00:00
|
|
|
*ndp->ni_next = '\0';
|
2009-05-29 10:02:44 +00:00
|
|
|
cnp->cn_flags |= TRAILINGSLASH;
|
1995-07-31 00:35:58 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
2009-11-10 11:50:37 +00:00
|
|
|
if ((cnp->cn_flags & ISLASTCN) != 0 &&
|
|
|
|
|
cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.' &&
|
|
|
|
|
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
|
|
|
|
|
error = EINVAL;
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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;
|
2006-02-05 15:42:01 +00:00
|
|
|
|
|
|
|
|
if (cnp->cn_flags & AUDITVNODE1)
|
2009-07-28 21:52:24 +00:00
|
|
|
AUDIT_ARG_VNODE1(dp);
|
2006-02-05 15:42:01 +00:00
|
|
|
else if (cnp->cn_flags & AUDITVNODE2)
|
2009-07-28 21:52:24 +00:00
|
|
|
AUDIT_ARG_VNODE2(dp);
|
2006-02-05 15:42:01 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if (!(cnp->cn_flags & (LOCKPARENT | LOCKLEAF)))
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(dp, 0);
|
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");
|
2005-01-24 10:27:05 +00:00
|
|
|
goto success;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2011-08-13 09:21:16 +00:00
|
|
|
* Handle "..": five special cases.
|
|
|
|
|
* 0. If doing a capability lookup, return ENOTCAPABLE (this is a
|
|
|
|
|
* fairly conservative design choice, but it's the only one that we
|
|
|
|
|
* are satisfied guarantees the property we're looking for).
|
2006-01-21 19:57:56 +00:00
|
|
|
* 1. Return an error if this is the last component of
|
|
|
|
|
* the name and the operation is DELETE or RENAME.
|
|
|
|
|
* 2. If at root directory (e.g. after chroot)
|
1994-05-24 10:09:53 +00:00
|
|
|
* or at absolute root directory
|
|
|
|
|
* then ignore it so can't get out.
|
2006-01-21 19:57:56 +00:00
|
|
|
* 3. If this vnode is the root of a mounted
|
1994-05-24 10:09:53 +00:00
|
|
|
* 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.
|
2006-01-21 19:57:56 +00:00
|
|
|
* 4. If the vnode is the top directory of
|
1999-09-25 14:14:21 +00:00
|
|
|
* the jail or chroot, don't let them out.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
if (cnp->cn_flags & ISDOTDOT) {
|
2011-08-13 09:21:16 +00:00
|
|
|
if (ndp->ni_strictrelative != 0) {
|
2011-10-18 07:28:58 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
|
if (KTRPOINT(curthread, KTR_CAPFAIL))
|
|
|
|
|
ktrcapfail(CAPFAIL_LOOKUP, 0, 0);
|
|
|
|
|
#endif
|
2011-08-13 09:21:16 +00:00
|
|
|
error = ENOTCAPABLE;
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
2006-01-21 19:57:56 +00:00
|
|
|
if ((cnp->cn_flags & ISLASTCN) != 0 &&
|
|
|
|
|
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
|
2006-01-22 19:37:02 +00:00
|
|
|
error = EINVAL;
|
2006-01-21 19:57:56 +00:00
|
|
|
goto bad;
|
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
for (;;) {
|
2009-05-27 14:11:23 +00:00
|
|
|
for (pr = cnp->cn_cred->cr_prison; pr != NULL;
|
|
|
|
|
pr = pr->pr_parent)
|
|
|
|
|
if (dp == pr->pr_root)
|
|
|
|
|
break;
|
1999-09-25 14:14:21 +00:00
|
|
|
if (dp == ndp->ni_rootdir ||
|
|
|
|
|
dp == ndp->ni_topdir ||
|
2007-02-15 09:53:49 +00:00
|
|
|
dp == rootvnode ||
|
2009-05-27 14:11:23 +00:00
|
|
|
pr != NULL ||
|
2007-02-15 09:53:49 +00:00
|
|
|
((dp->v_vflag & VV_ROOT) != 0 &&
|
|
|
|
|
(cnp->cn_flags & NOCROSSMOUNT) != 0)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
ndp->ni_dvp = dp;
|
|
|
|
|
ndp->ni_vp = dp;
|
2006-04-29 07:13:49 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(dp->v_mount);
|
1994-05-24 10:09:53 +00:00
|
|
|
VREF(dp);
|
|
|
|
|
goto nextname;
|
|
|
|
|
}
|
2007-02-15 09:53:49 +00:00
|
|
|
if ((dp->v_vflag & VV_ROOT) == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
2006-02-06 10:15:27 +00:00
|
|
|
if (dp->v_iflag & VI_DOOMED) { /* forced unmount */
|
2009-03-24 18:16:42 +00:00
|
|
|
error = ENOENT;
|
2000-11-30 20:04:44 +00:00
|
|
|
goto bad;
|
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
tdp = dp;
|
|
|
|
|
dp = dp->v_mount->mnt_vnodecovered;
|
2006-04-28 00:59:48 +00:00
|
|
|
tvfslocked = dvfslocked;
|
|
|
|
|
dvfslocked = VFS_LOCK_GIANT(dp->v_mount);
|
1994-05-24 10:09:53 +00:00
|
|
|
VREF(dp);
|
2005-04-09 11:53:16 +00:00
|
|
|
vput(tdp);
|
|
|
|
|
VFS_UNLOCK_GIANT(tvfslocked);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(dp,
|
|
|
|
|
compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags |
|
|
|
|
|
LK_RETRY));
|
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) {
|
2009-05-11 15:33:26 +00:00
|
|
|
error = mac_vnode_check_lookup(cnp->cn_thread->td_ucred, dp,
|
|
|
|
|
cnp);
|
2002-10-19 21:25:51 +00:00
|
|
|
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;
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_LOCKED(dp, "lookup");
|
2006-04-28 00:59:48 +00:00
|
|
|
VNASSERT(vfslocked == 0, dp, ("lookup: vfslocked %d", vfslocked));
|
2005-03-29 10:07:15 +00:00
|
|
|
/*
|
|
|
|
|
* If we have a shared lock we may need to upgrade the lock for the
|
|
|
|
|
* last operation.
|
|
|
|
|
*/
|
Below is slightly edited description of the LOR by Tor Egge:
--------------------------
[Deadlock] is caused by a lock order reversal in vfs_lookup(), where
[some] process is trying to lock a directory vnode, that is the parent
directory of covered vnode) while holding an exclusive vnode lock on
covering vnode.
A simplified scenario:
root fs var fs
/ A / (/var) D
/var B /log (/var/log) E
vfs lock C vfs lock F
Within each file system, the lock order is clear: C->A->B and F->D->E
When traversing across mounts, the system can choose between two lock orders,
but everything must then follow that lock order:
L1: C->A->B
|
+->F->D->E
L2: F->D->E
|
+->C->A->B
The lookup() process for namei("/var") mixes those two lock orders:
VOP_LOOKUP() obtains B while A is held
vfs_busy() obtains a shared lock on F while A and B are held (follows L1,
violates L2)
vput() releases lock on B
VOP_UNLOCK() releases lock on A
VFS_ROOT() obtains lock on D while shared lock on F is held
vfs_unbusy() releases shared lock on F
vn_lock() obtains lock on A while D is held (violates L1, follows L2)
dounmount() follows L1 (B is locked while F is drained).
Without unmount activity, vfs_busy() will always succeed without blocking
and the deadlock isn't triggered (the system behaves as if L2 is followed).
With unmount, you can get 4 processes in a deadlock:
p1: holds D, want A (in lookup())
p2: holds shared lock on F, want D (in VFS_ROOT())
p3: holds B, want drain lock on F (in dounmount())
p4: holds A, want B (in VOP_LOOKUP())
You can have more than one instance of p2.
The reversal was introduced in revision 1.81 of src/sys/kern/vfs_lookup.c and
MFCed to revision 1.80.2.1, probably to avoid a cascade of vnode locks when nfs
servers are dead (VFS_ROOT() just hangs) spreading to the root fs root vnode.
- Tor Egge
To fix the LOR, ups@ noted that when crossing the mount point, ni_dvp
is actually not used by the callers of namei. Thus, placeholder deadfs
vnode vp_crossmp is introduced that is filled into ni_dvp.
Idea by: ups
Reviewed by: tegge, ups, jeff, rwatson (mac interaction)
Tested by: Peter Holm
MFC after: 2 weeks
2007-01-22 11:25:22 +00:00
|
|
|
if (dp != vp_crossmp &&
|
2008-02-25 18:45:57 +00:00
|
|
|
VOP_ISLOCKED(dp) == LK_SHARED &&
|
2005-03-29 10:07:15 +00:00
|
|
|
(cnp->cn_flags & ISLASTCN) && (cnp->cn_flags & LOCKPARENT))
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(dp, LK_UPGRADE|LK_RETRY);
|
2005-03-29 10:07:15 +00:00
|
|
|
/*
|
|
|
|
|
* If we're looking up the last component and we need an exclusive
|
|
|
|
|
* lock, adjust our lkflags.
|
|
|
|
|
*/
|
2009-03-11 14:13:47 +00:00
|
|
|
if (needs_exclusive_leaf(dp->v_mount, cnp->cn_flags))
|
2005-03-29 10:07:15 +00:00
|
|
|
cnp->cn_lkflags = LK_EXCLUSIVE;
|
2004-12-03 12:15:39 +00:00
|
|
|
#ifdef NAMEI_DIAGNOSTIC
|
|
|
|
|
vprint("lookup in", dp);
|
|
|
|
|
#endif
|
2006-09-13 18:39:09 +00:00
|
|
|
lkflags_save = cnp->cn_lkflags;
|
|
|
|
|
cnp->cn_lkflags = compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = VOP_LOOKUP(dp, &ndp->ni_vp, cnp)) != 0) {
|
2006-09-13 18:39:09 +00:00
|
|
|
cnp->cn_lkflags = lkflags_save;
|
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;
|
2006-04-28 00:59:48 +00:00
|
|
|
tvfslocked = dvfslocked;
|
|
|
|
|
dvfslocked = VFS_LOCK_GIANT(dp->v_mount);
|
1994-05-24 10:09:53 +00:00
|
|
|
VREF(dp);
|
2005-04-09 11:53:16 +00:00
|
|
|
vput(tdp);
|
|
|
|
|
VFS_UNLOCK_GIANT(tvfslocked);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(dp,
|
|
|
|
|
compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags |
|
|
|
|
|
LK_RETRY));
|
1994-05-24 10:09:53 +00:00
|
|
|
goto unionlookup;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (error != EJUSTRETURN)
|
|
|
|
|
goto bad;
|
|
|
|
|
/*
|
2009-06-06 00:49:49 +00:00
|
|
|
* At this point, we know we're at the end of the
|
|
|
|
|
* pathname. If creating / renaming, we can consider
|
|
|
|
|
* allowing the file or directory to be created / renamed,
|
|
|
|
|
* provided we're not on a read-only filesystem.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-10-22 09:32:48 +00:00
|
|
|
if (rdonly) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EROFS;
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
2009-06-06 00:49:49 +00:00
|
|
|
/* trailing slash only allowed for directories */
|
|
|
|
|
if ((cnp->cn_flags & TRAILINGSLASH) &&
|
|
|
|
|
!(cnp->cn_flags & WILLBEDIR)) {
|
1995-07-31 00:35:58 +00:00
|
|
|
error = ENOENT;
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
2005-03-28 09:24:50 +00:00
|
|
|
if ((cnp->cn_flags & LOCKPARENT) == 0)
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(dp, 0);
|
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
|
2006-08-05 21:08:47 +00:00
|
|
|
* (possibly locked) directory vnode in ndp->ni_dvp.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
if (cnp->cn_flags & SAVESTART) {
|
|
|
|
|
ndp->ni_startdir = ndp->ni_dvp;
|
|
|
|
|
VREF(ndp->ni_startdir);
|
|
|
|
|
}
|
2005-01-24 10:27:05 +00:00
|
|
|
goto success;
|
2006-09-13 18:39:09 +00:00
|
|
|
} else
|
|
|
|
|
cnp->cn_lkflags = lkflags_save;
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef NAMEI_DIAGNOSTIC
|
|
|
|
|
printf("found\n");
|
|
|
|
|
#endif
|
|
|
|
|
/*
|
|
|
|
|
* 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;
|
2006-04-28 00:59:48 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(dp->v_mount);
|
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) {
|
2008-11-02 10:15:42 +00:00
|
|
|
if (vfs_busy(mp, 0))
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
2005-04-09 11:53:16 +00:00
|
|
|
vput(dp);
|
2006-04-28 00:59:48 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2006-02-01 09:34:32 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(mp);
|
2006-04-28 00:59:48 +00:00
|
|
|
if (dp != ndp->ni_dvp)
|
Below is slightly edited description of the LOR by Tor Egge:
--------------------------
[Deadlock] is caused by a lock order reversal in vfs_lookup(), where
[some] process is trying to lock a directory vnode, that is the parent
directory of covered vnode) while holding an exclusive vnode lock on
covering vnode.
A simplified scenario:
root fs var fs
/ A / (/var) D
/var B /log (/var/log) E
vfs lock C vfs lock F
Within each file system, the lock order is clear: C->A->B and F->D->E
When traversing across mounts, the system can choose between two lock orders,
but everything must then follow that lock order:
L1: C->A->B
|
+->F->D->E
L2: F->D->E
|
+->C->A->B
The lookup() process for namei("/var") mixes those two lock orders:
VOP_LOOKUP() obtains B while A is held
vfs_busy() obtains a shared lock on F while A and B are held (follows L1,
violates L2)
vput() releases lock on B
VOP_UNLOCK() releases lock on A
VFS_ROOT() obtains lock on D while shared lock on F is held
vfs_unbusy() releases shared lock on F
vn_lock() obtains lock on A while D is held (violates L1, follows L2)
dounmount() follows L1 (B is locked while F is drained).
Without unmount activity, vfs_busy() will always succeed without blocking
and the deadlock isn't triggered (the system behaves as if L2 is followed).
With unmount, you can get 4 processes in a deadlock:
p1: holds D, want A (in lookup())
p2: holds shared lock on F, want D (in VFS_ROOT())
p3: holds B, want drain lock on F (in dounmount())
p4: holds A, want B (in VOP_LOOKUP())
You can have more than one instance of p2.
The reversal was introduced in revision 1.81 of src/sys/kern/vfs_lookup.c and
MFCed to revision 1.80.2.1, probably to avoid a cascade of vnode locks when nfs
servers are dead (VFS_ROOT() just hangs) spreading to the root fs root vnode.
- Tor Egge
To fix the LOR, ups@ noted that when crossing the mount point, ni_dvp
is actually not used by the callers of namei. Thus, placeholder deadfs
vnode vp_crossmp is introduced that is filled into ni_dvp.
Idea by: ups
Reviewed by: tegge, ups, jeff, rwatson (mac interaction)
Tested by: Peter Holm
MFC after: 2 weeks
2007-01-22 11:25:22 +00:00
|
|
|
vput(ndp->ni_dvp);
|
|
|
|
|
else
|
|
|
|
|
vrele(ndp->ni_dvp);
|
|
|
|
|
VFS_UNLOCK_GIANT(dvfslocked);
|
|
|
|
|
dvfslocked = 0;
|
|
|
|
|
vref(vp_crossmp);
|
|
|
|
|
ndp->ni_dvp = vp_crossmp;
|
2009-05-11 15:33:26 +00:00
|
|
|
error = VFS_ROOT(mp, compute_cn_lkflags(mp, cnp->cn_lkflags),
|
|
|
|
|
&tdp);
|
2008-08-31 14:26:08 +00:00
|
|
|
vfs_unbusy(mp);
|
2008-01-10 01:10:58 +00:00
|
|
|
if (vn_lock(vp_crossmp, LK_SHARED | LK_NOWAIT))
|
Below is slightly edited description of the LOR by Tor Egge:
--------------------------
[Deadlock] is caused by a lock order reversal in vfs_lookup(), where
[some] process is trying to lock a directory vnode, that is the parent
directory of covered vnode) while holding an exclusive vnode lock on
covering vnode.
A simplified scenario:
root fs var fs
/ A / (/var) D
/var B /log (/var/log) E
vfs lock C vfs lock F
Within each file system, the lock order is clear: C->A->B and F->D->E
When traversing across mounts, the system can choose between two lock orders,
but everything must then follow that lock order:
L1: C->A->B
|
+->F->D->E
L2: F->D->E
|
+->C->A->B
The lookup() process for namei("/var") mixes those two lock orders:
VOP_LOOKUP() obtains B while A is held
vfs_busy() obtains a shared lock on F while A and B are held (follows L1,
violates L2)
vput() releases lock on B
VOP_UNLOCK() releases lock on A
VFS_ROOT() obtains lock on D while shared lock on F is held
vfs_unbusy() releases shared lock on F
vn_lock() obtains lock on A while D is held (violates L1, follows L2)
dounmount() follows L1 (B is locked while F is drained).
Without unmount activity, vfs_busy() will always succeed without blocking
and the deadlock isn't triggered (the system behaves as if L2 is followed).
With unmount, you can get 4 processes in a deadlock:
p1: holds D, want A (in lookup())
p2: holds shared lock on F, want D (in VFS_ROOT())
p3: holds B, want drain lock on F (in dounmount())
p4: holds A, want B (in VOP_LOOKUP())
You can have more than one instance of p2.
The reversal was introduced in revision 1.81 of src/sys/kern/vfs_lookup.c and
MFCed to revision 1.80.2.1, probably to avoid a cascade of vnode locks when nfs
servers are dead (VFS_ROOT() just hangs) spreading to the root fs root vnode.
- Tor Egge
To fix the LOR, ups@ noted that when crossing the mount point, ni_dvp
is actually not used by the callers of namei. Thus, placeholder deadfs
vnode vp_crossmp is introduced that is filled into ni_dvp.
Idea by: ups
Reviewed by: tegge, ups, jeff, rwatson (mac interaction)
Tested by: Peter Holm
MFC after: 2 weeks
2007-01-22 11:25:22 +00:00
|
|
|
panic("vp_crossmp exclusively locked or reclaimed");
|
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
|
|
|
}
|
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) &&
|
2009-06-06 00:49:49 +00:00
|
|
|
((cnp->cn_flags & FOLLOW) || (cnp->cn_flags & TRAILINGSLASH) ||
|
1995-08-24 10:17:39 +00:00
|
|
|
*ndp->ni_next == '/')) {
|
|
|
|
|
cnp->cn_flags |= ISSYMLINK;
|
2006-02-06 10:15:27 +00:00
|
|
|
if (dp->v_iflag & VI_DOOMED) {
|
2009-03-24 18:16:42 +00:00
|
|
|
/*
|
|
|
|
|
* We can't know whether the directory was mounted with
|
|
|
|
|
* NOSYMFOLLOW, so we can't follow safely.
|
|
|
|
|
*/
|
|
|
|
|
error = ENOENT;
|
2000-11-30 20:04:44 +00:00
|
|
|
goto bad2;
|
|
|
|
|
}
|
1998-04-08 18:31:59 +00:00
|
|
|
if (dp->v_mount->mnt_flag & MNT_NOSYMFOLLOW) {
|
|
|
|
|
error = EACCES;
|
|
|
|
|
goto bad2;
|
|
|
|
|
}
|
2005-04-09 11:53:16 +00:00
|
|
|
/*
|
|
|
|
|
* Symlink code always expects an unlocked dvp.
|
|
|
|
|
*/
|
2012-01-01 18:45:59 +00:00
|
|
|
if (ndp->ni_dvp != ndp->ni_vp) {
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(ndp->ni_dvp, 0);
|
2012-01-01 18:45:59 +00:00
|
|
|
ni_dvp_unlocked = 1;
|
|
|
|
|
}
|
2005-01-24 10:27:05 +00:00
|
|
|
goto success;
|
1995-08-24 10:17:39 +00:00
|
|
|
}
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
nextname:
|
|
|
|
|
/*
|
2009-06-06 00:49:49 +00:00
|
|
|
* Not a symbolic link that we will follow. Continue with the
|
|
|
|
|
* next component if there is any; otherwise, we're done.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-03-28 09:24:50 +00:00
|
|
|
KASSERT((cnp->cn_flags & ISLASTCN) || *ndp->ni_next == '/',
|
|
|
|
|
("lookup: invalid path state."));
|
1994-05-24 10:09:53 +00:00
|
|
|
if (*ndp->ni_next == '/') {
|
|
|
|
|
cnp->cn_nameptr = ndp->ni_next;
|
|
|
|
|
while (*cnp->cn_nameptr == '/') {
|
|
|
|
|
cnp->cn_nameptr++;
|
|
|
|
|
ndp->ni_pathlen--;
|
|
|
|
|
}
|
2005-04-09 11:53:16 +00:00
|
|
|
if (ndp->ni_dvp != dp)
|
|
|
|
|
vput(ndp->ni_dvp);
|
|
|
|
|
else
|
|
|
|
|
vrele(ndp->ni_dvp);
|
2006-02-01 09:34:32 +00:00
|
|
|
VFS_UNLOCK_GIANT(dvfslocked);
|
2006-04-28 00:59:48 +00:00
|
|
|
dvfslocked = vfslocked; /* dp becomes dvp in dirloop */
|
|
|
|
|
vfslocked = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto dirloop;
|
|
|
|
|
}
|
2009-05-29 10:02:44 +00:00
|
|
|
/*
|
|
|
|
|
* If we're processing a path with a trailing slash,
|
|
|
|
|
* check that the end result is a directory.
|
|
|
|
|
*/
|
|
|
|
|
if ((cnp->cn_flags & TRAILINGSLASH) && dp->v_type != VDIR) {
|
|
|
|
|
error = ENOTDIR;
|
|
|
|
|
goto bad2;
|
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
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);
|
|
|
|
|
}
|
2005-04-09 11:53:16 +00:00
|
|
|
if (!wantparent) {
|
2012-01-01 18:45:59 +00:00
|
|
|
ni_dvp_unlocked = 2;
|
2005-04-09 11:53:16 +00:00
|
|
|
if (ndp->ni_dvp != dp)
|
|
|
|
|
vput(ndp->ni_dvp);
|
|
|
|
|
else
|
|
|
|
|
vrele(ndp->ni_dvp);
|
2006-02-01 09:34:32 +00:00
|
|
|
VFS_UNLOCK_GIANT(dvfslocked);
|
|
|
|
|
dvfslocked = 0;
|
2012-01-01 18:45:59 +00:00
|
|
|
} else if ((cnp->cn_flags & LOCKPARENT) == 0 && ndp->ni_dvp != dp) {
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(ndp->ni_dvp, 0);
|
2012-01-01 18:45:59 +00:00
|
|
|
ni_dvp_unlocked = 1;
|
|
|
|
|
}
|
1997-12-29 00:25:11 +00:00
|
|
|
|
2006-02-05 15:42:01 +00:00
|
|
|
if (cnp->cn_flags & AUDITVNODE1)
|
2009-07-28 21:52:24 +00:00
|
|
|
AUDIT_ARG_VNODE1(dp);
|
2006-02-05 15:42:01 +00:00
|
|
|
else if (cnp->cn_flags & AUDITVNODE2)
|
2009-07-28 21:52:24 +00:00
|
|
|
AUDIT_ARG_VNODE2(dp);
|
2006-02-05 15:42:01 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((cnp->cn_flags & LOCKLEAF) == 0)
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(dp, 0);
|
2005-01-24 10:27:05 +00:00
|
|
|
success:
|
2007-09-21 10:16:56 +00:00
|
|
|
/*
|
|
|
|
|
* Because of lookup_shared we may have the vnode shared locked, but
|
|
|
|
|
* the caller may want it to be exclusively locked.
|
|
|
|
|
*/
|
2009-03-11 14:13:47 +00:00
|
|
|
if (needs_exclusive_leaf(dp->v_mount, cnp->cn_flags) &&
|
|
|
|
|
VOP_ISLOCKED(dp) != LK_EXCLUSIVE) {
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(dp, LK_UPGRADE | LK_RETRY);
|
2008-12-18 11:58:12 +00:00
|
|
|
if (dp->v_iflag & VI_DOOMED) {
|
|
|
|
|
error = ENOENT;
|
|
|
|
|
goto bad2;
|
|
|
|
|
}
|
2007-09-21 10:16:56 +00:00
|
|
|
}
|
2006-02-01 09:34:32 +00:00
|
|
|
if (vfslocked && dvfslocked)
|
|
|
|
|
VFS_UNLOCK_GIANT(dvfslocked); /* Only need one */
|
|
|
|
|
if (vfslocked || dvfslocked)
|
2005-01-24 10:27:05 +00:00
|
|
|
ndp->ni_cnd.cn_flags |= GIANTHELD;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
|
|
bad2:
|
2012-01-01 18:45:59 +00:00
|
|
|
if (ni_dvp_unlocked != 2) {
|
|
|
|
|
if (dp != ndp->ni_dvp && !ni_dvp_unlocked)
|
|
|
|
|
vput(ndp->ni_dvp);
|
|
|
|
|
else
|
|
|
|
|
vrele(ndp->ni_dvp);
|
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
bad:
|
2005-04-09 11:53:16 +00:00
|
|
|
if (!dpunlocked)
|
2000-09-13 08:57:56 +00:00
|
|
|
vput(dp);
|
2005-01-24 10:27:05 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2006-02-01 09:34:32 +00:00
|
|
|
VFS_UNLOCK_GIANT(dvfslocked);
|
2005-01-24 10:27:05 +00:00
|
|
|
ndp->ni_cnd.cn_flags &= ~GIANTHELD;
|
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
|
2007-05-27 20:50:23 +00:00
|
|
|
* Used by lookup to re-acquire things.
|
1994-09-27 20:33:41 +00:00
|
|
|
*/
|
|
|
|
|
int
|
2006-08-05 21:40:59 +00:00
|
|
|
relookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp)
|
1994-09-27 20:33:41 +00:00
|
|
|
{
|
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 wantparent; /* 1 => wantparent or lockparent flag */
|
|
|
|
|
int rdonly; /* lookup read-only flag bit */
|
|
|
|
|
int error = 0;
|
|
|
|
|
|
2005-03-28 09:24:50 +00:00
|
|
|
KASSERT(cnp->cn_flags & ISLASTCN,
|
|
|
|
|
("relookup: Not given last component."));
|
1994-09-27 20:33:41 +00:00
|
|
|
/*
|
|
|
|
|
* Setup: break out flag bits into variables.
|
|
|
|
|
*/
|
|
|
|
|
wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT);
|
2005-04-13 10:57:13 +00:00
|
|
|
KASSERT(wantparent, ("relookup: parent not wanted."));
|
1994-09-27 20:33:41 +00:00
|
|
|
rdonly = cnp->cn_flags & RDONLY;
|
|
|
|
|
cnp->cn_flags &= ~ISSYMLINK;
|
|
|
|
|
dp = dvp;
|
2005-03-29 10:07:15 +00:00
|
|
|
cnp->cn_lkflags = LK_EXCLUSIVE;
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(dp, LK_EXCLUSIVE | LK_RETRY);
|
1994-09-27 20:33:41 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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
|
|
|
|
|
|
|
|
|
|
/*
|
2010-03-26 11:33:12 +00:00
|
|
|
* Check for "" which represents the root directory after slash
|
|
|
|
|
* removal.
|
1994-09-27 20:33:41 +00:00
|
|
|
*/
|
|
|
|
|
if (cnp->cn_nameptr[0] == '\0') {
|
2010-03-26 11:33:12 +00:00
|
|
|
/*
|
|
|
|
|
* Support only LOOKUP for "/" because lookup()
|
|
|
|
|
* can't succeed for CREATE, DELETE and RENAME.
|
|
|
|
|
*/
|
|
|
|
|
KASSERT(cnp->cn_nameiop == LOOKUP, ("nameiop must be LOOKUP"));
|
|
|
|
|
KASSERT(dp->v_type == VDIR, ("dp is not a directory"));
|
|
|
|
|
|
1994-09-27 20:33:41 +00:00
|
|
|
if (!(cnp->cn_flags & LOCKLEAF))
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(dp, 0);
|
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);
|
2005-03-28 09:24:50 +00:00
|
|
|
if ((cnp->cn_flags & LOCKPARENT) == 0)
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(dp, 0);
|
1994-09-27 20:33:41 +00:00
|
|
|
/*
|
|
|
|
|
* We return with ni_vp NULL to indicate that the entry
|
|
|
|
|
* doesn't currently exist, leaving a pointer to the
|
2006-08-05 21:08:47 +00:00
|
|
|
* (possibly locked) directory vnode in ndp->ni_dvp.
|
1994-09-27 20:33:41 +00:00
|
|
|
*/
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
2006-09-13 18:39:09 +00:00
|
|
|
|
1994-09-27 20:33:41 +00:00
|
|
|
dp = *vpp;
|
|
|
|
|
|
|
|
|
|
/*
|
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)) {
|
2005-04-13 10:57:13 +00:00
|
|
|
if (dvp == dp)
|
|
|
|
|
vrele(dvp);
|
|
|
|
|
else
|
|
|
|
|
vput(dvp);
|
1995-10-22 09:32:48 +00:00
|
|
|
error = EROFS;
|
2005-04-13 10:57:13 +00:00
|
|
|
goto bad;
|
1994-09-27 20:33:41 +00:00
|
|
|
}
|
2005-04-13 10:57:13 +00:00
|
|
|
/*
|
|
|
|
|
* Set the parent lock/ref state to the requested state.
|
|
|
|
|
*/
|
|
|
|
|
if ((cnp->cn_flags & LOCKPARENT) == 0 && dvp != dp) {
|
|
|
|
|
if (wantparent)
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(dvp, 0);
|
2005-04-13 10:57:13 +00:00
|
|
|
else
|
|
|
|
|
vput(dvp);
|
|
|
|
|
} else if (!wantparent)
|
|
|
|
|
vrele(dvp);
|
|
|
|
|
/*
|
|
|
|
|
* Check for symbolic link
|
|
|
|
|
*/
|
|
|
|
|
KASSERT(dp->v_type != VLNK || !(cnp->cn_flags & FOLLOW),
|
|
|
|
|
("relookup: symlink found.\n"));
|
|
|
|
|
|
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 ((cnp->cn_flags & LOCKLEAF) == 0)
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(dp, 0);
|
1994-09-27 20:33:41 +00:00
|
|
|
return (0);
|
|
|
|
|
bad:
|
|
|
|
|
vput(dp);
|
|
|
|
|
*vpp = NULL;
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
2005-02-07 18:44:55 +00:00
|
|
|
|
2005-04-05 08:58:49 +00:00
|
|
|
/*
|
|
|
|
|
* Free data allocated by namei(); see namei(9) for details.
|
|
|
|
|
*/
|
|
|
|
|
void
|
2006-08-05 21:40:59 +00:00
|
|
|
NDFREE(struct nameidata *ndp, const u_int flags)
|
2005-04-05 08:58:49 +00:00
|
|
|
{
|
2005-04-09 11:53:16 +00:00
|
|
|
int unlock_dvp;
|
|
|
|
|
int unlock_vp;
|
|
|
|
|
|
|
|
|
|
unlock_dvp = 0;
|
|
|
|
|
unlock_vp = 0;
|
2005-04-05 08:58:49 +00:00
|
|
|
|
|
|
|
|
if (!(flags & NDF_NO_FREE_PNBUF) &&
|
|
|
|
|
(ndp->ni_cnd.cn_flags & HASBUF)) {
|
|
|
|
|
uma_zfree(namei_zone, ndp->ni_cnd.cn_pnbuf);
|
|
|
|
|
ndp->ni_cnd.cn_flags &= ~HASBUF;
|
|
|
|
|
}
|
2005-04-09 11:53:16 +00:00
|
|
|
if (!(flags & NDF_NO_VP_UNLOCK) &&
|
|
|
|
|
(ndp->ni_cnd.cn_flags & LOCKLEAF) && ndp->ni_vp)
|
|
|
|
|
unlock_vp = 1;
|
|
|
|
|
if (!(flags & NDF_NO_VP_RELE) && ndp->ni_vp) {
|
|
|
|
|
if (unlock_vp) {
|
|
|
|
|
vput(ndp->ni_vp);
|
|
|
|
|
unlock_vp = 0;
|
|
|
|
|
} else
|
|
|
|
|
vrele(ndp->ni_vp);
|
|
|
|
|
ndp->ni_vp = NULL;
|
|
|
|
|
}
|
|
|
|
|
if (unlock_vp)
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(ndp->ni_vp, 0);
|
2005-04-05 08:58:49 +00:00
|
|
|
if (!(flags & NDF_NO_DVP_UNLOCK) &&
|
|
|
|
|
(ndp->ni_cnd.cn_flags & LOCKPARENT) &&
|
|
|
|
|
ndp->ni_dvp != ndp->ni_vp)
|
2005-04-09 11:53:16 +00:00
|
|
|
unlock_dvp = 1;
|
2005-04-05 08:58:49 +00:00
|
|
|
if (!(flags & NDF_NO_DVP_RELE) &&
|
|
|
|
|
(ndp->ni_cnd.cn_flags & (LOCKPARENT|WANTPARENT))) {
|
2005-04-09 11:53:16 +00:00
|
|
|
if (unlock_dvp) {
|
|
|
|
|
vput(ndp->ni_dvp);
|
|
|
|
|
unlock_dvp = 0;
|
|
|
|
|
} else
|
|
|
|
|
vrele(ndp->ni_dvp);
|
2005-04-05 08:58:49 +00:00
|
|
|
ndp->ni_dvp = NULL;
|
|
|
|
|
}
|
2005-04-09 11:53:16 +00:00
|
|
|
if (unlock_dvp)
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(ndp->ni_dvp, 0);
|
2005-04-05 08:58:49 +00:00
|
|
|
if (!(flags & NDF_NO_STARTDIR_RELE) &&
|
|
|
|
|
(ndp->ni_cnd.cn_flags & SAVESTART)) {
|
|
|
|
|
vrele(ndp->ni_startdir);
|
|
|
|
|
ndp->ni_startdir = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
/*
|
|
|
|
|
* Determine if there is a suitable alternate filename under the specified
|
|
|
|
|
* prefix for the specified path. If the create flag is set, then the
|
|
|
|
|
* alternate prefix will be used so long as the parent directory exists.
|
|
|
|
|
* This is used by the various compatiblity ABIs so that Linux binaries prefer
|
|
|
|
|
* files under /compat/linux for example. The chosen path (whether under
|
|
|
|
|
* the prefix or under /) is returned in a kernel malloc'd buffer pointed
|
|
|
|
|
* to by pathbuf. The caller is responsible for free'ing the buffer from
|
|
|
|
|
* the M_TEMP bucket if one is returned.
|
|
|
|
|
*/
|
|
|
|
|
int
|
Implement the linux syscalls
openat, mkdirat, mknodat, fchownat, futimesat, fstatat, unlinkat,
renameat, linkat, symlinkat, readlinkat, fchmodat, faccessat.
Submitted by: rdivacky
Sponsored by: Google Summer of Code 2007
Tested by: pho
2008-04-08 09:45:49 +00:00
|
|
|
kern_alternate_path(struct thread *td, const char *prefix, const char *path,
|
|
|
|
|
enum uio_seg pathseg, char **pathbuf, int create, int dirfd)
|
2005-02-07 18:44:55 +00:00
|
|
|
{
|
|
|
|
|
struct nameidata nd, ndroot;
|
|
|
|
|
char *ptr, *buf, *cp;
|
|
|
|
|
size_t len, sz;
|
|
|
|
|
int error;
|
|
|
|
|
|
|
|
|
|
buf = (char *) malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
|
|
|
|
|
*pathbuf = buf;
|
|
|
|
|
|
|
|
|
|
/* Copy the prefix into the new pathname as a starting point. */
|
|
|
|
|
len = strlcpy(buf, prefix, MAXPATHLEN);
|
|
|
|
|
if (len >= MAXPATHLEN) {
|
|
|
|
|
*pathbuf = NULL;
|
|
|
|
|
free(buf, M_TEMP);
|
|
|
|
|
return (EINVAL);
|
|
|
|
|
}
|
|
|
|
|
sz = MAXPATHLEN - len;
|
|
|
|
|
ptr = buf + len;
|
|
|
|
|
|
|
|
|
|
/* Append the filename to the prefix. */
|
|
|
|
|
if (pathseg == UIO_SYSSPACE)
|
|
|
|
|
error = copystr(path, ptr, sz, &len);
|
|
|
|
|
else
|
|
|
|
|
error = copyinstr(path, ptr, sz, &len);
|
|
|
|
|
|
|
|
|
|
if (error) {
|
|
|
|
|
*pathbuf = NULL;
|
|
|
|
|
free(buf, M_TEMP);
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Only use a prefix with absolute pathnames. */
|
|
|
|
|
if (*ptr != '/') {
|
|
|
|
|
error = EINVAL;
|
|
|
|
|
goto keeporig;
|
|
|
|
|
}
|
|
|
|
|
|
Implement the linux syscalls
openat, mkdirat, mknodat, fchownat, futimesat, fstatat, unlinkat,
renameat, linkat, symlinkat, readlinkat, fchmodat, faccessat.
Submitted by: rdivacky
Sponsored by: Google Summer of Code 2007
Tested by: pho
2008-04-08 09:45:49 +00:00
|
|
|
if (dirfd != AT_FDCWD) {
|
|
|
|
|
/*
|
|
|
|
|
* We want the original because the "prefix" is
|
|
|
|
|
* included in the already opened dirfd.
|
|
|
|
|
*/
|
|
|
|
|
bcopy(ptr, buf, len);
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
/*
|
|
|
|
|
* We know that there is a / somewhere in this pathname.
|
|
|
|
|
* Search backwards for it, to find the file's parent dir
|
|
|
|
|
* to see if it exists in the alternate tree. If it does,
|
|
|
|
|
* and we want to create a file (cflag is set). We don't
|
|
|
|
|
* need to worry about the root comparison in this case.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (create) {
|
|
|
|
|
for (cp = &ptr[len] - 1; *cp != '/'; cp--);
|
|
|
|
|
*cp = '\0';
|
|
|
|
|
|
2005-09-21 19:49:42 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, buf, td);
|
2005-02-07 18:44:55 +00:00
|
|
|
error = namei(&nd);
|
|
|
|
|
*cp = '/';
|
|
|
|
|
if (error != 0)
|
2005-09-21 19:49:42 +00:00
|
|
|
goto keeporig;
|
2005-02-07 18:44:55 +00:00
|
|
|
} else {
|
2005-09-21 19:49:42 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, buf, td);
|
2005-02-07 18:44:55 +00:00
|
|
|
|
|
|
|
|
error = namei(&nd);
|
|
|
|
|
if (error != 0)
|
2005-09-21 19:49:42 +00:00
|
|
|
goto keeporig;
|
2005-02-07 18:44:55 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We now compare the vnode of the prefix to the one
|
|
|
|
|
* vnode asked. If they resolve to be the same, then we
|
|
|
|
|
* ignore the match so that the real root gets used.
|
|
|
|
|
* This avoids the problem of traversing "../.." to find the
|
|
|
|
|
* root directory and never finding it, because "/" resolves
|
|
|
|
|
* to the emulation root directory. This is expensive :-(
|
|
|
|
|
*/
|
2005-09-21 19:49:42 +00:00
|
|
|
NDINIT(&ndroot, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, prefix,
|
|
|
|
|
td);
|
2005-02-07 18:44:55 +00:00
|
|
|
|
|
|
|
|
/* We shouldn't ever get an error from this namei(). */
|
|
|
|
|
error = namei(&ndroot);
|
|
|
|
|
if (error == 0) {
|
|
|
|
|
if (nd.ni_vp == ndroot.ni_vp)
|
|
|
|
|
error = ENOENT;
|
|
|
|
|
|
|
|
|
|
NDFREE(&ndroot, NDF_ONLY_PNBUF);
|
|
|
|
|
vrele(ndroot.ni_vp);
|
2005-09-21 19:49:42 +00:00
|
|
|
VFS_UNLOCK_GIANT(NDHASGIANT(&ndroot));
|
2005-02-07 18:44:55 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
|
vrele(nd.ni_vp);
|
2005-09-21 19:49:42 +00:00
|
|
|
VFS_UNLOCK_GIANT(NDHASGIANT(&nd));
|
2005-02-07 18:44:55 +00:00
|
|
|
|
|
|
|
|
keeporig:
|
|
|
|
|
/* If there was an error, use the original path name. */
|
|
|
|
|
if (error)
|
|
|
|
|
bcopy(ptr, buf, len);
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
