VFS messaging/interfacing work stage 7g/99: More firming up of stage 7.

Fix a serious bug in cache_lookup(). The original lookup code could get
away with returning an unreferenced vnode but the new

VFS messaging/interfacing work stage 7g/99: More firming up of stage 7.

Fix a serious bug in cache_lookup(). The original lookup code could get
away with returning an unreferenced vnode but the new code's cache_hold()/
cache_drop() and related functions can interact badly with an unreferenced
vnode. So make cache_lookup() return a referenced vnode.

Detect and handle locking races in cache_nlookup() and cache_lookup().

Change cache_zap() to require a locked namecache record so it doesn't
rip data out from under cache_lookup()/cache_nlookup()/cache_resolve().

show more ...

VFS messaging/interfacing work stage 7f/99: More firming up of stage 7.

unlink, rmdir, rename, and whiteout removal functions use NAMEI_DELETE
namei() lookups. With the old API this zap'd the namec

VFS messaging/interfacing work stage 7f/99: More firming up of stage 7.

unlink, rmdir, rename, and whiteout removal functions use NAMEI_DELETE
namei() lookups. With the old API this zap'd the namecache entry before
the system actually runs the operation. If the operation fails we can be
left with a broken namecache hierarchy which is not allowed in the new API.

Change old API cache_lookup() semantics to *NOT* zap the namecache entry and
add explicit zaps after calls to VOP_UNLINK(), VOP_RMDIR(), etc. to replace
the functionality.

rename() attempts to issue a NAMEI_RENAME lookup which zaps the target, but
the same problem occurs if the target is preexisting and being overwritten.
A similar solution is employed for renames.

show more ...

VFS messaging/interfacing work stage 7e/99: More firming up of stage 7.

Fix the linux emulation code for [l]stat(), it was not properly
disposing of the nlookupdata structure.

Fix chroot()'s use of

VFS messaging/interfacing work stage 7e/99: More firming up of stage 7.

Fix the linux emulation code for [l]stat(), it was not properly
disposing of the nlookupdata structure.

Fix chroot()'s use of the new api, it was horribly broken.

Cleanup cache_alloc(). Rewrite __getcwd() and vn_fullpath() to use newapi
namecache data. Cleanup nlookup(). Fix bugs in nlookup() related to
stacked mount points. Fix a bug related to VFS_ROOT() mount errors.

Linux-bugs-reported-by: Bartek Stalewski, walt

show more ...

VFS messaging/interfacing work stage 7d/99: More firming up of stage 7.

Additional work to deal with old-api/new-api issues. Cut more stuff
out of the old-api's cache_enter() routine to deal with d

VFS messaging/interfacing work stage 7d/99: More firming up of stage 7.

Additional work to deal with old-api/new-api issues. Cut more stuff
out of the old-api's cache_enter() routine to deal with deadlocks, at
the cost of some performance loss (temporary until the VFS's start using
the new APIs). Change UFS and NFS to not purge whole directories in
*_rename() and *_rmdir().

Add some minor breakage to the API which will not be fixed until the VFS's
get new rename implementations - renaming a directory in which a process
has chdir'd will create problems for that process. This doesn't happen
normally anyway so this temporary breakage should not cause any significant
problems.

Bug-reports-by: walt, Sascha Wildner, others

show more ...

VFS messaging/interfacing work stage 7c/99: More firming up of stage 7.

Make a minor change to cache_alloc()'s semantics by having it returned a
ref'd locked ncp. Make the same change to cache_allo

VFS messaging/interfacing work stage 7c/99: More firming up of stage 7.

Make a minor change to cache_alloc()'s semantics by having it returned a
ref'd locked ncp. Make the same change to cache_allocroot().

Fix a bug in the resolver that could deadlock a namecache and vnode lock by
unlocking the namecache node before locking the vnode. This hack is only
needed until the old API has been removed.

Get rid of the old API compat code that tried to create dummy ncp's for
directory vnodes that did not have one and then merge old and new, it got
too messy. The idea was to be able to cache things in the middle of the
topology and then hook the topology up later when we knew the path.

Instead, the old API simply does not enter things into the namecache
if the parent directory vnode has not namecache structure associated
with it. This maintains the unbroken topology that we want to guarentee
at the cost of the old API functions potentially not caching as much
information. [ since kern_open(), [f]chdir(), and [f]stat() execute the
new API the loss of efficiency in the old API should not be noticeable ].

When cache_enter() re-enters the same vnode, it was zaping the old namecache
structure unnecessarily and causing problems with directories. It no longer
does this.

NFS CHANGE: get rid of the va_ctime vs n_ctime test. This test was supposed
to detect server-side directory changes and purge the directory, but half the
time it purged the directory anyway. The new API requires that the directory
topology remain intact so only purge if the directory is found not to exist.
This change may have to be revisited later.

NOTE: cache_nlookup() is sensitive to the directory topology when traversing
".." directories. If a directory in the middle of the topology is purged
it can cause the new API lookup to fail with EXDEV.

Bug-reports-by: drhodus, various other people.

show more ...

VFS messaging/interfacing work stage 7b/99: More firming up of stage 7.

(1) Enhance cache_resolve() to go up the directory chain as far as necessary
to resolve the chain. Previously I wimped ou

VFS messaging/interfacing work stage 7b/99: More firming up of stage 7.

(1) Enhance cache_resolve() to go up the directory chain as far as necessary
to resolve the chain. Previously I wimped out and returned an error.

(2) Be sure not to use the parent of a mount point to obtain the vnode
operations vector for a child of a mount point (which resides on a
different filesystem!).

Generally speaking the namecache directory chain should contain resolved
vnodes due to the fact that the vnode associated with a namecache entry is
held if any children exist, preventing the vnode from being recycled.
However, the NFS client code as originally written wimps out and does
wholesale namecache flushing of directories when it isn't sure about the
state of things (which is quite often, especially when you are rm'ing
files), and this breaks that assumption and causes some intermediate NFS
directory nodes to revert back into an 'unresolved' state. This will
eventually be fixed, but not right now.

Add a nc_mount pointer to the namecache structure. For the moment this is
only used to get at the mount point associated with a NCF_MOUNTPT namecache
node (whether resolved or unresolved), making it easier for us to resolve
the vnode. But eventually it will be used as the basis for obtaining the
v_ops for (new stlye) VOP calls on an unresolved namecache node, saving us
a few indirections so I don't consider it a hack.

Bugs-and-cores-by: drhodus

show more ...

VFS messaging/interfacing work stage 7a/99: Firm up stage 7 a bit by
automatically vhold()ing any vnodes associated with a locked namecache
record. This will prevent the vnode from being recycled (

VFS messaging/interfacing work stage 7a/99: Firm up stage 7 a bit by
automatically vhold()ing any vnodes associated with a locked namecache
record. This will prevent the vnode from being recycled (which would
unexpectedly cause the namecache entry to revert to an unresolved state
even while it is locked).

Previously only vnodes associated with namecache records with children
were being held (in order to guarentee that the vnode associated with the
parent directory of a locked leaf namecache record would stick around without
having to lock the parent directory's namecache record).

The point here being that we want to have to only lock and pass a single
namecache record to definitively identify an object in the namespace,
rather then the combination of directory and leaf nodes (and other junk)
that the old API required. For example, the old RENAME API required 6
arguments (fdvp, fvp, fcnp, tdvp, tvp, tcnp) while the new one will only
require two arguments (fncp, tncp).

show more ...

VFS messaging/interfacing work stage 7/99. BEGIN DESTABILIZATION!

Implement the infrastructure required to allow us to begin switching to the
new nlookup() VFS API.

filedesc->fd_ncdir, fd_nrdir,

VFS messaging/interfacing work stage 7/99. BEGIN DESTABILIZATION!

Implement the infrastructure required to allow us to begin switching to the
new nlookup() VFS API.

filedesc->fd_ncdir, fd_nrdir, fd_njdir

File descriptors (associated with processes) now record the
namecache pointer related to the current directory, root directory,
and jail directory, in addition to the vnode pointers. These
pointers are used as the basis for the new path lookup code
(nlookup() and friends).

file->f_ncp

File pointers may now have a referenced+unlocked namecache
pointer associated with them. All fp's representing directories
have this attached. This allows fchdir() to properly record
the ncp in fdp->fd_ncdir and friends.

mount->mnt_ncp

The namecache topology for crossing a mount point works as
follows: when looking up a path element which is a mount point,
cache_nlookup() will locate the ncp for the vnode-under the
mount point. mount->mnt_ncp represents the root of the mount,
that is the vnode-over. nlookup() detects the mount point and
accesses mount->mnt_ncp to skip past the vnode-under. When going
backwards (..), nlookup() detects the case and skips backwards.

The ncp linkages are: ncp->ncp->ncp[vnode_under]->ncp[vnode_over].
That is, when going forwards or backwards nlookup must explicitly
skip over the double-ncp when crossing a mount point. This allows
us to keep the namecache topology intact across mount points.

NEW CACHE level API functions:

cache_get() Reference and lock a namecache entry
cache_put() Dereference and unlock a namecache entry
cache_lock() lock an already-referenced namecache entry
cache_unlock() unlock a lockednamecache entry

NOTE: namecache locks are exclusive and recursive. These are
the 'namespace' locks that we will be using to guarentee namespace
operations such as in a CREATE, RENAME, or REMOVE.

vfs_cache_setroot() Set the new system-wide root directory
cache_allocroot() System bootstrap helper function to allocate
the root namecache node.

cache_resolve() Resolve a NCF_UNRESOLVED namecache node. The
namecache node should be locked on call.

cache_setvp() (resolver) associate a VP or create a negative
cache entry representation for a namecache
pointer and clear NCF_UNRESOLVED. The
namecache node should be locked on call.

cache_setunresolved() Revert a resolved namecache entry back to an
unresolved state, disassociating any vnode
but leaving the topology intact. The
namecache node should be locked on call.

cache_vget() Obtain the locked+refd vnode related to
a namecache entry, resolving the entry if
necessary. Return ENOENT if the entry
represents a negative cache hit.

cache_vref() Obtained a refd (not locked) vnode related to
a namecache entry, as above.

cache_nlookup() The new namecache lookup routine. This routine
does a lookup and allocates a new namecache
node (into an unresolved state) if necessary.
Returns a namecache record whether or not
the item can be found and whether or not it
represents a positive or negative hit.

cache_lookup() OLD API CODE DEPRECATED, but must be maintained
until everything has been converted over.
cache_enter() OLD API CODE DEPRECATED, but must be maintained
until everything has been converted over.

NEW default VOPs

vop_noresolve() Implements a namecache resolver for VFSs
which are still using the old VOP_LOOKUP/
VOP_CACHEDLOOKUP API (which is all of them
still).

VOP_LOOKUP OLD API CODE DEPRECATED, but must be maintained
until everything has been converted over.
VOP_CACHEDLOOKUP OLD API CODE DEPRECATED, but must be maintained
until everything has been converted over.

NEW PATHNAME LOOKUP CODE

nlookup_init() Similar to NDINIT, initialize a nlookupdata
structure for nlookup() and nlookup_done().

nlookup() Lookup a path. Unlike the old namei/lookup
code the new lookup code does not do any
fancy pre-disposition of the cache for
create/delete, it simply looks up the requested
path and returns the appropriate locked
namecache pointer. The caller can obtain the
vnode and directory vnode, as applicable, from
the one namecache structure that is returned.

Access checks are done on directories leading
up to the result but not done on the returned
namecache node.

nlookup_done() Mandatory routine to cleanup a nlookupdata
structure after it has been initialized and
all operations have been completed on it.

nlookup_simple() (in progress) all-in-one wrapped new lookup.

nlookup_mp() helper call for resolving a mount point's
glue NCP. hackish, will be cleaned up later.

nreadsymlink() helper call to resolve a symlink. Note that
the namecache does not yet cache symlink data
but the intention is to eventually do so to
avoid having to do VFS ops to get the data.

naccess() Perform access checks on a namecache node
given a mode and cred.

naccess_va() Perform access cheks on a vattr given a
mode and cred.

Begin switching VFS operations from using namei to using nlookup.
In this batch:

* mount (install mnt_ncp for cross-mount-point handling in
nlookup, simplify the vfs_mount() API to no longer
pass a nameidata structure)
* [l]stat (use nlookup)
* [f]chdir (use nlookup, use recorded f_ncp)
* [f]chroot (use nlookup, use recorded f_ncp)

show more ...

VFS messaging/interfacing work stage 6/99. Populate and maintain the
namecache pointers previously attached to struct filedesc, giving the new
lookup code a base from which to work.

Implement the n

VFS messaging/interfacing work stage 6/99. Populate and maintain the
namecache pointers previously attached to struct filedesc, giving the new
lookup code a base from which to work.

Implement the new lookup API (it is not yet being used by anything) and
augment the namecache API to handle the new functions, in particular
adding cache_setvp() to resolve an unresolved namecache entry into a
positive or negative hit and set various flags. Note that we do not yet
cache symlink data but we could very easily.

The new API is greatly simplified. Basically nlookups need only returned
a locked namecache pointer (guarenteeing namespace atomicy). Related
vnodes are not locked. Both the leaf and governing directory vnodes can
be extracted from the returned namecache pointer. namecache pointers may
also represent negative hits, which means that their namespace locking
feature serves to reserve a filename that has not yet been created (e.g.
open+create, rename).

The kernel is still using the old API as of this commit. This commit is
primarily introducing the management infrastructure required to actually
start writing code to use the new API.

VOP_RESOLVE() has been added, along with a default function which falls back
to VOP_LOOKUP()/VOP_CACHEDLOOKUP(). This VOP function is not yet being used
as of this commit. This VOP will be responsible for taking an unresolved
but locked namecache structure (hence the namespace is locked), and actually
does the directory lookup. But unlike the far more complex
VOP_LOOKUP()/VOP_CACHEDLOOKUP() API the VOP_RESOLVE() API only needs to
attach a vnode (or NULL if the entry does not exist) to the passed-in
namecache structure. It is likely that timeouts, e.g. for NFS, will also
be attached via this API.

This commit does not implement any of the cache-coherency infrastructure
but keeps this future requirement in mind in its design.

show more ...

VFS messaging/interfacing work stage 5/99. Start work on the new
namecache/lookup API. The core of this API will be the concept of a
'locked namespace' rather then a 'locked vnode' for namespace ce

VFS messaging/interfacing work stage 5/99. Start work on the new
namecache/lookup API. The core of this API will be the concept of a
'locked namespace' rather then a 'locked vnode' for namespace centric
operations like CREATE, DELETE, and RENAME. The namecache will no longer
be optional for a VFS but instead will become centric to all kernel
namespace operations.

This commit is mostly non-functional. It removes an extension I had made
to VOP_LOOKUP/VOP_CACHEDLOOKUP and starts adding support functions for the
new cache_nclookup() API. The work being backed out was originally intended
to shepard the new work, but the new interface is now so different (and far
more simplified) then the original that it's actually better to create a
new VOP for it instead of augmenting existing VOPs.

show more ...

VFS messaging/interfacing work stage 5/99. Start work on the new
namecache/lookup API. The core of this API will be the concept of a
'locked namespace' rather then a 'locked vnode' for namespace ce

VFS messaging/interfacing work stage 5/99. Start work on the new
namecache/lookup API. The core of this API will be the concept of a
'locked namespace' rather then a 'locked vnode' for namespace centric
operations like CREATE, DELETE, and RENAME. The namecache will no longer
be optional for a VFS but instead will become centric to all kernel
namespace operations.

This commit is mostly non-functional. It removes an extension I had made
to VOP_LOOKUP/VOP_CACHEDLOOKUP and starts adding support functions for the
new cache_nclookup() API. The work being backed out was originally intended
to shepard the new work, but the new interface is now so different (and far
more simplified) then the original that it's actually better to create a
new VOP for it instead of augmenting existing VOPs.

show more ...

Update all my personal copyrights to the Dragonfly Standard Copyright.

Remove a vn == vp case that was breaking out of the namecache lookup loop
in vn_fullpath(). This can cause a NULL pointer dereferencing panic. This
is believed to be pre-namecache legacy code that

Remove a vn == vp case that was breaking out of the namecache lookup loop
in vn_fullpath(). This can cause a NULL pointer dereferencing panic. This
is believed to be pre-namecache legacy code that is no longer required.

show more ...

Rearrange the kern_getcwd() procedure to return the base of the string
rather then relocating the string.

Also fix two bugs: (1) the original bcopy was copying data beyond the end of
the buffer ([bp

Rearrange the kern_getcwd() procedure to return the base of the string
rather then relocating the string.

Also fix two bugs: (1) the original bcopy was copying data beyond the end of
the buffer ([bp, bp+buflen] exceeds the buffer), and (2), the uap->buflen
checks must be made in __getcwd(), before the kernel tries to malloc() space.

show more ...

Swap order of first and second argument in bcopy, forgot this when changing
from strncpy.

Split the __getcwd syscall into a kernel and an userland part, so it can be
used in the kernel as well.

Pointers by: Matthew Dillon <dillon@apollo.backplane.com>

Surround a multi-line conditional block with braces for readability.

Suggested-by: Matthew Dillon <dillon at backplane.com>

Cleanup the textvp_fullpath() function; summary of changes:

* rename it to vn_fullpath(), and move prototype to sys/vnode.h;
for now, keep a compat macro called textvp_fullpath(); this
macro

Cleanup the textvp_fullpath() function; summary of changes:

* rename it to vn_fullpath(), and move prototype to sys/vnode.h;
for now, keep a compat macro called textvp_fullpath(); this
macro is temporary until I change linprocfs and procfs to play
with vn_fullpath().

* rename last argument to 'freebuf', instead of 'retfreebuf'.

* if the second argument (vnode pointer) is NULL, fall back
and use the passed-in process' p->p_textvp.

* make sure the client passes a process pointer, otherwise
return EINVAL.

A manual page will be added real soon.

show more ...

Rename the sysctl handler for nchstats to reflect reality; I named it
nchstats_agg() originally because it was aggregating the counters in
the handler and than exporting the result; the reality is th

Rename the sysctl handler for nchstats to reflect reality; I named it
nchstats_agg() originally because it was aggregating the counters in
the handler and than exporting the result; the reality is that it
exports them without aggregation so CPU affectiveness can be analysed.

The handler is now called sysctl_nchstats().

show more ...

Remove the VREF() macro and uses of it.
Remove uses of 0x20 before ^I inside vnode.h

namecache work stage 4a: Do some minor performance cleanups with negative
caching, add a cache entry timeout feature.

namecache work stage 4:

(1) Remove vnode->v_dd, vnode->v_ddid, namecache->nc_dvp_data, and
namecache->nc_dvp_id. These identifiers were being used to detect stale
parent directory linkages in the n

namecache work stage 4:

(1) Remove vnode->v_dd, vnode->v_ddid, namecache->nc_dvp_data, and
namecache->nc_dvp_id. These identifiers were being used to detect stale
parent directory linkages in the namecache and were leftovers from the
original FreeBSD-4.x namecache topology. The new namecache topology
actively discards such linkages and does not require them.

(2) Cleanup kern/vfs_cache.c, abstracting out allocation and parent
link/unlink operations into their own procedures.

(3) Formally allow a disjoint topology. That is, allow the case where
nc_parent is NULL. When constructing namecache entries (dvp,vp), require
that that dvp be associated with a namecache record so we can create the
proper parent->child linkage. Since no naming information is known for
dbp, formally allow unnamed namecache records to be created in order to
create the association.

(4) Properly relink parent namecache entries when ".." is entered into
the cache. This is what relinks a disjoint namecache topology after it
has been partially purged or when the namecache is instantiated in the
middle of the logical topology (and thus disjoint).

Note that the original plan was to not allow a disjoint topology, but after
much hair pulling I've come to the conclusion that it is impossible to do
this. So the work now formally allows a disjoint topology but also, unlike
the original FreeBSD code, takes pains to try to keep the topology intact
by only recycling 'leaf' vnodes. This is accomplished by vref()ing a vnode
when its namecache records have children.

show more ...

Per-CPU VFS Namecache Effectiveness Statistics:

* Convert nchstats into a CPU indexed array

* Export the per-CPU nchstats as a sysctl vfs.cache.nchstats
and let user-land aggregate them.

* A

Per-CPU VFS Namecache Effectiveness Statistics:

* Convert nchstats into a CPU indexed array

* Export the per-CPU nchstats as a sysctl vfs.cache.nchstats
and let user-land aggregate them.

* Add a function called kvm_nch_cpuagg() to libkvm; it is
shared by systat(1) and vmstat(1) and the ncache-stats test
program. As the function name suggests, it aggregates
the per-CPU nchstats.

* Move struct nchstats into a separate header to avoid
header file namespace pollution; sys/nchstats.h.

* Keep a cached copy of the globaldata pointer in the VFS
specific LOOKUP op, and use that to increment the
namecache effectiveness counters (nchstats).

* Modify systat(1) and vmstat(1) to accomodate the new
behavior of accessing nchstats. Remove a (now) redundant
sysctl to get the cpu count (hw.ncpu), instead we just divide
the total length of the nchstats array returned by sysctl
by sizeof(struct nchstats) to get the CPU count.

* Garbage-collect unused variables and fix nearby warnings
in systat(1) an vmstat(1).

* Add a very-cool test program, that prints the nchstats
per-CPU statistics to show CPU distribution. Here is the
output it generates on an 2-processor SMP machine:

gray# ncache-stats
VFS Name Cache Effectiveness Statistics
4207370 total name lookups
COUNTER CPU-1 CPU-2 TOTAL
goodhits 2477657 1060677 (3538334 )
neghits 107531 47294 (154825 )
badhits 28968 7720 (36688 )
falsehits 0 0 (0 )
misses 339671 137852 (477523 )
longnames 0 0 (0 )
passes 2 13104 6813 (19917 )
2-passes 25134 15257 (40391 )

The SMP machine used for testing this commit was proudly presented
by David Rhodus <drhodus@dragonflybsd.org>.

Reviewed-by: Matthew Dillon <dillon@backplane.com>

show more ...

Newtoken commit. Change the token implementation as follows: (1) Obtaining
a token no longer enters a critical section. (2) tokens can be held through
schedular switches and blocking conditions an

Newtoken commit. Change the token implementation as follows: (1) Obtaining
a token no longer enters a critical section. (2) tokens can be held through
schedular switches and blocking conditions and are effectively released and
reacquired on resume. Thus tokens serialize access only while the thread
is actually running. Serialization is not broken by preemptive interrupts.
That is, interrupt threads which preempt do no release the preempted thread's
tokens. (3) Unlike spl's, tokens will interlock w/ interrupt threads on
the same or on a different cpu.

The vnode interlock code has been rewritten and the API has changed. The
mountlist vnode scanning code has been consolidated and all known races have
been fixed. The vnode interlock is now a pool token.

The code that frees unreferenced vnodes whos last VM page has been freed has
been moved out of the low level vm_page_free() code and moved to the
periodic filesystem sycer code in vfs_msycn().

The SMP startup code and the IPI code has been cleaned up considerably.
Certain early token interactions on AP cpus have been moved to the BSP.

The LWKT rwlock API has been cleaned up and turned on.

Major testing by: David Rhodus

show more ...

Fix memory leaks in the namecache code commited so far to stabilize its
memory use. These are temporary fixes.