1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 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.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 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.
|
|
|
|
*
|
1997-02-10 02:22:35 +00:00
|
|
|
* @(#)vfs_subr.c 8.31 (Berkeley) 5/26/95
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* External virtual filesystem routines
|
|
|
|
*/
|
1996-01-04 21:13:23 +00:00
|
|
|
#include "opt_ddb.h"
|
2002-07-31 02:03:46 +00:00
|
|
|
#include "opt_mac.h"
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2000-05-05 09:59:14 +00:00
|
|
|
#include <sys/bio.h>
|
2000-01-07 08:36:44 +00:00
|
|
|
#include <sys/buf.h>
|
|
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/eventhandler.h>
|
2002-09-05 20:38:57 +00:00
|
|
|
#include <sys/extattr.h>
|
1998-12-24 12:07:16 +00:00
|
|
|
#include <sys/fcntl.h>
|
1995-11-16 09:45:23 +00:00
|
|
|
#include <sys/kernel.h>
|
1999-07-01 13:21:46 +00:00
|
|
|
#include <sys/kthread.h>
|
2002-07-31 02:03:46 +00:00
|
|
|
#include <sys/mac.h>
|
2002-08-01 17:47:56 +00:00
|
|
|
#include <sys/malloc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/mount.h>
|
2000-01-08 16:20:06 +00:00
|
|
|
#include <sys/namei.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/stat.h>
|
2000-01-07 08:36:44 +00:00
|
|
|
#include <sys/sysctl.h>
|
2001-12-18 20:48:54 +00:00
|
|
|
#include <sys/syslog.h>
|
1997-12-29 00:25:11 +00:00
|
|
|
#include <sys/vmmeter.h>
|
2000-01-07 08:36:44 +00:00
|
|
|
#include <sys/vnode.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
#include <vm/vm.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/vm_object.h>
|
|
|
|
#include <vm/vm_extern.h>
|
1997-12-19 09:03:37 +00:00
|
|
|
#include <vm/pmap.h>
|
|
|
|
#include <vm/vm_map.h>
|
1999-01-21 08:29:12 +00:00
|
|
|
#include <vm/vm_page.h>
|
2002-03-20 04:09:59 +00:00
|
|
|
#include <vm/uma.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-10-12 20:26:33 +00:00
|
|
|
static MALLOC_DEFINE(M_NETADDR, "Export Host", "Export host address structure");
|
1997-10-11 18:31:40 +00:00
|
|
|
|
2002-03-19 21:25:46 +00:00
|
|
|
static void addalias(struct vnode *vp, dev_t nvp_rdev);
|
|
|
|
static void insmntque(struct vnode *vp, struct mount *mp);
|
|
|
|
static void vclean(struct vnode *vp, int flags, struct thread *td);
|
2002-01-10 18:31:53 +00:00
|
|
|
static void vlruvp(struct vnode *vp);
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
static int flushbuflist(struct buf *blist, int flags, struct vnode *vp,
|
|
|
|
int slpflag, int slptimeo, int *errorp);
|
2002-10-11 01:04:14 +00:00
|
|
|
static int vcanrecycle(struct vnode *vp, struct mount **vnmpp);
|
2002-08-05 10:15:56 +00:00
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Number of vnodes in existence. Increased whenever getnewvnode()
|
|
|
|
* allocates a new vnode, never decreased.
|
|
|
|
*/
|
1997-11-22 08:35:46 +00:00
|
|
|
static unsigned long numvnodes;
|
2002-01-10 18:31:53 +00:00
|
|
|
|
2002-06-06 15:50:22 +00:00
|
|
|
SYSCTL_LONG(_vfs, OID_AUTO, numvnodes, CTLFLAG_RD, &numvnodes, 0, "");
|
1995-12-02 18:58:56 +00:00
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/*
|
|
|
|
* Conversion tables for conversion from vnode types to inode formats
|
|
|
|
* and back.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
enum vtype iftovt_tab[16] = {
|
|
|
|
VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
|
|
|
|
VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
|
|
|
|
};
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
int vttoif_tab[9] = {
|
1994-05-24 10:09:53 +00:00
|
|
|
0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK,
|
|
|
|
S_IFSOCK, S_IFIFO, S_IFMT,
|
|
|
|
};
|
|
|
|
|
2000-10-05 18:22:46 +00:00
|
|
|
/*
|
|
|
|
* List of vnodes that are ready for recycling.
|
|
|
|
*/
|
2000-09-22 12:22:36 +00:00
|
|
|
static TAILQ_HEAD(freelst, vnode) vnode_free_list;
|
1998-01-12 01:46:33 +00:00
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/*
|
|
|
|
* Minimum number of free vnodes. If there are fewer than this free vnodes,
|
|
|
|
* getnewvnode() will return a newly allocated vnode.
|
|
|
|
*/
|
1997-09-25 16:17:57 +00:00
|
|
|
static u_long wantfreevnodes = 25;
|
2002-06-06 15:50:22 +00:00
|
|
|
SYSCTL_LONG(_vfs, OID_AUTO, wantfreevnodes, CTLFLAG_RW, &wantfreevnodes, 0, "");
|
2000-09-22 12:22:36 +00:00
|
|
|
/* Number of vnodes in the free list. */
|
2001-12-19 01:35:18 +00:00
|
|
|
static u_long freevnodes;
|
2002-06-06 15:50:22 +00:00
|
|
|
SYSCTL_LONG(_vfs, OID_AUTO, freevnodes, CTLFLAG_RD, &freevnodes, 0, "");
|
2001-10-01 04:33:35 +00:00
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/*
|
2000-10-05 18:22:46 +00:00
|
|
|
* Various variables used for debugging the new implementation of
|
|
|
|
* reassignbuf().
|
|
|
|
* XXX these are probably of (very) limited utility now.
|
2000-09-22 12:22:36 +00:00
|
|
|
*/
|
The buffer queue mechanism has been reformulated. Instead of having
QUEUE_AGE, QUEUE_LRU, and QUEUE_EMPTY we instead have QUEUE_CLEAN,
QUEUE_DIRTY, QUEUE_EMPTY, and QUEUE_EMPTYKVA. With this patch clean
and dirty buffers have been separated. Empty buffers with KVM
assignments have been separated from truely empty buffers. getnewbuf()
has been rewritten and now operates in a 100% optimal fashion. That is,
it is able to find precisely the right kind of buffer it needs to
allocate a new buffer, defragment KVM, or to free-up an existing buffer
when the buffer cache is full (which is a steady-state situation for
the buffer cache).
Buffer flushing has been reorganized. Previously buffers were flushed
in the context of whatever process hit the conditions forcing buffer
flushing to occur. This resulted in processes blocking on conditions
unrelated to what they were doing. This also resulted in inappropriate
VFS stacking chains due to multiple processes getting stuck trying to
flush dirty buffers or due to a single process getting into a situation
where it might attempt to flush buffers recursively - a situation that
was only partially fixed in prior commits. We have added a new daemon
called the buf_daemon which is responsible for flushing dirty buffers
when the number of dirty buffers exceeds the vfs.hidirtybuffers limit.
This daemon attempts to dynamically adjust the rate at which dirty buffers
are flushed such that getnewbuf() calls (almost) never block.
The number of nbufs and amount of buffer space is now scaled past the
8MB limit that was previously imposed for systems with over 64MB of
memory, and the vfs.{lo,hi}dirtybuffers limits have been relaxed
somewhat. The number of physical buffers has been increased with the
intention that we will manage physical I/O differently in the future.
reassignbuf previously attempted to keep the dirtyblkhd list sorted which
could result in non-deterministic operation under certain conditions,
such as when a large number of dirty buffers are being managed. This
algorithm has been changed. reassignbuf now keeps buffers locally sorted
if it can do so cheaply, and otherwise gives up and adds buffers to
the head of the dirtyblkhd list. The new algorithm is deterministic but
not perfect. The new algorithm greatly reduces problems that previously
occured when write_behind was turned off in the system.
The P_FLSINPROG proc->p_flag bit has been replaced by the more descriptive
P_BUFEXHAUST bit. This bit allows processes working with filesystem
buffers to use available emergency reserves. Normal processes do not set
this bit and are not allowed to dig into emergency reserves. The purpose
of this bit is to avoid low-memory deadlocks.
A small race condition was fixed in getpbuf() in vm/vm_pager.c.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
Reviewed by: Kirk McKusick <mckusick@mckusick.com>
1999-07-04 00:25:38 +00:00
|
|
|
static int reassignbufcalls;
|
|
|
|
SYSCTL_INT(_vfs, OID_AUTO, reassignbufcalls, CTLFLAG_RW, &reassignbufcalls, 0, "");
|
2001-12-19 01:35:18 +00:00
|
|
|
static int nameileafonly;
|
2001-10-01 04:33:35 +00:00
|
|
|
SYSCTL_INT(_vfs, OID_AUTO, nameileafonly, CTLFLAG_RW, &nameileafonly, 0, "");
|
The buffer queue mechanism has been reformulated. Instead of having
QUEUE_AGE, QUEUE_LRU, and QUEUE_EMPTY we instead have QUEUE_CLEAN,
QUEUE_DIRTY, QUEUE_EMPTY, and QUEUE_EMPTYKVA. With this patch clean
and dirty buffers have been separated. Empty buffers with KVM
assignments have been separated from truely empty buffers. getnewbuf()
has been rewritten and now operates in a 100% optimal fashion. That is,
it is able to find precisely the right kind of buffer it needs to
allocate a new buffer, defragment KVM, or to free-up an existing buffer
when the buffer cache is full (which is a steady-state situation for
the buffer cache).
Buffer flushing has been reorganized. Previously buffers were flushed
in the context of whatever process hit the conditions forcing buffer
flushing to occur. This resulted in processes blocking on conditions
unrelated to what they were doing. This also resulted in inappropriate
VFS stacking chains due to multiple processes getting stuck trying to
flush dirty buffers or due to a single process getting into a situation
where it might attempt to flush buffers recursively - a situation that
was only partially fixed in prior commits. We have added a new daemon
called the buf_daemon which is responsible for flushing dirty buffers
when the number of dirty buffers exceeds the vfs.hidirtybuffers limit.
This daemon attempts to dynamically adjust the rate at which dirty buffers
are flushed such that getnewbuf() calls (almost) never block.
The number of nbufs and amount of buffer space is now scaled past the
8MB limit that was previously imposed for systems with over 64MB of
memory, and the vfs.{lo,hi}dirtybuffers limits have been relaxed
somewhat. The number of physical buffers has been increased with the
intention that we will manage physical I/O differently in the future.
reassignbuf previously attempted to keep the dirtyblkhd list sorted which
could result in non-deterministic operation under certain conditions,
such as when a large number of dirty buffers are being managed. This
algorithm has been changed. reassignbuf now keeps buffers locally sorted
if it can do so cheaply, and otherwise gives up and adds buffers to
the head of the dirtyblkhd list. The new algorithm is deterministic but
not perfect. The new algorithm greatly reduces problems that previously
occured when write_behind was turned off in the system.
The P_FLSINPROG proc->p_flag bit has been replaced by the more descriptive
P_BUFEXHAUST bit. This bit allows processes working with filesystem
buffers to use available emergency reserves. Normal processes do not set
this bit and are not allowed to dig into emergency reserves. The purpose
of this bit is to avoid low-memory deadlocks.
A small race condition was fixed in getpbuf() in vm/vm_pager.c.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
Reviewed by: Kirk McKusick <mckusick@mckusick.com>
1999-07-04 00:25:38 +00:00
|
|
|
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
#ifdef ENABLE_VFS_IOOPT
|
2000-10-05 18:22:46 +00:00
|
|
|
/* See NOTES for a description of this setting. */
|
2001-12-19 01:35:18 +00:00
|
|
|
int vfs_ioopt;
|
1997-12-29 01:03:55 +00:00
|
|
|
SYSCTL_INT(_vfs, OID_AUTO, ioopt, CTLFLAG_RW, &vfs_ioopt, 0, "");
|
1998-03-14 19:50:36 +00:00
|
|
|
#endif
|
1997-12-29 01:03:55 +00:00
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/*
|
|
|
|
* Cache for the mount type id assigned to NFS. This is used for
|
|
|
|
* special checks in nfs/nfs_nqlease.c and vm/vnode_pager.c.
|
|
|
|
*/
|
1998-09-05 15:17:34 +00:00
|
|
|
int nfs_mount_type = -1;
|
2000-09-22 12:22:36 +00:00
|
|
|
|
|
|
|
/* To keep more than one thread at a time from running vfs_getnewfsid */
|
2001-01-24 12:35:55 +00:00
|
|
|
static struct mtx mntid_mtx;
|
2000-10-05 18:22:46 +00:00
|
|
|
|
2002-08-13 05:29:48 +00:00
|
|
|
/*
|
|
|
|
* Lock for any access to the following:
|
|
|
|
* vnode_free_list
|
|
|
|
* numvnodes
|
|
|
|
* freevnodes
|
|
|
|
*/
|
2001-01-24 12:35:55 +00:00
|
|
|
static struct mtx vnode_free_list_mtx;
|
2000-09-22 12:22:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For any iteration/modification of dev->si_hlist (linked through
|
|
|
|
* v_specnext)
|
|
|
|
*/
|
2001-01-24 12:35:55 +00:00
|
|
|
static struct mtx spechash_mtx;
|
2000-09-22 12:22:36 +00:00
|
|
|
|
|
|
|
/* Publicly exported FS */
|
|
|
|
struct nfs_public nfs_pub;
|
2000-10-05 18:22:46 +00:00
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/* Zone for allocation of new vnodes - used exclusively by getnewvnode() */
|
2002-03-20 04:09:59 +00:00
|
|
|
static uma_zone_t vnode_zone;
|
|
|
|
static uma_zone_t vnodepoll_zone;
|
2000-10-05 18:22:46 +00:00
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/* Set to 1 to print out reclaim of active vnodes */
|
2001-12-19 01:35:18 +00:00
|
|
|
int prtactive;
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
|
1998-03-08 09:59:44 +00:00
|
|
|
/*
|
|
|
|
* The workitem queue.
|
2002-06-06 15:46:38 +00:00
|
|
|
*
|
2000-09-22 12:22:36 +00:00
|
|
|
* It is useful to delay writes of file data and filesystem metadata
|
|
|
|
* for tens of seconds so that quickly created and deleted files need
|
|
|
|
* not waste disk bandwidth being created and removed. To realize this,
|
|
|
|
* we append vnodes to a "workitem" queue. When running with a soft
|
|
|
|
* updates implementation, most pending metadata dependencies should
|
|
|
|
* not wait for more than a few seconds. Thus, mounted on block devices
|
|
|
|
* are delayed only about a half the time that file data is delayed.
|
|
|
|
* Similarly, directory updates are more critical, so are only delayed
|
|
|
|
* about a third the time that file data is delayed. Thus, there are
|
|
|
|
* SYNCER_MAXDELAY queues that are processed round-robin at a rate of
|
|
|
|
* one each second (driven off the filesystem syncer process). The
|
|
|
|
* syncer_delayno variable indicates the next queue that is to be processed.
|
|
|
|
* Items that need to be processed soon are placed in this queue:
|
|
|
|
*
|
|
|
|
* syncer_workitem_pending[syncer_delayno]
|
|
|
|
*
|
|
|
|
* A delay of fifteen seconds is done by placing the request fifteen
|
|
|
|
* entries later in the queue:
|
|
|
|
*
|
|
|
|
* syncer_workitem_pending[(syncer_delayno + 15) & syncer_mask]
|
|
|
|
*
|
1998-03-08 09:59:44 +00:00
|
|
|
*/
|
2001-12-19 01:35:18 +00:00
|
|
|
static int syncer_delayno;
|
2002-06-06 15:46:38 +00:00
|
|
|
static long syncer_mask;
|
2000-09-22 12:22:36 +00:00
|
|
|
LIST_HEAD(synclist, vnode);
|
|
|
|
static struct synclist *syncer_workitem_pending;
|
2002-09-25 02:22:21 +00:00
|
|
|
/*
|
|
|
|
* The sync_mtx protects:
|
|
|
|
* vp->v_synclist
|
|
|
|
* syncer_delayno
|
|
|
|
* syncer_workitem_pending
|
|
|
|
* rushjob
|
|
|
|
*/
|
|
|
|
static struct mtx sync_mtx;
|
2000-09-22 12:22:36 +00:00
|
|
|
|
1998-03-08 09:59:44 +00:00
|
|
|
#define SYNCER_MAXDELAY 32
|
1998-12-21 23:38:33 +00:00
|
|
|
static int syncer_maxdelay = SYNCER_MAXDELAY; /* maximum delay time */
|
2001-10-27 19:58:56 +00:00
|
|
|
static int syncdelay = 30; /* max time to delay syncing data */
|
|
|
|
static int filedelay = 30; /* time to delay syncing files */
|
1999-06-15 23:37:29 +00:00
|
|
|
SYSCTL_INT(_kern, OID_AUTO, filedelay, CTLFLAG_RW, &filedelay, 0, "");
|
2001-10-27 19:58:56 +00:00
|
|
|
static int dirdelay = 29; /* time to delay syncing directories */
|
1999-06-15 23:37:29 +00:00
|
|
|
SYSCTL_INT(_kern, OID_AUTO, dirdelay, CTLFLAG_RW, &dirdelay, 0, "");
|
2001-10-27 19:58:56 +00:00
|
|
|
static int metadelay = 28; /* time to delay syncing metadata */
|
1999-06-15 23:37:29 +00:00
|
|
|
SYSCTL_INT(_kern, OID_AUTO, metadelay, CTLFLAG_RW, &metadelay, 0, "");
|
2000-09-22 12:22:36 +00:00
|
|
|
static int rushjob; /* number of slots to run ASAP */
|
1999-06-15 23:37:29 +00:00
|
|
|
static int stat_rush_requests; /* number of times I/O speeded up */
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, rush_requests, CTLFLAG_RW, &stat_rush_requests, 0, "");
|
1998-03-08 09:59:44 +00:00
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/*
|
2000-10-05 18:22:46 +00:00
|
|
|
* Number of vnodes we want to exist at any one time. This is mostly used
|
|
|
|
* to size hash tables in vnode-related code. It is normally not used in
|
|
|
|
* getnewvnode(), as wantfreevnodes is normally nonzero.)
|
|
|
|
*
|
|
|
|
* XXX desiredvnodes is historical cruft and should not exist.
|
2000-09-22 12:22:36 +00:00
|
|
|
*/
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
int desiredvnodes;
|
2002-06-06 15:46:38 +00:00
|
|
|
SYSCTL_INT(_kern, KERN_MAXVNODES, maxvnodes, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&desiredvnodes, 0, "Maximum number of vnodes");
|
2002-06-06 15:46:38 +00:00
|
|
|
static int minvnodes;
|
2001-10-16 23:08:09 +00:00
|
|
|
SYSCTL_INT(_kern, OID_AUTO, minvnodes, CTLFLAG_RW,
|
2001-10-01 04:33:35 +00:00
|
|
|
&minvnodes, 0, "Minimum number of vnodes");
|
2001-12-19 01:35:18 +00:00
|
|
|
static int vnlru_nowhere;
|
2001-12-19 01:31:12 +00:00
|
|
|
SYSCTL_INT(_debug, OID_AUTO, vnlru_nowhere, CTLFLAG_RW, &vnlru_nowhere, 0,
|
|
|
|
"Number of times the vnlru process ran without success");
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-07-01 17:59:40 +00:00
|
|
|
/* Hook for calling soft updates */
|
|
|
|
int (*softdep_process_worklist_hook)(struct mount *);
|
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
/*
|
|
|
|
* This only exists to supress warnings from unlocked specfs accesses. It is
|
|
|
|
* no longer ok to have an unlocked VFS.
|
|
|
|
*/
|
|
|
|
#define IGNORE_LOCK(vp) ((vp)->v_type == VCHR || (vp)->v_type == VBAD)
|
|
|
|
|
2002-06-28 20:58:14 +00:00
|
|
|
/* Print lock violations */
|
|
|
|
int vfs_badlock_print = 1;
|
2002-08-21 06:19:29 +00:00
|
|
|
|
2002-06-28 20:58:14 +00:00
|
|
|
/* Panic on violation */
|
|
|
|
int vfs_badlock_panic = 1;
|
2002-07-06 04:39:48 +00:00
|
|
|
|
2002-08-21 06:19:29 +00:00
|
|
|
/* Check for interlock across VOPs */
|
2002-09-25 02:22:21 +00:00
|
|
|
int vfs_badlock_mutex = 1;
|
2002-08-21 06:19:29 +00:00
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
static void
|
|
|
|
vfs_badlock(char *msg, char *str, struct vnode *vp)
|
|
|
|
{
|
|
|
|
if (vfs_badlock_print)
|
|
|
|
printf("%s: %p %s\n", str, vp, msg);
|
|
|
|
if (vfs_badlock_panic)
|
|
|
|
Debugger("Lock violation.\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vi_unlocked(struct vnode *vp, char *str)
|
|
|
|
{
|
|
|
|
if (vfs_badlock_mutex && mtx_owned(VI_MTX(vp)))
|
|
|
|
vfs_badlock("interlock is locked but should not be", str, vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vi_locked(struct vnode *vp, char *str)
|
|
|
|
{
|
|
|
|
if (vfs_badlock_mutex && !mtx_owned(VI_MTX(vp)))
|
|
|
|
vfs_badlock("interlock is not locked but should be", str, vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vop_locked(struct vnode *vp, char *str)
|
|
|
|
{
|
|
|
|
if (vp && !IGNORE_LOCK(vp) && !VOP_ISLOCKED(vp, NULL))
|
|
|
|
vfs_badlock("is not locked but should be", str, vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vop_unlocked(struct vnode *vp, char *str)
|
|
|
|
{
|
|
|
|
if (vp && !IGNORE_LOCK(vp) &&
|
|
|
|
VOP_ISLOCKED(vp, curthread) == LK_EXCLUSIVE)
|
|
|
|
vfs_badlock("is locked but should not be", str, vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vop_elocked(struct vnode *vp, char *str)
|
|
|
|
{
|
|
|
|
if (vp && !IGNORE_LOCK(vp) &&
|
|
|
|
VOP_ISLOCKED(vp, curthread) != LK_EXCLUSIVE)
|
|
|
|
vfs_badlock("is not exclusive locked but should be", str, vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vop_elocked_other(struct vnode *vp, char *str)
|
|
|
|
{
|
|
|
|
if (vp && !IGNORE_LOCK(vp) &&
|
|
|
|
VOP_ISLOCKED(vp, curthread) != LK_EXCLOTHER)
|
|
|
|
vfs_badlock("is not exclusive locked by another thread",
|
|
|
|
str, vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vop_slocked(struct vnode *vp, char *str)
|
|
|
|
{
|
|
|
|
if (vp && !IGNORE_LOCK(vp) &&
|
|
|
|
VOP_ISLOCKED(vp, curthread) != LK_SHARED)
|
|
|
|
vfs_badlock("is not locked shared but should be", str, vp);
|
|
|
|
}
|
|
|
|
|
2002-07-06 04:39:48 +00:00
|
|
|
void
|
|
|
|
vop_rename_pre(void *ap)
|
|
|
|
{
|
|
|
|
struct vop_rename_args *a = ap;
|
|
|
|
|
2002-08-21 06:19:29 +00:00
|
|
|
if (a->a_tvp)
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_UNLOCKED(a->a_tvp, "VOP_RENAME");
|
|
|
|
ASSERT_VI_UNLOCKED(a->a_tdvp, "VOP_RENAME");
|
|
|
|
ASSERT_VI_UNLOCKED(a->a_fvp, "VOP_RENAME");
|
|
|
|
ASSERT_VI_UNLOCKED(a->a_fdvp, "VOP_RENAME");
|
2002-08-21 06:19:29 +00:00
|
|
|
|
2002-07-06 04:39:48 +00:00
|
|
|
/* Check the source (from) */
|
|
|
|
if (a->a_tdvp != a->a_fdvp)
|
|
|
|
ASSERT_VOP_UNLOCKED(a->a_fdvp, "vop_rename: fdvp locked.\n");
|
|
|
|
if (a->a_tvp != a->a_fvp)
|
|
|
|
ASSERT_VOP_UNLOCKED(a->a_fvp, "vop_rename: tvp locked.\n");
|
|
|
|
|
|
|
|
/* Check the target */
|
|
|
|
if (a->a_tvp)
|
|
|
|
ASSERT_VOP_LOCKED(a->a_tvp, "vop_rename: tvp not locked.\n");
|
|
|
|
|
|
|
|
ASSERT_VOP_LOCKED(a->a_tdvp, "vop_rename: tdvp not locked.\n");
|
|
|
|
}
|
|
|
|
|
2002-07-06 05:21:12 +00:00
|
|
|
void
|
|
|
|
vop_strategy_pre(void *ap)
|
|
|
|
{
|
|
|
|
struct vop_strategy_args *a = ap;
|
2002-07-07 05:29:45 +00:00
|
|
|
struct buf *bp;
|
2002-07-06 05:21:12 +00:00
|
|
|
|
2002-07-07 05:29:45 +00:00
|
|
|
bp = a->a_bp;
|
2002-07-06 05:21:12 +00:00
|
|
|
|
2002-07-07 05:29:45 +00:00
|
|
|
/*
|
|
|
|
* Cluster ops lock their component buffers but not the IO container.
|
|
|
|
*/
|
|
|
|
if ((bp->b_flags & B_CLUSTER) != 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (BUF_REFCNT(bp) < 1) {
|
2002-07-06 05:21:12 +00:00
|
|
|
if (vfs_badlock_print)
|
|
|
|
printf("VOP_STRATEGY: bp is not locked but should be.\n");
|
|
|
|
if (vfs_badlock_panic)
|
|
|
|
Debugger("Lock violation.\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-07-09 19:54:20 +00:00
|
|
|
void
|
|
|
|
vop_lookup_pre(void *ap)
|
|
|
|
{
|
|
|
|
struct vop_lookup_args *a = ap;
|
|
|
|
struct vnode *dvp;
|
|
|
|
|
|
|
|
dvp = a->a_dvp;
|
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_UNLOCKED(dvp, "VOP_LOOKUP");
|
2002-07-09 19:54:20 +00:00
|
|
|
ASSERT_VOP_LOCKED(dvp, "VOP_LOOKUP");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_lookup_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_lookup_args *a = ap;
|
|
|
|
struct componentname *cnp;
|
|
|
|
struct vnode *dvp;
|
|
|
|
struct vnode *vp;
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
dvp = a->a_dvp;
|
|
|
|
cnp = a->a_cnp;
|
|
|
|
vp = *(a->a_vpp);
|
|
|
|
flags = cnp->cn_flags;
|
|
|
|
|
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_UNLOCKED(dvp, "VOP_LOOKUP");
|
2002-07-09 19:54:20 +00:00
|
|
|
/*
|
|
|
|
* If this is the last path component for this lookup and LOCPARENT
|
|
|
|
* is set, OR if there is an error the directory has to be locked.
|
|
|
|
*/
|
|
|
|
if ((flags & LOCKPARENT) && (flags & ISLASTCN))
|
|
|
|
ASSERT_VOP_LOCKED(dvp, "VOP_LOOKUP (LOCKPARENT)");
|
|
|
|
else if (rc != 0)
|
|
|
|
ASSERT_VOP_LOCKED(dvp, "VOP_LOOKUP (error)");
|
|
|
|
else if (dvp != vp)
|
|
|
|
ASSERT_VOP_UNLOCKED(dvp, "VOP_LOOKUP (dvp)");
|
|
|
|
|
|
|
|
if (flags & PDIRUNLOCK)
|
|
|
|
ASSERT_VOP_UNLOCKED(dvp, "VOP_LOOKUP (PDIRUNLOCK)");
|
2002-08-21 06:19:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_unlock_pre(void *ap)
|
|
|
|
{
|
|
|
|
struct vop_unlock_args *a = ap;
|
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
if (a->a_flags & LK_INTERLOCK)
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(a->a_vp, "VOP_UNLOCK");
|
2002-09-25 02:22:21 +00:00
|
|
|
|
|
|
|
ASSERT_VOP_LOCKED(a->a_vp, "VOP_UNLOCK");
|
2002-08-21 06:19:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_unlock_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_unlock_args *a = ap;
|
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
if (a->a_flags & LK_INTERLOCK)
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNLOCK");
|
2002-08-21 06:19:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_lock_pre(void *ap)
|
|
|
|
{
|
|
|
|
struct vop_lock_args *a = ap;
|
|
|
|
|
|
|
|
if ((a->a_flags & LK_INTERLOCK) == 0)
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
|
2002-08-21 06:19:29 +00:00
|
|
|
else
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(a->a_vp, "VOP_LOCK");
|
2002-08-21 06:19:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_lock_post(void *ap, int rc)
|
|
|
|
{
|
2002-09-26 04:48:44 +00:00
|
|
|
struct vop_lock_args *a;
|
2002-08-21 06:19:29 +00:00
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
a = ap;
|
|
|
|
|
|
|
|
ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
|
2002-08-21 06:19:29 +00:00
|
|
|
ASSERT_VOP_LOCKED(a->a_vp, "VOP_LOCK");
|
2002-07-09 19:54:20 +00:00
|
|
|
}
|
|
|
|
|
2002-02-18 16:18:02 +00:00
|
|
|
void
|
2002-02-17 21:15:36 +00:00
|
|
|
v_addpollinfo(struct vnode *vp)
|
|
|
|
{
|
2003-02-19 05:47:46 +00:00
|
|
|
vp->v_pollinfo = uma_zalloc(vnodepoll_zone, M_WAITOK);
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&vp->v_pollinfo->vpi_lock, "vnode pollinfo", NULL, MTX_DEF);
|
2002-02-17 21:15:36 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Initialize the vnode management data structures.
|
|
|
|
*/
|
2000-12-06 07:09:08 +00:00
|
|
|
static void
|
|
|
|
vntblinit(void *dummy __unused)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
1997-12-29 00:25:11 +00:00
|
|
|
desiredvnodes = maxproc + cnt.v_page_count / 4;
|
2001-10-01 04:33:35 +00:00
|
|
|
minvnodes = desiredvnodes / 4;
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&mountlist_mtx, "mountlist", NULL, MTX_DEF);
|
|
|
|
mtx_init(&mntvnode_mtx, "mntvnode", NULL, MTX_DEF);
|
|
|
|
mtx_init(&mntid_mtx, "mntid", NULL, MTX_DEF);
|
|
|
|
mtx_init(&spechash_mtx, "spechash", NULL, MTX_DEF);
|
1994-05-24 10:09:53 +00:00
|
|
|
TAILQ_INIT(&vnode_free_list);
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&vnode_free_list_mtx, "vnode_free_list", NULL, MTX_DEF);
|
2002-03-20 04:09:59 +00:00
|
|
|
vnode_zone = uma_zcreate("VNODE", sizeof (struct vnode), NULL, NULL,
|
|
|
|
NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
|
|
|
|
vnodepoll_zone = uma_zcreate("VNODEPOLL", sizeof (struct vpollinfo),
|
|
|
|
NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
|
1998-03-08 09:59:44 +00:00
|
|
|
/*
|
|
|
|
* Initialize the filesystem syncer.
|
2002-06-06 15:46:38 +00:00
|
|
|
*/
|
|
|
|
syncer_workitem_pending = hashinit(syncer_maxdelay, M_VNODE,
|
1998-03-08 09:59:44 +00:00
|
|
|
&syncer_mask);
|
|
|
|
syncer_maxdelay = syncer_mask + 1;
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_init(&sync_mtx, "Syncer mtx", NULL, MTX_DEF);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-12-06 07:09:08 +00:00
|
|
|
SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_FIRST, vntblinit, NULL)
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Mark a mount point as busy. Used to synchronize access and to delay
|
|
|
|
* unmounting. Interlock is not released on failure.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
vfs_busy(mp, flags, interlkp, td)
|
1997-02-10 02:22:35 +00:00
|
|
|
struct mount *mp;
|
|
|
|
int flags;
|
2000-10-04 01:29:17 +00:00
|
|
|
struct mtx *interlkp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
int lkflags;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-11-12 05:42:33 +00:00
|
|
|
if (mp->mnt_kern_flag & MNTK_UNMOUNT) {
|
1997-02-10 02:22:35 +00:00
|
|
|
if (flags & LK_NOWAIT)
|
|
|
|
return (ENOENT);
|
1997-11-12 05:42:33 +00:00
|
|
|
mp->mnt_kern_flag |= MNTK_MWAIT;
|
1997-02-10 02:22:35 +00:00
|
|
|
/*
|
|
|
|
* Since all busy locks are shared except the exclusive
|
|
|
|
* lock granted when unmounting, the only place that a
|
|
|
|
* wakeup needs to be done is at the release of the
|
|
|
|
* exclusive lock at the end of dounmount.
|
|
|
|
*/
|
2002-06-28 23:17:36 +00:00
|
|
|
msleep(mp, interlkp, PVFS, "vfs_busy", 0);
|
1997-02-10 02:22:35 +00:00
|
|
|
return (ENOENT);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
This mega-commit is meant to fix numerous interrelated problems. There
has been some bitrot and incorrect assumptions in the vfs_bio code. These
problems have manifest themselves worse on NFS type filesystems, but can
still affect local filesystems under certain circumstances. Most of
the problems have involved mmap consistancy, and as a side-effect broke
the vfs.ioopt code. This code might have been committed seperately, but
almost everything is interrelated.
1) Allow (pmap_object_init_pt) prefaulting of buffer-busy pages that
are fully valid.
2) Rather than deactivating erroneously read initial (header) pages in
kern_exec, we now free them.
3) Fix the rundown of non-VMIO buffers that are in an inconsistent
(missing vp) state.
4) Fix the disassociation of pages from buffers in brelse. The previous
code had rotted and was faulty in a couple of important circumstances.
5) Remove a gratuitious buffer wakeup in vfs_vmio_release.
6) Remove a crufty and currently unused cluster mechanism for VBLK
files in vfs_bio_awrite. When the code is functional, I'll add back
a cleaner version.
7) The page busy count wakeups assocated with the buffer cache usage were
incorrectly cleaned up in a previous commit by me. Revert to the
original, correct version, but with a cleaner implementation.
8) The cluster read code now tries to keep data associated with buffers
more aggressively (without breaking the heuristics) when it is presumed
that the read data (buffers) will be soon needed.
9) Change to filesystem lockmgr locks so that they use LK_NOPAUSE. The
delay loop waiting is not useful for filesystem locks, due to the
length of the time intervals.
10) Correct and clean-up spec_getpages.
11) Implement a fully functional nfs_getpages, nfs_putpages.
12) Fix nfs_write so that modifications are coherent with the NFS data on
the server disk (at least as well as NFS seems to allow.)
13) Properly support MS_INVALIDATE on NFS.
14) Properly pass down MS_INVALIDATE to lower levels of the VM code from
vm_map_clean.
15) Better support the notion of pages being busy but valid, so that
fewer in-transit waits occur. (use p->busy more for pageouts instead
of PG_BUSY.) Since the page is fully valid, it is still usable for
reads.
16) It is possible (in error) for cached pages to be busy. Make the
page allocation code handle that case correctly. (It should probably
be a printf or panic, but I want the system to handle coding errors
robustly. I'll probably add a printf.)
17) Correct the design and usage of vm_page_sleep. It didn't handle
consistancy problems very well, so make the design a little less
lofty. After vm_page_sleep, if it ever blocked, it is still important
to relookup the page (if the object generation count changed), and
verify it's status (always.)
18) In vm_pageout.c, vm_pageout_clean had rotted, so clean that up.
19) Push the page busy for writes and VM_PROT_READ into vm_pageout_flush.
20) Fix vm_pager_put_pages and it's descendents to support an int flag
instead of a boolean, so that we can pass down the invalidate bit.
1998-03-07 21:37:31 +00:00
|
|
|
lkflags = LK_SHARED | LK_NOPAUSE;
|
1997-02-10 02:22:35 +00:00
|
|
|
if (interlkp)
|
|
|
|
lkflags |= LK_INTERLOCK;
|
2001-09-12 08:38:13 +00:00
|
|
|
if (lockmgr(&mp->mnt_lock, lkflags, interlkp, td))
|
1997-02-10 02:22:35 +00:00
|
|
|
panic("vfs_busy: unexpected lock failure");
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Free a busy filesystem.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
void
|
2001-09-12 08:38:13 +00:00
|
|
|
vfs_unbusy(mp, td)
|
1997-02-10 02:22:35 +00:00
|
|
|
struct mount *mp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lookup a mount point by filesystem identifier.
|
|
|
|
*/
|
|
|
|
struct mount *
|
1997-02-10 02:22:35 +00:00
|
|
|
vfs_getvfs(fsid)
|
1994-05-24 10:09:53 +00:00
|
|
|
fsid_t *fsid;
|
|
|
|
{
|
|
|
|
register struct mount *mp;
|
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
1999-11-20 10:00:46 +00:00
|
|
|
TAILQ_FOREACH(mp, &mountlist, mnt_list) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
|
1997-02-10 02:22:35 +00:00
|
|
|
mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mountlist_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (mp);
|
2002-10-01 15:48:31 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mountlist_mtx);
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
return ((struct mount *) 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2000-03-14 14:19:49 +00:00
|
|
|
* Get a new unique fsid. Try to make its val[0] unique, since this value
|
|
|
|
* will be used to create fake device numbers for stat(). Also try (but
|
|
|
|
* not so hard) make its val[0] unique mod 2^16, since some emulators only
|
|
|
|
* support 16-bit device numbers. We end up with unique val[0]'s for the
|
|
|
|
* first 2^16 calls and unique val[0]'s mod 2^16 for the first 2^8 calls.
|
1999-09-19 06:24:21 +00:00
|
|
|
*
|
2000-03-12 14:23:21 +00:00
|
|
|
* Keep in mind that several mounts may be running in parallel. Starting
|
2000-03-14 14:19:49 +00:00
|
|
|
* the search one past where the previous search terminated is both a
|
|
|
|
* micro-optimization and a defense against returning the same fsid to
|
|
|
|
* different mounts.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
void
|
1997-02-10 02:22:35 +00:00
|
|
|
vfs_getnewfsid(mp)
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mount *mp;
|
|
|
|
{
|
2000-03-14 14:19:49 +00:00
|
|
|
static u_int16_t mntid_base;
|
1994-05-24 10:09:53 +00:00
|
|
|
fsid_t tfsid;
|
2000-03-14 14:19:49 +00:00
|
|
|
int mtype;
|
1999-09-19 06:24:21 +00:00
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mntid_mtx);
|
1997-02-10 02:22:35 +00:00
|
|
|
mtype = mp->mnt_vfc->vfc_typenum;
|
2000-03-12 14:23:21 +00:00
|
|
|
tfsid.val[1] = mtype;
|
2000-07-07 14:01:08 +00:00
|
|
|
mtype = (mtype & 0xFF) << 24;
|
2000-03-14 14:19:49 +00:00
|
|
|
for (;;) {
|
2000-07-07 14:01:08 +00:00
|
|
|
tfsid.val[0] = makeudev(255,
|
|
|
|
mtype | ((mntid_base & 0xFF00) << 8) | (mntid_base & 0xFF));
|
|
|
|
mntid_base++;
|
1999-09-19 06:24:21 +00:00
|
|
|
if (vfs_getvfs(&tfsid) == NULL)
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
|
1999-09-19 06:24:21 +00:00
|
|
|
mp->mnt_stat.f_fsid.val[1] = tfsid.val[1];
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mntid_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
Support full-precision file timestamps. Until now, only the seconds
have been maintained, and that is still the default. A new sysctl
variable "vfs.timestamp_precision" can be used to enable higher
levels of precision:
0 = seconds only; nanoseconds zeroed (default).
1 = seconds and nanoseconds, accurate within 1/HZ.
2 = seconds and nanoseconds, truncated to microseconds.
>=3 = seconds and nanoseconds, maximum precision.
Level 1 uses getnanotime(), which is fast but can be wrong by up
to 1/HZ. Level 2 uses microtime(). It might be desirable for
consistency with utimes() and friends, which take timeval structures
rather than timespecs. Level 3 uses nanotime() for the higest
precision.
I benchmarked levels 0, 1, and 3 by copying a 550 MB tree with
"cpio -pdu". There was almost negligible difference in the system
times -- much less than 1%, and less than the variation among
multiple runs at the same level. Bruce Evans dreamed up a torture
test involving 1-byte reads with intervening fstat() calls, but
the cpio test seems more realistic to me.
This feature is currently implemented only for the UFS (FFS and
MFS) filesystems. But I think it should be easy to support it in
the others as well.
An earlier version of this was reviewed by Bruce. He's not to
blame for any breakage I've introduced since then.
Reviewed by: bde (an earlier version of the code)
1999-08-22 00:15:16 +00:00
|
|
|
/*
|
|
|
|
* Knob to control the precision of file timestamps:
|
|
|
|
*
|
|
|
|
* 0 = seconds only; nanoseconds zeroed.
|
|
|
|
* 1 = seconds and nanoseconds, accurate within 1/HZ.
|
|
|
|
* 2 = seconds and nanoseconds, truncated to microseconds.
|
|
|
|
* >=3 = seconds and nanoseconds, maximum precision.
|
|
|
|
*/
|
|
|
|
enum { TSP_SEC, TSP_HZ, TSP_USEC, TSP_NSEC };
|
|
|
|
|
|
|
|
static int timestamp_precision = TSP_SEC;
|
|
|
|
SYSCTL_INT(_vfs, OID_AUTO, timestamp_precision, CTLFLAG_RW,
|
|
|
|
×tamp_precision, 0, "");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a current timestamp.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
vfs_timestamp(tsp)
|
|
|
|
struct timespec *tsp;
|
|
|
|
{
|
|
|
|
struct timeval tv;
|
|
|
|
|
|
|
|
switch (timestamp_precision) {
|
|
|
|
case TSP_SEC:
|
|
|
|
tsp->tv_sec = time_second;
|
|
|
|
tsp->tv_nsec = 0;
|
|
|
|
break;
|
|
|
|
case TSP_HZ:
|
|
|
|
getnanotime(tsp);
|
|
|
|
break;
|
|
|
|
case TSP_USEC:
|
|
|
|
microtime(&tv);
|
|
|
|
TIMEVAL_TO_TIMESPEC(&tv, tsp);
|
|
|
|
break;
|
|
|
|
case TSP_NSEC:
|
|
|
|
default:
|
|
|
|
nanotime(tsp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Set vnode attributes to VNOVAL
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
|
|
|
vattr_null(vap)
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct vattr *vap;
|
|
|
|
{
|
|
|
|
|
|
|
|
vap->va_type = VNON;
|
1994-05-25 09:21:21 +00:00
|
|
|
vap->va_size = VNOVAL;
|
|
|
|
vap->va_bytes = VNOVAL;
|
1998-07-12 16:45:39 +00:00
|
|
|
vap->va_mode = VNOVAL;
|
|
|
|
vap->va_nlink = VNOVAL;
|
|
|
|
vap->va_uid = VNOVAL;
|
|
|
|
vap->va_gid = VNOVAL;
|
|
|
|
vap->va_fsid = VNOVAL;
|
|
|
|
vap->va_fileid = VNOVAL;
|
|
|
|
vap->va_blocksize = VNOVAL;
|
|
|
|
vap->va_rdev = VNOVAL;
|
|
|
|
vap->va_atime.tv_sec = VNOVAL;
|
|
|
|
vap->va_atime.tv_nsec = VNOVAL;
|
|
|
|
vap->va_mtime.tv_sec = VNOVAL;
|
|
|
|
vap->va_mtime.tv_nsec = VNOVAL;
|
|
|
|
vap->va_ctime.tv_sec = VNOVAL;
|
|
|
|
vap->va_ctime.tv_nsec = VNOVAL;
|
2002-07-17 02:03:19 +00:00
|
|
|
vap->va_birthtime.tv_sec = VNOVAL;
|
|
|
|
vap->va_birthtime.tv_nsec = VNOVAL;
|
1998-07-12 16:45:39 +00:00
|
|
|
vap->va_flags = VNOVAL;
|
|
|
|
vap->va_gen = VNOVAL;
|
1994-05-24 10:09:53 +00:00
|
|
|
vap->va_vaflags = 0;
|
|
|
|
}
|
|
|
|
|
2001-10-26 00:08:05 +00:00
|
|
|
/*
|
|
|
|
* This routine is called when we have too many vnodes. It attempts
|
|
|
|
* to free <count> vnodes and will potentially free vnodes that still
|
|
|
|
* have VM backing store (VM backing store is typically the cause
|
|
|
|
* of a vnode blowout so we want to do this). Therefore, this operation
|
|
|
|
* is not considered cheap.
|
|
|
|
*
|
|
|
|
* A number of conditions may prevent a vnode from being reclaimed.
|
|
|
|
* the buffer cache may have references on the vnode, a directory
|
|
|
|
* vnode may still have references due to the namei cache representing
|
|
|
|
* underlying files, or the vnode may be in active use. It is not
|
|
|
|
* desireable to reuse such vnodes. These conditions may cause the
|
|
|
|
* number of vnodes to reach some minimum value regardless of what
|
2001-12-18 20:48:54 +00:00
|
|
|
* you set kern.maxvnodes to. Do not set kern.maxvnodes too low.
|
2001-10-26 00:08:05 +00:00
|
|
|
*/
|
2001-12-18 20:48:54 +00:00
|
|
|
static int
|
2001-10-26 00:08:05 +00:00
|
|
|
vlrureclaim(struct mount *mp, int count)
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
2001-12-18 20:48:54 +00:00
|
|
|
int done;
|
2002-01-10 18:31:53 +00:00
|
|
|
int trigger;
|
|
|
|
int usevnodes;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate the trigger point, don't allow user
|
|
|
|
* screwups to blow us up. This prevents us from
|
|
|
|
* recycling vnodes with lots of resident pages. We
|
|
|
|
* aren't trying to free memory, we are trying to
|
|
|
|
* free vnodes.
|
|
|
|
*/
|
|
|
|
usevnodes = desiredvnodes;
|
|
|
|
if (usevnodes <= 0)
|
|
|
|
usevnodes = 1;
|
|
|
|
trigger = cnt.v_page_count * 2 / usevnodes;
|
2001-10-26 00:08:05 +00:00
|
|
|
|
2001-12-18 20:48:54 +00:00
|
|
|
done = 0;
|
2001-10-26 00:08:05 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
|
|
|
while (count && (vp = TAILQ_FIRST(&mp->mnt_nvnodelist)) != NULL) {
|
|
|
|
TAILQ_REMOVE(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
|
|
|
|
TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
|
|
|
|
|
|
|
|
if (vp->v_type != VNON &&
|
|
|
|
vp->v_type != VBAD &&
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_TRYLOCK(vp)) {
|
|
|
|
if (VMIGHTFREE(vp) && /* critical path opt */
|
|
|
|
(vp->v_object == NULL ||
|
|
|
|
vp->v_object->resident_page_count < trigger)) {
|
|
|
|
mtx_unlock(&mntvnode_mtx);
|
2001-10-26 00:08:05 +00:00
|
|
|
vgonel(vp, curthread);
|
2001-12-18 20:48:54 +00:00
|
|
|
done++;
|
2002-08-04 10:29:36 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
|
|
|
} else
|
|
|
|
VI_UNLOCK(vp);
|
2001-10-26 00:08:05 +00:00
|
|
|
}
|
|
|
|
--count;
|
|
|
|
}
|
|
|
|
mtx_unlock(&mntvnode_mtx);
|
2001-12-18 20:48:54 +00:00
|
|
|
return done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to recycle vnodes in a context that is always safe to block.
|
2002-05-16 21:28:32 +00:00
|
|
|
* Calling vlrurecycle() from the bowels of filesystem code has some
|
2001-12-18 20:48:54 +00:00
|
|
|
* interesting deadlock problems.
|
|
|
|
*/
|
|
|
|
static struct proc *vnlruproc;
|
|
|
|
static int vnlruproc_sig;
|
|
|
|
|
2002-06-06 15:46:38 +00:00
|
|
|
static void
|
2001-12-18 20:48:54 +00:00
|
|
|
vnlru_proc(void)
|
|
|
|
{
|
|
|
|
struct mount *mp, *nmp;
|
|
|
|
int s;
|
2002-12-29 10:39:05 +00:00
|
|
|
int done, take;
|
2001-12-18 20:48:54 +00:00
|
|
|
struct proc *p = vnlruproc;
|
2002-02-07 20:58:47 +00:00
|
|
|
struct thread *td = FIRST_THREAD_IN_PROC(p); /* XXXKSE */
|
2001-12-18 20:48:54 +00:00
|
|
|
|
|
|
|
mtx_lock(&Giant);
|
|
|
|
|
|
|
|
EVENTHANDLER_REGISTER(shutdown_pre_sync, kproc_shutdown, p,
|
2002-06-06 15:46:38 +00:00
|
|
|
SHUTDOWN_PRI_FIRST);
|
2001-12-18 20:48:54 +00:00
|
|
|
|
|
|
|
s = splbio();
|
|
|
|
for (;;) {
|
|
|
|
kthread_suspend_check(p);
|
2002-08-13 05:29:48 +00:00
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
2001-12-18 20:48:54 +00:00
|
|
|
if (numvnodes - freevnodes <= desiredvnodes * 9 / 10) {
|
2002-08-13 05:29:48 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
2001-12-18 20:48:54 +00:00
|
|
|
vnlruproc_sig = 0;
|
2002-12-29 10:39:05 +00:00
|
|
|
wakeup(&vnlruproc_sig);
|
2002-12-29 11:18:25 +00:00
|
|
|
tsleep(vnlruproc, PVFS, "vlruwt", hz);
|
2001-12-18 20:48:54 +00:00
|
|
|
continue;
|
|
|
|
}
|
2002-08-13 05:29:48 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
2001-12-18 20:48:54 +00:00
|
|
|
done = 0;
|
|
|
|
mtx_lock(&mountlist_mtx);
|
2002-12-29 10:39:05 +00:00
|
|
|
take = 0;
|
|
|
|
TAILQ_FOREACH(mp, &mountlist, mnt_list)
|
|
|
|
take++;
|
|
|
|
take = desiredvnodes / (take * 10);
|
2001-12-18 20:48:54 +00:00
|
|
|
for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
|
|
|
|
if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) {
|
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
|
|
|
continue;
|
|
|
|
}
|
2002-12-29 10:39:05 +00:00
|
|
|
done += vlrureclaim(mp, take);
|
2001-12-18 20:48:54 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
|
|
|
vfs_unbusy(mp, td);
|
|
|
|
}
|
|
|
|
mtx_unlock(&mountlist_mtx);
|
|
|
|
if (done == 0) {
|
2001-12-19 01:31:12 +00:00
|
|
|
#if 0
|
|
|
|
/* These messages are temporary debugging aids */
|
|
|
|
if (vnlru_nowhere < 5)
|
|
|
|
printf("vnlru process getting nowhere..\n");
|
|
|
|
else if (vnlru_nowhere == 5)
|
|
|
|
printf("vnlru process messages stopped.\n");
|
|
|
|
#endif
|
|
|
|
vnlru_nowhere++;
|
2001-12-25 01:23:25 +00:00
|
|
|
tsleep(vnlruproc, PPAUSE, "vlrup", hz * 3);
|
2001-12-18 20:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
splx(s);
|
2001-10-26 00:08:05 +00:00
|
|
|
}
|
|
|
|
|
2001-12-18 20:48:54 +00:00
|
|
|
static struct kproc_desc vnlru_kp = {
|
|
|
|
"vnlru",
|
|
|
|
vnlru_proc,
|
|
|
|
&vnlruproc
|
|
|
|
};
|
|
|
|
SYSINIT(vnlru, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &vnlru_kp)
|
|
|
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Routines having to do with the management of the vnode table.
|
|
|
|
*/
|
|
|
|
|
2002-08-05 10:15:56 +00:00
|
|
|
/*
|
2002-10-11 01:04:14 +00:00
|
|
|
* Check to see if a free vnode can be recycled. If it can,
|
|
|
|
* return it locked with the vn lock, but not interlock. Also
|
|
|
|
* get the vn_start_write lock. Otherwise indicate the error.
|
2002-08-05 10:15:56 +00:00
|
|
|
*/
|
|
|
|
static int
|
2002-10-11 01:04:14 +00:00
|
|
|
vcanrecycle(struct vnode *vp, struct mount **vnmpp)
|
2002-08-05 10:15:56 +00:00
|
|
|
{
|
|
|
|
struct thread *td = curthread;
|
|
|
|
vm_object_t object;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* Don't recycle if we can't get the interlock */
|
2002-09-25 02:22:21 +00:00
|
|
|
if (!VI_TRYLOCK(vp))
|
2002-08-05 10:15:56 +00:00
|
|
|
return (EWOULDBLOCK);
|
|
|
|
|
|
|
|
/* We should be able to immediately acquire this */
|
|
|
|
/* XXX This looks like it should panic if it fails */
|
2002-10-11 01:04:14 +00:00
|
|
|
if (vn_lock(vp, LK_INTERLOCK | LK_EXCLUSIVE, td) != 0) {
|
|
|
|
if (VOP_ISLOCKED(vp, td))
|
|
|
|
panic("vcanrecycle: locked vnode");
|
2002-08-05 10:15:56 +00:00
|
|
|
return (EWOULDBLOCK);
|
2002-10-11 01:04:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't recycle if its filesystem is being suspended.
|
|
|
|
*/
|
|
|
|
if (vn_start_write(vp, vnmpp, V_NOWAIT) != 0) {
|
|
|
|
error = EBUSY;
|
|
|
|
goto done;
|
|
|
|
}
|
2002-08-22 07:44:45 +00:00
|
|
|
|
2002-08-05 10:15:56 +00:00
|
|
|
/*
|
|
|
|
* Don't recycle if we still have cached pages.
|
|
|
|
*/
|
|
|
|
if (VOP_GETVOBJECT(vp, &object) == 0 &&
|
|
|
|
(object->resident_page_count ||
|
|
|
|
object->ref_count)) {
|
|
|
|
error = EBUSY;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (LIST_FIRST(&vp->v_cache_src)) {
|
|
|
|
/*
|
|
|
|
* note: nameileafonly sysctl is temporary,
|
|
|
|
* for debugging only, and will eventually be
|
|
|
|
* removed.
|
|
|
|
*/
|
|
|
|
if (nameileafonly > 0) {
|
|
|
|
/*
|
|
|
|
* Do not reuse namei-cached directory
|
|
|
|
* vnodes that have cached
|
|
|
|
* subdirectories.
|
|
|
|
*/
|
|
|
|
if (cache_leaf_test(vp) < 0) {
|
|
|
|
error = EISDIR;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
} else if (nameileafonly < 0 ||
|
|
|
|
vmiodirenable == 0) {
|
|
|
|
/*
|
|
|
|
* Do not reuse namei-cached directory
|
|
|
|
* vnodes if nameileafonly is -1 or
|
|
|
|
* if VMIO backing for directories is
|
|
|
|
* turned off (otherwise we reuse them
|
|
|
|
* too quickly).
|
|
|
|
*/
|
|
|
|
error = EBUSY;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
done:
|
|
|
|
VOP_UNLOCK(vp, 0, td);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Return the next vnode from the free list.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
getnewvnode(tag, mp, vops, vpp)
|
2002-09-14 09:02:28 +00:00
|
|
|
const char *tag;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mount *mp;
|
1995-11-09 08:17:23 +00:00
|
|
|
vop_t **vops;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vnode **vpp;
|
|
|
|
{
|
2001-10-26 00:08:05 +00:00
|
|
|
int s;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = curthread; /* XXX */
|
2000-07-04 04:32:40 +00:00
|
|
|
struct vnode *vp = NULL;
|
2002-12-08 05:06:50 +00:00
|
|
|
struct vpollinfo *pollinfo = NULL;
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *vnmp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-10-26 00:08:05 +00:00
|
|
|
s = splbio();
|
2002-08-13 05:29:48 +00:00
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
|
|
|
|
1995-03-09 20:27:04 +00:00
|
|
|
/*
|
2001-10-26 00:08:05 +00:00
|
|
|
* Try to reuse vnodes if we hit the max. This situation only
|
2001-12-18 20:48:54 +00:00
|
|
|
* occurs in certain large-memory (2G+) situations. We cannot
|
|
|
|
* attempt to directly reclaim vnodes due to nasty recursion
|
|
|
|
* problems.
|
2001-10-26 00:08:05 +00:00
|
|
|
*/
|
2002-12-29 10:39:05 +00:00
|
|
|
while (numvnodes - freevnodes > desiredvnodes) {
|
|
|
|
if (vnlruproc_sig == 0) {
|
|
|
|
vnlruproc_sig = 1; /* avoid unnecessary wakeups */
|
|
|
|
wakeup(vnlruproc);
|
|
|
|
}
|
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
|
|
|
tsleep(&vnlruproc_sig, PVFS, "vlruwk", hz);
|
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
2001-12-18 20:48:54 +00:00
|
|
|
}
|
2001-10-26 00:08:05 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to reuse a vnode already on the free list, allocating
|
|
|
|
* a new vnode if we can't find one or if we have not reached a
|
|
|
|
* good minimum for good LRU performance.
|
1995-03-09 20:27:04 +00:00
|
|
|
*/
|
1. Add a {pointer, v_id} pair to the vnode to store the reference to the
".." vnode. This is cheaper storagewise than keeping it in the
namecache, and it makes more sense since it's a 1:1 mapping.
2. Also handle the case of "." more intelligently rather than stuff
the namecache with pointless entries.
3. Add two lists to the vnode and hang namecache entries which go from
or to this vnode. When cleaning a vnode, delete all namecache
entries it invalidates.
4. Never reuse namecache enties, malloc new ones when we need it, free
old ones when they die. No longer a hard limit on how many we can
have.
5. Remove the upper limit on namelength of namecache entries.
6. Make a global list for negative namecache entries, limit their number
to a sysctl'able (debug.ncnegfactor) fraction of the total namecache.
Currently the default fraction is 1/16th. (Suggestions for better
default wanted!)
7. Assign v_id correctly in the face of 32bit rollover.
8. Remove the LRU list for namecache entries, not needed. Remove the
#ifdef NCH_STATISTICS stuff, it's not needed either.
9. Use the vnode freelist as a true LRU list, also for namecache accesses.
10. Reuse vnodes more aggresively but also more selectively, if we can't
reuse, malloc a new one. There is no longer a hard limit on their
number, they grow to the point where we don't reuse potentially
usable vnodes. A vnode will not get recycled if still has pages in
core or if it is the source of namecache entries (Yes, this does
indeed work :-) "." and ".." are not namecache entries any longer...)
11. Do not overload the v_id field in namecache entries with whiteout
information, use a char sized flags field instead, so we can get
rid of the vpid and v_id fields from the namecache struct. Since
we're linked to the vnodes and purged when they're cleaned, we don't
have to check the v_id any more.
12. NFS knew about the limitation on name length in the namecache, it
shouldn't and doesn't now.
Bugs:
The namecache statistics no longer includes the hits for ".."
and "." hits.
Performance impact:
Generally in the +/- 0.5% for "normal" workstations, but
I hope this will allow the system to be selftuning over a
bigger range of "special" applications. The case where
RAM is available but unused for cache because we don't have
any vnodes should be gone.
Future work:
Straighten out the namecache statistics.
"desiredvnodes" is still used to (bogusly ?) size hash
tables in the filesystems.
I have still to find a way to safely free unused vnodes
back so their number can shrink when not needed.
There is a few uses of the v_id field left in the filesystems,
scheduled for demolition at a later time.
Maybe a one slot cache for unused namecache entries should
be implemented to decrease the malloc/free frequency.
1997-05-04 09:17:38 +00:00
|
|
|
|
2001-10-26 00:08:05 +00:00
|
|
|
if (freevnodes >= wantfreevnodes && numvnodes >= minvnodes) {
|
2002-08-05 10:15:56 +00:00
|
|
|
int error;
|
2001-10-26 00:08:05 +00:00
|
|
|
int count;
|
|
|
|
|
2001-10-01 04:33:35 +00:00
|
|
|
for (count = 0; count < freevnodes; count++) {
|
|
|
|
vp = TAILQ_FIRST(&vnode_free_list);
|
|
|
|
|
2002-12-29 18:30:49 +00:00
|
|
|
KASSERT(vp->v_usecount == 0 &&
|
|
|
|
(vp->v_iflag & VI_DOINGINACT) == 0,
|
2002-08-05 10:15:56 +00:00
|
|
|
("getnewvnode: free vnode isn't"));
|
2002-05-07 02:44:06 +00:00
|
|
|
|
2002-08-05 10:15:56 +00:00
|
|
|
TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
|
2001-10-01 04:33:35 +00:00
|
|
|
/*
|
2002-08-05 10:15:56 +00:00
|
|
|
* We have to drop the free list mtx to avoid lock
|
|
|
|
* order reversals with interlock.
|
2001-10-01 04:33:35 +00:00
|
|
|
*/
|
2002-08-05 10:15:56 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
2002-10-11 01:04:14 +00:00
|
|
|
error = vcanrecycle(vp, &vnmp);
|
2002-08-05 10:15:56 +00:00
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
2002-10-14 19:54:39 +00:00
|
|
|
if (error == 0)
|
2001-10-01 04:33:35 +00:00
|
|
|
break;
|
2002-10-14 19:54:39 +00:00
|
|
|
TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
|
|
|
|
vp = NULL;
|
1996-01-19 04:00:31 +00:00
|
|
|
}
|
1. Add a {pointer, v_id} pair to the vnode to store the reference to the
".." vnode. This is cheaper storagewise than keeping it in the
namecache, and it makes more sense since it's a 1:1 mapping.
2. Also handle the case of "." more intelligently rather than stuff
the namecache with pointless entries.
3. Add two lists to the vnode and hang namecache entries which go from
or to this vnode. When cleaning a vnode, delete all namecache
entries it invalidates.
4. Never reuse namecache enties, malloc new ones when we need it, free
old ones when they die. No longer a hard limit on how many we can
have.
5. Remove the upper limit on namelength of namecache entries.
6. Make a global list for negative namecache entries, limit their number
to a sysctl'able (debug.ncnegfactor) fraction of the total namecache.
Currently the default fraction is 1/16th. (Suggestions for better
default wanted!)
7. Assign v_id correctly in the face of 32bit rollover.
8. Remove the LRU list for namecache entries, not needed. Remove the
#ifdef NCH_STATISTICS stuff, it's not needed either.
9. Use the vnode freelist as a true LRU list, also for namecache accesses.
10. Reuse vnodes more aggresively but also more selectively, if we can't
reuse, malloc a new one. There is no longer a hard limit on their
number, they grow to the point where we don't reuse potentially
usable vnodes. A vnode will not get recycled if still has pages in
core or if it is the source of namecache entries (Yes, this does
indeed work :-) "." and ".." are not namecache entries any longer...)
11. Do not overload the v_id field in namecache entries with whiteout
information, use a char sized flags field instead, so we can get
rid of the vpid and v_id fields from the namecache struct. Since
we're linked to the vnodes and purged when they're cleaned, we don't
have to check the v_id any more.
12. NFS knew about the limitation on name length in the namecache, it
shouldn't and doesn't now.
Bugs:
The namecache statistics no longer includes the hits for ".."
and "." hits.
Performance impact:
Generally in the +/- 0.5% for "normal" workstations, but
I hope this will allow the system to be selftuning over a
bigger range of "special" applications. The case where
RAM is available but unused for cache because we don't have
any vnodes should be gone.
Future work:
Straighten out the namecache statistics.
"desiredvnodes" is still used to (bogusly ?) size hash
tables in the filesystems.
I have still to find a way to safely free unused vnodes
back so their number can shrink when not needed.
There is a few uses of the v_id field left in the filesystems,
scheduled for demolition at a later time.
Maybe a one slot cache for unused namecache entries should
be implemented to decrease the malloc/free frequency.
1997-05-04 09:17:38 +00:00
|
|
|
}
|
|
|
|
if (vp) {
|
1995-03-09 20:27:04 +00:00
|
|
|
freevnodes--;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
2002-08-05 10:15:56 +00:00
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
cache_purge(vp);
|
|
|
|
VI_LOCK(vp);
|
2002-08-05 10:15:56 +00:00
|
|
|
vp->v_iflag |= VI_DOOMED;
|
|
|
|
vp->v_iflag &= ~VI_FREE;
|
1997-12-29 00:25:11 +00:00
|
|
|
if (vp->v_type != VBAD) {
|
2002-05-07 02:44:06 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
2002-09-25 02:22:21 +00:00
|
|
|
vgonel(vp, td);
|
|
|
|
VI_LOCK(vp);
|
1997-12-29 00:25:11 +00:00
|
|
|
} else {
|
2002-05-07 02:44:06 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(vnmp);
|
1996-01-19 04:00:31 +00:00
|
|
|
|
1999-01-08 17:31:30 +00:00
|
|
|
#ifdef INVARIANTS
|
1994-10-02 17:35:40 +00:00
|
|
|
{
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
if (vp->v_data)
|
|
|
|
panic("cleaned vnode isn't");
|
|
|
|
if (vp->v_numoutput)
|
|
|
|
panic("Clean vnode has pending I/O's");
|
2000-07-11 22:07:57 +00:00
|
|
|
if (vp->v_writecount != 0)
|
|
|
|
panic("Non-zero write count");
|
1994-10-02 17:35:40 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
2002-12-08 05:06:50 +00:00
|
|
|
if ((pollinfo = vp->v_pollinfo) != NULL) {
|
|
|
|
/*
|
|
|
|
* To avoid lock order reversals, the call to
|
|
|
|
* uma_zfree() must be delayed until the vnode
|
|
|
|
* interlock is released.
|
|
|
|
*/
|
2002-11-27 16:45:54 +00:00
|
|
|
vp->v_pollinfo = NULL;
|
2002-02-17 21:15:36 +00:00
|
|
|
}
|
2002-07-31 02:03:46 +00:00
|
|
|
#ifdef MAC
|
|
|
|
mac_destroy_vnode(vp);
|
|
|
|
#endif
|
2002-08-04 10:29:36 +00:00
|
|
|
vp->v_iflag = 0;
|
|
|
|
vp->v_vflag = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_lastw = 0;
|
|
|
|
vp->v_lasta = 0;
|
|
|
|
vp->v_cstart = 0;
|
|
|
|
vp->v_clen = 0;
|
|
|
|
vp->v_socket = 0;
|
2002-10-14 03:20:36 +00:00
|
|
|
lockdestroy(vp->v_vnlock);
|
|
|
|
lockinit(vp->v_vnlock, PVFS, tag, VLKTIMEOUT, LK_NOPAUSE);
|
2002-07-10 17:02:32 +00:00
|
|
|
KASSERT(vp->v_cleanblkroot == NULL, ("cleanblkroot not NULL"));
|
|
|
|
KASSERT(vp->v_dirtyblkroot == NULL, ("dirtyblkroot not NULL"));
|
1. Add a {pointer, v_id} pair to the vnode to store the reference to the
".." vnode. This is cheaper storagewise than keeping it in the
namecache, and it makes more sense since it's a 1:1 mapping.
2. Also handle the case of "." more intelligently rather than stuff
the namecache with pointless entries.
3. Add two lists to the vnode and hang namecache entries which go from
or to this vnode. When cleaning a vnode, delete all namecache
entries it invalidates.
4. Never reuse namecache enties, malloc new ones when we need it, free
old ones when they die. No longer a hard limit on how many we can
have.
5. Remove the upper limit on namelength of namecache entries.
6. Make a global list for negative namecache entries, limit their number
to a sysctl'able (debug.ncnegfactor) fraction of the total namecache.
Currently the default fraction is 1/16th. (Suggestions for better
default wanted!)
7. Assign v_id correctly in the face of 32bit rollover.
8. Remove the LRU list for namecache entries, not needed. Remove the
#ifdef NCH_STATISTICS stuff, it's not needed either.
9. Use the vnode freelist as a true LRU list, also for namecache accesses.
10. Reuse vnodes more aggresively but also more selectively, if we can't
reuse, malloc a new one. There is no longer a hard limit on their
number, they grow to the point where we don't reuse potentially
usable vnodes. A vnode will not get recycled if still has pages in
core or if it is the source of namecache entries (Yes, this does
indeed work :-) "." and ".." are not namecache entries any longer...)
11. Do not overload the v_id field in namecache entries with whiteout
information, use a char sized flags field instead, so we can get
rid of the vpid and v_id fields from the namecache struct. Since
we're linked to the vnodes and purged when they're cleaned, we don't
have to check the v_id any more.
12. NFS knew about the limitation on name length in the namecache, it
shouldn't and doesn't now.
Bugs:
The namecache statistics no longer includes the hits for ".."
and "." hits.
Performance impact:
Generally in the +/- 0.5% for "normal" workstations, but
I hope this will allow the system to be selftuning over a
bigger range of "special" applications. The case where
RAM is available but unused for cache because we don't have
any vnodes should be gone.
Future work:
Straighten out the namecache statistics.
"desiredvnodes" is still used to (bogusly ?) size hash
tables in the filesystems.
I have still to find a way to safely free unused vnodes
back so their number can shrink when not needed.
There is a few uses of the v_id field left in the filesystems,
scheduled for demolition at a later time.
Maybe a one slot cache for unused namecache entries should
be implemented to decrease the malloc/free frequency.
1997-05-04 09:17:38 +00:00
|
|
|
} else {
|
2002-08-05 10:15:56 +00:00
|
|
|
numvnodes++;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
2002-08-05 10:15:56 +00:00
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
vp = (struct vnode *) uma_zalloc(vnode_zone, M_WAITOK|M_ZERO);
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&vp->v_interlock, "vnode interlock", NULL, MTX_DEF);
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
1. Add a {pointer, v_id} pair to the vnode to store the reference to the
".." vnode. This is cheaper storagewise than keeping it in the
namecache, and it makes more sense since it's a 1:1 mapping.
2. Also handle the case of "." more intelligently rather than stuff
the namecache with pointless entries.
3. Add two lists to the vnode and hang namecache entries which go from
or to this vnode. When cleaning a vnode, delete all namecache
entries it invalidates.
4. Never reuse namecache enties, malloc new ones when we need it, free
old ones when they die. No longer a hard limit on how many we can
have.
5. Remove the upper limit on namelength of namecache entries.
6. Make a global list for negative namecache entries, limit their number
to a sysctl'able (debug.ncnegfactor) fraction of the total namecache.
Currently the default fraction is 1/16th. (Suggestions for better
default wanted!)
7. Assign v_id correctly in the face of 32bit rollover.
8. Remove the LRU list for namecache entries, not needed. Remove the
#ifdef NCH_STATISTICS stuff, it's not needed either.
9. Use the vnode freelist as a true LRU list, also for namecache accesses.
10. Reuse vnodes more aggresively but also more selectively, if we can't
reuse, malloc a new one. There is no longer a hard limit on their
number, they grow to the point where we don't reuse potentially
usable vnodes. A vnode will not get recycled if still has pages in
core or if it is the source of namecache entries (Yes, this does
indeed work :-) "." and ".." are not namecache entries any longer...)
11. Do not overload the v_id field in namecache entries with whiteout
information, use a char sized flags field instead, so we can get
rid of the vpid and v_id fields from the namecache struct. Since
we're linked to the vnodes and purged when they're cleaned, we don't
have to check the v_id any more.
12. NFS knew about the limitation on name length in the namecache, it
shouldn't and doesn't now.
Bugs:
The namecache statistics no longer includes the hits for ".."
and "." hits.
Performance impact:
Generally in the +/- 0.5% for "normal" workstations, but
I hope this will allow the system to be selftuning over a
bigger range of "special" applications. The case where
RAM is available but unused for cache because we don't have
any vnodes should be gone.
Future work:
Straighten out the namecache statistics.
"desiredvnodes" is still used to (bogusly ?) size hash
tables in the filesystems.
I have still to find a way to safely free unused vnodes
back so their number can shrink when not needed.
There is a few uses of the v_id field left in the filesystems,
scheduled for demolition at a later time.
Maybe a one slot cache for unused namecache entries should
be implemented to decrease the malloc/free frequency.
1997-05-04 09:17:38 +00:00
|
|
|
vp->v_dd = vp;
|
2002-10-14 03:20:36 +00:00
|
|
|
vp->v_vnlock = &vp->v_lock;
|
|
|
|
lockinit(vp->v_vnlock, PVFS, tag, VLKTIMEOUT, LK_NOPAUSE);
|
1997-08-31 07:32:39 +00:00
|
|
|
cache_purge(vp);
|
1. Add a {pointer, v_id} pair to the vnode to store the reference to the
".." vnode. This is cheaper storagewise than keeping it in the
namecache, and it makes more sense since it's a 1:1 mapping.
2. Also handle the case of "." more intelligently rather than stuff
the namecache with pointless entries.
3. Add two lists to the vnode and hang namecache entries which go from
or to this vnode. When cleaning a vnode, delete all namecache
entries it invalidates.
4. Never reuse namecache enties, malloc new ones when we need it, free
old ones when they die. No longer a hard limit on how many we can
have.
5. Remove the upper limit on namelength of namecache entries.
6. Make a global list for negative namecache entries, limit their number
to a sysctl'able (debug.ncnegfactor) fraction of the total namecache.
Currently the default fraction is 1/16th. (Suggestions for better
default wanted!)
7. Assign v_id correctly in the face of 32bit rollover.
8. Remove the LRU list for namecache entries, not needed. Remove the
#ifdef NCH_STATISTICS stuff, it's not needed either.
9. Use the vnode freelist as a true LRU list, also for namecache accesses.
10. Reuse vnodes more aggresively but also more selectively, if we can't
reuse, malloc a new one. There is no longer a hard limit on their
number, they grow to the point where we don't reuse potentially
usable vnodes. A vnode will not get recycled if still has pages in
core or if it is the source of namecache entries (Yes, this does
indeed work :-) "." and ".." are not namecache entries any longer...)
11. Do not overload the v_id field in namecache entries with whiteout
information, use a char sized flags field instead, so we can get
rid of the vpid and v_id fields from the namecache struct. Since
we're linked to the vnodes and purged when they're cleaned, we don't
have to check the v_id any more.
12. NFS knew about the limitation on name length in the namecache, it
shouldn't and doesn't now.
Bugs:
The namecache statistics no longer includes the hits for ".."
and "." hits.
Performance impact:
Generally in the +/- 0.5% for "normal" workstations, but
I hope this will allow the system to be selftuning over a
bigger range of "special" applications. The case where
RAM is available but unused for cache because we don't have
any vnodes should be gone.
Future work:
Straighten out the namecache statistics.
"desiredvnodes" is still used to (bogusly ?) size hash
tables in the filesystems.
I have still to find a way to safely free unused vnodes
back so their number can shrink when not needed.
There is a few uses of the v_id field left in the filesystems,
scheduled for demolition at a later time.
Maybe a one slot cache for unused namecache entries should
be implemented to decrease the malloc/free frequency.
1997-05-04 09:17:38 +00:00
|
|
|
LIST_INIT(&vp->v_cache_src);
|
|
|
|
TAILQ_INIT(&vp->v_cache_dst);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1. Add a {pointer, v_id} pair to the vnode to store the reference to the
".." vnode. This is cheaper storagewise than keeping it in the
namecache, and it makes more sense since it's a 1:1 mapping.
2. Also handle the case of "." more intelligently rather than stuff
the namecache with pointless entries.
3. Add two lists to the vnode and hang namecache entries which go from
or to this vnode. When cleaning a vnode, delete all namecache
entries it invalidates.
4. Never reuse namecache enties, malloc new ones when we need it, free
old ones when they die. No longer a hard limit on how many we can
have.
5. Remove the upper limit on namelength of namecache entries.
6. Make a global list for negative namecache entries, limit their number
to a sysctl'able (debug.ncnegfactor) fraction of the total namecache.
Currently the default fraction is 1/16th. (Suggestions for better
default wanted!)
7. Assign v_id correctly in the face of 32bit rollover.
8. Remove the LRU list for namecache entries, not needed. Remove the
#ifdef NCH_STATISTICS stuff, it's not needed either.
9. Use the vnode freelist as a true LRU list, also for namecache accesses.
10. Reuse vnodes more aggresively but also more selectively, if we can't
reuse, malloc a new one. There is no longer a hard limit on their
number, they grow to the point where we don't reuse potentially
usable vnodes. A vnode will not get recycled if still has pages in
core or if it is the source of namecache entries (Yes, this does
indeed work :-) "." and ".." are not namecache entries any longer...)
11. Do not overload the v_id field in namecache entries with whiteout
information, use a char sized flags field instead, so we can get
rid of the vpid and v_id fields from the namecache struct. Since
we're linked to the vnodes and purged when they're cleaned, we don't
have to check the v_id any more.
12. NFS knew about the limitation on name length in the namecache, it
shouldn't and doesn't now.
Bugs:
The namecache statistics no longer includes the hits for ".."
and "." hits.
Performance impact:
Generally in the +/- 0.5% for "normal" workstations, but
I hope this will allow the system to be selftuning over a
bigger range of "special" applications. The case where
RAM is available but unused for cache because we don't have
any vnodes should be gone.
Future work:
Straighten out the namecache statistics.
"desiredvnodes" is still used to (bogusly ?) size hash
tables in the filesystems.
I have still to find a way to safely free unused vnodes
back so their number can shrink when not needed.
There is a few uses of the v_id field left in the filesystems,
scheduled for demolition at a later time.
Maybe a one slot cache for unused namecache entries should
be implemented to decrease the malloc/free frequency.
1997-05-04 09:17:38 +00:00
|
|
|
|
1998-10-31 14:20:39 +00:00
|
|
|
TAILQ_INIT(&vp->v_cleanblkhd);
|
|
|
|
TAILQ_INIT(&vp->v_dirtyblkhd);
|
1995-02-27 06:50:08 +00:00
|
|
|
vp->v_type = VNON;
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_tag = tag;
|
|
|
|
vp->v_op = vops;
|
|
|
|
*vpp = vp;
|
|
|
|
vp->v_usecount = 1;
|
|
|
|
vp->v_data = 0;
|
2002-07-31 12:24:35 +00:00
|
|
|
vp->v_cachedid = -1;
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
2002-12-08 05:06:50 +00:00
|
|
|
if (pollinfo != NULL) {
|
|
|
|
mtx_destroy(&pollinfo->vpi_lock);
|
|
|
|
uma_zfree(vnodepoll_zone, pollinfo);
|
|
|
|
}
|
2002-09-30 20:51:48 +00:00
|
|
|
#ifdef MAC
|
|
|
|
mac_init_vnode(vp);
|
Slightly change the semantics of vnode labels for MAC: rather than
"refreshing" the label on the vnode before use, just get the label
right from inception. For single-label file systems, set the label
in the generic VFS getnewvnode() code; for multi-label file systems,
leave the labeling up to the file system. With UFS1/2, this means
reading the extended attribute during vfs_vget() as the inode is
pulled off disk, rather than hitting the extended attributes
frequently during operations later, improving performance. This
also corrects sematics for shared vnode locks, which were not
previously present in the system. This chances the cache
coherrency properties WRT out-of-band access to label data, but in
an acceptable form. With UFS1, there is a small race condition
during automatic extended attribute start -- this is not present
with UFS2, and occurs because EAs aren't available at vnode
inception. We'll introduce a work around for this shortly.
Approved by: re
Obtained from: TrustedBSD Project
Sponsored by: DARPA, Network Associates Laboratories
2002-10-26 14:38:24 +00:00
|
|
|
if (mp != NULL && (mp->mnt_flag & MNT_MULTILABEL) == 0)
|
|
|
|
mac_associate_vnode_singlelabel(mp, vp);
|
2002-09-30 20:51:48 +00:00
|
|
|
#endif
|
2002-09-25 02:22:21 +00:00
|
|
|
insmntque(vp, mp);
|
1998-02-23 06:59:52 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move a vnode from one mount queue to another.
|
|
|
|
*/
|
1997-11-22 08:35:46 +00:00
|
|
|
static void
|
1994-05-24 10:09:53 +00:00
|
|
|
insmntque(vp, mp)
|
|
|
|
register struct vnode *vp;
|
|
|
|
register struct mount *mp;
|
|
|
|
{
|
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Delete from old mount point vnode list, if on one.
|
|
|
|
*/
|
|
|
|
if (vp->v_mount != NULL)
|
2001-10-23 01:21:29 +00:00
|
|
|
TAILQ_REMOVE(&vp->v_mount->mnt_nvnodelist, vp, v_nmntvnodes);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Insert into list of vnodes for the new mount point, if available.
|
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
if ((vp->v_mount = mp) == NULL) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mntvnode_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
return;
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
2001-10-23 01:21:29 +00:00
|
|
|
TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mntvnode_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update outstanding I/O count and do wakeup if requested.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
vwakeup(bp)
|
|
|
|
register struct buf *bp;
|
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
|
|
|
|
bp->b_flags &= ~B_WRITEINPROG;
|
1994-09-25 19:34:02 +00:00
|
|
|
if ((vp = bp->b_vp)) {
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_numoutput--;
|
|
|
|
if (vp->v_numoutput < 0)
|
|
|
|
panic("vwakeup: neg numoutput");
|
2002-08-04 10:29:36 +00:00
|
|
|
if ((vp->v_numoutput == 0) && (vp->v_iflag & VI_BWAIT)) {
|
|
|
|
vp->v_iflag &= ~VI_BWAIT;
|
2002-06-28 23:17:36 +00:00
|
|
|
wakeup(&vp->v_numoutput);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush out and invalidate all buffers associated with a vnode.
|
|
|
|
* Called with the underlying object locked.
|
|
|
|
*/
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
vinvalbuf(vp, flags, cred, td, slpflag, slptimeo)
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
int flags;
|
|
|
|
struct ucred *cred;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
int slpflag, slptimeo;
|
|
|
|
{
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
struct buf *blist;
|
1994-05-24 10:09:53 +00:00
|
|
|
int s, error;
|
1994-08-29 06:09:15 +00:00
|
|
|
vm_object_t object;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-07-04 16:20:28 +00:00
|
|
|
GIANT_REQUIRED;
|
2001-05-19 01:28:09 +00:00
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
ASSERT_VOP_LOCKED(vp, "vinvalbuf");
|
|
|
|
|
|
|
|
VI_LOCK(vp);
|
1998-06-10 18:13:19 +00:00
|
|
|
if (flags & V_SAVE) {
|
|
|
|
s = splbio();
|
|
|
|
while (vp->v_numoutput) {
|
2002-08-04 10:29:36 +00:00
|
|
|
vp->v_iflag |= VI_BWAIT;
|
|
|
|
error = msleep(&vp->v_numoutput, VI_MTX(vp),
|
1998-12-22 00:44:11 +00:00
|
|
|
slpflag | (PRIBIO + 1), "vinvlbuf", slptimeo);
|
|
|
|
if (error) {
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1998-12-22 00:44:11 +00:00
|
|
|
splx(s);
|
|
|
|
return (error);
|
|
|
|
}
|
1998-06-10 18:13:19 +00:00
|
|
|
}
|
1998-10-31 14:20:39 +00:00
|
|
|
if (!TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
|
1998-06-10 18:13:19 +00:00
|
|
|
splx(s);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
2001-09-12 08:38:13 +00:00
|
|
|
if ((error = VOP_FSYNC(vp, cred, MNT_WAIT, td)) != 0)
|
1998-06-10 18:13:19 +00:00
|
|
|
return (error);
|
2002-08-04 10:29:36 +00:00
|
|
|
/*
|
|
|
|
* XXX We could save a lock/unlock if this was only
|
|
|
|
* enabled under INVARIANTS
|
|
|
|
*/
|
|
|
|
VI_LOCK(vp);
|
1998-06-10 18:13:19 +00:00
|
|
|
s = splbio();
|
|
|
|
if (vp->v_numoutput > 0 ||
|
1998-10-31 14:20:39 +00:00
|
|
|
!TAILQ_EMPTY(&vp->v_dirtyblkhd))
|
1998-06-10 18:13:19 +00:00
|
|
|
panic("vinvalbuf: dirty bufs");
|
|
|
|
}
|
|
|
|
splx(s);
|
2002-06-06 15:46:38 +00:00
|
|
|
}
|
1996-08-21 21:56:23 +00:00
|
|
|
s = splbio();
|
2002-09-25 02:22:21 +00:00
|
|
|
/*
|
|
|
|
* If you alter this loop please notice that interlock is dropped and
|
|
|
|
* reacquired in flushbuflist. Special care is needed to ensure that
|
|
|
|
* no race conditions occur from this.
|
|
|
|
*/
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
for (error = 0;;) {
|
|
|
|
if ((blist = TAILQ_FIRST(&vp->v_cleanblkhd)) != 0 &&
|
|
|
|
flushbuflist(blist, flags, vp, slpflag, slptimeo, &error)) {
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
continue;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
if ((blist = TAILQ_FIRST(&vp->v_dirtyblkhd)) != 0 &&
|
|
|
|
flushbuflist(blist, flags, vp, slpflag, slptimeo, &error)) {
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (error) {
|
|
|
|
splx(s);
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1994-08-29 06:09:15 +00:00
|
|
|
|
2001-10-05 20:10:32 +00:00
|
|
|
/*
|
|
|
|
* Wait for I/O to complete. XXX needs cleaning up. The vnode can
|
|
|
|
* have write I/O in-progress but if there is a VM object then the
|
|
|
|
* VM object can also have read-I/O in-progress.
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
while (vp->v_numoutput > 0) {
|
2002-08-04 10:29:36 +00:00
|
|
|
vp->v_iflag |= VI_BWAIT;
|
|
|
|
msleep(&vp->v_numoutput, VI_MTX(vp), PVM, "vnvlbv", 0);
|
2001-10-05 20:10:32 +00:00
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
2001-10-05 20:10:32 +00:00
|
|
|
if (VOP_GETVOBJECT(vp, &object) == 0) {
|
|
|
|
while (object->paging_in_progress)
|
|
|
|
vm_object_pip_sleep(object, "vnvlbx");
|
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
2001-10-05 20:10:32 +00:00
|
|
|
} while (vp->v_numoutput > 0);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1997-03-05 04:54:54 +00:00
|
|
|
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
splx(s);
|
|
|
|
|
1995-03-20 02:08:24 +00:00
|
|
|
/*
|
|
|
|
* Destroy the copy in the VM cache, too.
|
|
|
|
*/
|
2000-09-12 09:49:08 +00:00
|
|
|
if (VOP_GETVOBJECT(vp, &object) == 0) {
|
2002-12-15 05:41:56 +00:00
|
|
|
vm_object_lock(object);
|
1998-10-29 09:51:28 +00:00
|
|
|
vm_object_page_remove(object, 0, 0,
|
|
|
|
(flags & V_SAVE) ? TRUE : FALSE);
|
2002-12-15 05:41:56 +00:00
|
|
|
vm_object_unlock(object);
|
1994-08-29 06:09:15 +00:00
|
|
|
}
|
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
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
#ifdef INVARIANTS
|
|
|
|
VI_LOCK(vp);
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
if ((flags & (V_ALT | V_NORMAL)) == 0 &&
|
|
|
|
(!TAILQ_EMPTY(&vp->v_dirtyblkhd) ||
|
|
|
|
!TAILQ_EMPTY(&vp->v_cleanblkhd)))
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("vinvalbuf: flush failed");
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
/*
|
|
|
|
* Flush out buffers on the specified list.
|
2002-09-25 02:22:21 +00:00
|
|
|
*
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
flushbuflist(blist, flags, vp, slpflag, slptimeo, errorp)
|
|
|
|
struct buf *blist;
|
|
|
|
int flags;
|
|
|
|
struct vnode *vp;
|
|
|
|
int slpflag, slptimeo;
|
|
|
|
int *errorp;
|
|
|
|
{
|
|
|
|
struct buf *bp, *nbp;
|
|
|
|
int found, error;
|
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "flushbuflist");
|
2002-09-25 02:22:21 +00:00
|
|
|
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
for (found = 0, bp = blist; bp; bp = nbp) {
|
|
|
|
nbp = TAILQ_NEXT(bp, b_vnbufs);
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
if (((flags & V_NORMAL) && (bp->b_xflags & BX_ALTDATA)) ||
|
2002-09-25 02:22:21 +00:00
|
|
|
((flags & V_ALT) && (bp->b_xflags & BX_ALTDATA) == 0)) {
|
|
|
|
VI_LOCK(vp);
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
continue;
|
2002-09-25 02:22:21 +00:00
|
|
|
}
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
found += 1;
|
|
|
|
if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
|
|
|
|
error = BUF_TIMELOCK(bp,
|
|
|
|
LK_EXCLUSIVE | LK_SLEEPFAIL,
|
|
|
|
"flushbuf", slpflag, slptimeo);
|
|
|
|
if (error != ENOLCK)
|
|
|
|
*errorp = error;
|
2002-09-25 02:22:21 +00:00
|
|
|
goto done;
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* XXX Since there are no node locks for NFS, I
|
|
|
|
* believe there is a slight chance that a delayed
|
|
|
|
* write will occur while sleeping just above, so
|
|
|
|
* check for it. Note that vfs_bio_awrite expects
|
|
|
|
* buffers to reside on a queue, while BUF_WRITE and
|
|
|
|
* brelse do not.
|
|
|
|
*/
|
|
|
|
if (((bp->b_flags & (B_DELWRI | B_INVAL)) == B_DELWRI) &&
|
|
|
|
(flags & V_SAVE)) {
|
|
|
|
|
|
|
|
if (bp->b_vp == vp) {
|
|
|
|
if (bp->b_flags & B_CLUSTEROK) {
|
|
|
|
BUF_UNLOCK(bp);
|
|
|
|
vfs_bio_awrite(bp);
|
|
|
|
} else {
|
|
|
|
bremfree(bp);
|
|
|
|
bp->b_flags |= B_ASYNC;
|
|
|
|
BUF_WRITE(bp);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
bremfree(bp);
|
|
|
|
(void) BUF_WRITE(bp);
|
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
goto done;
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
}
|
|
|
|
bremfree(bp);
|
|
|
|
bp->b_flags |= (B_INVAL | B_NOCACHE | B_RELBUF);
|
|
|
|
bp->b_flags &= ~B_ASYNC;
|
|
|
|
brelse(bp);
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
}
|
|
|
|
return (found);
|
2002-09-25 02:22:21 +00:00
|
|
|
done:
|
|
|
|
VI_LOCK(vp);
|
|
|
|
return (found);
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
}
|
|
|
|
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
/*
|
|
|
|
* Truncate a file's buffer and pages to a specified length. This
|
|
|
|
* is in lieu of the old vinvalbuf mechanism, which performed unneeded
|
|
|
|
* sync activity.
|
|
|
|
*/
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
vtruncbuf(vp, cred, td, length, blksize)
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
register struct vnode *vp;
|
|
|
|
struct ucred *cred;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
off_t length;
|
|
|
|
int blksize;
|
|
|
|
{
|
|
|
|
register struct buf *bp;
|
1998-10-25 17:44:59 +00:00
|
|
|
struct buf *nbp;
|
|
|
|
int s, anyfreed;
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
int trunclbn;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Round up to the *next* lbn.
|
|
|
|
*/
|
1998-03-19 18:46:58 +00:00
|
|
|
trunclbn = (length + blksize - 1) / blksize;
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
|
|
|
|
s = splbio();
|
2002-09-25 02:22:21 +00:00
|
|
|
ASSERT_VOP_LOCKED(vp, "vtruncbuf");
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
restart:
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
anyfreed = 1;
|
|
|
|
for (;anyfreed;) {
|
|
|
|
anyfreed = 0;
|
1998-10-31 14:20:39 +00:00
|
|
|
for (bp = TAILQ_FIRST(&vp->v_cleanblkhd); bp; bp = nbp) {
|
|
|
|
nbp = TAILQ_NEXT(bp, b_vnbufs);
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
if (bp->b_lblkno >= trunclbn) {
|
1999-06-26 02:47:16 +00:00
|
|
|
if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
|
|
|
|
BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL);
|
In kern_physio.c fix tsleep priority messup.
In vfs_bio.c, remove b_generation count usage,
remove redundant reassignbuf,
remove redundant spl(s),
manage page PG_ZERO flags more correctly,
utilize in invalid value for b_offset until it
is properly initialized. Add asserts
for #ifdef DIAGNOSTIC, when b_offset is
improperly used.
when a process is not performing I/O, and just waiting
on a buffer generally, make the sleep priority
low.
only check page validity in getblk for B_VMIO buffers.
In vfs_cluster, add b_offset asserts, correct pointer calculation
for clustered reads. Improve readability of certain parts of
the code. Remove redundant spl(s).
In vfs_subr, correct usage of vfs_bio_awrite (From Andrew Gallatin
<gallatin@cs.duke.edu>). More vtruncbuf problems fixed.
1998-03-19 22:48:16 +00:00
|
|
|
goto restart;
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
} else {
|
|
|
|
bremfree(bp);
|
1999-06-26 02:47:16 +00:00
|
|
|
bp->b_flags |= (B_INVAL | B_RELBUF);
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
bp->b_flags &= ~B_ASYNC;
|
|
|
|
brelse(bp);
|
|
|
|
anyfreed = 1;
|
|
|
|
}
|
1999-12-22 03:11:04 +00:00
|
|
|
if (nbp &&
|
|
|
|
(((nbp->b_xflags & BX_VNCLEAN) == 0) ||
|
|
|
|
(nbp->b_vp != vp) ||
|
|
|
|
(nbp->b_flags & B_DELWRI))) {
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
}
|
|
|
|
|
1998-10-31 14:20:39 +00:00
|
|
|
for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
|
|
|
|
nbp = TAILQ_NEXT(bp, b_vnbufs);
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
if (bp->b_lblkno >= trunclbn) {
|
1999-06-26 02:47:16 +00:00
|
|
|
if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
|
|
|
|
BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL);
|
In kern_physio.c fix tsleep priority messup.
In vfs_bio.c, remove b_generation count usage,
remove redundant reassignbuf,
remove redundant spl(s),
manage page PG_ZERO flags more correctly,
utilize in invalid value for b_offset until it
is properly initialized. Add asserts
for #ifdef DIAGNOSTIC, when b_offset is
improperly used.
when a process is not performing I/O, and just waiting
on a buffer generally, make the sleep priority
low.
only check page validity in getblk for B_VMIO buffers.
In vfs_cluster, add b_offset asserts, correct pointer calculation
for clustered reads. Improve readability of certain parts of
the code. Remove redundant spl(s).
In vfs_subr, correct usage of vfs_bio_awrite (From Andrew Gallatin
<gallatin@cs.duke.edu>). More vtruncbuf problems fixed.
1998-03-19 22:48:16 +00:00
|
|
|
goto restart;
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
} else {
|
|
|
|
bremfree(bp);
|
1999-06-26 02:47:16 +00:00
|
|
|
bp->b_flags |= (B_INVAL | B_RELBUF);
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
bp->b_flags &= ~B_ASYNC;
|
|
|
|
brelse(bp);
|
|
|
|
anyfreed = 1;
|
|
|
|
}
|
1999-12-22 03:11:04 +00:00
|
|
|
if (nbp &&
|
|
|
|
(((nbp->b_xflags & BX_VNDIRTY) == 0) ||
|
|
|
|
(nbp->b_vp != vp) ||
|
|
|
|
(nbp->b_flags & B_DELWRI) == 0)) {
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
}
|
|
|
|
}
|
1998-03-17 06:30:52 +00:00
|
|
|
|
In kern_physio.c fix tsleep priority messup.
In vfs_bio.c, remove b_generation count usage,
remove redundant reassignbuf,
remove redundant spl(s),
manage page PG_ZERO flags more correctly,
utilize in invalid value for b_offset until it
is properly initialized. Add asserts
for #ifdef DIAGNOSTIC, when b_offset is
improperly used.
when a process is not performing I/O, and just waiting
on a buffer generally, make the sleep priority
low.
only check page validity in getblk for B_VMIO buffers.
In vfs_cluster, add b_offset asserts, correct pointer calculation
for clustered reads. Improve readability of certain parts of
the code. Remove redundant spl(s).
In vfs_subr, correct usage of vfs_bio_awrite (From Andrew Gallatin
<gallatin@cs.duke.edu>). More vtruncbuf problems fixed.
1998-03-19 22:48:16 +00:00
|
|
|
if (length > 0) {
|
|
|
|
restartsync:
|
1998-10-31 14:20:39 +00:00
|
|
|
for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
|
|
|
|
nbp = TAILQ_NEXT(bp, b_vnbufs);
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
1998-03-17 06:30:52 +00:00
|
|
|
if ((bp->b_flags & B_DELWRI) && (bp->b_lblkno < 0)) {
|
1999-06-26 02:47:16 +00:00
|
|
|
if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
|
|
|
|
BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL);
|
|
|
|
goto restart;
|
1998-03-17 06:30:52 +00:00
|
|
|
} else {
|
|
|
|
bremfree(bp);
|
In kern_physio.c fix tsleep priority messup.
In vfs_bio.c, remove b_generation count usage,
remove redundant reassignbuf,
remove redundant spl(s),
manage page PG_ZERO flags more correctly,
utilize in invalid value for b_offset until it
is properly initialized. Add asserts
for #ifdef DIAGNOSTIC, when b_offset is
improperly used.
when a process is not performing I/O, and just waiting
on a buffer generally, make the sleep priority
low.
only check page validity in getblk for B_VMIO buffers.
In vfs_cluster, add b_offset asserts, correct pointer calculation
for clustered reads. Improve readability of certain parts of
the code. Remove redundant spl(s).
In vfs_subr, correct usage of vfs_bio_awrite (From Andrew Gallatin
<gallatin@cs.duke.edu>). More vtruncbuf problems fixed.
1998-03-19 22:48:16 +00:00
|
|
|
if (bp->b_vp == vp) {
|
|
|
|
bp->b_flags |= B_ASYNC;
|
|
|
|
} else {
|
|
|
|
bp->b_flags &= ~B_ASYNC;
|
|
|
|
}
|
2000-03-20 11:29:10 +00:00
|
|
|
BUF_WRITE(bp);
|
1998-03-17 06:30:52 +00:00
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
In kern_physio.c fix tsleep priority messup.
In vfs_bio.c, remove b_generation count usage,
remove redundant reassignbuf,
remove redundant spl(s),
manage page PG_ZERO flags more correctly,
utilize in invalid value for b_offset until it
is properly initialized. Add asserts
for #ifdef DIAGNOSTIC, when b_offset is
improperly used.
when a process is not performing I/O, and just waiting
on a buffer generally, make the sleep priority
low.
only check page validity in getblk for B_VMIO buffers.
In vfs_cluster, add b_offset asserts, correct pointer calculation
for clustered reads. Improve readability of certain parts of
the code. Remove redundant spl(s).
In vfs_subr, correct usage of vfs_bio_awrite (From Andrew Gallatin
<gallatin@cs.duke.edu>). More vtruncbuf problems fixed.
1998-03-19 22:48:16 +00:00
|
|
|
goto restartsync;
|
1998-03-17 06:30:52 +00:00
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
1998-03-17 06:30:52 +00:00
|
|
|
}
|
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
|
1998-03-17 06:30:52 +00:00
|
|
|
while (vp->v_numoutput > 0) {
|
2002-08-04 10:29:36 +00:00
|
|
|
vp->v_iflag |= VI_BWAIT;
|
|
|
|
msleep(&vp->v_numoutput, VI_MTX(vp), PVM, "vbtrunc", 0);
|
1998-03-17 06:30:52 +00:00
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
Some VM improvements, including elimination of alot of Sig-11
problems. Tor Egge and others have helped with various VM bugs
lately, but don't blame him -- blame me!!!
pmap.c:
1) Create an object for kernel page table allocations. This
fixes a bogus allocation method previously used for such, by
grabbing pages from the kernel object, using bogus pindexes.
(This was a code cleanup, and perhaps a minor system stability
issue.)
pmap.c:
2) Pre-set the modify and accessed bits when prudent. This will
decrease bus traffic under certain circumstances.
vfs_bio.c, vfs_cluster.c:
3) Rather than calculating the beginning virtual byte offset
multiple times, stick the offset into the buffer header, so
that the calculated offset can be reused. (Long long multiplies
are often expensive, and this is a probably unmeasurable performance
improvement, and code cleanup.)
vfs_bio.c:
4) Handle write recursion more intelligently (but not perfectly) so
that it is less likely to cause a system panic, and is also
much more robust.
vfs_bio.c:
5) getblk incorrectly wrote out blocks that are incorrectly sized.
The problem is fixed, and writes blocks out ONLY when B_DELWRI
is true.
vfs_bio.c:
6) Check that already constituted buffers have fully valid pages. If
not, then make sure that the B_CACHE bit is not set. (This was
a major source of Sig-11 type problems.)
vfs_bio.c:
7) Fix a potential system deadlock due to an incorrectly specified
sleep priority while waiting for a buffer write operation. The
change that I made opens the system up to serious problems, and
we need to examine the issue of process sleep priorities.
vfs_cluster.c, vfs_bio.c:
8) Make clustered reads work more correctly (and more completely)
when buffers are already constituted, but not fully valid.
(This was another system reliability issue.)
vfs_subr.c, ffs_inode.c:
9) Create a vtruncbuf function, which is used by filesystems that
can truncate files. The vinvalbuf forced a file sync type operation,
while vtruncbuf only invalidates the buffers past the new end of file,
and also invalidates the appropriate pages. (This was a system reliabiliy
and performance issue.)
10) Modify FFS to use vtruncbuf.
vm_object.c:
11) Make the object rundown mechanism for OBJT_VNODE type objects work
more correctly. Included in that fix, create pager entries for
the OBJT_DEAD pager type, so that paging requests that might slip
in during race conditions are properly handled. (This was a system
reliability issue.)
vm_page.c:
12) Make some of the page validation routines be a little less picky
about arguments passed to them. Also, support page invalidation
change the object generation count so that we handle generation
counts a little more robustly.
vm_pageout.c:
13) Further reduce pageout daemon activity when the system doesn't
need help from it. There should be no additional performance
decrease even when the pageout daemon is running. (This was
a significant performance issue.)
vnode_pager.c:
14) Teach the vnode pager to handle race conditions during vnode
deallocations.
1998-03-16 01:56:03 +00:00
|
|
|
splx(s);
|
|
|
|
|
|
|
|
vnode_pager_setsize(vp, length);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2002-07-10 17:02:32 +00:00
|
|
|
/*
|
|
|
|
* buf_splay() - splay tree core for the clean/dirty list of buffers in
|
|
|
|
* a vnode.
|
|
|
|
*
|
|
|
|
* NOTE: We have to deal with the special case of a background bitmap
|
|
|
|
* buffer, a situation where two buffers will have the same logical
|
|
|
|
* block offset. We want (1) only the foreground buffer to be accessed
|
|
|
|
* in a lookup and (2) must differentiate between the foreground and
|
|
|
|
* background buffer in the splay tree algorithm because the splay
|
|
|
|
* tree cannot normally handle multiple entities with the same 'index'.
|
|
|
|
* We accomplish this by adding differentiating flags to the splay tree's
|
|
|
|
* numerical domain.
|
|
|
|
*/
|
|
|
|
static
|
|
|
|
struct buf *
|
|
|
|
buf_splay(daddr_t lblkno, b_xflags_t xflags, struct buf *root)
|
|
|
|
{
|
|
|
|
struct buf dummy;
|
|
|
|
struct buf *lefttreemax, *righttreemin, *y;
|
|
|
|
|
|
|
|
if (root == NULL)
|
|
|
|
return (NULL);
|
|
|
|
lefttreemax = righttreemin = &dummy;
|
|
|
|
for (;;) {
|
|
|
|
if (lblkno < root->b_lblkno ||
|
|
|
|
(lblkno == root->b_lblkno &&
|
|
|
|
(xflags & BX_BKGRDMARKER) < (root->b_xflags & BX_BKGRDMARKER))) {
|
|
|
|
if ((y = root->b_left) == NULL)
|
|
|
|
break;
|
|
|
|
if (lblkno < y->b_lblkno) {
|
|
|
|
/* Rotate right. */
|
|
|
|
root->b_left = y->b_right;
|
|
|
|
y->b_right = root;
|
|
|
|
root = y;
|
|
|
|
if ((y = root->b_left) == NULL)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Link into the new root's right tree. */
|
|
|
|
righttreemin->b_left = root;
|
|
|
|
righttreemin = root;
|
|
|
|
} else if (lblkno > root->b_lblkno ||
|
|
|
|
(lblkno == root->b_lblkno &&
|
|
|
|
(xflags & BX_BKGRDMARKER) > (root->b_xflags & BX_BKGRDMARKER))) {
|
|
|
|
if ((y = root->b_right) == NULL)
|
|
|
|
break;
|
|
|
|
if (lblkno > y->b_lblkno) {
|
|
|
|
/* Rotate left. */
|
|
|
|
root->b_right = y->b_left;
|
|
|
|
y->b_left = root;
|
|
|
|
root = y;
|
|
|
|
if ((y = root->b_right) == NULL)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Link into the new root's left tree. */
|
|
|
|
lefttreemax->b_right = root;
|
|
|
|
lefttreemax = root;
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
root = y;
|
|
|
|
}
|
|
|
|
/* Assemble the new root. */
|
|
|
|
lefttreemax->b_right = root->b_left;
|
|
|
|
righttreemin->b_left = root->b_right;
|
|
|
|
root->b_left = dummy.b_right;
|
|
|
|
root->b_right = dummy.b_left;
|
|
|
|
return (root);
|
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
void
|
|
|
|
buf_vlist_remove(struct buf *bp)
|
|
|
|
{
|
|
|
|
struct vnode *vp = bp->b_vp;
|
|
|
|
struct buf *root;
|
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "buf_vlist_remove");
|
2002-07-10 17:02:32 +00:00
|
|
|
if (bp->b_xflags & BX_VNDIRTY) {
|
|
|
|
if (bp != vp->v_dirtyblkroot) {
|
|
|
|
root = buf_splay(bp->b_lblkno, bp->b_xflags, vp->v_dirtyblkroot);
|
|
|
|
KASSERT(root == bp, ("splay lookup failed during dirty remove"));
|
|
|
|
}
|
|
|
|
if (bp->b_left == NULL) {
|
|
|
|
root = bp->b_right;
|
|
|
|
} else {
|
|
|
|
root = buf_splay(bp->b_lblkno, bp->b_xflags, bp->b_left);
|
|
|
|
root->b_right = bp->b_right;
|
|
|
|
}
|
|
|
|
vp->v_dirtyblkroot = root;
|
|
|
|
TAILQ_REMOVE(&vp->v_dirtyblkhd, bp, b_vnbufs);
|
|
|
|
} else {
|
|
|
|
/* KASSERT(bp->b_xflags & BX_VNCLEAN, ("bp wasn't clean")); */
|
|
|
|
if (bp != vp->v_cleanblkroot) {
|
|
|
|
root = buf_splay(bp->b_lblkno, bp->b_xflags, vp->v_cleanblkroot);
|
|
|
|
KASSERT(root == bp, ("splay lookup failed during clean remove"));
|
|
|
|
}
|
|
|
|
if (bp->b_left == NULL) {
|
|
|
|
root = bp->b_right;
|
|
|
|
} else {
|
|
|
|
root = buf_splay(bp->b_lblkno, bp->b_xflags, bp->b_left);
|
|
|
|
root->b_right = bp->b_right;
|
|
|
|
}
|
|
|
|
vp->v_cleanblkroot = root;
|
|
|
|
TAILQ_REMOVE(&vp->v_cleanblkhd, bp, b_vnbufs);
|
|
|
|
}
|
|
|
|
bp->b_xflags &= ~(BX_VNDIRTY | BX_VNCLEAN);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add the buffer to the sorted clean or dirty block list using a
|
|
|
|
* splay tree algorithm.
|
|
|
|
*
|
|
|
|
* NOTE: xflags is passed as a constant, optimizing this inline function!
|
|
|
|
*/
|
|
|
|
static
|
|
|
|
void
|
|
|
|
buf_vlist_add(struct buf *bp, struct vnode *vp, b_xflags_t xflags)
|
|
|
|
{
|
|
|
|
struct buf *root;
|
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "buf_vlist_add");
|
2002-07-10 17:02:32 +00:00
|
|
|
bp->b_xflags |= xflags;
|
|
|
|
if (xflags & BX_VNDIRTY) {
|
|
|
|
root = buf_splay(bp->b_lblkno, bp->b_xflags, vp->v_dirtyblkroot);
|
|
|
|
if (root == NULL) {
|
|
|
|
bp->b_left = NULL;
|
|
|
|
bp->b_right = NULL;
|
|
|
|
TAILQ_INSERT_TAIL(&vp->v_dirtyblkhd, bp, b_vnbufs);
|
|
|
|
} else if (bp->b_lblkno < root->b_lblkno ||
|
|
|
|
(bp->b_lblkno == root->b_lblkno &&
|
|
|
|
(bp->b_xflags & BX_BKGRDMARKER) < (root->b_xflags & BX_BKGRDMARKER))) {
|
|
|
|
bp->b_left = root->b_left;
|
|
|
|
bp->b_right = root;
|
|
|
|
root->b_left = NULL;
|
|
|
|
TAILQ_INSERT_BEFORE(root, bp, b_vnbufs);
|
|
|
|
} else {
|
|
|
|
bp->b_right = root->b_right;
|
|
|
|
bp->b_left = root;
|
|
|
|
root->b_right = NULL;
|
|
|
|
TAILQ_INSERT_AFTER(&vp->v_dirtyblkhd,
|
|
|
|
root, bp, b_vnbufs);
|
|
|
|
}
|
|
|
|
vp->v_dirtyblkroot = bp;
|
|
|
|
} else {
|
|
|
|
/* KASSERT(xflags & BX_VNCLEAN, ("xflags not clean")); */
|
|
|
|
root = buf_splay(bp->b_lblkno, bp->b_xflags, vp->v_cleanblkroot);
|
|
|
|
if (root == NULL) {
|
|
|
|
bp->b_left = NULL;
|
|
|
|
bp->b_right = NULL;
|
|
|
|
TAILQ_INSERT_TAIL(&vp->v_cleanblkhd, bp, b_vnbufs);
|
|
|
|
} else if (bp->b_lblkno < root->b_lblkno ||
|
|
|
|
(bp->b_lblkno == root->b_lblkno &&
|
|
|
|
(bp->b_xflags & BX_BKGRDMARKER) < (root->b_xflags & BX_BKGRDMARKER))) {
|
|
|
|
bp->b_left = root->b_left;
|
|
|
|
bp->b_right = root;
|
|
|
|
root->b_left = NULL;
|
|
|
|
TAILQ_INSERT_BEFORE(root, bp, b_vnbufs);
|
|
|
|
} else {
|
|
|
|
bp->b_right = root->b_right;
|
|
|
|
bp->b_left = root;
|
|
|
|
root->b_right = NULL;
|
|
|
|
TAILQ_INSERT_AFTER(&vp->v_cleanblkhd,
|
|
|
|
root, bp, b_vnbufs);
|
|
|
|
}
|
|
|
|
vp->v_cleanblkroot = bp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef USE_BUFHASH
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lookup a buffer using the splay tree. Note that we specifically avoid
|
|
|
|
* shadow buffers used in background bitmap writes.
|
|
|
|
*
|
|
|
|
* This code isn't quite efficient as it could be because we are maintaining
|
|
|
|
* two sorted lists and do not know which list the block resides in.
|
|
|
|
*/
|
|
|
|
struct buf *
|
|
|
|
gbincore(struct vnode *vp, daddr_t lblkno)
|
|
|
|
{
|
|
|
|
struct buf *bp;
|
|
|
|
|
|
|
|
GIANT_REQUIRED;
|
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "gbincore");
|
2002-07-10 17:02:32 +00:00
|
|
|
bp = vp->v_cleanblkroot = buf_splay(lblkno, 0, vp->v_cleanblkroot);
|
|
|
|
if (bp && bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
|
|
|
|
return(bp);
|
|
|
|
bp = vp->v_dirtyblkroot = buf_splay(lblkno, 0, vp->v_dirtyblkroot);
|
|
|
|
if (bp && bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
|
|
|
|
return(bp);
|
|
|
|
return(NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Associate a buffer with a vnode.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
bgetvp(vp, bp)
|
|
|
|
register struct vnode *vp;
|
|
|
|
register struct buf *bp;
|
|
|
|
{
|
1994-12-23 04:52:55 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(bp->b_vp == NULL, ("bgetvp: not free"));
|
1999-01-10 01:58:29 +00:00
|
|
|
|
2002-07-10 17:02:32 +00:00
|
|
|
KASSERT((bp->b_xflags & (BX_VNDIRTY|BX_VNCLEAN)) == 0,
|
|
|
|
("bgetvp: bp already attached! %p", bp));
|
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
|
|
|
vholdl(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
bp->b_vp = vp;
|
1999-08-25 12:24:39 +00:00
|
|
|
bp->b_dev = vn_todev(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Insert onto list for new vnode.
|
|
|
|
*/
|
1994-12-23 04:52:55 +00:00
|
|
|
s = splbio();
|
2002-07-10 17:02:32 +00:00
|
|
|
buf_vlist_add(bp, vp, BX_VNCLEAN);
|
1994-12-23 04:52:55 +00:00
|
|
|
splx(s);
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disassociate a buffer from a vnode.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
brelvp(bp)
|
|
|
|
register struct buf *bp;
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
1994-12-23 04:52:55 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(bp->b_vp != NULL, ("brelvp: NULL"));
|
1997-12-29 00:25:11 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Delete from old vnode list, if on one.
|
|
|
|
*/
|
1998-03-08 09:59:44 +00:00
|
|
|
vp = bp->b_vp;
|
1994-12-23 04:52:55 +00:00
|
|
|
s = splbio();
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
2002-07-10 17:02:32 +00:00
|
|
|
if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN))
|
|
|
|
buf_vlist_remove(bp);
|
2002-08-04 10:29:36 +00:00
|
|
|
if ((vp->v_iflag & VI_ONWORKLST) && TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
|
|
|
|
vp->v_iflag &= ~VI_ONWORKLST;
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
LIST_REMOVE(vp, v_synclist);
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
vdropl(vp);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
bp->b_vp = (struct vnode *) 0;
|
2002-07-06 21:27:20 +00:00
|
|
|
if (bp->b_object)
|
2002-07-06 08:59:52 +00:00
|
|
|
bp->b_object = NULL;
|
2002-09-25 02:22:21 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1998-03-08 09:59:44 +00:00
|
|
|
/*
|
|
|
|
* Add an item to the syncer work queue.
|
|
|
|
*/
|
1999-02-19 17:36:58 +00:00
|
|
|
static void
|
|
|
|
vn_syncer_add_to_worklist(struct vnode *vp, int delay)
|
1998-03-08 09:59:44 +00:00
|
|
|
{
|
|
|
|
int s, slot;
|
|
|
|
|
|
|
|
s = splbio();
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "vn_syncer_add_to_worklist");
|
1998-03-08 09:59:44 +00:00
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_iflag & VI_ONWORKLST)
|
1998-03-08 09:59:44 +00:00
|
|
|
LIST_REMOVE(vp, v_synclist);
|
2002-08-04 10:29:36 +00:00
|
|
|
else
|
|
|
|
vp->v_iflag |= VI_ONWORKLST;
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
if (delay > syncer_maxdelay - 2)
|
|
|
|
delay = syncer_maxdelay - 2;
|
|
|
|
slot = (syncer_delayno + delay) & syncer_mask;
|
|
|
|
|
|
|
|
LIST_INSERT_HEAD(&syncer_workitem_pending[slot], vp, v_synclist);
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
2002-08-04 10:29:36 +00:00
|
|
|
|
1998-03-08 09:59:44 +00:00
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
1999-03-12 02:24:58 +00:00
|
|
|
struct proc *updateproc;
|
2002-03-19 21:25:46 +00:00
|
|
|
static void sched_sync(void);
|
1999-07-01 13:21:46 +00:00
|
|
|
static struct kproc_desc up_kp = {
|
1998-03-08 09:59:44 +00:00
|
|
|
"syncer",
|
|
|
|
sched_sync,
|
|
|
|
&updateproc
|
|
|
|
};
|
1999-07-01 13:21:46 +00:00
|
|
|
SYSINIT(syncer, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &up_kp)
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* System filesystem synchronizer daemon.
|
|
|
|
*/
|
2002-09-28 17:15:38 +00:00
|
|
|
static void
|
1998-03-08 09:59:44 +00:00
|
|
|
sched_sync(void)
|
|
|
|
{
|
|
|
|
struct synclist *slp;
|
|
|
|
struct vnode *vp;
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
1998-03-08 09:59:44 +00:00
|
|
|
long starttime;
|
|
|
|
int s;
|
2002-02-07 20:58:47 +00:00
|
|
|
struct thread *td = FIRST_THREAD_IN_PROC(updateproc); /* XXXKSE */
|
1998-03-08 09:59:44 +00:00
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&Giant);
|
2000-09-07 01:33:02 +00:00
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
EVENTHANDLER_REGISTER(shutdown_pre_sync, kproc_shutdown, td->td_proc,
|
2002-06-06 15:46:38 +00:00
|
|
|
SHUTDOWN_PRI_LAST);
|
2000-01-07 08:36:44 +00:00
|
|
|
|
1998-03-08 09:59:44 +00:00
|
|
|
for (;;) {
|
2001-09-12 08:38:13 +00:00
|
|
|
kthread_suspend_check(td->td_proc);
|
2000-01-07 08:36:44 +00:00
|
|
|
|
1998-03-30 09:56:58 +00:00
|
|
|
starttime = time_second;
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
/*
|
1999-02-19 17:36:58 +00:00
|
|
|
* Push files whose dirty time has expired. Be careful
|
|
|
|
* of interrupt race on slp queue.
|
1998-03-08 09:59:44 +00:00
|
|
|
*/
|
|
|
|
s = splbio();
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
slp = &syncer_workitem_pending[syncer_delayno];
|
|
|
|
syncer_delayno += 1;
|
|
|
|
if (syncer_delayno == syncer_maxdelay)
|
|
|
|
syncer_delayno = 0;
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
while ((vp = LIST_FIRST(slp)) != NULL) {
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
2000-07-11 22:07:57 +00:00
|
|
|
if (VOP_ISLOCKED(vp, NULL) == 0 &&
|
|
|
|
vn_start_write(vp, &mp, V_NOWAIT) == 0) {
|
2001-09-12 08:38:13 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
|
2002-02-27 18:32:23 +00:00
|
|
|
(void) VOP_FSYNC(vp, td->td_ucred, MNT_LAZY, td);
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
1999-03-12 02:24:58 +00:00
|
|
|
}
|
1999-02-19 17:36:58 +00:00
|
|
|
s = splbio();
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
if (LIST_FIRST(slp) == vp) {
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
1999-03-12 02:24:58 +00:00
|
|
|
/*
|
2002-09-14 09:02:28 +00:00
|
|
|
* Note: VFS vnodes can remain on the
|
2002-06-06 15:46:38 +00:00
|
|
|
* worklist too with no dirty blocks, but
|
|
|
|
* since sync_fsync() moves it to a different
|
1999-03-12 02:24:58 +00:00
|
|
|
* slot we are safe.
|
|
|
|
*/
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
1998-10-31 14:20:39 +00:00
|
|
|
if (TAILQ_EMPTY(&vp->v_dirtyblkhd) &&
|
2002-09-14 09:02:28 +00:00
|
|
|
!vn_isdisk(vp, NULL)) {
|
|
|
|
panic("sched_sync: fsync failed "
|
|
|
|
"vp %p tag %s", vp, vp->v_tag);
|
|
|
|
}
|
1998-03-08 09:59:44 +00:00
|
|
|
/*
|
1999-02-19 17:36:58 +00:00
|
|
|
* Put us back on the worklist. The worklist
|
|
|
|
* routine will remove us from our current
|
|
|
|
* position and then add us back in at a later
|
|
|
|
* position.
|
1998-03-08 09:59:44 +00:00
|
|
|
*/
|
|
|
|
vn_syncer_add_to_worklist(vp, syncdelay);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
1999-02-19 17:36:58 +00:00
|
|
|
splx(s);
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Do soft update processing.
|
|
|
|
*/
|
2002-07-01 17:59:40 +00:00
|
|
|
if (softdep_process_worklist_hook != NULL)
|
|
|
|
(*softdep_process_worklist_hook)(NULL);
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The variable rushjob allows the kernel to speed up the
|
|
|
|
* processing of the filesystem syncer process. A rushjob
|
|
|
|
* value of N tells the filesystem syncer to process the next
|
|
|
|
* N seconds worth of work on its queue ASAP. Currently rushjob
|
|
|
|
* is used by the soft update code to speed up the filesystem
|
|
|
|
* syncer process when the incore state is getting so far
|
|
|
|
* ahead of the disk that the kernel memory pool is being
|
|
|
|
* threatened with exhaustion.
|
|
|
|
*/
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
if (rushjob > 0) {
|
|
|
|
rushjob -= 1;
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
continue;
|
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
/*
|
|
|
|
* If it has taken us less than a second to process the
|
|
|
|
* current work, then wait. Otherwise start right over
|
|
|
|
* again. We can still lose time if any single round
|
|
|
|
* takes more than two seconds, but it does not really
|
|
|
|
* matter as we are just trying to generally pace the
|
|
|
|
* filesystem activity.
|
|
|
|
*/
|
1998-03-30 09:56:58 +00:00
|
|
|
if (time_second == starttime)
|
1998-03-08 09:59:44 +00:00
|
|
|
tsleep(&lbolt, PPAUSE, "syncer", 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-06-15 23:37:29 +00:00
|
|
|
/*
|
|
|
|
* Request the syncer daemon to speed up its work.
|
|
|
|
* We never push it to speed up more than half of its
|
|
|
|
* normal turn time, otherwise it could take over the cpu.
|
2001-09-12 08:38:13 +00:00
|
|
|
* XXXKSE only one update?
|
1999-06-15 23:37:29 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
speedup_syncer()
|
|
|
|
{
|
2002-09-11 08:13:56 +00:00
|
|
|
struct thread *td;
|
2002-09-25 02:22:21 +00:00
|
|
|
int ret = 0;
|
1999-06-15 23:37:29 +00:00
|
|
|
|
2002-09-11 08:13:56 +00:00
|
|
|
td = FIRST_THREAD_IN_PROC(updateproc);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sched_lock);
|
2002-09-11 18:15:26 +00:00
|
|
|
if (td->td_wchan == &lbolt) {
|
2002-09-11 08:13:56 +00:00
|
|
|
unsleep(td);
|
|
|
|
TD_CLR_SLEEPING(td);
|
|
|
|
setrunnable(td);
|
2002-09-11 18:15:26 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sched_lock);
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
1999-06-15 23:37:29 +00:00
|
|
|
if (rushjob < syncdelay / 2) {
|
|
|
|
rushjob += 1;
|
|
|
|
stat_rush_requests += 1;
|
2002-09-25 02:22:21 +00:00
|
|
|
ret = 1;
|
1999-06-15 23:37:29 +00:00
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
|
|
|
return (ret);
|
1999-06-15 23:37:29 +00:00
|
|
|
}
|
|
|
|
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
/*
|
|
|
|
* Associate a p-buffer with a vnode.
|
1999-01-21 08:29:12 +00:00
|
|
|
*
|
|
|
|
* Also sets B_PAGING flag to indicate that vnode is not fully associated
|
|
|
|
* with the buffer. i.e. the bp has not been linked into the vnode or
|
|
|
|
* ref-counted.
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
pbgetvp(vp, bp)
|
|
|
|
register struct vnode *vp;
|
|
|
|
register struct buf *bp;
|
|
|
|
{
|
1999-01-10 01:58:29 +00:00
|
|
|
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(bp->b_vp == NULL, ("pbgetvp: not free"));
|
|
|
|
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
bp->b_vp = vp;
|
1999-01-21 08:29:12 +00:00
|
|
|
bp->b_flags |= B_PAGING;
|
1999-08-25 12:24:39 +00:00
|
|
|
bp->b_dev = vn_todev(vp);
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disassociate a p-buffer from a vnode.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
pbrelvp(bp)
|
|
|
|
register struct buf *bp;
|
|
|
|
{
|
|
|
|
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(bp->b_vp != NULL, ("pbrelvp: NULL"));
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
|
1999-01-21 08:29:12 +00:00
|
|
|
/* XXX REMOVE ME */
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(bp->b_vp);
|
2001-02-04 13:13:25 +00:00
|
|
|
if (TAILQ_NEXT(bp, b_vnbufs) != NULL) {
|
1999-01-21 08:29:12 +00:00
|
|
|
panic(
|
2002-06-06 15:46:38 +00:00
|
|
|
"relpbuf(): b_vp was probably reassignbuf()d %p %x",
|
1999-01-21 08:29:12 +00:00
|
|
|
bp,
|
|
|
|
(int)bp->b_flags
|
|
|
|
);
|
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(bp->b_vp);
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
bp->b_vp = (struct vnode *) 0;
|
1999-01-21 08:29:12 +00:00
|
|
|
bp->b_flags &= ~B_PAGING;
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Reassign a buffer from one vnode to another.
|
|
|
|
* Used to assign file specific control information
|
|
|
|
* (indirect blocks) to the vnode to which they belong.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
reassignbuf(bp, newvp)
|
|
|
|
register struct buf *bp;
|
|
|
|
register struct vnode *newvp;
|
|
|
|
{
|
1998-03-08 09:59:44 +00:00
|
|
|
int delay;
|
1996-08-15 06:45:01 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (newvp == NULL) {
|
|
|
|
printf("reassignbuf: NULL");
|
|
|
|
return;
|
|
|
|
}
|
The buffer queue mechanism has been reformulated. Instead of having
QUEUE_AGE, QUEUE_LRU, and QUEUE_EMPTY we instead have QUEUE_CLEAN,
QUEUE_DIRTY, QUEUE_EMPTY, and QUEUE_EMPTYKVA. With this patch clean
and dirty buffers have been separated. Empty buffers with KVM
assignments have been separated from truely empty buffers. getnewbuf()
has been rewritten and now operates in a 100% optimal fashion. That is,
it is able to find precisely the right kind of buffer it needs to
allocate a new buffer, defragment KVM, or to free-up an existing buffer
when the buffer cache is full (which is a steady-state situation for
the buffer cache).
Buffer flushing has been reorganized. Previously buffers were flushed
in the context of whatever process hit the conditions forcing buffer
flushing to occur. This resulted in processes blocking on conditions
unrelated to what they were doing. This also resulted in inappropriate
VFS stacking chains due to multiple processes getting stuck trying to
flush dirty buffers or due to a single process getting into a situation
where it might attempt to flush buffers recursively - a situation that
was only partially fixed in prior commits. We have added a new daemon
called the buf_daemon which is responsible for flushing dirty buffers
when the number of dirty buffers exceeds the vfs.hidirtybuffers limit.
This daemon attempts to dynamically adjust the rate at which dirty buffers
are flushed such that getnewbuf() calls (almost) never block.
The number of nbufs and amount of buffer space is now scaled past the
8MB limit that was previously imposed for systems with over 64MB of
memory, and the vfs.{lo,hi}dirtybuffers limits have been relaxed
somewhat. The number of physical buffers has been increased with the
intention that we will manage physical I/O differently in the future.
reassignbuf previously attempted to keep the dirtyblkhd list sorted which
could result in non-deterministic operation under certain conditions,
such as when a large number of dirty buffers are being managed. This
algorithm has been changed. reassignbuf now keeps buffers locally sorted
if it can do so cheaply, and otherwise gives up and adds buffers to
the head of the dirtyblkhd list. The new algorithm is deterministic but
not perfect. The new algorithm greatly reduces problems that previously
occured when write_behind was turned off in the system.
The P_FLSINPROG proc->p_flag bit has been replaced by the more descriptive
P_BUFEXHAUST bit. This bit allows processes working with filesystem
buffers to use available emergency reserves. Normal processes do not set
this bit and are not allowed to dig into emergency reserves. The purpose
of this bit is to avoid low-memory deadlocks.
A small race condition was fixed in getpbuf() in vm/vm_pager.c.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
Reviewed by: Kirk McKusick <mckusick@mckusick.com>
1999-07-04 00:25:38 +00:00
|
|
|
++reassignbufcalls;
|
1996-08-15 06:45:01 +00:00
|
|
|
|
1999-01-21 08:29:12 +00:00
|
|
|
/*
|
|
|
|
* B_PAGING flagged buffers cannot be reassigned because their vp
|
|
|
|
* is not fully linked in.
|
|
|
|
*/
|
|
|
|
if (bp->b_flags & B_PAGING)
|
|
|
|
panic("cannot reassign paging buffer");
|
|
|
|
|
1996-08-15 06:45:01 +00:00
|
|
|
s = splbio();
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Delete from old vnode list, if on one.
|
|
|
|
*/
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(bp->b_vp);
|
1999-12-22 03:11:04 +00:00
|
|
|
if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN)) {
|
2002-07-10 17:02:32 +00:00
|
|
|
buf_vlist_remove(bp);
|
1999-03-12 02:24:58 +00:00
|
|
|
if (bp->b_vp != newvp) {
|
2002-09-25 02:22:21 +00:00
|
|
|
vdropl(bp->b_vp);
|
1999-03-12 02:24:58 +00:00
|
|
|
bp->b_vp = NULL; /* for clarification */
|
|
|
|
}
|
1997-08-31 07:32:39 +00:00
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(bp->b_vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
* If dirty, put on list of dirty buffers; otherwise insert onto list
|
|
|
|
* of clean buffers.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(newvp);
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
if (bp->b_flags & B_DELWRI) {
|
2002-08-04 10:29:36 +00:00
|
|
|
if ((newvp->v_iflag & VI_ONWORKLST) == 0) {
|
1998-03-08 09:59:44 +00:00
|
|
|
switch (newvp->v_type) {
|
|
|
|
case VDIR:
|
1999-06-15 23:37:29 +00:00
|
|
|
delay = dirdelay;
|
1998-03-08 09:59:44 +00:00
|
|
|
break;
|
1999-11-22 10:33:55 +00:00
|
|
|
case VCHR:
|
2000-10-09 17:31:39 +00:00
|
|
|
if (newvp->v_rdev->si_mountpoint != NULL) {
|
1999-06-15 23:37:29 +00:00
|
|
|
delay = metadelay;
|
1998-03-08 09:59:44 +00:00
|
|
|
break;
|
|
|
|
}
|
2002-08-25 13:23:09 +00:00
|
|
|
/* FALLTHROUGH */
|
1998-03-08 09:59:44 +00:00
|
|
|
default:
|
1999-06-15 23:37:29 +00:00
|
|
|
delay = filedelay;
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
|
|
|
vn_syncer_add_to_worklist(newvp, delay);
|
|
|
|
}
|
2002-07-10 17:02:32 +00:00
|
|
|
buf_vlist_add(bp, newvp, BX_VNDIRTY);
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
} else {
|
2002-07-10 17:02:32 +00:00
|
|
|
buf_vlist_add(bp, newvp, BX_VNCLEAN);
|
|
|
|
|
2002-08-04 10:29:36 +00:00
|
|
|
if ((newvp->v_iflag & VI_ONWORKLST) &&
|
1998-10-31 14:20:39 +00:00
|
|
|
TAILQ_EMPTY(&newvp->v_dirtyblkhd)) {
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
LIST_REMOVE(newvp, v_synclist);
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
|
|
|
newvp->v_iflag &= ~VI_ONWORKLST;
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
}
|
1999-03-12 02:24:58 +00:00
|
|
|
if (bp->b_vp != newvp) {
|
|
|
|
bp->b_vp = newvp;
|
2002-09-25 02:22:21 +00:00
|
|
|
vholdl(bp->b_vp);
|
1999-03-12 02:24:58 +00:00
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(newvp);
|
1996-08-15 06:45:01 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2000-11-02 21:14:13 +00:00
|
|
|
* Create a vnode for a device.
|
2002-05-16 21:28:32 +00:00
|
|
|
* Used for mounting the root filesystem.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
bdevvp(dev, vpp)
|
|
|
|
dev_t dev;
|
|
|
|
struct vnode **vpp;
|
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct vnode *nvp;
|
|
|
|
int error;
|
|
|
|
|
1999-05-31 11:29:30 +00:00
|
|
|
if (dev == NODEV) {
|
1998-10-25 16:11:49 +00:00
|
|
|
*vpp = NULLVP;
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
2000-09-27 18:03:17 +00:00
|
|
|
if (vfinddev(dev, VCHR, vpp))
|
|
|
|
return (0);
|
2002-09-14 09:02:28 +00:00
|
|
|
error = getnewvnode("none", (struct mount *)0, spec_vnodeop_p, &nvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error) {
|
1998-10-25 16:11:49 +00:00
|
|
|
*vpp = NULLVP;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
vp = nvp;
|
2000-05-14 07:43:12 +00:00
|
|
|
vp->v_type = VCHR;
|
1999-08-26 14:53:31 +00:00
|
|
|
addalias(vp, dev);
|
1994-05-24 10:09:53 +00:00
|
|
|
*vpp = vp;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2002-10-24 19:38:56 +00:00
|
|
|
static void
|
|
|
|
v_incr_usecount(struct vnode *vp, int delta)
|
|
|
|
{
|
|
|
|
vp->v_usecount += delta;
|
2002-10-25 07:58:25 +00:00
|
|
|
if (vp->v_type == VCHR && vp->v_rdev != NULL) {
|
2002-10-24 19:38:56 +00:00
|
|
|
mtx_lock(&spechash_mtx);
|
|
|
|
vp->v_rdev->si_usecount += delta;
|
|
|
|
mtx_unlock(&spechash_mtx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1999-08-26 14:53:31 +00:00
|
|
|
* Add vnode to the alias list hung off the dev_t.
|
|
|
|
*
|
|
|
|
* The reason for this gunk is that multiple vnodes can reference
|
|
|
|
* the same physical device, so checking vp->v_usecount to see
|
|
|
|
* how many users there are is inadequate; the v_usecount for
|
|
|
|
* the vnodes need to be accumulated. vcount() does that.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2000-07-24 05:28:33 +00:00
|
|
|
struct vnode *
|
1999-08-26 14:53:31 +00:00
|
|
|
addaliasu(nvp, nvp_rdev)
|
|
|
|
struct vnode *nvp;
|
Divorce "dev_t" from the "major|minor" bitmap, which is now called
udev_t in the kernel but still called dev_t in userland.
Provide functions to manipulate both types:
major() umajor()
minor() uminor()
makedev() umakedev()
dev2udev() udev2dev()
For now they're functions, they will become in-line functions
after one of the next two steps in this process.
Return major/minor/makedev to macro-hood for userland.
Register a name in cdevsw[] for the "filedescriptor" driver.
In the kernel the udev_t appears in places where we have the
major/minor number combination, (ie: a potential device: we
may not have the driver nor the device), like in inodes, vattr,
cdevsw registration and so on, whereas the dev_t appears where
we carry around a reference to a actual device.
In the future the cdevsw and the aliased-from vnode will be hung
directly from the dev_t, along with up to two softc pointers for
the device driver and a few houskeeping bits. This will essentially
replace the current "alias" check code (same buck, bigger bang).
A little stunt has been provided to try to catch places where the
wrong type is being used (dev_t vs udev_t), if you see something
not working, #undef DEVT_FASCIST in kern/kern_conf.c and see if
it makes a difference. If it does, please try to track it down
(many hands make light work) or at least try to reproduce it
as simply as possible, and describe how to do that.
Without DEVT_FASCIST I belive this patch is a no-op.
Stylistic/posixoid comments about the userland view of the <sys/*.h>
files welcome now, from userland they now contain the end result.
Next planned step: make all dev_t's refer to the same devsw[] which
means convert BLK's to CHR's at the perimeter of the vnodes and
other places where they enter the game (bootdev, mknod, sysctl).
1999-05-11 19:55:07 +00:00
|
|
|
udev_t nvp_rdev;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-07-24 05:28:33 +00:00
|
|
|
struct vnode *ovp;
|
|
|
|
vop_t **ops;
|
|
|
|
dev_t dev;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-11-02 21:14:13 +00:00
|
|
|
if (nvp->v_type == VBLK)
|
|
|
|
return (nvp);
|
|
|
|
if (nvp->v_type != VCHR)
|
1999-08-26 14:53:31 +00:00
|
|
|
panic("addaliasu on non-special vnode");
|
2000-11-02 21:14:13 +00:00
|
|
|
dev = udev2dev(nvp_rdev, 0);
|
2000-07-24 05:28:33 +00:00
|
|
|
/*
|
|
|
|
* Check to see if we have a bdevvp vnode with no associated
|
|
|
|
* filesystem. If so, we want to associate the filesystem of
|
|
|
|
* the new newly instigated vnode with the bdevvp vnode and
|
|
|
|
* discard the newly created vnode rather than leaving the
|
|
|
|
* bdevvp vnode lying around with no associated filesystem.
|
|
|
|
*/
|
|
|
|
if (vfinddev(dev, nvp->v_type, &ovp) == 0 || ovp->v_data != NULL) {
|
|
|
|
addalias(nvp, dev);
|
|
|
|
return (nvp);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Discard unneeded vnode, but save its node specific data.
|
|
|
|
* Note that if there is a lock, it is carried over in the
|
|
|
|
* node specific data to the replacement vnode.
|
|
|
|
*/
|
|
|
|
vref(ovp);
|
|
|
|
ovp->v_data = nvp->v_data;
|
|
|
|
ovp->v_tag = nvp->v_tag;
|
|
|
|
nvp->v_data = NULL;
|
2002-10-14 03:20:36 +00:00
|
|
|
lockdestroy(ovp->v_vnlock);
|
|
|
|
lockinit(ovp->v_vnlock, PVFS, nvp->v_vnlock->lk_wmesg,
|
|
|
|
nvp->v_vnlock->lk_timo, nvp->v_vnlock->lk_flags & LK_EXTFLG_MASK);
|
2001-01-31 04:54:23 +00:00
|
|
|
ops = ovp->v_op;
|
|
|
|
ovp->v_op = nvp->v_op;
|
2001-09-12 08:38:13 +00:00
|
|
|
if (VOP_ISLOCKED(nvp, curthread)) {
|
|
|
|
VOP_UNLOCK(nvp, 0, curthread);
|
|
|
|
vn_lock(ovp, LK_EXCLUSIVE | LK_RETRY, curthread);
|
2001-01-31 04:54:23 +00:00
|
|
|
}
|
|
|
|
nvp->v_op = ops;
|
2000-07-24 05:28:33 +00:00
|
|
|
insmntque(ovp, nvp->v_mount);
|
|
|
|
vrele(nvp);
|
|
|
|
vgone(nvp);
|
|
|
|
return (ovp);
|
1999-07-20 09:47:55 +00:00
|
|
|
}
|
Divorce "dev_t" from the "major|minor" bitmap, which is now called
udev_t in the kernel but still called dev_t in userland.
Provide functions to manipulate both types:
major() umajor()
minor() uminor()
makedev() umakedev()
dev2udev() udev2dev()
For now they're functions, they will become in-line functions
after one of the next two steps in this process.
Return major/minor/makedev to macro-hood for userland.
Register a name in cdevsw[] for the "filedescriptor" driver.
In the kernel the udev_t appears in places where we have the
major/minor number combination, (ie: a potential device: we
may not have the driver nor the device), like in inodes, vattr,
cdevsw registration and so on, whereas the dev_t appears where
we carry around a reference to a actual device.
In the future the cdevsw and the aliased-from vnode will be hung
directly from the dev_t, along with up to two softc pointers for
the device driver and a few houskeeping bits. This will essentially
replace the current "alias" check code (same buck, bigger bang).
A little stunt has been provided to try to catch places where the
wrong type is being used (dev_t vs udev_t), if you see something
not working, #undef DEVT_FASCIST in kern/kern_conf.c and see if
it makes a difference. If it does, please try to track it down
(many hands make light work) or at least try to reproduce it
as simply as possible, and describe how to do that.
Without DEVT_FASCIST I belive this patch is a no-op.
Stylistic/posixoid comments about the userland view of the <sys/*.h>
files welcome now, from userland they now contain the end result.
Next planned step: make all dev_t's refer to the same devsw[] which
means convert BLK's to CHR's at the perimeter of the vnodes and
other places where they enter the game (bootdev, mknod, sysctl).
1999-05-11 19:55:07 +00:00
|
|
|
|
2000-10-05 18:22:46 +00:00
|
|
|
/* This is a local helper function that do the same as addaliasu, but for a
|
|
|
|
* dev_t instead of an udev_t. */
|
2000-09-22 11:54:48 +00:00
|
|
|
static void
|
1999-08-26 14:53:31 +00:00
|
|
|
addalias(nvp, dev)
|
|
|
|
struct vnode *nvp;
|
1999-07-20 09:47:55 +00:00
|
|
|
dev_t dev;
|
|
|
|
{
|
2000-10-05 18:22:46 +00:00
|
|
|
|
2000-11-02 21:14:13 +00:00
|
|
|
KASSERT(nvp->v_type == VCHR, ("addalias on non-special vnode"));
|
1999-08-26 14:53:31 +00:00
|
|
|
nvp->v_rdev = dev;
|
2002-10-24 19:38:56 +00:00
|
|
|
VI_LOCK(nvp);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&spechash_mtx);
|
1999-08-26 14:53:31 +00:00
|
|
|
SLIST_INSERT_HEAD(&dev->si_hlist, nvp, v_specnext);
|
2002-10-24 19:38:56 +00:00
|
|
|
dev->si_usecount += nvp->v_usecount;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&spechash_mtx);
|
2002-10-24 19:38:56 +00:00
|
|
|
VI_UNLOCK(nvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Grab a particular vnode from the free list, increment its
|
1999-07-12 15:02:51 +00:00
|
|
|
* reference count and lock it. The vnode lock bit is set if the
|
1994-05-24 10:09:53 +00:00
|
|
|
* vnode is being eliminated in vgone. The process is awakened
|
|
|
|
* when the transition is completed, and an error returned to
|
|
|
|
* indicate that the vnode is no longer usable (possibly having
|
2002-05-16 21:28:32 +00:00
|
|
|
* been changed to a new filesystem type).
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
vget(vp, flags, td)
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct vnode *vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
int flags;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* If the vnode is in the process of being cleaned out for
|
|
|
|
* another use, we wait for the cleaning to finish and then
|
|
|
|
* return failure. Cleaning is determined by checking that
|
2002-08-04 10:29:36 +00:00
|
|
|
* the VI_XLOCK flag is set.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2000-09-22 12:22:36 +00:00
|
|
|
if ((flags & LK_INTERLOCK) == 0)
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
2002-08-22 07:44:45 +00:00
|
|
|
if (vp->v_iflag & VI_XLOCK && vp->v_vxproc != curthread) {
|
|
|
|
vp->v_iflag |= VI_XWANT;
|
|
|
|
msleep(vp, VI_MTX(vp), PINOD | PDROP, "vget", 0);
|
|
|
|
return (ENOENT);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-12-29 00:25:11 +00:00
|
|
|
|
2002-10-24 19:38:56 +00:00
|
|
|
v_incr_usecount(vp, 1);
|
1997-12-29 00:25:11 +00:00
|
|
|
|
1997-08-31 07:32:39 +00:00
|
|
|
if (VSHOULDBUSY(vp))
|
|
|
|
vbusy(vp);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (flags & LK_TYPE_MASK) {
|
2001-09-12 08:38:13 +00:00
|
|
|
if ((error = vn_lock(vp, flags | LK_INTERLOCK, td)) != 0) {
|
1998-02-23 06:59:52 +00:00
|
|
|
/*
|
|
|
|
* must expand vrele here because we do not want
|
|
|
|
* to call VOP_INACTIVE if the reference count
|
|
|
|
* drops back to zero since it was never really
|
|
|
|
* active. We must remove it from the free list
|
|
|
|
* before sleeping so that multiple processes do
|
|
|
|
* not try to recycle it.
|
|
|
|
*/
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
2002-10-24 19:38:56 +00:00
|
|
|
v_incr_usecount(vp, -1);
|
1998-02-23 06:59:52 +00:00
|
|
|
if (VSHOULDFREE(vp))
|
|
|
|
vfree(vp);
|
2002-01-10 18:31:53 +00:00
|
|
|
else
|
|
|
|
vlruvp(vp);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1998-02-23 06:59:52 +00:00
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
return (error);
|
1996-08-21 21:56:23 +00:00
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1997-02-10 02:22:35 +00:00
|
|
|
return (0);
|
|
|
|
}
|
1997-12-29 00:25:11 +00:00
|
|
|
|
2002-06-06 15:46:38 +00:00
|
|
|
/*
|
2000-10-05 18:22:46 +00:00
|
|
|
* Increase the reference count of a vnode.
|
2000-09-22 12:22:36 +00:00
|
|
|
*/
|
1997-12-29 16:54:03 +00:00
|
|
|
void
|
|
|
|
vref(struct vnode *vp)
|
|
|
|
{
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
2002-10-24 19:38:56 +00:00
|
|
|
v_incr_usecount(vp, 1);
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
1997-12-29 16:54:03 +00:00
|
|
|
}
|
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
/*
|
|
|
|
* Return reference count of a vnode.
|
|
|
|
*
|
|
|
|
* The results of this call are only guaranteed when some mechanism other
|
|
|
|
* than the VI lock is used to stop other processes from gaining references
|
|
|
|
* to the vnode. This may be the case if the caller holds the only reference.
|
|
|
|
* This is also useful when stale data is acceptable as race conditions may
|
|
|
|
* be accounted for by some other means.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vrefcnt(struct vnode *vp)
|
|
|
|
{
|
|
|
|
int usecnt;
|
|
|
|
|
|
|
|
VI_LOCK(vp);
|
|
|
|
usecnt = vp->v_usecount;
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
|
|
|
|
return (usecnt);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1997-12-29 00:25:11 +00:00
|
|
|
* Vnode put/release.
|
|
|
|
* If count drops to zero, call inactive routine and return to freelist.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1997-12-29 00:25:11 +00:00
|
|
|
vrele(vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = curthread; /* XXX */
|
1997-12-29 00:25:11 +00:00
|
|
|
|
1999-01-10 01:58:29 +00:00
|
|
|
KASSERT(vp != NULL, ("vrele: null vp"));
|
1999-01-08 17:31:30 +00:00
|
|
|
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
1996-08-21 21:56:23 +00:00
|
|
|
|
2001-05-11 20:42:41 +00:00
|
|
|
/* Skip this v_writecount check if we're going to panic below. */
|
|
|
|
KASSERT(vp->v_writecount < vp->v_usecount || vp->v_usecount < 1,
|
|
|
|
("vrele: missed vn_close"));
|
2000-10-02 09:57:06 +00:00
|
|
|
|
2002-12-29 18:30:49 +00:00
|
|
|
if (vp->v_usecount > 1 || ((vp->v_iflag & VI_DOINGINACT) &&
|
|
|
|
vp->v_usecount == 1)) {
|
2002-10-24 19:38:56 +00:00
|
|
|
v_incr_usecount(vp, -1);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1997-12-29 00:25:11 +00:00
|
|
|
|
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
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vp->v_usecount == 1) {
|
2002-10-24 19:38:56 +00:00
|
|
|
v_incr_usecount(vp, -1);
|
2002-02-02 01:49:18 +00:00
|
|
|
/*
|
2002-12-29 18:30:49 +00:00
|
|
|
* We must call VOP_INACTIVE with the node locked. Mark
|
|
|
|
* as VI_DOINGINACT to avoid recursion.
|
2002-02-02 01:49:18 +00:00
|
|
|
*/
|
2002-12-29 18:30:49 +00:00
|
|
|
if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, td) == 0) {
|
|
|
|
VI_LOCK(vp);
|
|
|
|
vp->v_iflag |= VI_DOINGINACT;
|
|
|
|
VI_UNLOCK(vp);
|
2002-02-02 01:49:18 +00:00
|
|
|
VOP_INACTIVE(vp, td);
|
2002-12-29 18:30:49 +00:00
|
|
|
VI_LOCK(vp);
|
|
|
|
KASSERT(vp->v_iflag & VI_DOINGINACT,
|
|
|
|
("vrele: lost VI_DOINGINACT"));
|
|
|
|
vp->v_iflag &= ~VI_DOINGINACT;
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
1997-12-29 00:25:11 +00:00
|
|
|
if (VSHOULDFREE(vp))
|
|
|
|
vfree(vp);
|
2002-01-10 18:31:53 +00:00
|
|
|
else
|
|
|
|
vlruvp(vp);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1997-12-29 00:25:11 +00:00
|
|
|
|
|
|
|
} else {
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
vprint("vrele: negative ref count", vp);
|
|
|
|
#endif
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
1997-12-29 00:25:11 +00:00
|
|
|
panic("vrele: negative ref cnt");
|
1996-08-21 21:56:23 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2002-06-06 15:46:38 +00:00
|
|
|
/*
|
2000-10-05 18:22:46 +00:00
|
|
|
* Release an already locked vnode. This give the same effects as
|
|
|
|
* unlock+vrele(), but takes less time and avoids releasing and
|
|
|
|
* re-aquiring the lock (as vrele() aquires the lock internally.)
|
2000-09-22 12:22:36 +00:00
|
|
|
*/
|
1997-12-29 00:25:11 +00:00
|
|
|
void
|
|
|
|
vput(vp)
|
1997-02-10 02:22:35 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = curthread; /* XXX */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-07-04 16:20:28 +00:00
|
|
|
GIANT_REQUIRED;
|
|
|
|
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(vp != NULL, ("vput: null vp"));
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
2001-05-11 20:42:41 +00:00
|
|
|
/* Skip this v_writecount check if we're going to panic below. */
|
|
|
|
KASSERT(vp->v_writecount < vp->v_usecount || vp->v_usecount < 1,
|
|
|
|
("vput: missed vn_close"));
|
2000-10-02 09:57:06 +00:00
|
|
|
|
2002-12-29 18:30:49 +00:00
|
|
|
if (vp->v_usecount > 1 || ((vp->v_iflag & VI_DOINGINACT) &&
|
|
|
|
vp->v_usecount == 1)) {
|
2002-10-24 19:38:56 +00:00
|
|
|
v_incr_usecount(vp, -1);
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(vp, LK_INTERLOCK, td);
|
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
|
|
|
return;
|
|
|
|
}
|
1996-08-21 21:56:23 +00:00
|
|
|
|
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
|
|
|
if (vp->v_usecount == 1) {
|
2002-10-24 19:38:56 +00:00
|
|
|
v_incr_usecount(vp, -1);
|
2002-02-02 01:49:18 +00:00
|
|
|
/*
|
2002-12-29 18:30:49 +00:00
|
|
|
* We must call VOP_INACTIVE with the node locked, so
|
|
|
|
* we just need to release the vnode mutex. Mark as
|
|
|
|
* as VI_DOINGINACT to avoid recursion.
|
2002-02-02 01:49:18 +00:00
|
|
|
*/
|
2002-12-29 18:30:49 +00:00
|
|
|
vp->v_iflag |= VI_DOINGINACT;
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
2002-02-02 01:49:18 +00:00
|
|
|
VOP_INACTIVE(vp, td);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
2002-12-29 18:30:49 +00:00
|
|
|
KASSERT(vp->v_iflag & VI_DOINGINACT,
|
|
|
|
("vput: lost VI_DOINGINACT"));
|
|
|
|
vp->v_iflag &= ~VI_DOINGINACT;
|
1997-12-29 00:25:11 +00:00
|
|
|
if (VSHOULDFREE(vp))
|
|
|
|
vfree(vp);
|
2002-01-10 18:31:53 +00:00
|
|
|
else
|
|
|
|
vlruvp(vp);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-12-29 00:25:11 +00:00
|
|
|
} else {
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
vprint("vput: negative ref count", vp);
|
|
|
|
#endif
|
|
|
|
panic("vput: negative ref cnt");
|
|
|
|
}
|
1997-02-27 02:57:03 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1997-08-31 07:32:39 +00:00
|
|
|
* Somebody doesn't want the vnode recycled.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
2002-09-25 02:22:21 +00:00
|
|
|
vhold(struct vnode *vp)
|
|
|
|
{
|
|
|
|
VI_LOCK(vp);
|
|
|
|
vholdl(vp);
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vholdl(vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct vnode *vp;
|
|
|
|
{
|
1998-03-14 02:55:01 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-06-06 15:46:38 +00:00
|
|
|
s = splbio();
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_holdcnt++;
|
1997-08-31 07:32:39 +00:00
|
|
|
if (VSHOULDBUSY(vp))
|
|
|
|
vbusy(vp);
|
1998-03-14 02:55:01 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2000-10-05 18:22:46 +00:00
|
|
|
* Note that there is one less who cares about this vnode. vdrop() is the
|
|
|
|
* opposite of vhold().
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
2002-09-25 02:22:21 +00:00
|
|
|
vdrop(struct vnode *vp)
|
|
|
|
{
|
|
|
|
VI_LOCK(vp);
|
|
|
|
vdropl(vp);
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vdropl(vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct vnode *vp;
|
|
|
|
{
|
1998-03-14 02:55:01 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-03-14 02:55:01 +00:00
|
|
|
s = splbio();
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_holdcnt <= 0)
|
1998-03-08 09:59:44 +00:00
|
|
|
panic("vdrop: holdcnt");
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_holdcnt--;
|
1997-08-31 07:32:39 +00:00
|
|
|
if (VSHOULDFREE(vp))
|
|
|
|
vfree(vp);
|
2002-01-10 18:31:53 +00:00
|
|
|
else
|
|
|
|
vlruvp(vp);
|
1998-03-14 02:55:01 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove any vnodes in the vnode table belonging to mount point mp.
|
|
|
|
*
|
2001-05-16 18:04:37 +00:00
|
|
|
* If FORCECLOSE is not specified, there should not be any active ones,
|
1994-05-24 10:09:53 +00:00
|
|
|
* return error if any are found (nb: this is a user error, not a
|
2001-05-16 18:04:37 +00:00
|
|
|
* system error). If FORCECLOSE is specified, detach any active vnodes
|
1994-05-24 10:09:53 +00:00
|
|
|
* that are found.
|
2001-05-16 18:04:37 +00:00
|
|
|
*
|
|
|
|
* If WRITECLOSE is set, only flush out regular file vnodes open for
|
|
|
|
* writing.
|
|
|
|
*
|
2002-08-04 10:29:36 +00:00
|
|
|
* SKIPSYSTEM causes any vnodes marked VV_SYSTEM to be skipped.
|
2001-05-16 18:04:37 +00:00
|
|
|
*
|
|
|
|
* `rootrefs' specifies the base reference count for the root vnode
|
|
|
|
* of this filesystem. The root vnode is considered busy if its
|
|
|
|
* v_usecount exceeds this value. On a successful return, vflush()
|
|
|
|
* will call vrele() on the root vnode exactly rootrefs times.
|
|
|
|
* If the SKIPSYSTEM or WRITECLOSE flags are specified, rootrefs must
|
|
|
|
* be zero.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
#ifdef DIAGNOSTIC
|
1995-12-17 21:23:44 +00:00
|
|
|
static int busyprt = 0; /* print out busy vnodes */
|
1997-04-01 13:05:34 +00:00
|
|
|
SYSCTL_INT(_debug, OID_AUTO, busyprt, CTLFLAG_RW, &busyprt, 0, "");
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2001-05-16 18:04:37 +00:00
|
|
|
vflush(mp, rootrefs, flags)
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mount *mp;
|
2001-05-16 18:04:37 +00:00
|
|
|
int rootrefs;
|
1994-05-24 10:09:53 +00:00
|
|
|
int flags;
|
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = curthread; /* XXX */
|
2001-05-16 18:04:37 +00:00
|
|
|
struct vnode *vp, *nvp, *rootvp = NULL;
|
2002-01-15 07:17:12 +00:00
|
|
|
struct vattr vattr;
|
2001-05-16 18:04:37 +00:00
|
|
|
int busy = 0, error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-05-16 18:04:37 +00:00
|
|
|
if (rootrefs > 0) {
|
|
|
|
KASSERT((flags & (SKIPSYSTEM | WRITECLOSE)) == 0,
|
|
|
|
("vflush: bad args"));
|
|
|
|
/*
|
|
|
|
* Get the filesystem root vnode. We can vput() it
|
|
|
|
* immediately, since with rootrefs > 0, it won't go away.
|
|
|
|
*/
|
|
|
|
if ((error = VFS_ROOT(mp, &rootvp)) != 0)
|
|
|
|
return (error);
|
|
|
|
vput(rootvp);
|
2002-07-07 06:38:22 +00:00
|
|
|
|
2001-05-16 18:04:37 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
loop:
|
2001-10-23 01:21:29 +00:00
|
|
|
for (vp = TAILQ_FIRST(&mp->mnt_nvnodelist); vp; vp = nvp) {
|
1995-03-11 22:29:07 +00:00
|
|
|
/*
|
|
|
|
* Make sure this vnode wasn't reclaimed in getnewvnode().
|
|
|
|
* Start over if it has (it won't be on the list anymore).
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_mount != mp)
|
|
|
|
goto loop;
|
2001-10-23 01:21:29 +00:00
|
|
|
nvp = TAILQ_NEXT(vp, v_nmntvnodes);
|
1997-02-10 02:22:35 +00:00
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
2001-06-28 04:05:54 +00:00
|
|
|
mtx_unlock(&mntvnode_mtx);
|
2002-09-25 02:22:21 +00:00
|
|
|
vn_lock(vp, LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2002-08-04 10:29:36 +00:00
|
|
|
* Skip over a vnodes marked VV_SYSTEM.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-08-04 10:29:36 +00:00
|
|
|
if ((flags & SKIPSYSTEM) && (vp->v_vflag & VV_SYSTEM)) {
|
2002-08-22 06:51:06 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
2001-06-28 04:05:54 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2002-01-15 07:17:12 +00:00
|
|
|
* If WRITECLOSE is set, flush out unlinked but still open
|
|
|
|
* files (even if open only for reading) and regular file
|
2002-06-06 15:46:38 +00:00
|
|
|
* vnodes open for writing.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-09-25 02:22:21 +00:00
|
|
|
if (flags & WRITECLOSE) {
|
|
|
|
error = VOP_GETATTR(vp, &vattr, td->td_ucred, td);
|
|
|
|
VI_LOCK(vp);
|
2002-08-22 06:51:06 +00:00
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
if ((vp->v_type == VNON ||
|
|
|
|
(error == 0 && vattr.va_nlink > 0)) &&
|
|
|
|
(vp->v_writecount == 0 || vp->v_type != VREG)) {
|
|
|
|
VOP_UNLOCK(vp, LK_INTERLOCK, td);
|
|
|
|
mtx_lock(&mntvnode_mtx);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
VI_LOCK(vp);
|
1996-08-21 21:56:23 +00:00
|
|
|
|
2002-08-22 06:51:06 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
* With v_usecount == 0, all we need to do is clear out the
|
|
|
|
* vnode data structures and we are done.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
if (vp->v_usecount == 0) {
|
2001-09-12 08:38:13 +00:00
|
|
|
vgonel(vp, td);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
|
|
|
}
|
1996-10-17 02:49:35 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
* If FORCECLOSE is set, forcibly close the vnode. For block
|
|
|
|
* or character devices, revert to an anonymous device. For
|
|
|
|
* all other files, just kill them.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
if (flags & FORCECLOSE) {
|
2000-11-02 21:14:13 +00:00
|
|
|
if (vp->v_type != VCHR) {
|
2001-09-12 08:38:13 +00:00
|
|
|
vgonel(vp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
2001-09-12 08:38:13 +00:00
|
|
|
vclean(vp, 0, td);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_op = spec_vnodeop_p;
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
insmntque(vp, (struct mount *) 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (busyprt)
|
|
|
|
vprint("vflush: busy vnode", vp);
|
|
|
|
#endif
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
2001-06-28 04:05:54 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
busy++;
|
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mntvnode_mtx);
|
2001-05-16 18:04:37 +00:00
|
|
|
if (rootrefs > 0 && (flags & FORCECLOSE) == 0) {
|
|
|
|
/*
|
|
|
|
* If just the root vnode is busy, and if its refcount
|
|
|
|
* is equal to `rootrefs', then go ahead and kill it.
|
|
|
|
*/
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(rootvp);
|
2001-05-16 18:04:37 +00:00
|
|
|
KASSERT(busy > 0, ("vflush: not busy"));
|
|
|
|
KASSERT(rootvp->v_usecount >= rootrefs, ("vflush: rootrefs"));
|
|
|
|
if (busy == 1 && rootvp->v_usecount == rootrefs) {
|
2001-09-12 08:38:13 +00:00
|
|
|
vgonel(rootvp, td);
|
2001-05-16 18:04:37 +00:00
|
|
|
busy = 0;
|
|
|
|
} else
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(rootvp);
|
2001-05-16 18:04:37 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if (busy)
|
|
|
|
return (EBUSY);
|
2001-05-16 18:04:37 +00:00
|
|
|
for (; rootrefs > 0; rootrefs--)
|
|
|
|
vrele(rootvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2002-01-10 18:31:53 +00:00
|
|
|
/*
|
|
|
|
* This moves a now (likely recyclable) vnode to the end of the
|
|
|
|
* mountlist. XXX However, it is temporarily disabled until we
|
|
|
|
* can clean up ffs_sync() and friends, which have loop restart
|
|
|
|
* conditions which this code causes to operate O(N^2).
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
vlruvp(struct vnode *vp)
|
|
|
|
{
|
|
|
|
#if 0
|
|
|
|
struct mount *mp;
|
|
|
|
|
|
|
|
if ((mp = vp->v_mount) != NULL) {
|
|
|
|
mtx_lock(&mntvnode_mtx);
|
|
|
|
TAILQ_REMOVE(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
|
|
|
|
TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
|
|
|
|
mtx_unlock(&mntvnode_mtx);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2002-05-16 21:28:32 +00:00
|
|
|
* Disassociate the underlying filesystem from a vnode.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
static void
|
2001-09-12 08:38:13 +00:00
|
|
|
vclean(vp, flags, td)
|
1997-09-16 11:44:05 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
int flags;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
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
|
|
|
int active;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "vclean");
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
* Check to see if the vnode is in use. If so we have to reference it
|
|
|
|
* before we clean it out so that its count cannot fall to zero and
|
|
|
|
* generate a race against ourselves to recycle it.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-09-25 19:34:02 +00:00
|
|
|
if ((active = vp->v_usecount))
|
2002-10-24 19:38:56 +00:00
|
|
|
v_incr_usecount(vp, 1);
|
Make our v_usecount vnode reference count work identically to the
original BSD code. The association between the vnode and the vm_object
no longer includes reference counts. The major difference is that
vm_object's are no longer freed gratuitiously from the vnode, and so
once an object is created for the vnode, it will last as long as the
vnode does.
When a vnode object reference count is incremented, then the underlying
vnode reference count is incremented also. The two "objects" are now
more intimately related, and so the interactions are now much less
complex.
When vnodes are now normally placed onto the free queue with an object still
attached. The rundown of the object happens at vnode rundown time, and
happens with exactly the same filesystem semantics of the original VFS
code. There is absolutely no need for vnode_pager_uncache and other
travesties like that anymore.
A side-effect of these changes is that SMP locking should be much simpler,
the I/O copyin/copyout optimizations work, NFS should be more ponderable,
and further work on layered filesystems should be less frustrating, because
of the totally coherent management of the vnode objects and vnodes.
Please be careful with your system while running this code, but I would
greatly appreciate feedback as soon a reasonably possible.
1998-01-06 05:26:17 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
* Prevent the vnode from being recycled or brought into use while we
|
|
|
|
* clean it out.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_iflag & VI_XLOCK)
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("vclean: deadlock");
|
2002-08-04 10:29:36 +00:00
|
|
|
vp->v_iflag |= VI_XLOCK;
|
2001-09-12 08:38:13 +00:00
|
|
|
vp->v_vxproc = curthread;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Even if the count is zero, the VOP_INACTIVE routine may still
|
|
|
|
* have the object locked while it cleans it out. The VOP_LOCK
|
|
|
|
* ensures that the VOP_INACTIVE routine is done with its work.
|
|
|
|
* For active vnodes, it ensures that no other activity can
|
|
|
|
* occur while the underlying object is being cleaned out.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_LOCK(vp, LK_DRAIN | LK_INTERLOCK, td);
|
1997-06-22 03:00:24 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Clean out any buffers associated with the vnode.
|
2000-07-04 03:23:29 +00:00
|
|
|
* If the flush fails, just toss the buffers.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2000-07-04 03:23:29 +00:00
|
|
|
if (flags & DOCLOSE) {
|
2002-09-25 02:22:21 +00:00
|
|
|
struct buf *bp;
|
|
|
|
VI_LOCK(vp);
|
|
|
|
bp = TAILQ_FIRST(&vp->v_dirtyblkhd);
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
if (bp != NULL)
|
2000-07-24 05:28:33 +00:00
|
|
|
(void) vn_write_suspend_wait(vp, NULL, V_WAIT);
|
2001-09-12 08:38:13 +00:00
|
|
|
if (vinvalbuf(vp, V_SAVE, NOCRED, td, 0, 0) != 0)
|
|
|
|
vinvalbuf(vp, 0, NOCRED, td, 0, 0);
|
2000-07-04 03:23:29 +00:00
|
|
|
}
|
|
|
|
|
2000-09-12 09:49:08 +00:00
|
|
|
VOP_DESTROYVOBJECT(vp);
|
1997-06-22 03:00:24 +00:00
|
|
|
|
2002-07-07 06:38:22 +00:00
|
|
|
/*
|
|
|
|
* Any other processes trying to obtain this lock must first
|
|
|
|
* wait for VXLOCK to clear, then call the new lock operation.
|
|
|
|
*/
|
|
|
|
VOP_UNLOCK(vp, 0, td);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* If purging an active vnode, it must be closed and
|
|
|
|
* deactivated before being reclaimed. Note that the
|
|
|
|
* VOP_INACTIVE will unlock the vnode.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
if (active) {
|
|
|
|
if (flags & DOCLOSE)
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_CLOSE(vp, FNONBLOCK, NOCRED, td);
|
2002-12-29 18:30:49 +00:00
|
|
|
VI_LOCK(vp);
|
|
|
|
if ((vp->v_iflag & VI_DOINGINACT) == 0) {
|
|
|
|
vp->v_iflag |= VI_DOINGINACT;
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
if (vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT, td) != 0)
|
|
|
|
panic("vclean: cannot relock.");
|
|
|
|
VOP_INACTIVE(vp, td);
|
|
|
|
VI_LOCK(vp);
|
|
|
|
KASSERT(vp->v_iflag & VI_DOINGINACT,
|
|
|
|
("vclean: lost VI_DOINGINACT"));
|
|
|
|
vp->v_iflag &= ~VI_DOINGINACT;
|
|
|
|
}
|
|
|
|
VI_UNLOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2002-07-07 06:38:22 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Reclaim the vnode.
|
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
if (VOP_RECLAIM(vp, td))
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("vclean: cannot reclaim");
|
1998-02-23 06:59:52 +00:00
|
|
|
|
2000-01-29 15:22:58 +00:00
|
|
|
if (active) {
|
|
|
|
/*
|
|
|
|
* Inline copy of vrele() since VOP_INACTIVE
|
|
|
|
* has already been called.
|
|
|
|
*/
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
2002-10-24 19:38:56 +00:00
|
|
|
v_incr_usecount(vp, -1);
|
|
|
|
if (vp->v_usecount <= 0) {
|
2000-01-29 15:22:58 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (vp->v_usecount < 0 || vp->v_writecount != 0) {
|
|
|
|
vprint("vclean: bad ref count", vp);
|
|
|
|
panic("vclean: ref cnt");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
vfree(vp);
|
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
2000-01-29 15:22:58 +00:00
|
|
|
}
|
1998-02-23 06:59:52 +00:00
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
cache_purge(vp);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
1998-02-23 06:59:52 +00:00
|
|
|
if (VSHOULDFREE(vp))
|
|
|
|
vfree(vp);
|
2002-06-06 15:46:38 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2002-10-14 19:44:51 +00:00
|
|
|
* Done with purge, reset to the standard lock and
|
|
|
|
* notify sleepers of the grim news.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-10-14 19:44:51 +00:00
|
|
|
vp->v_vnlock = &vp->v_lock;
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_op = dead_vnodeop_p;
|
2002-02-17 21:15:36 +00:00
|
|
|
if (vp->v_pollinfo != NULL)
|
|
|
|
vn_pollgone(vp);
|
2002-09-14 09:02:28 +00:00
|
|
|
vp->v_tag = "none";
|
2002-08-04 10:29:36 +00:00
|
|
|
vp->v_iflag &= ~VI_XLOCK;
|
Implement a low-memory deadlock solution.
Removed most of the hacks that were trying to deal with low-memory
situations prior to now.
The new code is based on the concept that I/O must be able to function in
a low memory situation. All major modules related to I/O (except
networking) have been adjusted to allow allocation out of the system
reserve memory pool. These modules now detect a low memory situation but
rather then block they instead continue to operate, then return resources
to the memory pool instead of cache them or leave them wired.
Code has been added to stall in a low-memory situation prior to a vnode
being locked.
Thus situations where a process blocks in a low-memory condition while
holding a locked vnode have been reduced to near nothing. Not only will
I/O continue to operate, but many prior deadlock conditions simply no
longer exist.
Implement a number of VFS/BIO fixes
(found by Ian): in biodone(), bogus-page replacement code, the loop
was not properly incrementing loop variables prior to a continue
statement. We do not believe this code can be hit anyway but we
aren't taking any chances. We'll turn the whole section into a
panic (as it already is in brelse()) after the release is rolled.
In biodone(), the foff calculation was incorrectly
clamped to the iosize, causing the wrong foff to be calculated
for pages in the case of an I/O error or biodone() called without
initiating I/O. The problem always caused a panic before. Now it
doesn't. The problem is mainly an issue with NFS.
Fixed casts for ~PAGE_MASK. This code worked properly before only
because the calculations use signed arithmatic. Better to properly
extend PAGE_MASK first before inverting it for the 64 bit masking
op.
In brelse(), the bogus_page fixup code was improperly throwing
away the original contents of 'm' when it did the j-loop to
fix the bogus pages. The result was that it would potentially
invalidate parts of the *WRONG* page(!), leading to corruption.
There may still be cases where a background bitmap write is
being duplicated, causing potential corruption. We have identified
a potentially serious bug related to this but the fix is still TBD.
So instead this patch contains a KASSERT to detect the problem
and panic the machine rather then continue to corrupt the filesystem.
The problem does not occur very often.. it is very hard to
reproduce, and it may or may not be the cause of the corruption
people have reported.
Review by: (VFS/BIO: mckusick, Ian Dowse <iedowse@maths.tcd.ie>)
Testing by: (VM/Deadlock) Paul Saab <ps@yahoo-inc.com>
2000-11-18 23:06:26 +00:00
|
|
|
vp->v_vxproc = NULL;
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_iflag & VI_XWANT) {
|
|
|
|
vp->v_iflag &= ~VI_XWANT;
|
2002-06-28 23:17:36 +00:00
|
|
|
wakeup(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Eliminate all activity associated with the requested vnode
|
1994-05-24 10:09:53 +00:00
|
|
|
* and with all vnodes aliased to the requested vnode.
|
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
int
|
|
|
|
vop_revoke(ap)
|
|
|
|
struct vop_revoke_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
int a_flags;
|
|
|
|
} */ *ap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
struct vnode *vp, *vq;
|
1999-08-26 14:53:31 +00:00
|
|
|
dev_t dev;
|
1997-02-10 02:22:35 +00:00
|
|
|
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT((ap->a_flags & REVOKEALL) != 0, ("vop_revoke"));
|
1997-02-10 02:22:35 +00:00
|
|
|
vp = ap->a_vp;
|
2002-12-28 22:27:14 +00:00
|
|
|
KASSERT((vp->v_type == VCHR), ("vop_revoke: not VCHR"));
|
|
|
|
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
1999-08-26 14:53:31 +00:00
|
|
|
/*
|
|
|
|
* If a vgone (or vclean) is already in progress,
|
|
|
|
* wait until it is done and return.
|
|
|
|
*/
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_iflag & VI_XLOCK) {
|
|
|
|
vp->v_iflag |= VI_XWANT;
|
|
|
|
msleep(vp, VI_MTX(vp), PINOD | PDROP,
|
2000-12-01 03:43:33 +00:00
|
|
|
"vop_revokeall", 0);
|
1999-08-26 14:53:31 +00:00
|
|
|
return (0);
|
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1999-08-26 14:53:31 +00:00
|
|
|
dev = vp->v_rdev;
|
|
|
|
for (;;) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&spechash_mtx);
|
1999-08-26 14:53:31 +00:00
|
|
|
vq = SLIST_FIRST(&dev->si_hlist);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&spechash_mtx);
|
1999-08-26 14:53:31 +00:00
|
|
|
if (!vq)
|
|
|
|
break;
|
|
|
|
vgone(vq);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Recycle an unused vnode to the front of the free list.
|
|
|
|
* Release the passed interlock if the vnode will be recycled.
|
|
|
|
*/
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
vrecycle(vp, inter_lkp, td)
|
1997-02-10 02:22:35 +00:00
|
|
|
struct vnode *vp;
|
2001-01-24 12:35:55 +00:00
|
|
|
struct mtx *inter_lkp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
{
|
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (vp->v_usecount == 0) {
|
|
|
|
if (inter_lkp) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(inter_lkp);
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
vgonel(vp, td);
|
1997-02-10 02:22:35 +00:00
|
|
|
return (1);
|
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_UNLOCK(vp);
|
1997-02-10 02:22:35 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Eliminate all activity associated with a vnode
|
|
|
|
* in preparation for reuse.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
|
|
|
vgone(vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct vnode *vp;
|
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = curthread; /* XXX */
|
1997-02-10 02:22:35 +00:00
|
|
|
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
2001-09-12 08:38:13 +00:00
|
|
|
vgonel(vp, td);
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vgone, with the vp interlock held.
|
|
|
|
*/
|
2000-02-02 07:07:17 +00:00
|
|
|
void
|
2001-09-12 08:38:13 +00:00
|
|
|
vgonel(vp, td)
|
1997-02-10 02:22:35 +00:00
|
|
|
struct vnode *vp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
{
|
1998-01-12 01:46:33 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* If a vgone (or vclean) is already in progress,
|
|
|
|
* wait until it is done and return.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "vgonel");
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_iflag & VI_XLOCK) {
|
|
|
|
vp->v_iflag |= VI_XWANT;
|
2002-08-23 00:32:03 +00:00
|
|
|
msleep(vp, VI_MTX(vp), PINOD | PDROP, "vgone", 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
return;
|
|
|
|
}
|
1996-10-17 02:49:35 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Clean out the filesystem specific data.
|
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
vclean(vp, DOCLOSE, td);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1997-12-29 00:25:11 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Delete from old mount point vnode list, if on one.
|
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
if (vp->v_mount != NULL)
|
|
|
|
insmntque(vp, (struct mount *)0);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* If special device, remove it from special device alias list
|
|
|
|
* if it is on one.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2000-11-02 21:14:13 +00:00
|
|
|
if (vp->v_type == VCHR && vp->v_rdev != NULL && vp->v_rdev != NODEV) {
|
2002-10-24 19:38:56 +00:00
|
|
|
VI_LOCK(vp);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&spechash_mtx);
|
2000-09-19 10:28:44 +00:00
|
|
|
SLIST_REMOVE(&vp->v_rdev->si_hlist, vp, vnode, v_specnext);
|
2002-10-24 19:38:56 +00:00
|
|
|
vp->v_rdev->si_usecount -= vp->v_usecount;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&spechash_mtx);
|
2002-10-24 19:38:56 +00:00
|
|
|
VI_UNLOCK(vp);
|
1999-08-13 10:10:12 +00:00
|
|
|
vp->v_rdev = NULL;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* If it is on the freelist and not already at the head,
|
2000-07-04 04:32:40 +00:00
|
|
|
* move it to the head of the list. The test of the
|
|
|
|
* VDOOMED flag and the reference count of zero is because
|
1997-02-10 02:22:35 +00:00
|
|
|
* it will be removed from the free list by getnewvnode,
|
|
|
|
* but will not have its reference count incremented until
|
|
|
|
* after calling vgone. If the reference count were
|
|
|
|
* incremented first, vgone would (incorrectly) try to
|
|
|
|
* close the previous instance of the underlying object.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
|
|
|
if (vp->v_usecount == 0 && !(vp->v_iflag & VI_DOOMED)) {
|
1998-01-12 01:46:33 +00:00
|
|
|
s = splbio();
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_iflag & VI_FREE) {
|
1998-01-12 01:46:33 +00:00
|
|
|
TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
|
2002-08-04 10:29:36 +00:00
|
|
|
} else {
|
|
|
|
vp->v_iflag |= VI_FREE;
|
1998-01-31 01:17:58 +00:00
|
|
|
freevnodes++;
|
2002-08-04 10:29:36 +00:00
|
|
|
}
|
1997-08-31 07:32:39 +00:00
|
|
|
TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
1998-01-12 01:46:33 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_type = VBAD;
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lookup a vnode by device number.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
vfinddev(dev, type, vpp)
|
|
|
|
dev_t dev;
|
|
|
|
enum vtype type;
|
|
|
|
struct vnode **vpp;
|
|
|
|
{
|
1999-08-26 14:53:31 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&spechash_mtx);
|
1999-08-26 14:53:31 +00:00
|
|
|
SLIST_FOREACH(vp, &dev->si_hlist, v_specnext) {
|
|
|
|
if (type == vp->v_type) {
|
|
|
|
*vpp = vp;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&spechash_mtx);
|
1999-08-26 14:53:31 +00:00
|
|
|
return (1);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&spechash_mtx);
|
1999-08-26 14:53:31 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate the total number of references to a special device.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
vcount(vp)
|
1999-08-26 14:53:31 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int count;
|
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&spechash_mtx);
|
2002-10-24 19:38:56 +00:00
|
|
|
count = vp->v_rdev->si_usecount;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&spechash_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (count);
|
|
|
|
}
|
1999-08-26 14:53:31 +00:00
|
|
|
|
2000-02-07 23:05:40 +00:00
|
|
|
/*
|
|
|
|
* Same as above, but using the dev_t as argument
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
count_dev(dev)
|
|
|
|
dev_t dev;
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
|
|
|
|
|
|
|
vp = SLIST_FIRST(&dev->si_hlist);
|
|
|
|
if (vp == NULL)
|
|
|
|
return (0);
|
|
|
|
return(vcount(vp));
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Print out a description of a vnode.
|
|
|
|
*/
|
|
|
|
static char *typename[] =
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
{"VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD"};
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
vprint(label, vp)
|
|
|
|
char *label;
|
1999-08-26 14:53:31 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1998-12-04 22:54:57 +00:00
|
|
|
char buf[96];
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (label != NULL)
|
1998-07-11 07:46:16 +00:00
|
|
|
printf("%s: %p: ", label, (void *)vp);
|
1997-04-04 17:46:21 +00:00
|
|
|
else
|
1998-07-11 07:46:16 +00:00
|
|
|
printf("%p: ", (void *)vp);
|
2002-09-18 20:42:04 +00:00
|
|
|
printf("tag %s, type %s, usecount %d, writecount %d, refcount %d,",
|
|
|
|
vp->v_tag, typename[vp->v_type], vp->v_usecount,
|
|
|
|
vp->v_writecount, vp->v_holdcnt);
|
1994-05-24 10:09:53 +00:00
|
|
|
buf[0] = '\0';
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_vflag & VV_ROOT)
|
|
|
|
strcat(buf, "|VV_ROOT");
|
|
|
|
if (vp->v_vflag & VV_TEXT)
|
|
|
|
strcat(buf, "|VV_TEXT");
|
|
|
|
if (vp->v_vflag & VV_SYSTEM)
|
|
|
|
strcat(buf, "|VV_SYSTEM");
|
|
|
|
if (vp->v_iflag & VI_XLOCK)
|
|
|
|
strcat(buf, "|VI_XLOCK");
|
|
|
|
if (vp->v_iflag & VI_XWANT)
|
|
|
|
strcat(buf, "|VI_XWANT");
|
|
|
|
if (vp->v_iflag & VI_BWAIT)
|
|
|
|
strcat(buf, "|VI_BWAIT");
|
|
|
|
if (vp->v_iflag & VI_DOOMED)
|
|
|
|
strcat(buf, "|VI_DOOMED");
|
|
|
|
if (vp->v_iflag & VI_FREE)
|
|
|
|
strcat(buf, "|VI_FREE");
|
|
|
|
if (vp->v_vflag & VV_OBJBUF)
|
|
|
|
strcat(buf, "|VV_OBJBUF");
|
1994-05-24 10:09:53 +00:00
|
|
|
if (buf[0] != '\0')
|
2002-09-18 20:42:04 +00:00
|
|
|
printf(" flags (%s),", &buf[1]);
|
2002-10-14 03:20:36 +00:00
|
|
|
lockmgr_printinfo(vp->v_vnlock);
|
2002-09-18 20:42:04 +00:00
|
|
|
printf("\n");
|
|
|
|
if (vp->v_data != NULL) {
|
|
|
|
printf("\t");
|
1994-05-24 10:09:53 +00:00
|
|
|
VOP_PRINT(vp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1995-04-16 11:33:33 +00:00
|
|
|
#ifdef DDB
|
1998-10-25 17:44:59 +00:00
|
|
|
#include <ddb/ddb.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* List all of the locked vnodes in the system.
|
|
|
|
* Called when debugging the kernel.
|
|
|
|
*/
|
2002-06-29 04:45:09 +00:00
|
|
|
DB_SHOW_COMMAND(lockedvnods, lockedvnodes)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = curthread; /* XXX */
|
1997-02-25 19:33:23 +00:00
|
|
|
struct mount *mp, *nmp;
|
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
printf("Locked vnodes\n");
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
1999-11-20 10:00:46 +00:00
|
|
|
for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
|
2001-09-12 08:38:13 +00:00
|
|
|
if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) {
|
1999-11-20 10:00:46 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
1997-02-25 19:33:23 +00:00
|
|
|
continue;
|
|
|
|
}
|
2001-06-28 04:05:54 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
2001-10-23 01:21:29 +00:00
|
|
|
TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes) {
|
1999-12-11 16:13:02 +00:00
|
|
|
if (VOP_ISLOCKED(vp, NULL))
|
1997-02-25 19:33:23 +00:00
|
|
|
vprint((char *)0, vp);
|
|
|
|
}
|
2001-06-28 04:05:54 +00:00
|
|
|
mtx_unlock(&mntvnode_mtx);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
1999-11-20 10:00:46 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
2001-09-12 08:38:13 +00:00
|
|
|
vfs_unbusy(mp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mountlist_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
- Introduce a new struct xvfsconf, the userland version of struct vfsconf.
- Make getvfsbyname() take a struct xvfsconf *.
- Convert several consumers of getvfsbyname() to use struct xvfsconf.
- Correct the getvfsbyname.3 manpage.
- Create a new vfs.conflist sysctl to dump all the struct xvfsconf in the
kernel, and rewrite getvfsbyname() to use this instead of the weird
existing API.
- Convert some {set,get,end}vfsent() consumers to use the new vfs.conflist
sysctl.
- Convert a vfsload() call in nfsiod.c to kldload() and remove the useless
vfsisloadable() and endvfsent() calls.
- Add a warning printf() in vfs_sysctl() to tell people they are using
an old userland.
After these changes, it's possible to modify struct vfsconf without
breaking the binary compatibility. Please note that these changes don't
break this compatibility either.
When bp will have updated mount_smbfs(8) with the patch I sent him, there
will be no more consumers of the {set,get,end}vfsent(), vfsisloadable()
and vfsload() API, and I will promptly delete it.
2002-08-10 20:19:04 +00:00
|
|
|
/*
|
|
|
|
* Fill in a struct xvfsconf based on a struct vfsconf.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
vfsconf2x(struct vfsconf *vfsp, struct xvfsconf *xvfsp)
|
|
|
|
{
|
|
|
|
|
|
|
|
strcpy(xvfsp->vfc_name, vfsp->vfc_name);
|
|
|
|
xvfsp->vfc_typenum = vfsp->vfc_typenum;
|
|
|
|
xvfsp->vfc_refcount = vfsp->vfc_refcount;
|
|
|
|
xvfsp->vfc_flags = vfsp->vfc_flags;
|
|
|
|
/*
|
|
|
|
* These are unused in userland, we keep them
|
|
|
|
* to not break binary compatibility.
|
|
|
|
*/
|
|
|
|
xvfsp->vfc_vfsops = NULL;
|
|
|
|
xvfsp->vfc_next = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
sysctl_vfs_conflist(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct vfsconf *vfsp;
|
|
|
|
struct xvfsconf *xvfsp;
|
|
|
|
int cnt, error, i;
|
|
|
|
|
|
|
|
cnt = 0;
|
|
|
|
for (vfsp = vfsconf; vfsp != NULL; vfsp = vfsp->vfc_next)
|
|
|
|
cnt++;
|
2003-02-19 05:47:46 +00:00
|
|
|
xvfsp = malloc(sizeof(struct xvfsconf) * cnt, M_TEMP, M_WAITOK);
|
- Introduce a new struct xvfsconf, the userland version of struct vfsconf.
- Make getvfsbyname() take a struct xvfsconf *.
- Convert several consumers of getvfsbyname() to use struct xvfsconf.
- Correct the getvfsbyname.3 manpage.
- Create a new vfs.conflist sysctl to dump all the struct xvfsconf in the
kernel, and rewrite getvfsbyname() to use this instead of the weird
existing API.
- Convert some {set,get,end}vfsent() consumers to use the new vfs.conflist
sysctl.
- Convert a vfsload() call in nfsiod.c to kldload() and remove the useless
vfsisloadable() and endvfsent() calls.
- Add a warning printf() in vfs_sysctl() to tell people they are using
an old userland.
After these changes, it's possible to modify struct vfsconf without
breaking the binary compatibility. Please note that these changes don't
break this compatibility either.
When bp will have updated mount_smbfs(8) with the patch I sent him, there
will be no more consumers of the {set,get,end}vfsent(), vfsisloadable()
and vfsload() API, and I will promptly delete it.
2002-08-10 20:19:04 +00:00
|
|
|
/*
|
|
|
|
* Handle the race that we will have here when struct vfsconf
|
|
|
|
* will be locked down by using both cnt and checking vfc_next
|
|
|
|
* against NULL to determine the end of the loop. The race will
|
|
|
|
* happen because we will have to unlock before calling malloc().
|
|
|
|
* We are protected by Giant for now.
|
|
|
|
*/
|
|
|
|
i = 0;
|
|
|
|
for (vfsp = vfsconf; vfsp != NULL && i < cnt; vfsp = vfsp->vfc_next) {
|
|
|
|
vfsconf2x(vfsp, xvfsp + i);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
error = SYSCTL_OUT(req, xvfsp, sizeof(struct xvfsconf) * i);
|
|
|
|
free(xvfsp, M_TEMP);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_vfs, OID_AUTO, conflist, CTLFLAG_RD, NULL, 0, sysctl_vfs_conflist,
|
|
|
|
"S,xvfsconf", "List of all configured filesystems");
|
|
|
|
|
1997-03-03 12:58:20 +00:00
|
|
|
/*
|
|
|
|
* Top level filesystem related information gathering.
|
|
|
|
*/
|
2002-03-19 21:25:46 +00:00
|
|
|
static int sysctl_ovfs_conf(SYSCTL_HANDLER_ARGS);
|
1997-03-03 12:58:20 +00:00
|
|
|
|
1997-03-04 18:31:56 +00:00
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
vfs_sysctl(SYSCTL_HANDLER_ARGS)
|
1997-03-02 11:06:22 +00:00
|
|
|
{
|
1997-03-04 18:31:56 +00:00
|
|
|
int *name = (int *)arg1 - 1; /* XXX */
|
|
|
|
u_int namelen = arg2 + 1; /* XXX */
|
1997-03-02 11:06:22 +00:00
|
|
|
struct vfsconf *vfsp;
|
- Introduce a new struct xvfsconf, the userland version of struct vfsconf.
- Make getvfsbyname() take a struct xvfsconf *.
- Convert several consumers of getvfsbyname() to use struct xvfsconf.
- Correct the getvfsbyname.3 manpage.
- Create a new vfs.conflist sysctl to dump all the struct xvfsconf in the
kernel, and rewrite getvfsbyname() to use this instead of the weird
existing API.
- Convert some {set,get,end}vfsent() consumers to use the new vfs.conflist
sysctl.
- Convert a vfsload() call in nfsiod.c to kldload() and remove the useless
vfsisloadable() and endvfsent() calls.
- Add a warning printf() in vfs_sysctl() to tell people they are using
an old userland.
After these changes, it's possible to modify struct vfsconf without
breaking the binary compatibility. Please note that these changes don't
break this compatibility either.
When bp will have updated mount_smbfs(8) with the patch I sent him, there
will be no more consumers of the {set,get,end}vfsent(), vfsisloadable()
and vfsload() API, and I will promptly delete it.
2002-08-10 20:19:04 +00:00
|
|
|
struct xvfsconf xvfsp;
|
|
|
|
|
|
|
|
printf("WARNING: userland calling deprecated sysctl, "
|
|
|
|
"please rebuild world\n");
|
1997-03-02 11:06:22 +00:00
|
|
|
|
1998-08-29 13:13:10 +00:00
|
|
|
#if 1 || defined(COMPAT_PRELITE2)
|
1997-03-03 12:58:20 +00:00
|
|
|
/* Resolve ambiguity between VFS_VFSCONF and VFS_GENERIC. */
|
1997-03-04 18:31:56 +00:00
|
|
|
if (namelen == 1)
|
1997-03-03 12:58:20 +00:00
|
|
|
return (sysctl_ovfs_conf(oidp, arg1, arg2, req));
|
|
|
|
#endif
|
1997-03-02 11:06:22 +00:00
|
|
|
|
1997-03-03 12:58:20 +00:00
|
|
|
switch (name[1]) {
|
|
|
|
case VFS_MAXTYPENUM:
|
|
|
|
if (namelen != 2)
|
|
|
|
return (ENOTDIR);
|
|
|
|
return (SYSCTL_OUT(req, &maxvfsconf, sizeof(int)));
|
|
|
|
case VFS_CONF:
|
|
|
|
if (namelen != 3)
|
|
|
|
return (ENOTDIR); /* overloaded */
|
|
|
|
for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
|
|
|
|
if (vfsp->vfc_typenum == name[2])
|
|
|
|
break;
|
|
|
|
if (vfsp == NULL)
|
|
|
|
return (EOPNOTSUPP);
|
- Introduce a new struct xvfsconf, the userland version of struct vfsconf.
- Make getvfsbyname() take a struct xvfsconf *.
- Convert several consumers of getvfsbyname() to use struct xvfsconf.
- Correct the getvfsbyname.3 manpage.
- Create a new vfs.conflist sysctl to dump all the struct xvfsconf in the
kernel, and rewrite getvfsbyname() to use this instead of the weird
existing API.
- Convert some {set,get,end}vfsent() consumers to use the new vfs.conflist
sysctl.
- Convert a vfsload() call in nfsiod.c to kldload() and remove the useless
vfsisloadable() and endvfsent() calls.
- Add a warning printf() in vfs_sysctl() to tell people they are using
an old userland.
After these changes, it's possible to modify struct vfsconf without
breaking the binary compatibility. Please note that these changes don't
break this compatibility either.
When bp will have updated mount_smbfs(8) with the patch I sent him, there
will be no more consumers of the {set,get,end}vfsent(), vfsisloadable()
and vfsload() API, and I will promptly delete it.
2002-08-10 20:19:04 +00:00
|
|
|
vfsconf2x(vfsp, &xvfsp);
|
|
|
|
return (SYSCTL_OUT(req, &xvfsp, sizeof(xvfsp)));
|
1997-03-03 12:58:20 +00:00
|
|
|
}
|
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
1997-03-02 11:06:22 +00:00
|
|
|
|
- Introduce a new struct xvfsconf, the userland version of struct vfsconf.
- Make getvfsbyname() take a struct xvfsconf *.
- Convert several consumers of getvfsbyname() to use struct xvfsconf.
- Correct the getvfsbyname.3 manpage.
- Create a new vfs.conflist sysctl to dump all the struct xvfsconf in the
kernel, and rewrite getvfsbyname() to use this instead of the weird
existing API.
- Convert some {set,get,end}vfsent() consumers to use the new vfs.conflist
sysctl.
- Convert a vfsload() call in nfsiod.c to kldload() and remove the useless
vfsisloadable() and endvfsent() calls.
- Add a warning printf() in vfs_sysctl() to tell people they are using
an old userland.
After these changes, it's possible to modify struct vfsconf without
breaking the binary compatibility. Please note that these changes don't
break this compatibility either.
When bp will have updated mount_smbfs(8) with the patch I sent him, there
will be no more consumers of the {set,get,end}vfsent(), vfsisloadable()
and vfsload() API, and I will promptly delete it.
2002-08-10 20:19:04 +00:00
|
|
|
SYSCTL_NODE(_vfs, VFS_GENERIC, generic, CTLFLAG_RD | CTLFLAG_SKIP, vfs_sysctl,
|
1997-03-04 18:31:56 +00:00
|
|
|
"Generic filesystem");
|
|
|
|
|
1998-08-29 13:13:10 +00:00
|
|
|
#if 1 || defined(COMPAT_PRELITE2)
|
1997-03-02 11:06:22 +00:00
|
|
|
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_ovfs_conf(SYSCTL_HANDLER_ARGS)
|
1997-03-02 11:06:22 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct vfsconf *vfsp;
|
1997-03-03 12:58:20 +00:00
|
|
|
struct ovfsconf ovfs;
|
1997-03-02 11:06:22 +00:00
|
|
|
|
|
|
|
for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
|
|
|
|
ovfs.vfc_vfsops = vfsp->vfc_vfsops; /* XXX used as flag */
|
|
|
|
strcpy(ovfs.vfc_name, vfsp->vfc_name);
|
|
|
|
ovfs.vfc_index = vfsp->vfc_typenum;
|
|
|
|
ovfs.vfc_refcount = vfsp->vfc_refcount;
|
|
|
|
ovfs.vfc_flags = vfsp->vfc_flags;
|
|
|
|
error = SYSCTL_OUT(req, &ovfs, sizeof ovfs);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
1998-08-29 13:13:10 +00:00
|
|
|
#endif /* 1 || COMPAT_PRELITE2 */
|
1997-03-02 11:06:22 +00:00
|
|
|
|
2002-07-31 12:24:35 +00:00
|
|
|
#define KINFO_VNODESLOP 10
|
2003-02-23 18:09:05 +00:00
|
|
|
#ifdef notyet
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Dump vnode list (via sysctl).
|
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
1995-11-20 12:42:39 +00:00
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_vnode(SYSCTL_HANDLER_ARGS)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-07-31 12:24:35 +00:00
|
|
|
struct xvnode *xvn;
|
|
|
|
struct thread *td = req->td;
|
|
|
|
struct mount *mp;
|
|
|
|
struct vnode *vp;
|
|
|
|
int error, len, n;
|
1995-11-20 12:42:39 +00:00
|
|
|
|
2002-08-13 05:29:48 +00:00
|
|
|
/*
|
|
|
|
* Stale numvnodes access is not fatal here.
|
|
|
|
*/
|
1995-11-20 12:42:39 +00:00
|
|
|
req->lock = 0;
|
2002-07-31 12:24:35 +00:00
|
|
|
len = (numvnodes + KINFO_VNODESLOP) * sizeof *xvn;
|
|
|
|
if (!req->oldptr)
|
|
|
|
/* Make an estimate */
|
|
|
|
return (SYSCTL_OUT(req, 0, len));
|
These changes embody the support of the fully coherent merged VM buffer cache,
much higher filesystem I/O performance, and much better paging performance. It
represents the culmination of over 6 months of R&D.
The majority of the merged VM/cache work is by John Dyson.
The following highlights the most significant changes. Additionally, there are
(mostly minor) changes to the various filesystem modules (nfs, msdosfs, etc) to
support the new VM/buffer scheme.
vfs_bio.c:
Significant rewrite of most of vfs_bio to support the merged VM buffer cache
scheme. The scheme is almost fully compatible with the old filesystem
interface. Significant improvement in the number of opportunities for write
clustering.
vfs_cluster.c, vfs_subr.c
Upgrade and performance enhancements in vfs layer code to support merged
VM/buffer cache. Fixup of vfs_cluster to eliminate the bogus pagemove stuff.
vm_object.c:
Yet more improvements in the collapse code. Elimination of some windows that
can cause list corruption.
vm_pageout.c:
Fixed it, it really works better now. Somehow in 2.0, some "enhancements"
broke the code. This code has been reworked from the ground-up.
vm_fault.c, vm_page.c, pmap.c, vm_object.c
Support for small-block filesystems with merged VM/buffer cache scheme.
pmap.c vm_map.c
Dynamic kernel VM size, now we dont have to pre-allocate excessive numbers of
kernel PTs.
vm_glue.c
Much simpler and more effective swapping code. No more gratuitous swapping.
proc.h
Fixed the problem that the p_lock flag was not being cleared on a fork.
swap_pager.c, vnode_pager.c
Removal of old vfs_bio cruft to support the past pseudo-coherency. Now the
code doesn't need it anymore.
machdep.c
Changes to better support the parameter values for the merged VM/buffer cache
scheme.
machdep.c, kern_exec.c, vm_glue.c
Implemented a seperate submap for temporary exec string space and another one
to contain process upages. This eliminates all map fragmentation problems
that previously existed.
ffs_inode.c, ufs_inode.c, ufs_readwrite.c
Changes for merged VM/buffer cache. Add "bypass" support for sneaking in on
busy buffers.
Submitted by: John Dyson and David Greenman
1995-01-09 16:06:02 +00:00
|
|
|
|
2002-07-28 19:59:31 +00:00
|
|
|
sysctl_wire_old_buffer(req, 0);
|
2003-02-19 05:47:46 +00:00
|
|
|
xvn = malloc(len, M_TEMP, M_ZERO | M_WAITOK);
|
2002-07-31 12:24:35 +00:00
|
|
|
n = 0;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
2002-07-31 12:24:35 +00:00
|
|
|
TAILQ_FOREACH(mp, &mountlist, mnt_list) {
|
|
|
|
if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td))
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
2002-07-31 12:24:35 +00:00
|
|
|
TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes) {
|
|
|
|
if (n == len)
|
|
|
|
break;
|
|
|
|
vref(vp);
|
|
|
|
xvn[n].xv_size = sizeof *xvn;
|
|
|
|
xvn[n].xv_vnode = vp;
|
|
|
|
#define XV_COPY(field) xvn[n].xv_##field = vp->v_##field
|
|
|
|
XV_COPY(usecount);
|
|
|
|
XV_COPY(writecount);
|
|
|
|
XV_COPY(holdcnt);
|
|
|
|
XV_COPY(id);
|
|
|
|
XV_COPY(mount);
|
|
|
|
XV_COPY(numoutput);
|
|
|
|
XV_COPY(type);
|
|
|
|
#undef XV_COPY
|
2002-08-04 10:29:36 +00:00
|
|
|
xvn[n].xv_flag = vp->v_vflag;
|
|
|
|
|
2002-07-31 12:24:35 +00:00
|
|
|
switch (vp->v_type) {
|
|
|
|
case VREG:
|
|
|
|
case VDIR:
|
|
|
|
case VLNK:
|
|
|
|
xvn[n].xv_dev = vp->v_cachedfs;
|
|
|
|
xvn[n].xv_ino = vp->v_cachedid;
|
|
|
|
break;
|
|
|
|
case VBLK:
|
|
|
|
case VCHR:
|
|
|
|
if (vp->v_rdev == NULL) {
|
|
|
|
vrele(vp);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
xvn[n].xv_dev = dev2udev(vp->v_rdev);
|
|
|
|
break;
|
|
|
|
case VSOCK:
|
|
|
|
xvn[n].xv_socket = vp->v_socket;
|
|
|
|
break;
|
|
|
|
case VFIFO:
|
|
|
|
xvn[n].xv_fifo = vp->v_fifoinfo;
|
|
|
|
break;
|
|
|
|
case VNON:
|
|
|
|
case VBAD:
|
|
|
|
default:
|
|
|
|
/* shouldn't happen? */
|
|
|
|
vrele(vp);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
vrele(vp);
|
|
|
|
++n;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mntvnode_mtx);
|
|
|
|
mtx_lock(&mountlist_mtx);
|
2001-09-12 08:38:13 +00:00
|
|
|
vfs_unbusy(mp, td);
|
2002-07-31 12:24:35 +00:00
|
|
|
if (n == len)
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mountlist_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-07-31 12:24:35 +00:00
|
|
|
error = SYSCTL_OUT(req, xvn, n * sizeof *xvn);
|
|
|
|
free(xvn, M_TEMP);
|
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-12-06 13:27:39 +00:00
|
|
|
SYSCTL_PROC(_kern, KERN_VNODE, vnode, CTLTYPE_OPAQUE|CTLFLAG_RD,
|
2002-07-31 12:25:28 +00:00
|
|
|
0, 0, sysctl_vnode, "S,xvnode", "");
|
2003-02-23 18:09:05 +00:00
|
|
|
#endif
|
1995-11-20 12:42:39 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Check to see if a filesystem is mounted on a block device.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vfs_mountedon(vp)
|
1997-02-10 02:22:35 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
2000-10-09 17:31:39 +00:00
|
|
|
if (vp->v_rdev->si_mountpoint != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EBUSY);
|
1999-08-26 14:53:31 +00:00
|
|
|
return (0);
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-02-26 15:35:42 +00:00
|
|
|
* Unmount all filesystems. The list is traversed in reverse order
|
|
|
|
* of mounting to avoid dependencies.
|
1997-02-10 02:22:35 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
vfs_unmountall()
|
|
|
|
{
|
1999-11-20 10:00:46 +00:00
|
|
|
struct mount *mp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
int error;
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
if (curthread != NULL)
|
|
|
|
td = curthread;
|
1998-05-17 19:38:55 +00:00
|
|
|
else
|
2002-02-07 23:06:26 +00:00
|
|
|
td = FIRST_THREAD_IN_PROC(initproc); /* XXX XXX proc0? */
|
1997-02-26 15:35:42 +00:00
|
|
|
/*
|
|
|
|
* Since this only runs when rebooting, it is not interlocked.
|
|
|
|
*/
|
1999-11-20 10:00:46 +00:00
|
|
|
while(!TAILQ_EMPTY(&mountlist)) {
|
|
|
|
mp = TAILQ_LAST(&mountlist, mntlist);
|
2001-09-12 08:38:13 +00:00
|
|
|
error = dounmount(mp, MNT_FORCE, td);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error) {
|
1999-11-20 10:00:46 +00:00
|
|
|
TAILQ_REMOVE(&mountlist, mp, mnt_list);
|
1997-02-26 15:35:42 +00:00
|
|
|
printf("unmount of %s failed (",
|
|
|
|
mp->mnt_stat.f_mntonname);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error == EBUSY)
|
|
|
|
printf("BUSY)\n");
|
|
|
|
else
|
|
|
|
printf("%d)\n", error);
|
1999-11-20 10:00:46 +00:00
|
|
|
} else {
|
|
|
|
/* The unmount has removed mp from the mountlist */
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-05-21 21:39:31 +00:00
|
|
|
/*
|
|
|
|
* perform msync on all vnodes under a mount point
|
|
|
|
* the mount point must be locked.
|
|
|
|
*/
|
|
|
|
void
|
2001-10-23 01:21:29 +00:00
|
|
|
vfs_msync(struct mount *mp, int flags)
|
|
|
|
{
|
1995-12-11 04:58:34 +00:00
|
|
|
struct vnode *vp, *nvp;
|
1998-04-18 06:26:16 +00:00
|
|
|
struct vm_object *obj;
|
2001-10-26 00:08:05 +00:00
|
|
|
int tries;
|
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
|
|
|
|
2001-07-04 16:20:28 +00:00
|
|
|
GIANT_REQUIRED;
|
|
|
|
|
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
|
|
|
tries = 5;
|
2001-06-28 04:05:54 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
2001-10-26 00:08:05 +00:00
|
|
|
loop:
|
2001-10-23 01:21:29 +00:00
|
|
|
for (vp = TAILQ_FIRST(&mp->mnt_nvnodelist); vp != NULL; vp = nvp) {
|
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
|
|
|
if (vp->v_mount != mp) {
|
2001-10-26 00:08:05 +00:00
|
|
|
if (--tries > 0)
|
|
|
|
goto loop;
|
|
|
|
break;
|
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
|
|
|
}
|
2001-10-26 00:08:05 +00:00
|
|
|
nvp = TAILQ_NEXT(vp, v_nmntvnodes);
|
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
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
|
|
|
if (vp->v_iflag & VI_XLOCK) { /* XXX: what if MNT_WAIT? */
|
|
|
|
VI_UNLOCK(vp);
|
2001-08-27 06:09:56 +00:00
|
|
|
continue;
|
2002-09-25 02:22:21 +00:00
|
|
|
}
|
2001-08-27 06:09:56 +00:00
|
|
|
|
2002-08-04 10:29:36 +00:00
|
|
|
if ((vp->v_iflag & VI_OBJDIRTY) &&
|
2001-10-26 00:08:05 +00:00
|
|
|
(flags == MNT_WAIT || VOP_ISLOCKED(vp, NULL) == 0)) {
|
|
|
|
mtx_unlock(&mntvnode_mtx);
|
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
|
|
|
if (!vget(vp,
|
2002-09-25 02:22:21 +00:00
|
|
|
LK_EXCLUSIVE | LK_RETRY | LK_INTERLOCK,
|
|
|
|
curthread)) {
|
|
|
|
if (vp->v_vflag & VV_NOSYNC) { /* unlinked */
|
|
|
|
vput(vp);
|
2002-10-05 12:56:10 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
2002-09-25 02:22:21 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2000-09-12 09:49:08 +00:00
|
|
|
if (VOP_GETVOBJECT(vp, &obj) == 0) {
|
2001-05-19 01:28:09 +00:00
|
|
|
vm_object_page_clean(obj, 0, 0,
|
|
|
|
flags == MNT_WAIT ?
|
|
|
|
OBJPC_SYNC : OBJPC_NOSYNC);
|
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
|
|
|
}
|
|
|
|
vput(vp);
|
|
|
|
}
|
2001-10-26 00:08:05 +00:00
|
|
|
mtx_lock(&mntvnode_mtx);
|
|
|
|
if (TAILQ_NEXT(vp, v_nmntvnodes) != nvp) {
|
|
|
|
if (--tries > 0)
|
|
|
|
goto loop;
|
|
|
|
break;
|
|
|
|
}
|
2002-09-25 02:22:21 +00:00
|
|
|
} else
|
|
|
|
VI_UNLOCK(vp);
|
1995-05-21 21:39:31 +00:00
|
|
|
}
|
2001-06-28 04:05:54 +00:00
|
|
|
mtx_unlock(&mntvnode_mtx);
|
1995-05-21 21:39:31 +00:00
|
|
|
}
|
1996-08-21 21:56:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the VM object needed for VMIO and mmap support. This
|
|
|
|
* is done for all VREG files in the system. Some filesystems might
|
|
|
|
* afford the additional metadata buffering capability of the
|
|
|
|
* VMIO code by making the device node be VMIO mode also.
|
Make our v_usecount vnode reference count work identically to the
original BSD code. The association between the vnode and the vm_object
no longer includes reference counts. The major difference is that
vm_object's are no longer freed gratuitiously from the vnode, and so
once an object is created for the vnode, it will last as long as the
vnode does.
When a vnode object reference count is incremented, then the underlying
vnode reference count is incremented also. The two "objects" are now
more intimately related, and so the interactions are now much less
complex.
When vnodes are now normally placed onto the free queue with an object still
attached. The rundown of the object happens at vnode rundown time, and
happens with exactly the same filesystem semantics of the original VFS
code. There is absolutely no need for vnode_pager_uncache and other
travesties like that anymore.
A side-effect of these changes is that SMP locking should be much simpler,
the I/O copyin/copyout optimizations work, NFS should be more ponderable,
and further work on layered filesystems should be less frustrating, because
of the totally coherent management of the vnode objects and vnodes.
Please be careful with your system while running this code, but I would
greatly appreciate feedback as soon a reasonably possible.
1998-01-06 05:26:17 +00:00
|
|
|
*
|
1999-01-05 18:50:03 +00:00
|
|
|
* vp must be locked when vfs_object_create is called.
|
1996-08-21 21:56:23 +00:00
|
|
|
*/
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
vfs_object_create(vp, td, cred)
|
1996-08-21 21:56:23 +00:00
|
|
|
struct vnode *vp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1996-08-21 21:56:23 +00:00
|
|
|
struct ucred *cred;
|
|
|
|
{
|
2001-07-04 16:20:28 +00:00
|
|
|
GIANT_REQUIRED;
|
2001-09-12 08:38:13 +00:00
|
|
|
return (VOP_CREATEVOBJECT(vp, cred, td));
|
1996-08-21 21:56:23 +00:00
|
|
|
}
|
1. Add a {pointer, v_id} pair to the vnode to store the reference to the
".." vnode. This is cheaper storagewise than keeping it in the
namecache, and it makes more sense since it's a 1:1 mapping.
2. Also handle the case of "." more intelligently rather than stuff
the namecache with pointless entries.
3. Add two lists to the vnode and hang namecache entries which go from
or to this vnode. When cleaning a vnode, delete all namecache
entries it invalidates.
4. Never reuse namecache enties, malloc new ones when we need it, free
old ones when they die. No longer a hard limit on how many we can
have.
5. Remove the upper limit on namelength of namecache entries.
6. Make a global list for negative namecache entries, limit their number
to a sysctl'able (debug.ncnegfactor) fraction of the total namecache.
Currently the default fraction is 1/16th. (Suggestions for better
default wanted!)
7. Assign v_id correctly in the face of 32bit rollover.
8. Remove the LRU list for namecache entries, not needed. Remove the
#ifdef NCH_STATISTICS stuff, it's not needed either.
9. Use the vnode freelist as a true LRU list, also for namecache accesses.
10. Reuse vnodes more aggresively but also more selectively, if we can't
reuse, malloc a new one. There is no longer a hard limit on their
number, they grow to the point where we don't reuse potentially
usable vnodes. A vnode will not get recycled if still has pages in
core or if it is the source of namecache entries (Yes, this does
indeed work :-) "." and ".." are not namecache entries any longer...)
11. Do not overload the v_id field in namecache entries with whiteout
information, use a char sized flags field instead, so we can get
rid of the vpid and v_id fields from the namecache struct. Since
we're linked to the vnodes and purged when they're cleaned, we don't
have to check the v_id any more.
12. NFS knew about the limitation on name length in the namecache, it
shouldn't and doesn't now.
Bugs:
The namecache statistics no longer includes the hits for ".."
and "." hits.
Performance impact:
Generally in the +/- 0.5% for "normal" workstations, but
I hope this will allow the system to be selftuning over a
bigger range of "special" applications. The case where
RAM is available but unused for cache because we don't have
any vnodes should be gone.
Future work:
Straighten out the namecache statistics.
"desiredvnodes" is still used to (bogusly ?) size hash
tables in the filesystems.
I have still to find a way to safely free unused vnodes
back so their number can shrink when not needed.
There is a few uses of the v_id field left in the filesystems,
scheduled for demolition at a later time.
Maybe a one slot cache for unused namecache entries should
be implemented to decrease the malloc/free frequency.
1997-05-04 09:17:38 +00:00
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/*
|
|
|
|
* Mark a vnode as free, putting it up for recycling.
|
|
|
|
*/
|
2000-07-04 04:32:40 +00:00
|
|
|
void
|
1997-08-31 07:32:39 +00:00
|
|
|
vfree(vp)
|
1. Add a {pointer, v_id} pair to the vnode to store the reference to the
".." vnode. This is cheaper storagewise than keeping it in the
namecache, and it makes more sense since it's a 1:1 mapping.
2. Also handle the case of "." more intelligently rather than stuff
the namecache with pointless entries.
3. Add two lists to the vnode and hang namecache entries which go from
or to this vnode. When cleaning a vnode, delete all namecache
entries it invalidates.
4. Never reuse namecache enties, malloc new ones when we need it, free
old ones when they die. No longer a hard limit on how many we can
have.
5. Remove the upper limit on namelength of namecache entries.
6. Make a global list for negative namecache entries, limit their number
to a sysctl'able (debug.ncnegfactor) fraction of the total namecache.
Currently the default fraction is 1/16th. (Suggestions for better
default wanted!)
7. Assign v_id correctly in the face of 32bit rollover.
8. Remove the LRU list for namecache entries, not needed. Remove the
#ifdef NCH_STATISTICS stuff, it's not needed either.
9. Use the vnode freelist as a true LRU list, also for namecache accesses.
10. Reuse vnodes more aggresively but also more selectively, if we can't
reuse, malloc a new one. There is no longer a hard limit on their
number, they grow to the point where we don't reuse potentially
usable vnodes. A vnode will not get recycled if still has pages in
core or if it is the source of namecache entries (Yes, this does
indeed work :-) "." and ".." are not namecache entries any longer...)
11. Do not overload the v_id field in namecache entries with whiteout
information, use a char sized flags field instead, so we can get
rid of the vpid and v_id fields from the namecache struct. Since
we're linked to the vnodes and purged when they're cleaned, we don't
have to check the v_id any more.
12. NFS knew about the limitation on name length in the namecache, it
shouldn't and doesn't now.
Bugs:
The namecache statistics no longer includes the hits for ".."
and "." hits.
Performance impact:
Generally in the +/- 0.5% for "normal" workstations, but
I hope this will allow the system to be selftuning over a
bigger range of "special" applications. The case where
RAM is available but unused for cache because we don't have
any vnodes should be gone.
Future work:
Straighten out the namecache statistics.
"desiredvnodes" is still used to (bogusly ?) size hash
tables in the filesystems.
I have still to find a way to safely free unused vnodes
back so their number can shrink when not needed.
There is a few uses of the v_id field left in the filesystems,
scheduled for demolition at a later time.
Maybe a one slot cache for unused namecache entries should
be implemented to decrease the malloc/free frequency.
1997-05-04 09:17:38 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
{
|
1998-01-12 01:46:33 +00:00
|
|
|
int s;
|
|
|
|
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "vfree");
|
1998-01-12 01:46:33 +00:00
|
|
|
s = splbio();
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
2002-08-04 10:29:36 +00:00
|
|
|
KASSERT((vp->v_iflag & VI_FREE) == 0, ("vnode already free"));
|
|
|
|
if (vp->v_iflag & VI_AGE) {
|
1997-08-31 07:32:39 +00:00
|
|
|
TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
|
|
|
|
} else {
|
|
|
|
TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
|
1. Add a {pointer, v_id} pair to the vnode to store the reference to the
".." vnode. This is cheaper storagewise than keeping it in the
namecache, and it makes more sense since it's a 1:1 mapping.
2. Also handle the case of "." more intelligently rather than stuff
the namecache with pointless entries.
3. Add two lists to the vnode and hang namecache entries which go from
or to this vnode. When cleaning a vnode, delete all namecache
entries it invalidates.
4. Never reuse namecache enties, malloc new ones when we need it, free
old ones when they die. No longer a hard limit on how many we can
have.
5. Remove the upper limit on namelength of namecache entries.
6. Make a global list for negative namecache entries, limit their number
to a sysctl'able (debug.ncnegfactor) fraction of the total namecache.
Currently the default fraction is 1/16th. (Suggestions for better
default wanted!)
7. Assign v_id correctly in the face of 32bit rollover.
8. Remove the LRU list for namecache entries, not needed. Remove the
#ifdef NCH_STATISTICS stuff, it's not needed either.
9. Use the vnode freelist as a true LRU list, also for namecache accesses.
10. Reuse vnodes more aggresively but also more selectively, if we can't
reuse, malloc a new one. There is no longer a hard limit on their
number, they grow to the point where we don't reuse potentially
usable vnodes. A vnode will not get recycled if still has pages in
core or if it is the source of namecache entries (Yes, this does
indeed work :-) "." and ".." are not namecache entries any longer...)
11. Do not overload the v_id field in namecache entries with whiteout
information, use a char sized flags field instead, so we can get
rid of the vpid and v_id fields from the namecache struct. Since
we're linked to the vnodes and purged when they're cleaned, we don't
have to check the v_id any more.
12. NFS knew about the limitation on name length in the namecache, it
shouldn't and doesn't now.
Bugs:
The namecache statistics no longer includes the hits for ".."
and "." hits.
Performance impact:
Generally in the +/- 0.5% for "normal" workstations, but
I hope this will allow the system to be selftuning over a
bigger range of "special" applications. The case where
RAM is available but unused for cache because we don't have
any vnodes should be gone.
Future work:
Straighten out the namecache statistics.
"desiredvnodes" is still used to (bogusly ?) size hash
tables in the filesystems.
I have still to find a way to safely free unused vnodes
back so their number can shrink when not needed.
There is a few uses of the v_id field left in the filesystems,
scheduled for demolition at a later time.
Maybe a one slot cache for unused namecache entries should
be implemented to decrease the malloc/free frequency.
1997-05-04 09:17:38 +00:00
|
|
|
}
|
1997-08-31 07:32:39 +00:00
|
|
|
freevnodes++;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
2002-08-04 10:29:36 +00:00
|
|
|
vp->v_iflag &= ~VI_AGE;
|
|
|
|
vp->v_iflag |= VI_FREE;
|
1998-01-12 01:46:33 +00:00
|
|
|
splx(s);
|
1997-08-31 07:32:39 +00:00
|
|
|
}
|
|
|
|
|
2002-06-06 15:46:38 +00:00
|
|
|
/*
|
2000-09-22 12:22:36 +00:00
|
|
|
* Opposite of vfree() - mark a vnode as in use.
|
|
|
|
*/
|
1998-01-17 09:17:02 +00:00
|
|
|
void
|
1997-08-31 07:32:39 +00:00
|
|
|
vbusy(vp)
|
|
|
|
struct vnode *vp;
|
|
|
|
{
|
1998-01-12 01:46:33 +00:00
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splbio();
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "vbusy");
|
2002-08-04 10:29:36 +00:00
|
|
|
KASSERT((vp->v_iflag & VI_FREE) != 0, ("vnode not free"));
|
2002-09-25 02:22:21 +00:00
|
|
|
|
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
2000-07-04 04:32:40 +00:00
|
|
|
TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
|
|
|
|
freevnodes--;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
2002-09-25 02:22:21 +00:00
|
|
|
|
2002-08-04 10:29:36 +00:00
|
|
|
vp->v_iflag &= ~(VI_FREE|VI_AGE);
|
1998-01-12 01:46:33 +00:00
|
|
|
splx(s);
|
1. Add a {pointer, v_id} pair to the vnode to store the reference to the
".." vnode. This is cheaper storagewise than keeping it in the
namecache, and it makes more sense since it's a 1:1 mapping.
2. Also handle the case of "." more intelligently rather than stuff
the namecache with pointless entries.
3. Add two lists to the vnode and hang namecache entries which go from
or to this vnode. When cleaning a vnode, delete all namecache
entries it invalidates.
4. Never reuse namecache enties, malloc new ones when we need it, free
old ones when they die. No longer a hard limit on how many we can
have.
5. Remove the upper limit on namelength of namecache entries.
6. Make a global list for negative namecache entries, limit their number
to a sysctl'able (debug.ncnegfactor) fraction of the total namecache.
Currently the default fraction is 1/16th. (Suggestions for better
default wanted!)
7. Assign v_id correctly in the face of 32bit rollover.
8. Remove the LRU list for namecache entries, not needed. Remove the
#ifdef NCH_STATISTICS stuff, it's not needed either.
9. Use the vnode freelist as a true LRU list, also for namecache accesses.
10. Reuse vnodes more aggresively but also more selectively, if we can't
reuse, malloc a new one. There is no longer a hard limit on their
number, they grow to the point where we don't reuse potentially
usable vnodes. A vnode will not get recycled if still has pages in
core or if it is the source of namecache entries (Yes, this does
indeed work :-) "." and ".." are not namecache entries any longer...)
11. Do not overload the v_id field in namecache entries with whiteout
information, use a char sized flags field instead, so we can get
rid of the vpid and v_id fields from the namecache struct. Since
we're linked to the vnodes and purged when they're cleaned, we don't
have to check the v_id any more.
12. NFS knew about the limitation on name length in the namecache, it
shouldn't and doesn't now.
Bugs:
The namecache statistics no longer includes the hits for ".."
and "." hits.
Performance impact:
Generally in the +/- 0.5% for "normal" workstations, but
I hope this will allow the system to be selftuning over a
bigger range of "special" applications. The case where
RAM is available but unused for cache because we don't have
any vnodes should be gone.
Future work:
Straighten out the namecache statistics.
"desiredvnodes" is still used to (bogusly ?) size hash
tables in the filesystems.
I have still to find a way to safely free unused vnodes
back so their number can shrink when not needed.
There is a few uses of the v_id field left in the filesystems,
scheduled for demolition at a later time.
Maybe a one slot cache for unused namecache entries should
be implemented to decrease the malloc/free frequency.
1997-05-04 09:17:38 +00:00
|
|
|
}
|
1997-12-15 03:09:59 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Record a process's interest in events which might happen to
|
|
|
|
* a vnode. Because poll uses the historic select-style interface
|
|
|
|
* internally, this routine serves as both the ``check for any
|
|
|
|
* pending events'' and the ``record my interest in future events''
|
|
|
|
* functions. (These are done together, while the lock is held,
|
|
|
|
* to avoid race conditions.)
|
|
|
|
*/
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
vn_pollrecord(vp, td, events)
|
1997-12-15 03:09:59 +00:00
|
|
|
struct vnode *vp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1997-12-15 03:09:59 +00:00
|
|
|
short events;
|
|
|
|
{
|
2002-02-17 21:15:36 +00:00
|
|
|
|
2002-02-18 16:18:02 +00:00
|
|
|
if (vp->v_pollinfo == NULL)
|
2002-06-06 15:46:38 +00:00
|
|
|
v_addpollinfo(vp);
|
2002-02-17 21:15:36 +00:00
|
|
|
mtx_lock(&vp->v_pollinfo->vpi_lock);
|
|
|
|
if (vp->v_pollinfo->vpi_revents & events) {
|
1997-12-15 03:09:59 +00:00
|
|
|
/*
|
|
|
|
* This leaves events we are not interested
|
|
|
|
* in available for the other process which
|
|
|
|
* which presumably had requested them
|
|
|
|
* (otherwise they would never have been
|
|
|
|
* recorded).
|
|
|
|
*/
|
2002-02-17 21:15:36 +00:00
|
|
|
events &= vp->v_pollinfo->vpi_revents;
|
|
|
|
vp->v_pollinfo->vpi_revents &= ~events;
|
1997-12-15 03:09:59 +00:00
|
|
|
|
2002-02-17 21:15:36 +00:00
|
|
|
mtx_unlock(&vp->v_pollinfo->vpi_lock);
|
1997-12-15 03:09:59 +00:00
|
|
|
return events;
|
|
|
|
}
|
2002-02-17 21:15:36 +00:00
|
|
|
vp->v_pollinfo->vpi_events |= events;
|
|
|
|
selrecord(td, &vp->v_pollinfo->vpi_selinfo);
|
|
|
|
mtx_unlock(&vp->v_pollinfo->vpi_lock);
|
1997-12-15 03:09:59 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note the occurrence of an event. If the VN_POLLEVENT macro is used,
|
|
|
|
* it is possible for us to miss an event due to race conditions, but
|
|
|
|
* that condition is expected to be rare, so for the moment it is the
|
|
|
|
* preferred interface.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
vn_pollevent(vp, events)
|
|
|
|
struct vnode *vp;
|
|
|
|
short events;
|
|
|
|
{
|
2002-02-17 21:15:36 +00:00
|
|
|
|
2002-02-18 16:18:02 +00:00
|
|
|
if (vp->v_pollinfo == NULL)
|
2002-06-06 15:46:38 +00:00
|
|
|
v_addpollinfo(vp);
|
2002-02-17 21:15:36 +00:00
|
|
|
mtx_lock(&vp->v_pollinfo->vpi_lock);
|
|
|
|
if (vp->v_pollinfo->vpi_events & events) {
|
1997-12-15 03:09:59 +00:00
|
|
|
/*
|
|
|
|
* We clear vpi_events so that we don't
|
|
|
|
* call selwakeup() twice if two events are
|
|
|
|
* posted before the polling process(es) is
|
|
|
|
* awakened. This also ensures that we take at
|
|
|
|
* most one selwakeup() if the polling process
|
|
|
|
* is no longer interested. However, it does
|
|
|
|
* mean that only one event can be noticed at
|
|
|
|
* a time. (Perhaps we should only clear those
|
|
|
|
* event bits which we note?) XXX
|
|
|
|
*/
|
2002-02-17 21:15:36 +00:00
|
|
|
vp->v_pollinfo->vpi_events = 0; /* &= ~events ??? */
|
|
|
|
vp->v_pollinfo->vpi_revents |= events;
|
|
|
|
selwakeup(&vp->v_pollinfo->vpi_selinfo);
|
1997-12-15 03:09:59 +00:00
|
|
|
}
|
2002-02-17 21:15:36 +00:00
|
|
|
mtx_unlock(&vp->v_pollinfo->vpi_lock);
|
1997-12-15 03:09:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wake up anyone polling on vp because it is being revoked.
|
|
|
|
* This depends on dead_poll() returning POLLHUP for correct
|
|
|
|
* behavior.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
vn_pollgone(vp)
|
|
|
|
struct vnode *vp;
|
|
|
|
{
|
2002-02-17 21:15:36 +00:00
|
|
|
|
|
|
|
mtx_lock(&vp->v_pollinfo->vpi_lock);
|
2002-06-06 15:46:38 +00:00
|
|
|
VN_KNOTE(vp, NOTE_REVOKE);
|
2002-02-17 21:15:36 +00:00
|
|
|
if (vp->v_pollinfo->vpi_events) {
|
|
|
|
vp->v_pollinfo->vpi_events = 0;
|
|
|
|
selwakeup(&vp->v_pollinfo->vpi_selinfo);
|
1997-12-15 03:09:59 +00:00
|
|
|
}
|
2002-02-17 21:15:36 +00:00
|
|
|
mtx_unlock(&vp->v_pollinfo->vpi_lock);
|
1997-12-15 03:09:59 +00:00
|
|
|
}
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Routine to create and manage a filesystem syncer vnode.
|
|
|
|
*/
|
2002-03-19 21:25:46 +00:00
|
|
|
#define sync_close ((int (*)(struct vop_close_args *))nullop)
|
|
|
|
static int sync_fsync(struct vop_fsync_args *);
|
|
|
|
static int sync_inactive(struct vop_inactive_args *);
|
|
|
|
static int sync_reclaim(struct vop_reclaim_args *);
|
|
|
|
static int sync_print(struct vop_print_args *);
|
1998-03-08 09:59:44 +00:00
|
|
|
|
1998-12-21 23:38:33 +00:00
|
|
|
static vop_t **sync_vnodeop_p;
|
|
|
|
static struct vnodeopv_entry_desc sync_vnodeop_entries[] = {
|
1998-03-08 09:59:44 +00:00
|
|
|
{ &vop_default_desc, (vop_t *) vop_eopnotsupp },
|
|
|
|
{ &vop_close_desc, (vop_t *) sync_close }, /* close */
|
|
|
|
{ &vop_fsync_desc, (vop_t *) sync_fsync }, /* fsync */
|
|
|
|
{ &vop_inactive_desc, (vop_t *) sync_inactive }, /* inactive */
|
|
|
|
{ &vop_reclaim_desc, (vop_t *) sync_reclaim }, /* reclaim */
|
2002-07-09 19:54:20 +00:00
|
|
|
{ &vop_lock_desc, (vop_t *) vop_stdlock }, /* lock */
|
|
|
|
{ &vop_unlock_desc, (vop_t *) vop_stdunlock }, /* unlock */
|
1998-03-08 09:59:44 +00:00
|
|
|
{ &vop_print_desc, (vop_t *) sync_print }, /* print */
|
2002-07-09 19:54:20 +00:00
|
|
|
{ &vop_islocked_desc, (vop_t *) vop_stdislocked }, /* islocked */
|
1998-03-08 09:59:44 +00:00
|
|
|
{ NULL, NULL }
|
|
|
|
};
|
1998-12-21 23:38:33 +00:00
|
|
|
static struct vnodeopv_desc sync_vnodeop_opv_desc =
|
1998-03-08 09:59:44 +00:00
|
|
|
{ &sync_vnodeop_p, sync_vnodeop_entries };
|
|
|
|
|
|
|
|
VNODEOP_SET(sync_vnodeop_opv_desc);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a new filesystem syncer vnode for the specified mount point.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vfs_allocate_syncvnode(mp)
|
|
|
|
struct mount *mp;
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
|
|
|
static long start, incr, next;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* Allocate a new vnode */
|
2002-09-14 09:02:28 +00:00
|
|
|
if ((error = getnewvnode("vfs", mp, sync_vnodeop_p, &vp)) != 0) {
|
1998-03-08 09:59:44 +00:00
|
|
|
mp->mnt_syncer = NULL;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
vp->v_type = VNON;
|
|
|
|
/*
|
|
|
|
* Place the vnode onto the syncer worklist. We attempt to
|
|
|
|
* scatter them about on the list so that they will go off
|
|
|
|
* at evenly distributed times even if all the filesystems
|
|
|
|
* are mounted at once.
|
|
|
|
*/
|
|
|
|
next += incr;
|
|
|
|
if (next == 0 || next > syncer_maxdelay) {
|
|
|
|
start /= 2;
|
|
|
|
incr /= 2;
|
|
|
|
if (start == 0) {
|
|
|
|
start = syncer_maxdelay / 2;
|
|
|
|
incr = syncer_maxdelay;
|
|
|
|
}
|
|
|
|
next = start;
|
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
1998-03-08 09:59:44 +00:00
|
|
|
vn_syncer_add_to_worklist(vp, syncdelay > 0 ? next % syncdelay : 0);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1998-03-08 09:59:44 +00:00
|
|
|
mp->mnt_syncer = vp;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do a lazy sync of the filesystem.
|
|
|
|
*/
|
1998-12-21 23:38:33 +00:00
|
|
|
static int
|
1998-03-08 09:59:44 +00:00
|
|
|
sync_fsync(ap)
|
|
|
|
struct vop_fsync_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
struct ucred *a_cred;
|
|
|
|
int a_waitfor;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *a_td;
|
1998-03-08 09:59:44 +00:00
|
|
|
} */ *ap;
|
|
|
|
{
|
|
|
|
struct vnode *syncvp = ap->a_vp;
|
|
|
|
struct mount *mp = syncvp->v_mount;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = ap->a_td;
|
2002-10-25 00:20:37 +00:00
|
|
|
int error, asyncflag;
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We only need to do something if this is a lazy evaluation.
|
|
|
|
*/
|
|
|
|
if (ap->a_waitfor != MNT_LAZY)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move ourselves to the back of the sync list.
|
|
|
|
*/
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(syncvp);
|
1998-03-08 09:59:44 +00:00
|
|
|
vn_syncer_add_to_worklist(syncvp, syncdelay);
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(syncvp);
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Walk the list of vnodes pushing all that are dirty and
|
|
|
|
* not already on the sync list.
|
|
|
|
*/
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
2001-09-12 08:38:13 +00:00
|
|
|
if (vfs_busy(mp, LK_EXCLUSIVE | LK_NOWAIT, &mountlist_mtx, td) != 0) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mountlist_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
return (0);
|
1998-04-15 18:37:49 +00:00
|
|
|
}
|
2000-07-11 22:07:57 +00:00
|
|
|
if (vn_start_write(NULL, &mp, V_NOWAIT) != 0) {
|
2001-09-12 08:38:13 +00:00
|
|
|
vfs_unbusy(mp, td);
|
2000-07-11 22:07:57 +00:00
|
|
|
return (0);
|
|
|
|
}
|
1998-03-08 09:59:44 +00:00
|
|
|
asyncflag = mp->mnt_flag & MNT_ASYNC;
|
|
|
|
mp->mnt_flag &= ~MNT_ASYNC;
|
1998-04-16 03:31:26 +00:00
|
|
|
vfs_msync(mp, MNT_NOWAIT);
|
2002-10-25 00:20:37 +00:00
|
|
|
error = VFS_SYNC(mp, MNT_LAZY, ap->a_cred, td);
|
1998-03-08 09:59:44 +00:00
|
|
|
if (asyncflag)
|
|
|
|
mp->mnt_flag |= MNT_ASYNC;
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2001-09-12 08:38:13 +00:00
|
|
|
vfs_unbusy(mp, td);
|
2002-10-25 00:20:37 +00:00
|
|
|
return (error);
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The syncer vnode is no referenced.
|
|
|
|
*/
|
1998-12-21 23:38:33 +00:00
|
|
|
static int
|
1998-03-08 09:59:44 +00:00
|
|
|
sync_inactive(ap)
|
|
|
|
struct vop_inactive_args /* {
|
|
|
|
struct vnode *a_vp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *a_td;
|
1998-03-08 09:59:44 +00:00
|
|
|
} */ *ap;
|
|
|
|
{
|
|
|
|
|
2002-07-29 06:26:55 +00:00
|
|
|
VOP_UNLOCK(ap->a_vp, 0, ap->a_td);
|
1998-03-08 09:59:44 +00:00
|
|
|
vgone(ap->a_vp);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The syncer vnode is no longer needed and is being decommissioned.
|
1999-02-19 17:36:58 +00:00
|
|
|
*
|
|
|
|
* Modifications to the worklist must be protected at splbio().
|
1998-03-08 09:59:44 +00:00
|
|
|
*/
|
1998-12-21 23:38:33 +00:00
|
|
|
static int
|
1998-03-08 09:59:44 +00:00
|
|
|
sync_reclaim(ap)
|
|
|
|
struct vop_reclaim_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
} */ *ap;
|
|
|
|
{
|
|
|
|
struct vnode *vp = ap->a_vp;
|
1999-02-19 17:36:58 +00:00
|
|
|
int s;
|
1998-03-08 09:59:44 +00:00
|
|
|
|
1999-02-19 17:36:58 +00:00
|
|
|
s = splbio();
|
1998-03-08 09:59:44 +00:00
|
|
|
vp->v_mount->mnt_syncer = NULL;
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
|
|
|
if (vp->v_iflag & VI_ONWORKLST) {
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
LIST_REMOVE(vp, v_synclist);
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
2002-08-04 10:29:36 +00:00
|
|
|
vp->v_iflag &= ~VI_ONWORKLST;
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1999-02-19 17:36:58 +00:00
|
|
|
splx(s);
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print out a syncer vnode.
|
|
|
|
*/
|
1998-12-21 23:38:33 +00:00
|
|
|
static int
|
1998-03-08 09:59:44 +00:00
|
|
|
sync_print(ap)
|
|
|
|
struct vop_print_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
} */ *ap;
|
|
|
|
{
|
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
|
|
|
|
printf("syncer vnode");
|
|
|
|
if (vp->v_vnlock != NULL)
|
|
|
|
lockmgr_printinfo(vp->v_vnlock);
|
|
|
|
printf("\n");
|
|
|
|
return (0);
|
|
|
|
}
|
1999-07-18 14:30:37 +00:00
|
|
|
|
|
|
|
/*
|
2000-11-02 21:14:13 +00:00
|
|
|
* extract the dev_t from a VCHR
|
1999-07-18 14:30:37 +00:00
|
|
|
*/
|
|
|
|
dev_t
|
|
|
|
vn_todev(vp)
|
|
|
|
struct vnode *vp;
|
|
|
|
{
|
2000-11-02 21:14:13 +00:00
|
|
|
if (vp->v_type != VCHR)
|
1999-07-18 14:30:37 +00:00
|
|
|
return (NODEV);
|
|
|
|
return (vp->v_rdev);
|
|
|
|
}
|
1999-08-25 12:24:39 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if vnode represents a disk device
|
|
|
|
*/
|
|
|
|
int
|
2000-01-10 12:04:27 +00:00
|
|
|
vn_isdisk(vp, errp)
|
1999-08-25 12:24:39 +00:00
|
|
|
struct vnode *vp;
|
2000-01-10 12:04:27 +00:00
|
|
|
int *errp;
|
1999-08-25 12:24:39 +00:00
|
|
|
{
|
2000-09-05 21:09:56 +00:00
|
|
|
struct cdevsw *cdevsw;
|
|
|
|
|
2000-11-02 21:14:13 +00:00
|
|
|
if (vp->v_type != VCHR) {
|
2000-01-10 12:04:27 +00:00
|
|
|
if (errp != NULL)
|
|
|
|
*errp = ENOTBLK;
|
1999-08-25 12:24:39 +00:00
|
|
|
return (0);
|
2000-01-10 12:04:27 +00:00
|
|
|
}
|
2000-03-18 01:27:44 +00:00
|
|
|
if (vp->v_rdev == NULL) {
|
|
|
|
if (errp != NULL)
|
|
|
|
*errp = ENXIO;
|
|
|
|
return (0);
|
|
|
|
}
|
2000-09-05 21:09:56 +00:00
|
|
|
cdevsw = devsw(vp->v_rdev);
|
|
|
|
if (cdevsw == NULL) {
|
2000-01-10 12:04:27 +00:00
|
|
|
if (errp != NULL)
|
|
|
|
*errp = ENXIO;
|
1999-08-25 12:24:39 +00:00
|
|
|
return (0);
|
2000-01-10 12:04:27 +00:00
|
|
|
}
|
2000-09-05 21:09:56 +00:00
|
|
|
if (!(cdevsw->d_flags & D_DISK)) {
|
2000-01-10 12:04:27 +00:00
|
|
|
if (errp != NULL)
|
|
|
|
*errp = ENOTBLK;
|
1999-08-25 12:24:39 +00:00
|
|
|
return (0);
|
2000-01-10 12:04:27 +00:00
|
|
|
}
|
|
|
|
if (errp != NULL)
|
|
|
|
*errp = 0;
|
1999-08-25 12:24:39 +00:00
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/*
|
2000-10-05 18:22:46 +00:00
|
|
|
* Free data allocated by namei(); see namei(9) for details.
|
2000-09-22 12:22:36 +00:00
|
|
|
*/
|
2000-01-08 16:20:06 +00:00
|
|
|
void
|
|
|
|
NDFREE(ndp, flags)
|
|
|
|
struct nameidata *ndp;
|
|
|
|
const uint flags;
|
|
|
|
{
|
|
|
|
if (!(flags & NDF_NO_FREE_PNBUF) &&
|
|
|
|
(ndp->ni_cnd.cn_flags & HASBUF)) {
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zfree(namei_zone, ndp->ni_cnd.cn_pnbuf);
|
2000-01-08 16:20:06 +00:00
|
|
|
ndp->ni_cnd.cn_flags &= ~HASBUF;
|
|
|
|
}
|
|
|
|
if (!(flags & NDF_NO_DVP_UNLOCK) &&
|
|
|
|
(ndp->ni_cnd.cn_flags & LOCKPARENT) &&
|
|
|
|
ndp->ni_dvp != ndp->ni_vp)
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(ndp->ni_dvp, 0, ndp->ni_cnd.cn_thread);
|
2000-01-08 16:20:06 +00:00
|
|
|
if (!(flags & NDF_NO_DVP_RELE) &&
|
|
|
|
(ndp->ni_cnd.cn_flags & (LOCKPARENT|WANTPARENT))) {
|
|
|
|
vrele(ndp->ni_dvp);
|
|
|
|
ndp->ni_dvp = NULL;
|
|
|
|
}
|
|
|
|
if (!(flags & NDF_NO_VP_UNLOCK) &&
|
|
|
|
(ndp->ni_cnd.cn_flags & LOCKLEAF) && ndp->ni_vp)
|
2001-09-12 08:38:13 +00:00
|
|
|
VOP_UNLOCK(ndp->ni_vp, 0, ndp->ni_cnd.cn_thread);
|
2000-01-08 16:20:06 +00:00
|
|
|
if (!(flags & NDF_NO_VP_RELE) &&
|
|
|
|
ndp->ni_vp) {
|
|
|
|
vrele(ndp->ni_vp);
|
|
|
|
ndp->ni_vp = NULL;
|
|
|
|
}
|
|
|
|
if (!(flags & NDF_NO_STARTDIR_RELE) &&
|
|
|
|
(ndp->ni_cnd.cn_flags & SAVESTART)) {
|
|
|
|
vrele(ndp->ni_startdir);
|
|
|
|
ndp->ni_startdir = NULL;
|
|
|
|
}
|
|
|
|
}
|
2000-08-20 08:36:26 +00:00
|
|
|
|
2000-09-20 17:18:12 +00:00
|
|
|
/*
|
2002-05-16 21:28:32 +00:00
|
|
|
* Common filesystem object access control check routine. Accepts a
|
2000-09-20 17:18:12 +00:00
|
|
|
* vnode's type, "mode", uid and gid, requested access mode, credentials,
|
|
|
|
* and optional call-by-reference privused argument allowing vaccess()
|
|
|
|
* to indicate to the caller whether privilege was used to satisfy the
|
2002-07-31 02:05:12 +00:00
|
|
|
* request (obsoleted). Returns 0 on success, or an errno on failure.
|
2000-09-20 17:18:12 +00:00
|
|
|
*/
|
2000-08-20 08:36:26 +00:00
|
|
|
int
|
2000-08-29 14:45:49 +00:00
|
|
|
vaccess(type, file_mode, file_uid, file_gid, acc_mode, cred, privused)
|
2000-08-20 08:36:26 +00:00
|
|
|
enum vtype type;
|
|
|
|
mode_t file_mode;
|
2000-08-29 14:45:49 +00:00
|
|
|
uid_t file_uid;
|
|
|
|
gid_t file_gid;
|
2000-08-20 08:36:26 +00:00
|
|
|
mode_t acc_mode;
|
|
|
|
struct ucred *cred;
|
2000-08-29 14:45:49 +00:00
|
|
|
int *privused;
|
2000-08-20 08:36:26 +00:00
|
|
|
{
|
2000-08-29 14:45:49 +00:00
|
|
|
mode_t dac_granted;
|
|
|
|
#ifdef CAPABILITIES
|
|
|
|
mode_t cap_granted;
|
|
|
|
#endif
|
2000-08-20 08:36:26 +00:00
|
|
|
|
|
|
|
/*
|
2000-08-29 14:45:49 +00:00
|
|
|
* Look for a normal, non-privileged way to access the file/directory
|
|
|
|
* as requested. If it exists, go with that.
|
2000-08-20 08:36:26 +00:00
|
|
|
*/
|
2000-08-29 14:45:49 +00:00
|
|
|
|
|
|
|
if (privused != NULL)
|
|
|
|
*privused = 0;
|
|
|
|
|
|
|
|
dac_granted = 0;
|
|
|
|
|
|
|
|
/* Check the owner. */
|
|
|
|
if (cred->cr_uid == file_uid) {
|
2000-10-19 07:53:59 +00:00
|
|
|
dac_granted |= VADMIN;
|
2000-08-29 14:45:49 +00:00
|
|
|
if (file_mode & S_IXUSR)
|
|
|
|
dac_granted |= VEXEC;
|
|
|
|
if (file_mode & S_IRUSR)
|
|
|
|
dac_granted |= VREAD;
|
|
|
|
if (file_mode & S_IWUSR)
|
2002-07-22 03:57:07 +00:00
|
|
|
dac_granted |= (VWRITE | VAPPEND);
|
2000-08-29 14:45:49 +00:00
|
|
|
|
|
|
|
if ((acc_mode & dac_granted) == acc_mode)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
goto privcheck;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Otherwise, check the groups (first match) */
|
|
|
|
if (groupmember(file_gid, cred)) {
|
|
|
|
if (file_mode & S_IXGRP)
|
|
|
|
dac_granted |= VEXEC;
|
|
|
|
if (file_mode & S_IRGRP)
|
|
|
|
dac_granted |= VREAD;
|
|
|
|
if (file_mode & S_IWGRP)
|
2002-07-22 03:57:07 +00:00
|
|
|
dac_granted |= (VWRITE | VAPPEND);
|
2000-08-29 14:45:49 +00:00
|
|
|
|
|
|
|
if ((acc_mode & dac_granted) == acc_mode)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
goto privcheck;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Otherwise, check everyone else. */
|
|
|
|
if (file_mode & S_IXOTH)
|
|
|
|
dac_granted |= VEXEC;
|
|
|
|
if (file_mode & S_IROTH)
|
|
|
|
dac_granted |= VREAD;
|
|
|
|
if (file_mode & S_IWOTH)
|
2002-07-22 03:57:07 +00:00
|
|
|
dac_granted |= (VWRITE | VAPPEND);
|
2000-08-29 14:45:49 +00:00
|
|
|
if ((acc_mode & dac_granted) == acc_mode)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
privcheck:
|
2002-04-01 21:31:13 +00:00
|
|
|
if (!suser_cred(cred, PRISON_ROOT)) {
|
2000-08-29 14:45:49 +00:00
|
|
|
/* XXX audit: privilege used */
|
|
|
|
if (privused != NULL)
|
|
|
|
*privused = 1;
|
2000-08-20 08:36:26 +00:00
|
|
|
return (0);
|
2000-08-29 14:45:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CAPABILITIES
|
|
|
|
/*
|
|
|
|
* Build a capability mask to determine if the set of capabilities
|
|
|
|
* satisfies the requirements when combined with the granted mask
|
|
|
|
* from above.
|
|
|
|
* For each capability, if the capability is required, bitwise
|
|
|
|
* or the request type onto the cap_granted mask.
|
|
|
|
*/
|
|
|
|
cap_granted = 0;
|
2001-11-02 15:16:59 +00:00
|
|
|
|
|
|
|
if (type == VDIR) {
|
|
|
|
/*
|
|
|
|
* For directories, use CAP_DAC_READ_SEARCH to satisfy
|
|
|
|
* VEXEC requests, instead of CAP_DAC_EXECUTE.
|
|
|
|
*/
|
|
|
|
if ((acc_mode & VEXEC) && ((dac_granted & VEXEC) == 0) &&
|
|
|
|
!cap_check(cred, NULL, CAP_DAC_READ_SEARCH, PRISON_ROOT))
|
|
|
|
cap_granted |= VEXEC;
|
|
|
|
} else {
|
|
|
|
if ((acc_mode & VEXEC) && ((dac_granted & VEXEC) == 0) &&
|
|
|
|
!cap_check(cred, NULL, CAP_DAC_EXECUTE, PRISON_ROOT))
|
|
|
|
cap_granted |= VEXEC;
|
|
|
|
}
|
2000-08-29 14:45:49 +00:00
|
|
|
|
|
|
|
if ((acc_mode & VREAD) && ((dac_granted & VREAD) == 0) &&
|
2001-11-02 15:16:59 +00:00
|
|
|
!cap_check(cred, NULL, CAP_DAC_READ_SEARCH, PRISON_ROOT))
|
2000-08-29 14:45:49 +00:00
|
|
|
cap_granted |= VREAD;
|
|
|
|
|
|
|
|
if ((acc_mode & VWRITE) && ((dac_granted & VWRITE) == 0) &&
|
2001-11-02 15:16:59 +00:00
|
|
|
!cap_check(cred, NULL, CAP_DAC_WRITE, PRISON_ROOT))
|
2002-07-22 03:57:07 +00:00
|
|
|
cap_granted |= (VWRITE | VAPPEND);
|
2000-08-29 14:45:49 +00:00
|
|
|
|
2000-10-19 07:53:59 +00:00
|
|
|
if ((acc_mode & VADMIN) && ((dac_granted & VADMIN) == 0) &&
|
2001-11-02 15:16:59 +00:00
|
|
|
!cap_check(cred, NULL, CAP_FOWNER, PRISON_ROOT))
|
2000-10-19 07:53:59 +00:00
|
|
|
cap_granted |= VADMIN;
|
|
|
|
|
2000-09-06 12:18:24 +00:00
|
|
|
if ((acc_mode & (cap_granted | dac_granted)) == acc_mode) {
|
2000-08-29 14:45:49 +00:00
|
|
|
/* XXX audit: privilege used */
|
|
|
|
if (privused != NULL)
|
|
|
|
*privused = 1;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
#endif
|
2000-08-20 08:36:26 +00:00
|
|
|
|
2001-01-23 04:15:19 +00:00
|
|
|
return ((acc_mode & VADMIN) ? EPERM : EACCES);
|
2000-08-20 08:36:26 +00:00
|
|
|
}
|
2002-09-05 20:38:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Credential check based on process requesting service, and per-attribute
|
|
|
|
* permissions.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
extattr_check_cred(struct vnode *vp, int attrnamespace,
|
|
|
|
struct ucred *cred, struct thread *td, int access)
|
|
|
|
{
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Kernel-invoked always succeeds.
|
|
|
|
*/
|
2002-09-05 20:46:19 +00:00
|
|
|
if (cred == NOCRED)
|
2002-09-05 20:38:57 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do not allow privileged processes in jail to directly
|
|
|
|
* manipulate system attributes.
|
|
|
|
*
|
|
|
|
* XXX What capability should apply here?
|
|
|
|
* Probably CAP_SYS_SETFFLAG.
|
|
|
|
*/
|
|
|
|
switch (attrnamespace) {
|
|
|
|
case EXTATTR_NAMESPACE_SYSTEM:
|
|
|
|
/* Potentially should be: return (EPERM); */
|
|
|
|
return (suser_cred(cred, 0));
|
|
|
|
case EXTATTR_NAMESPACE_USER:
|
|
|
|
return (VOP_ACCESS(vp, access, cred, td));
|
|
|
|
default:
|
|
|
|
return (EPERM);
|
|
|
|
}
|
|
|
|
}
|