2005-01-06 23:35:40 +00:00
|
|
|
/*-
|
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.
|
|
|
|
* 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
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* External virtual filesystem routines
|
|
|
|
*/
|
2003-06-11 00:56:59 +00:00
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
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>
|
2005-09-12 08:46:07 +00:00
|
|
|
#include <sys/dirent.h>
|
2004-07-04 10:52:54 +00:00
|
|
|
#include <sys/event.h>
|
2000-01-07 08:36:44 +00:00
|
|
|
#include <sys/eventhandler.h>
|
2002-09-05 20:38:57 +00:00
|
|
|
#include <sys/extattr.h>
|
2005-06-09 20:20:31 +00:00
|
|
|
#include <sys/file.h>
|
1998-12-24 12:07:16 +00:00
|
|
|
#include <sys/fcntl.h>
|
2007-04-13 23:54:22 +00:00
|
|
|
#include <sys/jail.h>
|
2004-07-10 21:47:53 +00:00
|
|
|
#include <sys/kdb.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-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>
|
2006-11-06 13:42:10 +00:00
|
|
|
#include <sys/priv.h>
|
2004-08-20 19:21:47 +00:00
|
|
|
#include <sys/reboot.h>
|
Switch the sleep/wakeup and condition variable implementations to use the
sleep queue interface:
- Sleep queues attempt to merge some of the benefits of both sleep queues
and condition variables. Having sleep qeueus in a hash table avoids
having to allocate a queue head for each wait channel. Thus, struct cv
has shrunk down to just a single char * pointer now. However, the
hash table does not hold threads directly, but queue heads. This means
that once you have located a queue in the hash bucket, you no longer have
to walk the rest of the hash chain looking for threads. Instead, you have
a list of all the threads sleeping on that wait channel.
- Outside of the sleepq code and the sleep/cv code the kernel no longer
differentiates between cv's and sleep/wakeup. For example, calls to
abortsleep() and cv_abort() are replaced with a call to sleepq_abort().
Thus, the TDF_CVWAITQ flag is removed. Also, calls to unsleep() and
cv_waitq_remove() have been replaced with calls to sleepq_remove().
- The sched_sleep() function no longer accepts a priority argument as
sleep's no longer inherently bump the priority. Instead, this is soley
a propery of msleep() which explicitly calls sched_prio() before
blocking.
- The TDF_ONSLEEPQ flag has been dropped as it was never used. The
associated TDF_SET_ONSLEEPQ and TDF_CLR_ON_SLEEPQ macros have also been
dropped and replaced with a single explicit clearing of td_wchan.
TD_SET_ONSLEEPQ() would really have only made sense if it had taken
the wait channel and message as arguments anyway. Now that that only
happens in one place, a macro would be overkill.
2004-02-27 18:52:44 +00:00
|
|
|
#include <sys/sleepqueue.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
|
|
|
|
2005-01-24 13:58:08 +00:00
|
|
|
#include <machine/stdarg.h>
|
|
|
|
|
2006-10-22 11:52:19 +00:00
|
|
|
#include <security/mac/mac_framework.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>
|
2003-05-23 19:54:02 +00:00
|
|
|
#include <vm/vm_kern.h>
|
2002-03-20 04:09:59 +00:00
|
|
|
#include <vm/uma.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2006-09-04 22:15:44 +00:00
|
|
|
#ifdef DDB
|
|
|
|
#include <ddb/ddb.h>
|
|
|
|
#endif
|
|
|
|
|
2005-10-31 15:41:29 +00:00
|
|
|
static MALLOC_DEFINE(M_NETADDR, "subr_export_host", "Export host address structure");
|
1997-10-11 18:31:40 +00:00
|
|
|
|
2004-07-04 08:52:35 +00:00
|
|
|
static void delmntque(struct vnode *vp);
|
2005-02-19 11:44:57 +00:00
|
|
|
static int flushbuflist(struct bufv *bufv, int flags, struct bufobj *bo,
|
2005-01-11 10:01:54 +00:00
|
|
|
int slpflag, int slptimeo);
|
2004-07-01 23:59:19 +00:00
|
|
|
static void syncer_shutdown(void *arg, int howto);
|
2003-10-05 05:35:41 +00:00
|
|
|
static int vtryrecycle(struct vnode *vp);
|
2005-02-10 12:28:58 +00:00
|
|
|
static void vbusy(struct vnode *vp);
|
2005-03-13 11:54:28 +00:00
|
|
|
static void vinactive(struct vnode *, struct thread *);
|
2005-06-16 04:41:42 +00:00
|
|
|
static void v_incr_usecount(struct vnode *);
|
|
|
|
static void v_decr_usecount(struct vnode *);
|
|
|
|
static void v_decr_useonly(struct vnode *);
|
2006-02-01 00:30:05 +00:00
|
|
|
static void v_upgrade_usecount(struct vnode *);
|
2005-03-15 14:38:16 +00:00
|
|
|
static void vfree(struct vnode *);
|
2005-03-25 05:34:39 +00:00
|
|
|
static void vnlru_free(int);
|
|
|
|
static void vdestroy(struct vnode *);
|
2005-06-16 04:41:42 +00:00
|
|
|
static void vgonel(struct vnode *);
|
2005-07-01 16:28:32 +00:00
|
|
|
static void vfs_knllock(void *arg);
|
|
|
|
static void vfs_knlunlock(void *arg);
|
|
|
|
static int vfs_knllocked(void *arg);
|
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
|
2005-01-24 10:41:01 +00:00
|
|
|
/*
|
|
|
|
* Enable Giant pushdown based on whether or not the vm is mpsafe in this
|
|
|
|
* build. Without mpsafevm the buffer cache can not run Giant free.
|
|
|
|
*/
|
2005-02-23 10:05:43 +00:00
|
|
|
int mpsafe_vfs = 1;
|
2005-01-24 10:41:01 +00:00
|
|
|
TUNABLE_INT("debug.mpsafevfs", &mpsafe_vfs);
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, mpsafevfs, CTLFLAG_RD, &mpsafe_vfs, 0,
|
|
|
|
"MPSAFE VFS");
|
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/*
|
|
|
|
* Number of vnodes in existence. Increased whenever getnewvnode()
|
2006-10-02 07:25:58 +00:00
|
|
|
* allocates a new vnode, decreased on vdestroy() called on VI_DOOMed
|
|
|
|
* vnode.
|
2000-09-22 12:22:36 +00:00
|
|
|
*/
|
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,
|
|
|
|
};
|
2006-01-09 20:42:19 +00:00
|
|
|
int vttoif_tab[10] = {
|
1994-05-24 10:09:53 +00:00
|
|
|
0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK,
|
2006-01-09 20:42:19 +00:00
|
|
|
S_IFSOCK, S_IFIFO, S_IFMT, S_IFMT
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
|
|
|
|
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
|
|
|
/*
|
2005-03-25 05:34:39 +00:00
|
|
|
* Free vnode target. Free vnodes may simply be files which have been stat'd
|
|
|
|
* but not read. This is somewhat common, and a small cache of such files
|
|
|
|
* should be kept to avoid recreation costs.
|
2000-09-22 12:22:36 +00:00
|
|
|
*/
|
2005-03-25 05:34:39 +00:00
|
|
|
static u_long wantfreevnodes;
|
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, "");
|
|
|
|
|
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
|
|
|
|
|
|
|
/* 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;
|
2004-10-27 08:05:02 +00:00
|
|
|
LIST_HEAD(synclist, bufobj);
|
2000-09-22 12:22:36 +00:00
|
|
|
static struct synclist *syncer_workitem_pending;
|
2002-09-25 02:22:21 +00:00
|
|
|
/*
|
|
|
|
* The sync_mtx protects:
|
2004-10-27 08:05:02 +00:00
|
|
|
* bo->bo_synclist
|
2004-07-01 23:59:19 +00:00
|
|
|
* sync_vnode_count
|
2002-09-25 02:22:21 +00:00
|
|
|
* syncer_delayno
|
2004-07-05 01:07:33 +00:00
|
|
|
* syncer_state
|
2002-09-25 02:22:21 +00:00
|
|
|
* syncer_workitem_pending
|
2004-07-01 23:59:19 +00:00
|
|
|
* syncer_worklist_len
|
2002-09-25 02:22:21 +00:00
|
|
|
* 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
|
|
|
|
2004-07-01 23:59:19 +00:00
|
|
|
/*
|
2004-07-05 01:07:33 +00:00
|
|
|
* When shutting down the syncer, run it at four times normal speed.
|
2004-07-01 23:59:19 +00:00
|
|
|
*/
|
2004-07-05 01:07:33 +00:00
|
|
|
#define SYNCER_SHUTDOWN_SPEEDUP 4
|
2004-07-01 23:59:19 +00:00
|
|
|
static int sync_vnode_count;
|
|
|
|
static int syncer_worklist_len;
|
2004-07-05 01:07:33 +00:00
|
|
|
static enum { SYNCER_RUNNING, SYNCER_SHUTTING_DOWN, SYNCER_FINAL_DELAY }
|
|
|
|
syncer_state;
|
2004-07-01 23:59:19 +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");
|
2001-10-16 23:08:09 +00:00
|
|
|
SYSCTL_INT(_kern, OID_AUTO, minvnodes, CTLFLAG_RW,
|
2005-03-25 05:34:39 +00:00
|
|
|
&wantfreevnodes, 0, "Minimum number of vnodes (legacy)");
|
2001-12-19 01:35:18 +00:00
|
|
|
static int vnlru_nowhere;
|
2004-01-05 19:04:29 +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
|
|
|
|
2005-03-15 14:38:16 +00:00
|
|
|
/*
|
|
|
|
* Macros to control when a vnode is freed and recycled. All require
|
|
|
|
* the vnode interlock.
|
|
|
|
*/
|
|
|
|
#define VCANRECYCLE(vp) (((vp)->v_iflag & VI_FREE) && !(vp)->v_holdcnt)
|
|
|
|
#define VSHOULDFREE(vp) (!((vp)->v_iflag & VI_FREE) && !(vp)->v_holdcnt)
|
|
|
|
#define VSHOULDBUSY(vp) (((vp)->v_iflag & VI_FREE) && (vp)->v_holdcnt)
|
|
|
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Initialize the vnode management data structures.
|
|
|
|
*/
|
2004-08-16 08:33:37 +00:00
|
|
|
#ifndef MAXVNODES_MAX
|
|
|
|
#define MAXVNODES_MAX 100000
|
|
|
|
#endif
|
2000-12-06 07:09:08 +00:00
|
|
|
static void
|
|
|
|
vntblinit(void *dummy __unused)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
2003-05-23 19:54:02 +00:00
|
|
|
/*
|
|
|
|
* Desiredvnodes is a function of the physical memory size and
|
|
|
|
* the kernel's heap size. Specifically, desiredvnodes scales
|
|
|
|
* in proportion to the physical memory size until two fifths
|
|
|
|
* of the kernel's heap size is consumed by vnodes and vm
|
2004-01-05 19:04:29 +00:00
|
|
|
* objects.
|
2003-05-23 19:54:02 +00:00
|
|
|
*/
|
2007-05-31 22:52:15 +00:00
|
|
|
desiredvnodes = min(maxproc + cnt.v_page_count / 4, 2 * vm_kmem_size /
|
|
|
|
(5 * (sizeof(struct vm_object) + sizeof(struct vnode))));
|
2004-08-16 08:33:37 +00:00
|
|
|
if (desiredvnodes > MAXVNODES_MAX) {
|
2004-08-02 21:52:43 +00:00
|
|
|
if (bootverbose)
|
|
|
|
printf("Reducing kern.maxvnodes %d -> %d\n",
|
2004-08-16 08:33:37 +00:00
|
|
|
desiredvnodes, MAXVNODES_MAX);
|
|
|
|
desiredvnodes = MAXVNODES_MAX;
|
2004-08-02 21:52:43 +00:00
|
|
|
}
|
2007-04-10 15:29:37 +00:00
|
|
|
wantfreevnodes = desiredvnodes / 4;
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&mntid_mtx, "mntid", 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),
|
2007-04-10 15:29:37 +00:00
|
|
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
vfs_busy(struct mount *mp, int flags, struct mtx *interlkp,
|
|
|
|
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
|
|
|
|
2005-01-24 10:41:01 +00:00
|
|
|
MNT_ILOCK(mp);
|
2006-02-22 06:20:12 +00:00
|
|
|
MNT_REF(mp);
|
1997-11-12 05:42:33 +00:00
|
|
|
if (mp->mnt_kern_flag & MNTK_UNMOUNT) {
|
2005-01-24 10:41:01 +00:00
|
|
|
if (flags & LK_NOWAIT) {
|
2006-02-22 06:20:12 +00:00
|
|
|
MNT_REL(mp);
|
2005-01-24 10:41:01 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
1997-02-10 02:22:35 +00:00
|
|
|
return (ENOENT);
|
2005-01-24 10:41:01 +00:00
|
|
|
}
|
|
|
|
if (interlkp)
|
|
|
|
mtx_unlock(interlkp);
|
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.
|
|
|
|
*/
|
2006-02-22 06:20:12 +00:00
|
|
|
msleep(mp, MNT_MTX(mp), PVFS, "vfs_busy", 0);
|
|
|
|
MNT_REL(mp);
|
|
|
|
MNT_IUNLOCK(mp);
|
2005-01-24 10:41:01 +00:00
|
|
|
if (interlkp)
|
|
|
|
mtx_lock(interlkp);
|
1997-02-10 02:22:35 +00:00
|
|
|
return (ENOENT);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
if (interlkp)
|
2005-01-24 10:41:01 +00:00
|
|
|
mtx_unlock(interlkp);
|
2005-03-31 04:37:09 +00:00
|
|
|
lkflags = LK_SHARED | LK_INTERLOCK;
|
2005-01-24 10:41:01 +00:00
|
|
|
if (lockmgr(&mp->mnt_lock, lkflags, MNT_MTX(mp), 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
|
2006-01-21 19:42:10 +00:00
|
|
|
vfs_unbusy(struct mount *mp, 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);
|
2006-03-31 03:53:25 +00:00
|
|
|
vfs_rel(mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lookup a mount point by filesystem identifier.
|
|
|
|
*/
|
|
|
|
struct mount *
|
2006-01-21 19:42:10 +00:00
|
|
|
vfs_getvfs(fsid_t *fsid)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-01-28 12:39:10 +00:00
|
|
|
struct mount *mp;
|
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(&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]) {
|
2006-03-31 03:53:25 +00:00
|
|
|
vfs_ref(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_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
|
|
|
}
|
|
|
|
|
2004-07-06 09:37:43 +00:00
|
|
|
/*
|
2007-04-10 15:22:40 +00:00
|
|
|
* Check if a user can access privileged mount options.
|
2004-07-06 09:37:43 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
vfs_suser(struct mount *mp, struct thread *td)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2007-04-13 23:54:22 +00:00
|
|
|
/*
|
|
|
|
* If the thread is jailed, but this is not a jail-friendly file
|
|
|
|
* system, deny immediately.
|
|
|
|
*/
|
|
|
|
if (jailed(td->td_ucred) && !(mp->mnt_vfc->vfc_flags & VFCF_JAIL))
|
|
|
|
return (EPERM);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the file system was mounted outside a jail and a jailed thread
|
|
|
|
* tries to access it, deny immediately.
|
|
|
|
*/
|
|
|
|
if (!jailed(mp->mnt_cred) && jailed(td->td_ucred))
|
|
|
|
return (EPERM);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the file system was mounted inside different jail that the jail of
|
|
|
|
* the calling thread, deny immediately.
|
|
|
|
*/
|
|
|
|
if (jailed(mp->mnt_cred) && jailed(td->td_ucred) &&
|
|
|
|
mp->mnt_cred->cr_prison != td->td_ucred->cr_prison) {
|
|
|
|
return (EPERM);
|
|
|
|
}
|
|
|
|
|
2004-07-06 09:37:43 +00:00
|
|
|
if ((mp->mnt_flag & MNT_USER) == 0 ||
|
|
|
|
mp->mnt_cred->cr_uid != td->td_ucred->cr_uid) {
|
2006-11-06 13:42:10 +00:00
|
|
|
if ((error = priv_check(td, PRIV_VFS_MOUNT_OWNER)) != 0)
|
2004-07-06 09:37:43 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
return (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
|
2006-01-21 19:42:10 +00:00
|
|
|
vfs_getnewfsid(struct mount *mp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-03-14 14:19:49 +00:00
|
|
|
static u_int16_t mntid_base;
|
2006-03-31 03:53:25 +00:00
|
|
|
struct mount *nmp;
|
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 (;;) {
|
2004-06-17 17:16:53 +00:00
|
|
|
tfsid.val[0] = makedev(255,
|
2000-07-07 14:01:08 +00:00
|
|
|
mtype | ((mntid_base & 0xFF00) << 8) | (mntid_base & 0xFF));
|
|
|
|
mntid_base++;
|
2006-03-31 03:53:25 +00:00
|
|
|
if ((nmp = vfs_getvfs(&tfsid)) == NULL)
|
1999-09-19 06:24:21 +00:00
|
|
|
break;
|
2006-03-31 03:53:25 +00:00
|
|
|
vfs_rel(nmp);
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
vfs_timestamp(struct timespec *tsp)
|
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
|
|
|
{
|
|
|
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
vattr_null(struct vattr *vap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
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
|
2003-03-26 22:15:58 +00:00
|
|
|
vlrureclaim(struct mount *mp)
|
2001-10-26 00:08:05 +00:00
|
|
|
{
|
2005-06-16 04:41:42 +00:00
|
|
|
struct thread *td;
|
2001-10-26 00:08:05 +00:00
|
|
|
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;
|
2003-03-26 22:15:58 +00:00
|
|
|
int count;
|
2002-01-10 18:31:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2007-05-31 22:52:15 +00:00
|
|
|
trigger = cnt.v_page_count * 2 / usevnodes;
|
2001-12-18 20:48:54 +00:00
|
|
|
done = 0;
|
2005-06-16 04:41:42 +00:00
|
|
|
td = curthread;
|
2005-03-13 11:54:28 +00:00
|
|
|
vn_start_write(NULL, &mp, V_WAIT);
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_ILOCK(mp);
|
2003-03-26 22:15:58 +00:00
|
|
|
count = mp->mnt_nvnodelistsize / 10 + 1;
|
2006-01-09 20:42:19 +00:00
|
|
|
while (count != 0) {
|
|
|
|
vp = TAILQ_FIRST(&mp->mnt_nvnodelist);
|
|
|
|
while (vp != NULL && vp->v_type == VMARKER)
|
|
|
|
vp = TAILQ_NEXT(vp, v_nmntvnodes);
|
|
|
|
if (vp == NULL)
|
|
|
|
break;
|
2001-10-26 00:08:05 +00:00
|
|
|
TAILQ_REMOVE(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
|
|
|
|
TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
|
|
|
|
--count;
|
2005-06-16 04:41:42 +00:00
|
|
|
if (!VI_TRYLOCK(vp))
|
2005-08-23 03:44:06 +00:00
|
|
|
goto next_iter;
|
2005-06-16 04:41:42 +00:00
|
|
|
/*
|
|
|
|
* If it's been deconstructed already, it's still
|
|
|
|
* referenced, or it exceeds the trigger, skip it.
|
|
|
|
*/
|
2005-08-23 03:44:06 +00:00
|
|
|
if (vp->v_usecount || !LIST_EMPTY(&(vp)->v_cache_src) ||
|
|
|
|
(vp->v_iflag & VI_DOOMED) != 0 || (vp->v_object != NULL &&
|
2005-06-16 04:41:42 +00:00
|
|
|
vp->v_object->resident_page_count > trigger)) {
|
|
|
|
VI_UNLOCK(vp);
|
2005-08-23 03:44:06 +00:00
|
|
|
goto next_iter;
|
2005-06-16 04:41:42 +00:00
|
|
|
}
|
|
|
|
MNT_IUNLOCK(mp);
|
|
|
|
vholdl(vp);
|
2005-08-23 03:44:06 +00:00
|
|
|
if (VOP_LOCK(vp, LK_INTERLOCK|LK_EXCLUSIVE|LK_NOWAIT, td)) {
|
2005-06-16 04:41:42 +00:00
|
|
|
vdrop(vp);
|
2005-08-23 03:44:06 +00:00
|
|
|
goto next_iter_mntunlocked;
|
2005-06-16 04:41:42 +00:00
|
|
|
}
|
|
|
|
VI_LOCK(vp);
|
2005-08-23 03:44:06 +00:00
|
|
|
/*
|
|
|
|
* v_usecount may have been bumped after VOP_LOCK() dropped
|
|
|
|
* the vnode interlock and before it was locked again.
|
|
|
|
*
|
|
|
|
* It is not necessary to recheck VI_DOOMED because it can
|
|
|
|
* only be set by another thread that holds both the vnode
|
|
|
|
* lock and vnode interlock. If another thread has the
|
|
|
|
* vnode lock before we get to VOP_LOCK() and obtains the
|
|
|
|
* vnode interlock after VOP_LOCK() drops the vnode
|
|
|
|
* interlock, the other thread will be unable to drop the
|
|
|
|
* vnode lock before our VOP_LOCK() call fails.
|
|
|
|
*/
|
|
|
|
if (vp->v_usecount || !LIST_EMPTY(&(vp)->v_cache_src) ||
|
2007-04-10 15:29:37 +00:00
|
|
|
(vp->v_object != NULL &&
|
2005-08-23 03:44:06 +00:00
|
|
|
vp->v_object->resident_page_count > trigger)) {
|
|
|
|
VOP_UNLOCK(vp, LK_INTERLOCK, td);
|
|
|
|
goto next_iter_mntunlocked;
|
|
|
|
}
|
|
|
|
KASSERT((vp->v_iflag & VI_DOOMED) == 0,
|
|
|
|
("VI_DOOMED unexpectedly detected in vlrureclaim()"));
|
2005-06-16 04:41:42 +00:00
|
|
|
vgonel(vp);
|
|
|
|
VOP_UNLOCK(vp, 0, td);
|
|
|
|
vdropl(vp);
|
|
|
|
done++;
|
2005-08-23 03:44:06 +00:00
|
|
|
next_iter_mntunlocked:
|
|
|
|
if ((count % 256) != 0)
|
|
|
|
goto relock_mnt;
|
|
|
|
goto yield;
|
|
|
|
next_iter:
|
|
|
|
if ((count % 256) != 0)
|
|
|
|
continue;
|
|
|
|
MNT_IUNLOCK(mp);
|
|
|
|
yield:
|
|
|
|
uio_yield();
|
|
|
|
relock_mnt:
|
2005-06-16 04:41:42 +00:00
|
|
|
MNT_ILOCK(mp);
|
2001-10-26 00:08:05 +00:00
|
|
|
}
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
2005-03-13 11:54:28 +00:00
|
|
|
vn_finished_write(mp);
|
2001-12-18 20:48:54 +00:00
|
|
|
return done;
|
|
|
|
}
|
|
|
|
|
2005-03-25 05:34:39 +00:00
|
|
|
/*
|
|
|
|
* Attempt to keep the free list at wantfreevnodes length.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
vnlru_free(int count)
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
2006-04-04 06:46:10 +00:00
|
|
|
int vfslocked;
|
2005-03-25 05:34:39 +00:00
|
|
|
|
|
|
|
mtx_assert(&vnode_free_list_mtx, MA_OWNED);
|
|
|
|
for (; count > 0; count--) {
|
|
|
|
vp = TAILQ_FIRST(&vnode_free_list);
|
|
|
|
/*
|
|
|
|
* The list can be modified while the free_list_mtx
|
|
|
|
* has been dropped and vp could be NULL here.
|
|
|
|
*/
|
|
|
|
if (!vp)
|
|
|
|
break;
|
2005-06-11 01:16:46 +00:00
|
|
|
VNASSERT(vp->v_op != NULL, vp,
|
|
|
|
("vnlru_free: vnode already reclaimed."));
|
2005-03-25 05:34:39 +00:00
|
|
|
TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
|
|
|
|
/*
|
|
|
|
* Don't recycle if we can't get the interlock.
|
|
|
|
*/
|
2005-04-30 11:22:40 +00:00
|
|
|
if (!VI_TRYLOCK(vp)) {
|
|
|
|
TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
|
2005-03-25 05:34:39 +00:00
|
|
|
continue;
|
2005-04-30 11:22:40 +00:00
|
|
|
}
|
2005-06-16 04:41:42 +00:00
|
|
|
VNASSERT(VCANRECYCLE(vp), vp,
|
|
|
|
("vp inconsistent on freelist"));
|
2005-03-25 05:34:39 +00:00
|
|
|
freevnodes--;
|
2005-04-30 11:22:40 +00:00
|
|
|
vp->v_iflag &= ~VI_FREE;
|
2005-06-16 04:41:42 +00:00
|
|
|
vholdl(vp);
|
2005-03-25 05:34:39 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
2005-06-16 04:41:42 +00:00
|
|
|
VI_UNLOCK(vp);
|
2006-04-04 06:46:10 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2005-06-16 04:41:42 +00:00
|
|
|
vtryrecycle(vp);
|
2006-04-04 06:46:10 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2005-06-16 04:41:42 +00:00
|
|
|
/*
|
|
|
|
* If the recycled succeeded this vdrop will actually free
|
|
|
|
* the vnode. If not it will simply place it back on
|
|
|
|
* the free list.
|
|
|
|
*/
|
|
|
|
vdrop(vp);
|
2005-03-25 05:34:39 +00:00
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
|
|
|
}
|
|
|
|
}
|
2001-12-18 20:48:54 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
2003-03-26 22:15:58 +00:00
|
|
|
int done;
|
2001-12-18 20:48:54 +00:00
|
|
|
struct proc *p = vnlruproc;
|
2004-03-29 22:45:33 +00:00
|
|
|
struct thread *td = FIRST_THREAD_IN_PROC(p);
|
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
|
|
|
|
|
|
|
for (;;) {
|
2007-10-20 23:23:23 +00:00
|
|
|
kproc_suspend_check(p);
|
2002-08-13 05:29:48 +00:00
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
2005-03-25 05:34:39 +00:00
|
|
|
if (freevnodes > wantfreevnodes)
|
|
|
|
vnlru_free(freevnodes - wantfreevnodes);
|
|
|
|
if (numvnodes <= desiredvnodes * 9 / 10) {
|
2001-12-18 20:48:54 +00:00
|
|
|
vnlruproc_sig = 0;
|
2002-12-29 10:39:05 +00:00
|
|
|
wakeup(&vnlruproc_sig);
|
2005-01-24 10:41:01 +00:00
|
|
|
msleep(vnlruproc, &vnode_free_list_mtx,
|
|
|
|
PVFS|PDROP, "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);
|
|
|
|
for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
|
2005-07-20 01:43:27 +00:00
|
|
|
int vfsunlocked;
|
2001-12-18 20:48:54 +00:00
|
|
|
if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) {
|
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-20 01:43:27 +00:00
|
|
|
if (!VFS_NEEDSGIANT(mp)) {
|
|
|
|
mtx_unlock(&Giant);
|
|
|
|
vfsunlocked = 1;
|
|
|
|
} else
|
|
|
|
vfsunlocked = 0;
|
2003-03-26 22:15:58 +00:00
|
|
|
done += vlrureclaim(mp);
|
2005-07-20 01:43:27 +00:00
|
|
|
if (vfsunlocked)
|
|
|
|
mtx_lock(&Giant);
|
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) {
|
2007-04-13 08:38:48 +00:00
|
|
|
EVENTHANDLER_INVOKE(vfs_lowvnodes, desiredvnodes / 10);
|
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);
|
2007-04-10 15:29:37 +00:00
|
|
|
} else
|
2005-07-20 01:43:27 +00:00
|
|
|
uio_yield();
|
2001-12-18 20:48:54 +00:00
|
|
|
}
|
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.
|
|
|
|
*/
|
|
|
|
|
2005-03-25 05:34:39 +00:00
|
|
|
static void
|
|
|
|
vdestroy(struct vnode *vp)
|
|
|
|
{
|
|
|
|
struct bufobj *bo;
|
|
|
|
|
2005-06-13 00:46:37 +00:00
|
|
|
CTR1(KTR_VFS, "vdestroy vp %p", vp);
|
2005-06-16 04:41:42 +00:00
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
|
|
|
numvnodes--;
|
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
2005-03-25 05:34:39 +00:00
|
|
|
bo = &vp->v_bufobj;
|
2005-06-11 01:16:46 +00:00
|
|
|
VNASSERT((vp->v_iflag & VI_FREE) == 0, vp,
|
|
|
|
("cleaned vnode still on the free list."));
|
2005-03-25 05:34:39 +00:00
|
|
|
VNASSERT(vp->v_data == NULL, vp, ("cleaned vnode isn't"));
|
2005-06-11 01:16:46 +00:00
|
|
|
VNASSERT(vp->v_holdcnt == 0, vp, ("Non-zero hold count"));
|
2005-03-25 05:34:39 +00:00
|
|
|
VNASSERT(vp->v_usecount == 0, vp, ("Non-zero use count"));
|
|
|
|
VNASSERT(vp->v_writecount == 0, vp, ("Non-zero write count"));
|
|
|
|
VNASSERT(bo->bo_numoutput == 0, vp, ("Clean vnode has pending I/O's"));
|
|
|
|
VNASSERT(bo->bo_clean.bv_cnt == 0, vp, ("cleanbufcnt not 0"));
|
|
|
|
VNASSERT(bo->bo_clean.bv_root == NULL, vp, ("cleanblkroot not NULL"));
|
|
|
|
VNASSERT(bo->bo_dirty.bv_cnt == 0, vp, ("dirtybufcnt not 0"));
|
|
|
|
VNASSERT(bo->bo_dirty.bv_root == NULL, vp, ("dirtyblkroot not NULL"));
|
2005-06-11 08:48:09 +00:00
|
|
|
VNASSERT(TAILQ_EMPTY(&vp->v_cache_dst), vp, ("vp has namecache dst"));
|
|
|
|
VNASSERT(LIST_EMPTY(&vp->v_cache_src), vp, ("vp has namecache src"));
|
2005-08-03 05:36:50 +00:00
|
|
|
VI_UNLOCK(vp);
|
2006-07-05 16:33:25 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
mac_vnode_destroy(vp);
|
2006-07-05 16:33:25 +00:00
|
|
|
#endif
|
2005-03-25 05:34:39 +00:00
|
|
|
if (vp->v_pollinfo != NULL) {
|
|
|
|
knlist_destroy(&vp->v_pollinfo->vpi_selinfo.si_note);
|
|
|
|
mtx_destroy(&vp->v_pollinfo->vpi_lock);
|
|
|
|
uma_zfree(vnodepoll_zone, vp->v_pollinfo);
|
|
|
|
}
|
2005-06-11 01:16:46 +00:00
|
|
|
#ifdef INVARIANTS
|
|
|
|
/* XXX Elsewhere we can detect an already freed vnode via NULL v_op. */
|
|
|
|
vp->v_op = NULL;
|
|
|
|
#endif
|
2005-03-25 05:34:39 +00:00
|
|
|
lockdestroy(vp->v_vnlock);
|
|
|
|
mtx_destroy(&vp->v_interlock);
|
|
|
|
uma_zfree(vnode_zone, vp);
|
|
|
|
}
|
|
|
|
|
2002-08-05 10:15:56 +00:00
|
|
|
/*
|
2005-06-16 04:41:42 +00:00
|
|
|
* Try to recycle a freed vnode. We abort if anyone picks up a reference
|
|
|
|
* before we actually vgone(). This function must be called with the vnode
|
|
|
|
* held to prevent the vnode from being returned to the free list midway
|
|
|
|
* through vgone().
|
2002-08-05 10:15:56 +00:00
|
|
|
*/
|
|
|
|
static int
|
2003-10-05 05:35:41 +00:00
|
|
|
vtryrecycle(struct vnode *vp)
|
2002-08-05 10:15:56 +00:00
|
|
|
{
|
|
|
|
struct thread *td = curthread;
|
2003-10-05 05:35:41 +00:00
|
|
|
struct mount *vnmp;
|
2002-08-05 10:15:56 +00:00
|
|
|
|
2005-06-11 01:16:46 +00:00
|
|
|
CTR1(KTR_VFS, "vtryrecycle: trying vp %p", vp);
|
2005-06-16 04:41:42 +00:00
|
|
|
VNASSERT(vp->v_holdcnt, vp,
|
|
|
|
("vtryrecycle: Recycling vp %p without a reference.", vp));
|
2003-10-04 15:10:40 +00:00
|
|
|
/*
|
|
|
|
* This vnode may found and locked via some other list, if so we
|
|
|
|
* can't recycle it yet.
|
|
|
|
*/
|
2005-06-16 04:41:42 +00:00
|
|
|
if (VOP_LOCK(vp, LK_EXCLUSIVE | LK_NOWAIT, td) != 0)
|
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.
|
|
|
|
*/
|
2003-10-05 05:35:41 +00:00
|
|
|
if (vn_start_write(vp, &vnmp, V_NOWAIT) != 0) {
|
2005-06-16 04:41:42 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
|
|
|
return (EBUSY);
|
2002-10-11 01:04:14 +00:00
|
|
|
}
|
2003-10-05 05:35:41 +00:00
|
|
|
/*
|
|
|
|
* If we got this far, we need to acquire the interlock and see if
|
|
|
|
* anyone picked up this vnode from another list. If not, we will
|
2005-03-15 14:38:16 +00:00
|
|
|
* mark it with DOOMED via vgonel() so that anyone who does find it
|
2003-10-05 05:35:41 +00:00
|
|
|
* will skip over it.
|
|
|
|
*/
|
|
|
|
VI_LOCK(vp);
|
2005-06-16 04:41:42 +00:00
|
|
|
if (vp->v_usecount) {
|
|
|
|
VOP_UNLOCK(vp, LK_INTERLOCK, td);
|
|
|
|
vn_finished_write(vnmp);
|
|
|
|
return (EBUSY);
|
2005-04-30 11:22:40 +00:00
|
|
|
}
|
2005-06-16 04:41:42 +00:00
|
|
|
if ((vp->v_iflag & VI_DOOMED) == 0)
|
|
|
|
vgonel(vp);
|
|
|
|
VOP_UNLOCK(vp, LK_INTERLOCK, td);
|
2004-03-06 04:09:54 +00:00
|
|
|
vn_finished_write(vnmp);
|
2005-06-11 01:16:46 +00:00
|
|
|
CTR1(KTR_VFS, "vtryrecycle: recycled vp %p", vp);
|
2005-04-30 11:22:40 +00:00
|
|
|
return (0);
|
2002-08-05 10:15:56 +00:00
|
|
|
}
|
|
|
|
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
getnewvnode(const char *tag, struct mount *mp, struct vop_vector *vops,
|
|
|
|
struct vnode **vpp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-07-04 04:32:40 +00:00
|
|
|
struct vnode *vp = NULL;
|
2004-10-21 14:42:31 +00:00
|
|
|
struct bufobj *bo;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-08-13 05:29:48 +00:00
|
|
|
mtx_lock(&vnode_free_list_mtx);
|
1995-03-09 20:27:04 +00:00
|
|
|
/*
|
2005-03-25 05:34:39 +00:00
|
|
|
* Lend our context to reclaim vnodes if they've exceeded the max.
|
|
|
|
*/
|
|
|
|
if (freevnodes > wantfreevnodes)
|
|
|
|
vnlru_free(1);
|
|
|
|
/*
|
|
|
|
* Wait for available vnodes.
|
2001-10-26 00:08:05 +00:00
|
|
|
*/
|
2005-04-04 11:43:44 +00:00
|
|
|
if (numvnodes > desiredvnodes) {
|
2006-08-10 08:56:03 +00:00
|
|
|
if (mp != NULL && (mp->mnt_kern_flag & MNTK_SUSPEND)) {
|
2006-08-09 12:47:30 +00:00
|
|
|
/*
|
|
|
|
* File system is beeing suspended, we cannot risk a
|
|
|
|
* deadlock here, so allocate new vnode anyway.
|
|
|
|
*/
|
|
|
|
if (freevnodes > wantfreevnodes)
|
|
|
|
vnlru_free(freevnodes - wantfreevnodes);
|
|
|
|
goto alloc;
|
|
|
|
}
|
2002-12-29 10:39:05 +00:00
|
|
|
if (vnlruproc_sig == 0) {
|
2007-04-10 15:29:37 +00:00
|
|
|
vnlruproc_sig = 1; /* avoid unnecessary wakeups */
|
2002-12-29 10:39:05 +00:00
|
|
|
wakeup(vnlruproc);
|
|
|
|
}
|
2005-01-24 10:41:01 +00:00
|
|
|
msleep(&vnlruproc_sig, &vnode_free_list_mtx, PVFS,
|
|
|
|
"vlruwk", hz);
|
2005-04-22 00:57:05 +00:00
|
|
|
#if 0 /* XXX Not all VFS_VGET/ffs_vget callers check returns. */
|
2005-04-04 12:07:16 +00:00
|
|
|
if (numvnodes > desiredvnodes) {
|
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
2005-04-04 11:43:44 +00:00
|
|
|
return (ENFILE);
|
2005-04-04 12:07:16 +00:00
|
|
|
}
|
2005-04-22 00:57:05 +00:00
|
|
|
#endif
|
2001-12-18 20:48:54 +00:00
|
|
|
}
|
2006-08-09 12:47:30 +00:00
|
|
|
alloc:
|
2005-03-25 05:34:39 +00:00
|
|
|
numvnodes++;
|
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
|
|
|
vp = (struct vnode *) uma_zalloc(vnode_zone, M_WAITOK|M_ZERO);
|
2001-10-26 00:08:05 +00:00
|
|
|
/*
|
2005-03-25 05:34:39 +00:00
|
|
|
* Setup locks.
|
1995-03-09 20:27:04 +00:00
|
|
|
*/
|
2005-03-25 05:34:39 +00:00
|
|
|
vp->v_vnlock = &vp->v_lock;
|
|
|
|
mtx_init(&vp->v_interlock, "vnode interlock", NULL, MTX_DEF);
|
2005-03-31 05:22:45 +00:00
|
|
|
/*
|
|
|
|
* By default, don't allow shared locks unless filesystems
|
|
|
|
* opt-in.
|
|
|
|
*/
|
|
|
|
lockinit(vp->v_vnlock, PVFS, tag, VLKTIMEOUT, LK_NOSHARE);
|
2005-03-25 05:34:39 +00:00
|
|
|
/*
|
|
|
|
* Initialize bufobj.
|
|
|
|
*/
|
|
|
|
bo = &vp->v_bufobj;
|
|
|
|
bo->__bo_vnode = vp;
|
|
|
|
bo->bo_mtx = &vp->v_interlock;
|
2004-10-24 20:03:41 +00:00
|
|
|
bo->bo_ops = &buf_ops_bio;
|
2004-11-03 21:09:23 +00:00
|
|
|
bo->bo_private = vp;
|
2005-03-25 05:34:39 +00:00
|
|
|
TAILQ_INIT(&bo->bo_clean.bv_hd);
|
|
|
|
TAILQ_INIT(&bo->bo_dirty.bv_hd);
|
|
|
|
/*
|
|
|
|
* Initialize namecache.
|
|
|
|
*/
|
|
|
|
LIST_INIT(&vp->v_cache_src);
|
|
|
|
TAILQ_INIT(&vp->v_cache_dst);
|
|
|
|
/*
|
|
|
|
* Finalize various vnode identity bits.
|
|
|
|
*/
|
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;
|
2005-06-16 04:41:42 +00:00
|
|
|
v_incr_usecount(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_data = 0;
|
2002-09-30 20:51:48 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
mac_vnode_init(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)
|
2007-10-24 19:04:04 +00:00
|
|
|
mac_vnode_associate_singlelabel(mp, vp);
|
2004-10-22 11:04:58 +00:00
|
|
|
else if (mp == NULL)
|
|
|
|
printf("NULL mp in getnewvnode()\n");
|
2002-09-30 20:51:48 +00:00
|
|
|
#endif
|
2004-10-26 07:39:12 +00:00
|
|
|
if (mp != NULL) {
|
|
|
|
bo->bo_bsize = mp->mnt_stat.f_iosize;
|
2005-08-06 01:42:04 +00:00
|
|
|
if ((mp->mnt_kern_flag & MNTK_NOKNOTE) != 0)
|
|
|
|
vp->v_vflag |= VV_NOKNOTE;
|
2004-10-26 07:39:12 +00:00
|
|
|
}
|
1998-02-23 06:59:52 +00:00
|
|
|
|
2005-06-11 01:16:46 +00:00
|
|
|
CTR2(KTR_VFS, "getnewvnode: mp %p vp %p", mp, vp);
|
2005-03-25 05:34:39 +00:00
|
|
|
*vpp = vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2004-07-04 08:52:35 +00:00
|
|
|
* Delete from old mount point vnode list, if on one.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1997-11-22 08:35:46 +00:00
|
|
|
static void
|
2004-07-04 08:52:35 +00:00
|
|
|
delmntque(struct vnode *vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-07-04 08:52:35 +00:00
|
|
|
struct mount *mp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-07-04 08:52:35 +00:00
|
|
|
mp = vp->v_mount;
|
2006-02-06 10:19:50 +00:00
|
|
|
if (mp == NULL)
|
|
|
|
return;
|
2004-07-04 08:52:35 +00:00
|
|
|
MNT_ILOCK(mp);
|
2006-02-23 05:15:37 +00:00
|
|
|
vp->v_mount = NULL;
|
2005-02-17 10:28:58 +00:00
|
|
|
VNASSERT(mp->mnt_nvnodelistsize > 0, vp,
|
2004-07-04 08:52:35 +00:00
|
|
|
("bad mount point vnode list size"));
|
|
|
|
TAILQ_REMOVE(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
|
|
|
|
mp->mnt_nvnodelistsize--;
|
2006-02-23 05:15:37 +00:00
|
|
|
MNT_REL(mp);
|
2004-07-04 08:52:35 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
|
|
|
}
|
|
|
|
|
2007-03-13 01:50:27 +00:00
|
|
|
static void
|
|
|
|
insmntque_stddtr(struct vnode *vp, void *dtr_arg)
|
|
|
|
{
|
|
|
|
struct thread *td;
|
|
|
|
|
|
|
|
td = curthread; /* XXX ? */
|
|
|
|
vp->v_data = NULL;
|
|
|
|
vp->v_op = &dead_vnodeops;
|
|
|
|
/* XXX non mp-safe fs may still call insmntque with vnode
|
|
|
|
unlocked */
|
|
|
|
if (!VOP_ISLOCKED(vp, td))
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
|
|
|
|
vgone(vp);
|
|
|
|
vput(vp);
|
|
|
|
}
|
|
|
|
|
2004-07-04 08:52:35 +00:00
|
|
|
/*
|
|
|
|
* Insert into list of vnodes for the new mount point, if available.
|
|
|
|
*/
|
2007-03-13 01:50:27 +00:00
|
|
|
int
|
|
|
|
insmntque1(struct vnode *vp, struct mount *mp,
|
|
|
|
void (*dtr)(struct vnode *, void *), void *dtr_arg)
|
2004-07-04 08:52:35 +00:00
|
|
|
{
|
|
|
|
|
2007-03-13 01:50:27 +00:00
|
|
|
KASSERT(vp->v_mount == NULL,
|
|
|
|
("insmntque: vnode already on per mount vnode list"));
|
2005-02-17 10:28:58 +00:00
|
|
|
VNASSERT(mp != NULL, vp, ("Don't call insmntque(foo, NULL)"));
|
2006-02-06 10:19:50 +00:00
|
|
|
MNT_ILOCK(mp);
|
2007-09-12 16:31:32 +00:00
|
|
|
if ((mp->mnt_kern_flag & MNTK_NOINSMNTQ) != 0 &&
|
2007-03-13 01:50:27 +00:00
|
|
|
mp->mnt_nvnodelistsize == 0) {
|
|
|
|
MNT_IUNLOCK(mp);
|
|
|
|
if (dtr != NULL)
|
|
|
|
dtr(vp, dtr_arg);
|
|
|
|
return (EBUSY);
|
|
|
|
}
|
|
|
|
vp->v_mount = mp;
|
2006-02-06 10:19:50 +00:00
|
|
|
MNT_REF(mp);
|
2004-07-04 08:52:35 +00:00
|
|
|
TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
|
2006-01-09 20:42:19 +00:00
|
|
|
VNASSERT(mp->mnt_nvnodelistsize >= 0, vp,
|
|
|
|
("neg mount point vnode list size"));
|
2004-07-04 08:52:35 +00:00
|
|
|
mp->mnt_nvnodelistsize++;
|
2006-02-06 10:19:50 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
2007-03-13 01:50:27 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
insmntque(struct vnode *vp, struct mount *mp)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (insmntque1(vp, mp, insmntque_stddtr, NULL));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-02-19 11:44:57 +00:00
|
|
|
* Flush out and invalidate all buffers associated with a bufobj
|
1994-05-24 10:09:53 +00:00
|
|
|
* Called with the underlying object locked.
|
|
|
|
*/
|
|
|
|
int
|
2006-01-21 19:42:10 +00:00
|
|
|
bufobj_invalbuf(struct bufobj *bo, int flags, struct thread *td, int slpflag,
|
|
|
|
int slptimeo)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-09-19 23:52:06 +00:00
|
|
|
int error;
|
2002-09-25 02:22:21 +00:00
|
|
|
|
2004-10-27 08:05:02 +00:00
|
|
|
BO_LOCK(bo);
|
1998-06-10 18:13:19 +00:00
|
|
|
if (flags & V_SAVE) {
|
2004-10-21 15:53:54 +00:00
|
|
|
error = bufobj_wwait(bo, slpflag, slptimeo);
|
|
|
|
if (error) {
|
2005-01-11 10:16:39 +00:00
|
|
|
BO_UNLOCK(bo);
|
2004-10-21 15:53:54 +00:00
|
|
|
return (error);
|
1998-06-10 18:13:19 +00:00
|
|
|
}
|
2004-10-21 15:53:54 +00:00
|
|
|
if (bo->bo_dirty.bv_cnt > 0) {
|
2005-01-11 10:16:39 +00:00
|
|
|
BO_UNLOCK(bo);
|
2005-01-11 10:43:08 +00:00
|
|
|
if ((error = BO_SYNC(bo, 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
|
|
|
|
*/
|
2005-01-11 10:16:39 +00:00
|
|
|
BO_LOCK(bo);
|
2004-10-21 15:53:54 +00:00
|
|
|
if (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0)
|
1998-06-10 18:13:19 +00:00
|
|
|
panic("vinvalbuf: dirty bufs");
|
|
|
|
}
|
2002-06-06 15:46:38 +00:00
|
|
|
}
|
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.
|
|
|
|
*/
|
2005-01-11 10:01:54 +00:00
|
|
|
do {
|
|
|
|
error = flushbuflist(&bo->bo_clean,
|
2005-02-19 11:44:57 +00:00
|
|
|
flags, bo, slpflag, slptimeo);
|
2005-01-11 10:01:54 +00:00
|
|
|
if (error == 0)
|
|
|
|
error = flushbuflist(&bo->bo_dirty,
|
2005-02-19 11:44:57 +00:00
|
|
|
flags, bo, slpflag, slptimeo);
|
2005-01-16 21:09:39 +00:00
|
|
|
if (error != 0 && error != EAGAIN) {
|
2005-01-11 10:01:54 +00:00
|
|
|
BO_UNLOCK(bo);
|
|
|
|
return (error);
|
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
|
|
|
}
|
2005-01-11 10:01:54 +00:00
|
|
|
} while (error != 0);
|
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 {
|
2004-10-21 15:53:54 +00:00
|
|
|
bufobj_wwait(bo, 0, 0);
|
2005-02-07 10:04:06 +00:00
|
|
|
BO_UNLOCK(bo);
|
|
|
|
if (bo->bo_object != NULL) {
|
|
|
|
VM_OBJECT_LOCK(bo->bo_object);
|
2005-02-19 11:44:57 +00:00
|
|
|
vm_object_pip_wait(bo->bo_object, "bovlbx");
|
2005-02-07 10:04:06 +00:00
|
|
|
VM_OBJECT_UNLOCK(bo->bo_object);
|
2001-10-05 20:10:32 +00:00
|
|
|
}
|
2005-02-07 10:04:06 +00:00
|
|
|
BO_LOCK(bo);
|
2004-10-25 09:14:03 +00:00
|
|
|
} while (bo->bo_numoutput > 0);
|
2005-02-07 10:04:06 +00:00
|
|
|
BO_UNLOCK(bo);
|
1997-03-05 04:54:54 +00:00
|
|
|
|
1995-03-20 02:08:24 +00:00
|
|
|
/*
|
|
|
|
* Destroy the copy in the VM cache, too.
|
|
|
|
*/
|
2005-02-07 10:04:06 +00:00
|
|
|
if (bo->bo_object != NULL) {
|
|
|
|
VM_OBJECT_LOCK(bo->bo_object);
|
|
|
|
vm_object_page_remove(bo->bo_object, 0, 0,
|
1998-10-29 09:51:28 +00:00
|
|
|
(flags & V_SAVE) ? TRUE : FALSE);
|
2005-02-07 10:04:06 +00:00
|
|
|
VM_OBJECT_UNLOCK(bo->bo_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
|
2005-01-11 10:16:39 +00:00
|
|
|
BO_LOCK(bo);
|
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 &&
|
2005-01-11 10:16:39 +00:00
|
|
|
(bo->bo_dirty.bv_cnt > 0 || bo->bo_clean.bv_cnt > 0))
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("vinvalbuf: flush failed");
|
2005-01-11 10:16:39 +00:00
|
|
|
BO_UNLOCK(bo);
|
2002-09-25 02:22:21 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2005-02-19 11:44:57 +00:00
|
|
|
/*
|
|
|
|
* Flush out and invalidate all buffers associated with a vnode.
|
|
|
|
* Called with the underlying object locked.
|
|
|
|
*/
|
|
|
|
int
|
2006-01-21 19:42:10 +00:00
|
|
|
vinvalbuf(struct vnode *vp, int flags, struct thread *td, int slpflag,
|
|
|
|
int slptimeo)
|
2005-02-19 11:44:57 +00:00
|
|
|
{
|
|
|
|
|
2005-06-13 00:46:37 +00:00
|
|
|
CTR2(KTR_VFS, "vinvalbuf vp %p flags %d", vp, flags);
|
2005-02-19 11:44:57 +00:00
|
|
|
ASSERT_VOP_LOCKED(vp, "vinvalbuf");
|
|
|
|
return (bufobj_invalbuf(&vp->v_bufobj, flags, 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
|
|
|
/*
|
|
|
|
* 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
|
2006-01-21 19:42:10 +00:00
|
|
|
flushbuflist( struct bufv *bufv, int flags, struct bufobj *bo, int slpflag,
|
|
|
|
int 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 *bp, *nbp;
|
2005-01-16 21:09:39 +00:00
|
|
|
int retval, error;
|
2005-09-16 18:28:12 +00:00
|
|
|
daddr_t lblkno;
|
|
|
|
b_xflags_t xflags;
|
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
|
|
|
|
2005-01-11 10:16:39 +00:00
|
|
|
ASSERT_BO_LOCKED(bo);
|
2002-09-25 02:22:21 +00:00
|
|
|
|
2005-01-16 21:09:39 +00:00
|
|
|
retval = 0;
|
2005-01-11 10:01:54 +00:00
|
|
|
TAILQ_FOREACH_SAFE(bp, &bufv->bv_hd, b_bobufs, nbp) {
|
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)) {
|
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
|
|
|
}
|
2005-09-16 18:28:12 +00:00
|
|
|
lblkno = 0;
|
|
|
|
xflags = 0;
|
|
|
|
if (nbp != NULL) {
|
|
|
|
lblkno = nbp->b_lblkno;
|
|
|
|
xflags = nbp->b_xflags &
|
|
|
|
(BX_BKGRDMARKER | BX_VNDIRTY | BX_VNCLEAN);
|
|
|
|
}
|
2005-01-16 21:09:39 +00:00
|
|
|
retval = EAGAIN;
|
2003-02-25 03:37:48 +00:00
|
|
|
error = BUF_TIMELOCK(bp,
|
2005-01-11 10:16:39 +00:00
|
|
|
LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK, BO_MTX(bo),
|
2003-02-25 03:37:48 +00:00
|
|
|
"flushbuf", slpflag, slptimeo);
|
|
|
|
if (error) {
|
2005-01-11 10:16:39 +00:00
|
|
|
BO_LOCK(bo);
|
2005-01-11 10:01:54 +00:00
|
|
|
return (error != ENOLCK ? error : EAGAIN);
|
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
|
|
|
}
|
2005-04-06 06:49:46 +00:00
|
|
|
KASSERT(bp->b_bufobj == bo,
|
2007-04-10 15:29:37 +00:00
|
|
|
("bp %p wrong b_bufobj %p should be %p",
|
2005-06-14 20:31:53 +00:00
|
|
|
bp, bp->b_bufobj, bo));
|
2005-02-19 11:44:57 +00:00
|
|
|
if (bp->b_bufobj != bo) { /* XXX: necessary ? */
|
2005-04-06 06:49:46 +00:00
|
|
|
BUF_UNLOCK(bp);
|
2005-02-19 11:44:57 +00:00
|
|
|
BO_LOCK(bo);
|
|
|
|
return (EAGAIN);
|
|
|
|
}
|
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
|
2005-02-19 11:44:57 +00:00
|
|
|
* check for it.
|
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 (((bp->b_flags & (B_DELWRI | B_INVAL)) == B_DELWRI) &&
|
2005-02-19 11:44:57 +00:00
|
|
|
(flags & V_SAVE)) {
|
|
|
|
bremfree(bp);
|
|
|
|
bp->b_flags |= B_ASYNC;
|
|
|
|
bwrite(bp);
|
2005-01-11 10:16:39 +00:00
|
|
|
BO_LOCK(bo);
|
2005-02-19 11:44:57 +00:00
|
|
|
return (EAGAIN); /* XXX: why not loop ? */
|
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);
|
2006-05-25 01:00:35 +00:00
|
|
|
bp->b_flags |= (B_INVAL | B_RELBUF);
|
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
|
|
|
bp->b_flags &= ~B_ASYNC;
|
|
|
|
brelse(bp);
|
2005-01-11 10:16:39 +00:00
|
|
|
BO_LOCK(bo);
|
2005-09-16 18:28:12 +00:00
|
|
|
if (nbp != NULL &&
|
2007-04-10 15:29:37 +00:00
|
|
|
(nbp->b_bufobj != bo ||
|
2005-09-16 18:28:12 +00:00
|
|
|
nbp->b_lblkno != lblkno ||
|
|
|
|
(nbp->b_xflags &
|
|
|
|
(BX_BKGRDMARKER | BX_VNDIRTY | BX_VNCLEAN)) != xflags))
|
|
|
|
break; /* nbp invalid */
|
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
|
|
|
}
|
2005-01-16 21:09:39 +00:00
|
|
|
return (retval);
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
vtruncbuf(struct vnode *vp, struct ucred *cred, struct thread *td,
|
|
|
|
off_t length, int 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
|
|
|
{
|
2004-10-21 14:13:54 +00:00
|
|
|
struct buf *bp, *nbp;
|
2003-09-19 23:52:06 +00:00
|
|
|
int 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;
|
2004-10-21 14:13:54 +00:00
|
|
|
struct bufobj *bo;
|
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
|
|
|
|
2005-06-13 00:46:37 +00:00
|
|
|
CTR2(KTR_VFS, "vtruncbuf vp %p length %jd", vp, length);
|
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
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
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);
|
2004-10-21 14:13:54 +00:00
|
|
|
bo = &vp->v_bufobj;
|
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;
|
2004-10-21 15:53:54 +00:00
|
|
|
TAILQ_FOREACH_SAFE(bp, &bo->bo_clean.bv_hd, b_bobufs, nbp) {
|
2004-10-21 14:13:54 +00:00
|
|
|
if (bp->b_lblkno < trunclbn)
|
|
|
|
continue;
|
|
|
|
if (BUF_LOCK(bp,
|
|
|
|
LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
|
|
|
|
VI_MTX(vp)) == ENOLCK)
|
|
|
|
goto restart;
|
|
|
|
|
|
|
|
bremfree(bp);
|
|
|
|
bp->b_flags |= (B_INVAL | B_RELBUF);
|
|
|
|
bp->b_flags &= ~B_ASYNC;
|
|
|
|
brelse(bp);
|
|
|
|
anyfreed = 1;
|
|
|
|
|
|
|
|
if (nbp != NULL &&
|
|
|
|
(((nbp->b_xflags & BX_VNCLEAN) == 0) ||
|
|
|
|
(nbp->b_vp != vp) ||
|
|
|
|
(nbp->b_flags & B_DELWRI))) {
|
|
|
|
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
|
|
|
}
|
2004-10-21 14:13:54 +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
|
|
|
}
|
|
|
|
|
2004-10-21 15:53:54 +00:00
|
|
|
TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
|
2004-10-21 14:13:54 +00:00
|
|
|
if (bp->b_lblkno < trunclbn)
|
|
|
|
continue;
|
|
|
|
if (BUF_LOCK(bp,
|
|
|
|
LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
|
|
|
|
VI_MTX(vp)) == ENOLCK)
|
|
|
|
goto restart;
|
|
|
|
bremfree(bp);
|
|
|
|
bp->b_flags |= (B_INVAL | B_RELBUF);
|
|
|
|
bp->b_flags &= ~B_ASYNC;
|
|
|
|
brelse(bp);
|
|
|
|
anyfreed = 1;
|
|
|
|
if (nbp != NULL &&
|
|
|
|
(((nbp->b_xflags & BX_VNDIRTY) == 0) ||
|
|
|
|
(nbp->b_vp != vp) ||
|
|
|
|
(nbp->b_flags & B_DELWRI) == 0)) {
|
|
|
|
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
|
|
|
}
|
2004-10-21 14:13:54 +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:
|
2004-10-21 15:53:54 +00:00
|
|
|
TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
|
2003-03-13 07:22:53 +00:00
|
|
|
if (bp->b_lblkno > 0)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* Since we hold the vnode lock this should only
|
|
|
|
* fail if we're racing with the buf daemon.
|
|
|
|
*/
|
|
|
|
if (BUF_LOCK(bp,
|
|
|
|
LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
|
|
|
|
VI_MTX(vp)) == ENOLCK) {
|
|
|
|
goto restart;
|
1998-03-17 06:30:52 +00:00
|
|
|
}
|
2005-02-17 10:28:58 +00:00
|
|
|
VNASSERT((bp->b_flags & B_DELWRI), vp,
|
2004-01-05 19:04:29 +00:00
|
|
|
("buf(%p) on dirty queue without DELWRI", bp));
|
2003-03-13 07:22:53 +00:00
|
|
|
|
|
|
|
bremfree(bp);
|
|
|
|
bawrite(bp);
|
|
|
|
VI_LOCK(vp);
|
|
|
|
goto restartsync;
|
1998-03-17 06:30:52 +00:00
|
|
|
}
|
|
|
|
}
|
2004-01-05 19:04:29 +00:00
|
|
|
|
2004-10-21 15:53:54 +00:00
|
|
|
bufobj_wwait(bo, 0, 0);
|
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
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2004-10-22 08:47:20 +00:00
|
|
|
static void
|
2002-07-10 17:02:32 +00:00
|
|
|
buf_vlist_remove(struct buf *bp)
|
|
|
|
{
|
|
|
|
struct buf *root;
|
2004-10-21 13:48:50 +00:00
|
|
|
struct bufv *bv;
|
2002-07-10 17:02:32 +00:00
|
|
|
|
2004-10-22 08:47:20 +00:00
|
|
|
KASSERT(bp->b_bufobj != NULL, ("No b_bufobj %p", bp));
|
|
|
|
ASSERT_BO_LOCKED(bp->b_bufobj);
|
2005-06-18 18:17:03 +00:00
|
|
|
KASSERT((bp->b_xflags & (BX_VNDIRTY|BX_VNCLEAN)) !=
|
|
|
|
(BX_VNDIRTY|BX_VNCLEAN),
|
|
|
|
("buf_vlist_remove: Buf %p is on two lists", bp));
|
2007-04-10 15:29:37 +00:00
|
|
|
if (bp->b_xflags & BX_VNDIRTY)
|
2004-10-22 08:47:20 +00:00
|
|
|
bv = &bp->b_bufobj->bo_dirty;
|
2004-10-21 13:48:50 +00:00
|
|
|
else
|
2004-10-22 08:47:20 +00:00
|
|
|
bv = &bp->b_bufobj->bo_clean;
|
2004-10-21 13:48:50 +00:00
|
|
|
if (bp != bv->bv_root) {
|
|
|
|
root = buf_splay(bp->b_lblkno, bp->b_xflags, bv->bv_root);
|
|
|
|
KASSERT(root == bp, ("splay lookup failed in remove"));
|
|
|
|
}
|
|
|
|
if (bp->b_left == NULL) {
|
|
|
|
root = bp->b_right;
|
2002-07-10 17:02:32 +00:00
|
|
|
} else {
|
2004-10-21 13:48:50 +00:00
|
|
|
root = buf_splay(bp->b_lblkno, bp->b_xflags, bp->b_left);
|
|
|
|
root->b_right = bp->b_right;
|
2002-07-10 17:02:32 +00:00
|
|
|
}
|
2004-10-21 13:48:50 +00:00
|
|
|
bv->bv_root = root;
|
2004-10-21 15:53:54 +00:00
|
|
|
TAILQ_REMOVE(&bv->bv_hd, bp, b_bobufs);
|
2004-10-21 13:48:50 +00:00
|
|
|
bv->bv_cnt--;
|
2002-07-10 17:02:32 +00:00
|
|
|
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!
|
|
|
|
*/
|
2004-10-22 08:47:20 +00:00
|
|
|
static void
|
|
|
|
buf_vlist_add(struct buf *bp, struct bufobj *bo, b_xflags_t xflags)
|
2002-07-10 17:02:32 +00:00
|
|
|
{
|
|
|
|
struct buf *root;
|
2004-10-22 08:47:20 +00:00
|
|
|
struct bufv *bv;
|
2002-07-10 17:02:32 +00:00
|
|
|
|
2004-10-22 08:47:20 +00:00
|
|
|
ASSERT_BO_LOCKED(bo);
|
2005-06-18 18:17:03 +00:00
|
|
|
KASSERT((bp->b_xflags & (BX_VNDIRTY|BX_VNCLEAN)) == 0,
|
|
|
|
("buf_vlist_add: Buf %p has existing xflags %d", bp, bp->b_xflags));
|
2002-07-10 17:02:32 +00:00
|
|
|
bp->b_xflags |= xflags;
|
2004-10-22 08:47:20 +00:00
|
|
|
if (xflags & BX_VNDIRTY)
|
|
|
|
bv = &bo->bo_dirty;
|
|
|
|
else
|
|
|
|
bv = &bo->bo_clean;
|
|
|
|
|
|
|
|
root = buf_splay(bp->b_lblkno, bp->b_xflags, bv->bv_root);
|
|
|
|
if (root == NULL) {
|
|
|
|
bp->b_left = NULL;
|
|
|
|
bp->b_right = NULL;
|
|
|
|
TAILQ_INSERT_TAIL(&bv->bv_hd, bp, b_bobufs);
|
|
|
|
} 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_bobufs);
|
2002-07-10 17:02:32 +00:00
|
|
|
} else {
|
2004-10-22 08:47:20 +00:00
|
|
|
bp->b_right = root->b_right;
|
|
|
|
bp->b_left = root;
|
|
|
|
root->b_right = NULL;
|
|
|
|
TAILQ_INSERT_AFTER(&bv->bv_hd, root, bp, b_bobufs);
|
2002-07-10 17:02:32 +00:00
|
|
|
}
|
2004-10-22 08:47:20 +00:00
|
|
|
bv->bv_cnt++;
|
|
|
|
bv->bv_root = bp;
|
2002-07-10 17:02:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
2003-05-13 04:36:02 +00:00
|
|
|
*
|
|
|
|
* During a "make buildworld" the desired buffer is found at one of
|
|
|
|
* the roots more than 60% of the time. Thus, checking both roots
|
|
|
|
* before performing either splay eliminates unnecessary splays on the
|
|
|
|
* first tree splayed.
|
2002-07-10 17:02:32 +00:00
|
|
|
*/
|
|
|
|
struct buf *
|
2004-10-22 08:47:20 +00:00
|
|
|
gbincore(struct bufobj *bo, daddr_t lblkno)
|
2002-07-10 17:02:32 +00:00
|
|
|
{
|
|
|
|
struct buf *bp;
|
|
|
|
|
2004-10-22 08:47:20 +00:00
|
|
|
ASSERT_BO_LOCKED(bo);
|
|
|
|
if ((bp = bo->bo_clean.bv_root) != NULL &&
|
2003-05-13 04:36:02 +00:00
|
|
|
bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
|
|
|
|
return (bp);
|
2004-10-22 08:47:20 +00:00
|
|
|
if ((bp = bo->bo_dirty.bv_root) != NULL &&
|
2003-05-13 04:36:02 +00:00
|
|
|
bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
|
|
|
|
return (bp);
|
2004-10-22 08:47:20 +00:00
|
|
|
if ((bp = bo->bo_clean.bv_root) != NULL) {
|
|
|
|
bo->bo_clean.bv_root = bp = buf_splay(lblkno, 0, bp);
|
2003-05-13 04:36:02 +00:00
|
|
|
if (bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
|
|
|
|
return (bp);
|
|
|
|
}
|
2004-10-22 08:47:20 +00:00
|
|
|
if ((bp = bo->bo_dirty.bv_root) != NULL) {
|
|
|
|
bo->bo_dirty.bv_root = bp = buf_splay(lblkno, 0, bp);
|
2003-05-13 04:36:02 +00:00
|
|
|
if (bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
|
|
|
|
return (bp);
|
|
|
|
}
|
|
|
|
return (NULL);
|
2002-07-10 17:02:32 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Associate a buffer with a vnode.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
2004-10-22 08:47:20 +00:00
|
|
|
bgetvp(struct vnode *vp, struct buf *bp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-02-17 10:28:58 +00:00
|
|
|
|
|
|
|
VNASSERT(bp->b_vp == NULL, bp->b_vp, ("bgetvp: not free"));
|
1999-01-10 01:58:29 +00:00
|
|
|
|
2005-01-24 10:41:01 +00:00
|
|
|
CTR3(KTR_BUF, "bgetvp(%p) vp %p flags %X", bp, vp, bp->b_flags);
|
2005-02-17 10:28:58 +00:00
|
|
|
VNASSERT((bp->b_xflags & (BX_VNDIRTY|BX_VNCLEAN)) == 0, vp,
|
2002-07-10 17:02:32 +00:00
|
|
|
("bgetvp: bp already attached! %p", bp));
|
|
|
|
|
2003-03-02 06:05:23 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "bgetvp");
|
2002-09-25 02:22:21 +00:00
|
|
|
vholdl(vp);
|
2006-04-28 01:05:31 +00:00
|
|
|
if (VFS_NEEDSGIANT(vp->v_mount) ||
|
|
|
|
vp->v_bufobj.bo_flag & BO_NEEDSGIANT)
|
2006-03-31 02:56:30 +00:00
|
|
|
bp->b_flags |= B_NEEDSGIANT;
|
1994-05-24 10:09:53 +00:00
|
|
|
bp->b_vp = vp;
|
2004-10-22 08:47:20 +00:00
|
|
|
bp->b_bufobj = &vp->v_bufobj;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Insert onto list for new vnode.
|
|
|
|
*/
|
2004-10-22 08:47:20 +00:00
|
|
|
buf_vlist_add(bp, &vp->v_bufobj, BX_VNCLEAN);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disassociate a buffer from a vnode.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
2004-10-22 08:47:20 +00:00
|
|
|
brelvp(struct buf *bp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-10-22 08:47:20 +00:00
|
|
|
struct bufobj *bo;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
|
2005-01-24 10:41:01 +00:00
|
|
|
CTR3(KTR_BUF, "brelvp(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
|
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.
|
|
|
|
*/
|
2004-10-27 08:05:02 +00:00
|
|
|
vp = bp->b_vp; /* XXX */
|
2004-10-22 08:47:20 +00:00
|
|
|
bo = bp->b_bufobj;
|
2004-10-27 08:05:02 +00:00
|
|
|
BO_LOCK(bo);
|
2002-07-10 17:02:32 +00:00
|
|
|
if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN))
|
|
|
|
buf_vlist_remove(bp);
|
2005-05-01 12:00:36 +00:00
|
|
|
else
|
|
|
|
panic("brelvp: Buffer %p not on queue.", bp);
|
2004-10-27 08:05:02 +00:00
|
|
|
if ((bo->bo_flag & BO_ONWORKLST) && bo->bo_dirty.bv_cnt == 0) {
|
|
|
|
bo->bo_flag &= ~BO_ONWORKLST;
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
2004-10-27 08:05:02 +00:00
|
|
|
LIST_REMOVE(bo, bo_synclist);
|
2007-04-10 15:29:37 +00:00
|
|
|
syncer_worklist_len--;
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
2006-03-31 02:56:30 +00:00
|
|
|
bp->b_flags &= ~B_NEEDSGIANT;
|
2004-10-22 08:47:20 +00:00
|
|
|
bp->b_vp = NULL;
|
|
|
|
bp->b_bufobj = NULL;
|
2005-06-16 04:41:42 +00:00
|
|
|
vdropl(vp);
|
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
|
2004-10-27 08:05:02 +00:00
|
|
|
vn_syncer_add_to_worklist(struct bufobj *bo, int delay)
|
1998-03-08 09:59:44 +00:00
|
|
|
{
|
2003-09-19 23:52:06 +00:00
|
|
|
int slot;
|
1998-03-08 09:59:44 +00:00
|
|
|
|
2004-10-27 08:05:02 +00:00
|
|
|
ASSERT_BO_LOCKED(bo);
|
1998-03-08 09:59:44 +00:00
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
2004-10-27 08:05:02 +00:00
|
|
|
if (bo->bo_flag & BO_ONWORKLST)
|
|
|
|
LIST_REMOVE(bo, bo_synclist);
|
2004-07-01 23:59:19 +00:00
|
|
|
else {
|
2004-10-27 08:05:02 +00:00
|
|
|
bo->bo_flag |= BO_ONWORKLST;
|
2007-04-10 15:29:37 +00:00
|
|
|
syncer_worklist_len++;
|
2004-07-01 23:59:19 +00:00
|
|
|
}
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
if (delay > syncer_maxdelay - 2)
|
|
|
|
delay = syncer_maxdelay - 2;
|
|
|
|
slot = (syncer_delayno + delay) & syncer_mask;
|
|
|
|
|
2004-10-27 08:05:02 +00:00
|
|
|
LIST_INSERT_HEAD(&syncer_workitem_pending[slot], bo, bo_synclist);
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
|
|
|
|
2004-07-05 01:07:33 +00:00
|
|
|
static int
|
|
|
|
sysctl_vfs_worklist_len(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error, len;
|
|
|
|
|
|
|
|
mtx_lock(&sync_mtx);
|
|
|
|
len = syncer_worklist_len - sync_vnode_count;
|
|
|
|
mtx_unlock(&sync_mtx);
|
|
|
|
error = SYSCTL_OUT(req, &len, sizeof(len));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_vfs, OID_AUTO, worklist_len, CTLTYPE_INT | CTLFLAG_RD, NULL, 0,
|
|
|
|
sysctl_vfs_worklist_len, "I", "Syncer thread worklist length");
|
|
|
|
|
2005-09-30 01:30:01 +00:00
|
|
|
static 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
|
|
|
|
2004-11-14 15:24:38 +00:00
|
|
|
static int
|
|
|
|
sync_vnode(struct bufobj *bo, struct thread *td)
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
|
|
|
struct mount *mp;
|
|
|
|
|
2007-04-10 15:29:37 +00:00
|
|
|
vp = bo->__bo_vnode; /* XXX */
|
2004-11-14 15:24:38 +00:00
|
|
|
if (VOP_ISLOCKED(vp, NULL) != 0)
|
|
|
|
return (1);
|
2005-01-24 10:41:01 +00:00
|
|
|
if (VI_TRYLOCK(vp) == 0)
|
2004-11-14 15:24:38 +00:00
|
|
|
return (1);
|
|
|
|
/*
|
|
|
|
* We use vhold in case the vnode does not
|
|
|
|
* successfully sync. vhold prevents the vnode from
|
|
|
|
* going away when we unlock the sync_mtx so that
|
|
|
|
* we can acquire the vnode interlock.
|
|
|
|
*/
|
|
|
|
vholdl(vp);
|
|
|
|
mtx_unlock(&sync_mtx);
|
2005-01-24 10:41:01 +00:00
|
|
|
VI_UNLOCK(vp);
|
|
|
|
if (vn_start_write(vp, &mp, V_NOWAIT) != 0) {
|
|
|
|
vdrop(vp);
|
|
|
|
mtx_lock(&sync_mtx);
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
|
2005-01-11 07:36:22 +00:00
|
|
|
(void) VOP_FSYNC(vp, MNT_LAZY, td);
|
2004-11-14 15:24:38 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
|
|
|
vn_finished_write(mp);
|
|
|
|
VI_LOCK(vp);
|
|
|
|
if ((bo->bo_flag & BO_ONWORKLST) != 0) {
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
vn_syncer_add_to_worklist(bo, syncdelay);
|
|
|
|
}
|
|
|
|
vdropl(vp);
|
|
|
|
mtx_lock(&sync_mtx);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2003-10-04 18:03:53 +00:00
|
|
|
struct synclist *next;
|
1998-03-08 09:59:44 +00:00
|
|
|
struct synclist *slp;
|
2004-10-27 08:05:02 +00:00
|
|
|
struct bufobj *bo;
|
1998-03-08 09:59:44 +00:00
|
|
|
long starttime;
|
2004-03-29 22:45:33 +00:00
|
|
|
struct thread *td = FIRST_THREAD_IN_PROC(updateproc);
|
2004-07-05 01:07:33 +00:00
|
|
|
static int dummychan;
|
|
|
|
int last_work_seen;
|
|
|
|
int net_worklist_len;
|
|
|
|
int syncer_final_iter;
|
2004-07-15 04:29:48 +00:00
|
|
|
int first_printf;
|
2004-11-14 15:24:38 +00:00
|
|
|
int error;
|
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);
|
2004-07-05 21:32:01 +00:00
|
|
|
last_work_seen = 0;
|
2004-07-05 01:07:33 +00:00
|
|
|
syncer_final_iter = 0;
|
2004-07-15 04:29:48 +00:00
|
|
|
first_printf = 1;
|
2004-07-05 01:07:33 +00:00
|
|
|
syncer_state = SYNCER_RUNNING;
|
2005-09-12 15:31:28 +00:00
|
|
|
starttime = time_uptime;
|
2005-09-30 01:30:01 +00:00
|
|
|
td->td_pflags |= TDP_NORUNNINGBUF;
|
2000-09-07 01:33:02 +00:00
|
|
|
|
2004-07-01 23:59:19 +00:00
|
|
|
EVENTHANDLER_REGISTER(shutdown_pre_sync, syncer_shutdown, td->td_proc,
|
2002-06-06 15:46:38 +00:00
|
|
|
SHUTDOWN_PRI_LAST);
|
2000-01-07 08:36:44 +00:00
|
|
|
|
2006-11-07 19:45:05 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
1998-03-08 09:59:44 +00:00
|
|
|
for (;;) {
|
2004-07-05 01:07:33 +00:00
|
|
|
if (syncer_state == SYNCER_FINAL_DELAY &&
|
|
|
|
syncer_final_iter == 0) {
|
2004-07-01 23:59:19 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
2007-10-20 23:23:23 +00:00
|
|
|
kproc_suspend_check(td->td_proc);
|
2004-07-01 23:59:19 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
|
|
|
}
|
2004-07-05 01:07:33 +00:00
|
|
|
net_worklist_len = syncer_worklist_len - sync_vnode_count;
|
2004-07-15 04:29:48 +00:00
|
|
|
if (syncer_state != SYNCER_RUNNING &&
|
2005-09-12 15:31:28 +00:00
|
|
|
starttime != time_uptime) {
|
2004-07-15 04:29:48 +00:00
|
|
|
if (first_printf) {
|
2004-08-10 01:32:05 +00:00
|
|
|
printf("\nSyncing disks, vnodes remaining...");
|
2004-07-15 04:29:48 +00:00
|
|
|
first_printf = 0;
|
|
|
|
}
|
2004-07-05 01:07:33 +00:00
|
|
|
printf("%d ", net_worklist_len);
|
2004-07-15 04:29:48 +00:00
|
|
|
}
|
2005-09-12 15:31:28 +00:00
|
|
|
starttime = time_uptime;
|
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.
|
2004-07-05 01:07:33 +00:00
|
|
|
*
|
|
|
|
* Skip over empty worklist slots when shutting down.
|
1998-03-08 09:59:44 +00:00
|
|
|
*/
|
2004-07-05 01:07:33 +00:00
|
|
|
do {
|
|
|
|
slp = &syncer_workitem_pending[syncer_delayno];
|
|
|
|
syncer_delayno += 1;
|
|
|
|
if (syncer_delayno == syncer_maxdelay)
|
|
|
|
syncer_delayno = 0;
|
|
|
|
next = &syncer_workitem_pending[syncer_delayno];
|
|
|
|
/*
|
|
|
|
* If the worklist has wrapped since the
|
2007-04-10 15:29:37 +00:00
|
|
|
* it was emptied of all but syncer vnodes,
|
2004-07-05 01:07:33 +00:00
|
|
|
* switch to the FINAL_DELAY state and run
|
|
|
|
* for one more second.
|
|
|
|
*/
|
|
|
|
if (syncer_state == SYNCER_SHUTTING_DOWN &&
|
|
|
|
net_worklist_len == 0 &&
|
|
|
|
last_work_seen == syncer_delayno) {
|
|
|
|
syncer_state = SYNCER_FINAL_DELAY;
|
|
|
|
syncer_final_iter = SYNCER_SHUTDOWN_SPEEDUP;
|
|
|
|
}
|
|
|
|
} while (syncer_state != SYNCER_RUNNING && LIST_EMPTY(slp) &&
|
|
|
|
syncer_worklist_len > 0);
|
1998-03-08 09:59:44 +00:00
|
|
|
|
2004-07-05 01:07:33 +00:00
|
|
|
/*
|
|
|
|
* Keep track of the last time there was anything
|
|
|
|
* on the worklist other than syncer vnodes.
|
|
|
|
* Return to the SHUTTING_DOWN state if any
|
|
|
|
* new work appears.
|
|
|
|
*/
|
2004-07-05 21:32:01 +00:00
|
|
|
if (net_worklist_len > 0 || syncer_state == SYNCER_RUNNING)
|
2004-07-05 01:07:33 +00:00
|
|
|
last_work_seen = syncer_delayno;
|
2004-07-05 21:32:01 +00:00
|
|
|
if (net_worklist_len > 0 && syncer_state == SYNCER_FINAL_DELAY)
|
|
|
|
syncer_state = SYNCER_SHUTTING_DOWN;
|
2004-10-27 08:05:02 +00:00
|
|
|
while ((bo = LIST_FIRST(slp)) != NULL) {
|
2004-11-14 15:24:38 +00:00
|
|
|
error = sync_vnode(bo, td);
|
|
|
|
if (error == 1) {
|
2004-10-27 08:05:02 +00:00
|
|
|
LIST_REMOVE(bo, bo_synclist);
|
|
|
|
LIST_INSERT_HEAD(next, bo, bo_synclist);
|
2003-10-04 18:03:53 +00:00
|
|
|
continue;
|
|
|
|
}
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
2004-07-05 01:07:33 +00:00
|
|
|
if (syncer_state == SYNCER_FINAL_DELAY && syncer_final_iter > 0)
|
|
|
|
syncer_final_iter--;
|
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.
|
|
|
|
*/
|
|
|
|
if (rushjob > 0) {
|
|
|
|
rushjob -= 1;
|
|
|
|
continue;
|
2004-07-05 01:07:33 +00:00
|
|
|
}
|
1998-03-08 09:59:44 +00:00
|
|
|
/*
|
2006-11-07 19:07:33 +00:00
|
|
|
* Just sleep for a short period of time between
|
2004-07-05 01:07:33 +00:00
|
|
|
* iterations when shutting down to allow some I/O
|
|
|
|
* to happen.
|
|
|
|
*
|
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.
|
|
|
|
*/
|
2004-07-05 01:07:33 +00:00
|
|
|
if (syncer_state != SYNCER_RUNNING)
|
2006-11-07 19:45:05 +00:00
|
|
|
msleep(&dummychan, &sync_mtx, PPAUSE, "syncfnl",
|
2004-07-05 01:07:33 +00:00
|
|
|
hz / SYNCER_SHUTDOWN_SPEEDUP);
|
2005-09-12 15:31:28 +00:00
|
|
|
else if (time_uptime == starttime)
|
2006-11-07 19:45:05 +00:00
|
|
|
msleep(&lbolt, &sync_mtx, PPAUSE, "syncer", 0);
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
int
|
2006-11-07 19:07:33 +00:00
|
|
|
speedup_syncer(void)
|
1999-06-15 23:37:29 +00:00
|
|
|
{
|
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);
|
Switch the sleep/wakeup and condition variable implementations to use the
sleep queue interface:
- Sleep queues attempt to merge some of the benefits of both sleep queues
and condition variables. Having sleep qeueus in a hash table avoids
having to allocate a queue head for each wait channel. Thus, struct cv
has shrunk down to just a single char * pointer now. However, the
hash table does not hold threads directly, but queue heads. This means
that once you have located a queue in the hash bucket, you no longer have
to walk the rest of the hash chain looking for threads. Instead, you have
a list of all the threads sleeping on that wait channel.
- Outside of the sleepq code and the sleep/cv code the kernel no longer
differentiates between cv's and sleep/wakeup. For example, calls to
abortsleep() and cv_abort() are replaced with a call to sleepq_abort().
Thus, the TDF_CVWAITQ flag is removed. Also, calls to unsleep() and
cv_waitq_remove() have been replaced with calls to sleepq_remove().
- The sched_sleep() function no longer accepts a priority argument as
sleep's no longer inherently bump the priority. Instead, this is soley
a propery of msleep() which explicitly calls sched_prio() before
blocking.
- The TDF_ONSLEEPQ flag has been dropped as it was never used. The
associated TDF_SET_ONSLEEPQ and TDF_CLR_ON_SLEEPQ macros have also been
dropped and replaced with a single explicit clearing of td_wchan.
TD_SET_ONSLEEPQ() would really have only made sense if it had taken
the wait channel and message as arguments anyway. Now that that only
happens in one place, a macro would be overkill.
2004-02-27 18:52:44 +00:00
|
|
|
sleepq_remove(td, &lbolt);
|
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
|
|
|
}
|
|
|
|
|
2004-07-01 23:59:19 +00:00
|
|
|
/*
|
|
|
|
* Tell the syncer to speed up its work and run though its work
|
|
|
|
* list several times, then tell it to shut down.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
syncer_shutdown(void *arg, int howto)
|
|
|
|
{
|
|
|
|
struct thread *td;
|
|
|
|
|
2004-08-20 19:21:47 +00:00
|
|
|
if (howto & RB_NOSYNC)
|
|
|
|
return;
|
2004-07-01 23:59:19 +00:00
|
|
|
td = FIRST_THREAD_IN_PROC(updateproc);
|
|
|
|
sleepq_remove(td, &lbolt);
|
|
|
|
mtx_lock(&sync_mtx);
|
2004-07-05 01:07:33 +00:00
|
|
|
syncer_state = SYNCER_SHUTTING_DOWN;
|
|
|
|
rushjob = 0;
|
2004-07-01 23:59:19 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
|
|
|
kproc_shutdown(arg, howto);
|
|
|
|
}
|
|
|
|
|
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
|
2004-07-25 21:24:23 +00:00
|
|
|
reassignbuf(struct buf *bp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-09-20 00:21:48 +00:00
|
|
|
struct vnode *vp;
|
2004-10-22 08:47:20 +00:00
|
|
|
struct bufobj *bo;
|
1998-03-08 09:59:44 +00:00
|
|
|
int delay;
|
2005-06-14 20:31:53 +00:00
|
|
|
#ifdef INVARIANTS
|
|
|
|
struct bufv *bv;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-09-20 00:21:48 +00:00
|
|
|
vp = bp->b_vp;
|
2004-10-22 08:47:20 +00:00
|
|
|
bo = bp->b_bufobj;
|
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
|
|
|
|
2005-01-24 10:41:01 +00:00
|
|
|
CTR3(KTR_BUF, "reassignbuf(%p) vp %p flags %X",
|
|
|
|
bp, bp->b_vp, bp->b_flags);
|
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");
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Delete from old vnode list, if on one.
|
|
|
|
*/
|
2003-09-20 00:21:48 +00:00
|
|
|
VI_LOCK(vp);
|
2004-07-25 21:24:23 +00:00
|
|
|
if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN))
|
2002-07-10 17:02:32 +00:00
|
|
|
buf_vlist_remove(bp);
|
2005-05-01 12:00:36 +00:00
|
|
|
else
|
|
|
|
panic("reassignbuf: Buffer %p not on queue.", bp);
|
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
|
|
|
*/
|
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) {
|
2004-10-27 08:05:02 +00:00
|
|
|
if ((bo->bo_flag & BO_ONWORKLST) == 0) {
|
2004-07-25 21:24:23 +00:00
|
|
|
switch (vp->v_type) {
|
1998-03-08 09:59:44 +00:00
|
|
|
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:
|
2004-06-14 14:25:03 +00:00
|
|
|
delay = metadelay;
|
|
|
|
break;
|
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
|
|
|
}
|
2004-10-27 08:05:02 +00:00
|
|
|
vn_syncer_add_to_worklist(bo, delay);
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
2004-10-22 08:47:20 +00:00
|
|
|
buf_vlist_add(bp, bo, 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 {
|
2004-10-22 08:47:20 +00:00
|
|
|
buf_vlist_add(bp, bo, BX_VNCLEAN);
|
2002-07-10 17:02:32 +00:00
|
|
|
|
2004-10-27 08:05:02 +00:00
|
|
|
if ((bo->bo_flag & BO_ONWORKLST) && bo->bo_dirty.bv_cnt == 0) {
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
2004-10-27 08:05:02 +00:00
|
|
|
LIST_REMOVE(bo, bo_synclist);
|
2007-04-10 15:29:37 +00:00
|
|
|
syncer_worklist_len--;
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
2004-10-27 08:05:02 +00:00
|
|
|
bo->bo_flag &= ~BO_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
|
|
|
}
|
2005-06-14 20:31:53 +00:00
|
|
|
#ifdef INVARIANTS
|
|
|
|
bv = &bo->bo_clean;
|
|
|
|
bp = TAILQ_FIRST(&bv->bv_hd);
|
|
|
|
KASSERT(bp == NULL || bp->b_bufobj == bo,
|
|
|
|
("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
|
|
|
|
bp = TAILQ_LAST(&bv->bv_hd, buflists);
|
|
|
|
KASSERT(bp == NULL || bp->b_bufobj == bo,
|
|
|
|
("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
|
|
|
|
bv = &bo->bo_dirty;
|
|
|
|
bp = TAILQ_FIRST(&bv->bv_hd);
|
|
|
|
KASSERT(bp == NULL || bp->b_bufobj == bo,
|
|
|
|
("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
|
|
|
|
bp = TAILQ_LAST(&bv->bv_hd, buflists);
|
|
|
|
KASSERT(bp == NULL || bp->b_bufobj == bo,
|
|
|
|
("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
|
|
|
|
#endif
|
2005-07-05 15:57:55 +00:00
|
|
|
VI_UNLOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2005-06-16 04:41:42 +00:00
|
|
|
/*
|
|
|
|
* Increment the use and hold counts on the vnode, taking care to reference
|
|
|
|
* the driver's usecount if this is a chardev. The vholdl() will remove
|
|
|
|
* the vnode from the free list if it is presently free. Requires the
|
|
|
|
* vnode interlock and returns with it held.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
v_incr_usecount(struct vnode *vp)
|
|
|
|
{
|
|
|
|
|
|
|
|
CTR3(KTR_VFS, "v_incr_usecount: vp %p holdcnt %d usecount %d\n",
|
|
|
|
vp, vp->v_holdcnt, vp->v_usecount);
|
|
|
|
vp->v_usecount++;
|
|
|
|
if (vp->v_type == VCHR && vp->v_rdev != NULL) {
|
|
|
|
dev_lock();
|
|
|
|
vp->v_rdev->si_usecount++;
|
|
|
|
dev_unlock();
|
|
|
|
}
|
|
|
|
vholdl(vp);
|
|
|
|
}
|
|
|
|
|
2006-02-01 00:30:05 +00:00
|
|
|
/*
|
|
|
|
* Turn a holdcnt into a use+holdcnt such that only one call to
|
|
|
|
* v_decr_usecount is needed.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
v_upgrade_usecount(struct vnode *vp)
|
|
|
|
{
|
|
|
|
|
|
|
|
CTR3(KTR_VFS, "v_upgrade_usecount: vp %p holdcnt %d usecount %d\n",
|
|
|
|
vp, vp->v_holdcnt, vp->v_usecount);
|
|
|
|
vp->v_usecount++;
|
|
|
|
if (vp->v_type == VCHR && vp->v_rdev != NULL) {
|
|
|
|
dev_lock();
|
|
|
|
vp->v_rdev->si_usecount++;
|
|
|
|
dev_unlock();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-16 04:41:42 +00:00
|
|
|
/*
|
|
|
|
* Decrement the vnode use and hold count along with the driver's usecount
|
|
|
|
* if this is a chardev. The vdropl() below releases the vnode interlock
|
|
|
|
* as it may free the vnode.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
v_decr_usecount(struct vnode *vp)
|
|
|
|
{
|
|
|
|
|
|
|
|
CTR3(KTR_VFS, "v_decr_usecount: vp %p holdcnt %d usecount %d\n",
|
|
|
|
vp, vp->v_holdcnt, vp->v_usecount);
|
|
|
|
ASSERT_VI_LOCKED(vp, __FUNCTION__);
|
|
|
|
VNASSERT(vp->v_usecount > 0, vp,
|
|
|
|
("v_decr_usecount: negative usecount"));
|
|
|
|
vp->v_usecount--;
|
|
|
|
if (vp->v_type == VCHR && vp->v_rdev != NULL) {
|
|
|
|
dev_lock();
|
|
|
|
vp->v_rdev->si_usecount--;
|
|
|
|
dev_unlock();
|
|
|
|
}
|
|
|
|
vdropl(vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decrement only the use count and driver use count. This is intended to
|
|
|
|
* be paired with a follow on vdropl() to release the remaining hold count.
|
|
|
|
* In this way we may vgone() a vnode with a 0 usecount without risk of
|
|
|
|
* having it end up on a free list because the hold count is kept above 0.
|
|
|
|
*/
|
2002-10-24 19:38:56 +00:00
|
|
|
static void
|
2005-06-16 04:41:42 +00:00
|
|
|
v_decr_useonly(struct vnode *vp)
|
2002-10-24 19:38:56 +00:00
|
|
|
{
|
2004-01-05 19:04:29 +00:00
|
|
|
|
2005-06-16 04:41:42 +00:00
|
|
|
CTR3(KTR_VFS, "v_decr_useonly: vp %p holdcnt %d usecount %d\n",
|
|
|
|
vp, vp->v_holdcnt, vp->v_usecount);
|
|
|
|
ASSERT_VI_LOCKED(vp, __FUNCTION__);
|
|
|
|
VNASSERT(vp->v_usecount > 0, vp,
|
|
|
|
("v_decr_useonly: negative usecount"));
|
|
|
|
vp->v_usecount--;
|
2002-10-25 07:58:25 +00:00
|
|
|
if (vp->v_type == VCHR && vp->v_rdev != NULL) {
|
2004-09-23 07:17:41 +00:00
|
|
|
dev_lock();
|
2005-06-16 04:41:42 +00:00
|
|
|
vp->v_rdev->si_usecount--;
|
2004-09-23 07:17:41 +00:00
|
|
|
dev_unlock();
|
2002-10-24 19:38:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
2006-02-01 00:30:05 +00:00
|
|
|
vget(struct vnode *vp, int flags, struct thread *td)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-04-11 09:28:32 +00:00
|
|
|
int oweinact;
|
|
|
|
int oldflags;
|
1997-02-10 02:22:35 +00:00
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2005-03-13 11:54:28 +00:00
|
|
|
error = 0;
|
2005-04-11 09:28:32 +00:00
|
|
|
oldflags = flags;
|
|
|
|
oweinact = 0;
|
2006-02-01 00:30:05 +00:00
|
|
|
VFS_ASSERT_GIANT(vp->v_mount);
|
2005-03-13 11:54:28 +00:00
|
|
|
if ((flags & LK_INTERLOCK) == 0)
|
|
|
|
VI_LOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2005-04-11 09:28:32 +00:00
|
|
|
* If the inactive call was deferred because vput() was called
|
|
|
|
* with a shared lock, we have to do it here before another thread
|
|
|
|
* gets a reference to data that should be dead.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-04-11 09:28:32 +00:00
|
|
|
if (vp->v_iflag & VI_OWEINACT) {
|
|
|
|
if (flags & LK_NOWAIT) {
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
return (EBUSY);
|
|
|
|
}
|
|
|
|
flags &= ~LK_TYPE_MASK;
|
|
|
|
flags |= LK_EXCLUSIVE;
|
|
|
|
oweinact = 1;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2006-02-01 00:30:05 +00:00
|
|
|
vholdl(vp);
|
2005-04-11 09:28:32 +00:00
|
|
|
if ((error = vn_lock(vp, flags | LK_INTERLOCK, td)) != 0) {
|
2006-02-01 00:30:05 +00:00
|
|
|
vdrop(vp);
|
2005-04-11 09:28:32 +00:00
|
|
|
return (error);
|
2005-03-13 11:54:28 +00:00
|
|
|
}
|
2006-02-01 00:30:05 +00:00
|
|
|
VI_LOCK(vp);
|
|
|
|
/* Upgrade our holdcnt to a usecount. */
|
|
|
|
v_upgrade_usecount(vp);
|
2005-04-11 09:28:32 +00:00
|
|
|
if (vp->v_iflag & VI_DOOMED && (flags & LK_RETRY) == 0)
|
|
|
|
panic("vget: vn_lock failed to return ENOENT\n");
|
|
|
|
if (oweinact) {
|
|
|
|
if (vp->v_iflag & VI_OWEINACT)
|
|
|
|
vinactive(vp, td);
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
if ((oldflags & LK_TYPE_MASK) == 0)
|
|
|
|
VOP_UNLOCK(vp, 0, td);
|
2006-02-01 00:30:05 +00:00
|
|
|
} else
|
|
|
|
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)
|
|
|
|
{
|
2004-01-05 19:04:29 +00:00
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
2005-06-16 04:41:42 +00:00
|
|
|
v_incr_usecount(vp);
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
vrele(struct vnode *vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
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"));
|
2006-02-01 00:30:05 +00:00
|
|
|
VFS_ASSERT_GIANT(vp->v_mount);
|
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. */
|
2005-02-17 10:28:58 +00:00
|
|
|
VNASSERT(vp->v_writecount < vp->v_usecount || vp->v_usecount < 1, vp,
|
2001-05-11 20:42:41 +00:00
|
|
|
("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)) {
|
2005-06-16 04:41:42 +00:00
|
|
|
v_decr_usecount(vp);
|
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;
|
|
|
|
}
|
2005-03-14 07:16:55 +00:00
|
|
|
if (vp->v_usecount != 1) {
|
1997-12-29 00:25:11 +00:00
|
|
|
#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
|
|
|
}
|
2005-06-16 04:41:42 +00:00
|
|
|
/*
|
|
|
|
* We want to hold the vnode until the inactive finishes to
|
|
|
|
* prevent vgone() races. We drop the use count here and the
|
|
|
|
* hold count below when we're done.
|
|
|
|
*/
|
|
|
|
v_decr_useonly(vp);
|
2005-03-14 07:16:55 +00:00
|
|
|
/*
|
|
|
|
* We must call VOP_INACTIVE with the node locked. Mark
|
|
|
|
* as VI_DOINGINACT to avoid recursion.
|
|
|
|
*/
|
2006-03-08 23:43:39 +00:00
|
|
|
vp->v_iflag |= VI_OWEINACT;
|
2005-03-14 07:16:55 +00:00
|
|
|
if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, td) == 0) {
|
|
|
|
VI_LOCK(vp);
|
2006-03-08 23:43:39 +00:00
|
|
|
if (vp->v_usecount > 0)
|
|
|
|
vp->v_iflag &= ~VI_OWEINACT;
|
|
|
|
if (vp->v_iflag & VI_OWEINACT)
|
|
|
|
vinactive(vp, td);
|
2005-03-14 07:16:55 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
2006-03-08 23:43:39 +00:00
|
|
|
} else {
|
2005-03-14 07:16:55 +00:00
|
|
|
VI_LOCK(vp);
|
2006-03-08 23:43:39 +00:00
|
|
|
if (vp->v_usecount > 0)
|
|
|
|
vp->v_iflag &= ~VI_OWEINACT;
|
|
|
|
}
|
2005-06-16 04:41:42 +00:00
|
|
|
vdropl(vp);
|
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
|
2007-05-27 20:50:23 +00:00
|
|
|
* re-aquiring the lock (as vrele() acquires the lock internally.)
|
2000-09-22 12:22:36 +00:00
|
|
|
*/
|
1997-12-29 00:25:11 +00:00
|
|
|
void
|
2006-01-21 19:42:10 +00:00
|
|
|
vput(struct vnode *vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = curthread; /* XXX */
|
2005-03-29 10:02:48 +00:00
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(vp != NULL, ("vput: null vp"));
|
2005-03-28 11:18:47 +00:00
|
|
|
ASSERT_VOP_LOCKED(vp, "vput");
|
2006-02-01 00:30:05 +00:00
|
|
|
VFS_ASSERT_GIANT(vp->v_mount);
|
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. */
|
2005-02-17 10:28:58 +00:00
|
|
|
VNASSERT(vp->v_writecount < vp->v_usecount || vp->v_usecount < 1, vp,
|
2001-05-11 20:42:41 +00:00
|
|
|
("vput: missed vn_close"));
|
2005-03-29 10:02:48 +00:00
|
|
|
error = 0;
|
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)) {
|
2005-06-16 04:41:42 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
|
|
|
v_decr_usecount(vp);
|
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
|
|
|
|
2005-03-28 11:18:47 +00:00
|
|
|
if (vp->v_usecount != 1) {
|
1997-12-29 00:25:11 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
vprint("vput: negative ref count", vp);
|
|
|
|
#endif
|
|
|
|
panic("vput: negative ref cnt");
|
|
|
|
}
|
2005-06-16 04:41:42 +00:00
|
|
|
/*
|
|
|
|
* We want to hold the vnode until the inactive finishes to
|
|
|
|
* prevent vgone() races. We drop the use count here and the
|
|
|
|
* hold count below when we're done.
|
|
|
|
*/
|
|
|
|
v_decr_useonly(vp);
|
2005-03-29 10:02:48 +00:00
|
|
|
vp->v_iflag |= VI_OWEINACT;
|
2005-04-13 10:57:53 +00:00
|
|
|
if (VOP_ISLOCKED(vp, NULL) != LK_EXCLUSIVE) {
|
2005-04-11 09:28:32 +00:00
|
|
|
error = VOP_LOCK(vp, LK_EXCLUPGRADE|LK_INTERLOCK|LK_NOWAIT, td);
|
2005-03-29 10:02:48 +00:00
|
|
|
VI_LOCK(vp);
|
2006-03-08 23:43:39 +00:00
|
|
|
if (error) {
|
|
|
|
if (vp->v_usecount > 0)
|
|
|
|
vp->v_iflag &= ~VI_OWEINACT;
|
2005-04-11 09:28:32 +00:00
|
|
|
goto done;
|
2006-03-08 23:43:39 +00:00
|
|
|
}
|
2005-03-29 10:02:48 +00:00
|
|
|
}
|
2006-03-08 23:43:39 +00:00
|
|
|
if (vp->v_usecount > 0)
|
|
|
|
vp->v_iflag &= ~VI_OWEINACT;
|
2005-04-11 09:28:32 +00:00
|
|
|
if (vp->v_iflag & VI_OWEINACT)
|
2005-03-28 11:18:47 +00:00
|
|
|
vinactive(vp, td);
|
|
|
|
VOP_UNLOCK(vp, 0, td);
|
2005-04-11 09:28:32 +00:00
|
|
|
done:
|
2005-06-16 04:41:42 +00:00
|
|
|
vdropl(vp);
|
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)
|
|
|
|
{
|
2004-01-05 19:04:29 +00:00
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
|
|
|
vholdl(vp);
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
}
|
|
|
|
|
2005-03-15 13:43:10 +00:00
|
|
|
void
|
2004-10-22 08:47:20 +00:00
|
|
|
vholdl(struct vnode *vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-01-05 19:04:29 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_holdcnt++;
|
1997-08-31 07:32:39 +00:00
|
|
|
if (VSHOULDBUSY(vp))
|
|
|
|
vbusy(vp);
|
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)
|
|
|
|
{
|
2004-01-05 19:04:29 +00:00
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
|
|
|
vdropl(vp);
|
|
|
|
}
|
2004-01-05 19:04:29 +00:00
|
|
|
|
2005-06-16 04:41:42 +00:00
|
|
|
/*
|
|
|
|
* Drop the hold count of the vnode. If this is the last reference to
|
|
|
|
* the vnode we will free it if it has been vgone'd otherwise it is
|
|
|
|
* placed on the free list.
|
|
|
|
*/
|
2007-03-31 23:57:17 +00:00
|
|
|
void
|
2005-02-10 12:28:58 +00:00
|
|
|
vdropl(struct vnode *vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-01-05 19:04:29 +00:00
|
|
|
|
2007-04-01 10:45:32 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "vdropl");
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_holdcnt <= 0)
|
2005-03-14 09:25:19 +00:00
|
|
|
panic("vdrop: holdcnt %d", vp->v_holdcnt);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_holdcnt--;
|
2005-06-16 04:41:42 +00:00
|
|
|
if (vp->v_holdcnt == 0) {
|
|
|
|
if (vp->v_iflag & VI_DOOMED) {
|
|
|
|
vdestroy(vp);
|
|
|
|
return;
|
|
|
|
} else
|
|
|
|
vfree(vp);
|
|
|
|
}
|
|
|
|
VI_UNLOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2005-06-16 04:41:42 +00:00
|
|
|
/*
|
|
|
|
* Call VOP_INACTIVE on the vnode and manage the DOINGINACT and OWEINACT
|
|
|
|
* flags. DOINGINACT prevents us from recursing in calls to vinactive.
|
|
|
|
* OWEINACT tracks whether a vnode missed a call to inactive due to a
|
|
|
|
* failed lock upgrade.
|
|
|
|
*/
|
2005-03-13 11:54:28 +00:00
|
|
|
static void
|
|
|
|
vinactive(struct vnode *vp, struct thread *td)
|
|
|
|
{
|
2005-06-16 04:41:42 +00:00
|
|
|
|
2005-03-13 11:54:28 +00:00
|
|
|
ASSERT_VOP_LOCKED(vp, "vinactive");
|
|
|
|
ASSERT_VI_LOCKED(vp, "vinactive");
|
|
|
|
VNASSERT((vp->v_iflag & VI_DOINGINACT) == 0, vp,
|
|
|
|
("vinactive: recursed on VI_DOINGINACT"));
|
|
|
|
vp->v_iflag |= VI_DOINGINACT;
|
2005-06-07 22:05:32 +00:00
|
|
|
vp->v_iflag &= ~VI_OWEINACT;
|
2005-03-13 11:54:28 +00:00
|
|
|
VI_UNLOCK(vp);
|
|
|
|
VOP_INACTIVE(vp, td);
|
|
|
|
VI_LOCK(vp);
|
|
|
|
VNASSERT(vp->v_iflag & VI_DOINGINACT, vp,
|
|
|
|
("vinactive: lost VI_DOINGINACT"));
|
2005-06-07 22:05:32 +00:00
|
|
|
vp->v_iflag &= ~VI_DOINGINACT;
|
2005-03-13 11:54:28 +00:00
|
|
|
}
|
|
|
|
|
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
|
2004-07-12 08:14:09 +00:00
|
|
|
* v_usecount exceeds this value. On a successful return, vflush(, td)
|
2001-05-16 18:04:37 +00:00
|
|
|
* 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
|
2006-01-21 19:42:10 +00:00
|
|
|
vflush( struct mount *mp, int rootrefs, int flags, struct thread *td)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2006-01-09 20:42:19 +00:00
|
|
|
struct vnode *vp, *mvp, *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
|
|
|
|
2005-06-11 01:16:46 +00:00
|
|
|
CTR1(KTR_VFS, "vflush: mp %p", mp);
|
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.
|
|
|
|
*/
|
2005-03-24 07:31:38 +00:00
|
|
|
if ((error = VFS_ROOT(mp, LK_EXCLUSIVE, &rootvp, td)) != 0)
|
2001-05-16 18:04:37 +00:00
|
|
|
return (error);
|
|
|
|
vput(rootvp);
|
2002-07-07 06:38:22 +00:00
|
|
|
|
2001-05-16 18:04:37 +00:00
|
|
|
}
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_ILOCK(mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
loop:
|
2006-01-09 20:42:19 +00:00
|
|
|
MNT_VNODE_FOREACH(vp, mp, mvp) {
|
1997-02-10 02:22:35 +00:00
|
|
|
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
2005-06-16 04:41:42 +00:00
|
|
|
vholdl(vp);
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
2003-10-05 07:12:38 +00:00
|
|
|
error = vn_lock(vp, LK_INTERLOCK | LK_EXCLUSIVE, td);
|
|
|
|
if (error) {
|
2005-06-16 04:41:42 +00:00
|
|
|
vdrop(vp);
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_ILOCK(mp);
|
2006-01-09 20:42:19 +00:00
|
|
|
MNT_VNODE_FOREACH_ABORT_ILOCKED(mp, mvp);
|
2003-05-16 19:46:51 +00:00
|
|
|
goto loop;
|
|
|
|
}
|
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);
|
2005-06-16 04:41:42 +00:00
|
|
|
vdrop(vp);
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_ILOCK(mp);
|
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)) {
|
2005-06-16 04:41:42 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
|
|
|
vdropl(vp);
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_ILOCK(mp);
|
2002-09-25 02:22:21 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
VI_LOCK(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
|
|
|
* With v_usecount == 0, all we need to do is clear out the
|
|
|
|
* vnode data structures and we are done.
|
2005-06-16 04:41:42 +00:00
|
|
|
*
|
|
|
|
* If FORCECLOSE is set, forcibly close the vnode.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-06-16 04:41:42 +00:00
|
|
|
if (vp->v_usecount == 0 || (flags & FORCECLOSE)) {
|
|
|
|
VNASSERT(vp->v_usecount == 0 ||
|
|
|
|
(vp->v_type != VCHR && vp->v_type != VBLK), vp,
|
2005-01-04 08:49:14 +00:00
|
|
|
("device VNODE %p is FORCECLOSED", vp));
|
2005-06-16 04:41:42 +00:00
|
|
|
vgonel(vp);
|
|
|
|
} else {
|
|
|
|
busy++;
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
2005-06-16 04:41:42 +00:00
|
|
|
if (busyprt)
|
|
|
|
vprint("vflush: busy vnode", vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
2005-06-16 04:41:42 +00:00
|
|
|
}
|
|
|
|
VOP_UNLOCK(vp, 0, td);
|
|
|
|
vdropl(vp);
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_ILOCK(mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
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"));
|
2005-02-17 10:28:58 +00:00
|
|
|
VNASSERT(rootvp->v_usecount >= rootrefs, rootvp,
|
2004-07-12 04:13:38 +00:00
|
|
|
("vflush: usecount %d < rootrefs %d",
|
|
|
|
rootvp->v_usecount, rootrefs));
|
2001-05-16 18:04:37 +00:00
|
|
|
if (busy == 1 && rootvp->v_usecount == rootrefs) {
|
2005-03-13 11:54:28 +00:00
|
|
|
VOP_LOCK(rootvp, LK_EXCLUSIVE|LK_INTERLOCK, td);
|
|
|
|
vgone(rootvp);
|
|
|
|
VOP_UNLOCK(rootvp, 0, 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);
|
|
|
|
}
|
|
|
|
|
2005-01-28 13:00:03 +00:00
|
|
|
/*
|
|
|
|
* Recycle an unused vnode to the front of the free list.
|
|
|
|
*/
|
|
|
|
int
|
2005-01-28 13:08:21 +00:00
|
|
|
vrecycle(struct vnode *vp, struct thread *td)
|
2005-01-28 13:00:03 +00:00
|
|
|
{
|
2005-06-16 04:41:42 +00:00
|
|
|
int recycled;
|
2005-01-28 13:00:03 +00:00
|
|
|
|
2005-03-13 11:54:28 +00:00
|
|
|
ASSERT_VOP_LOCKED(vp, "vrecycle");
|
2005-06-16 04:41:42 +00:00
|
|
|
recycled = 0;
|
2005-01-28 13:00:03 +00:00
|
|
|
VI_LOCK(vp);
|
2005-06-16 04:41:42 +00:00
|
|
|
if (vp->v_usecount == 0) {
|
|
|
|
recycled = 1;
|
|
|
|
vgonel(vp);
|
2005-01-28 13:00:03 +00:00
|
|
|
}
|
|
|
|
VI_UNLOCK(vp);
|
2005-06-16 04:41:42 +00:00
|
|
|
return (recycled);
|
2005-01-28 13:00:03 +00:00
|
|
|
}
|
2003-10-05 00:02:41 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2005-01-28 13:00:03 +00:00
|
|
|
* Eliminate all activity associated with a vnode
|
|
|
|
* in preparation for reuse.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-01-28 13:00:03 +00:00
|
|
|
void
|
|
|
|
vgone(struct vnode *vp)
|
|
|
|
{
|
|
|
|
VI_LOCK(vp);
|
2005-06-16 04:41:42 +00:00
|
|
|
vgonel(vp);
|
|
|
|
VI_UNLOCK(vp);
|
2005-01-28 13:00:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vgone, with the vp interlock held.
|
|
|
|
*/
|
|
|
|
void
|
2005-06-16 04:41:42 +00:00
|
|
|
vgonel(struct vnode *vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-06-13 06:26:55 +00:00
|
|
|
struct thread *td;
|
2005-03-29 10:02:48 +00:00
|
|
|
int oweinact;
|
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;
|
2006-03-08 23:43:39 +00:00
|
|
|
struct mount *mp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2005-06-11 01:16:46 +00:00
|
|
|
CTR1(KTR_VFS, "vgonel: vp %p", vp);
|
2005-03-13 11:54:28 +00:00
|
|
|
ASSERT_VOP_LOCKED(vp, "vgonel");
|
2005-01-28 13:00:03 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "vgonel");
|
2005-06-16 04:41:42 +00:00
|
|
|
VNASSERT(vp->v_holdcnt, vp,
|
|
|
|
("vgonel: vp %p has no reference.", vp));
|
2005-06-14 20:31:53 +00:00
|
|
|
td = curthread;
|
2005-01-28 13:00:03 +00:00
|
|
|
|
2005-06-13 06:26:55 +00:00
|
|
|
/*
|
|
|
|
* Don't vgonel if we're already doomed.
|
|
|
|
*/
|
2005-08-10 11:46:03 +00:00
|
|
|
if (vp->v_iflag & VI_DOOMED)
|
2005-06-13 06:26:55 +00:00
|
|
|
return;
|
2005-06-14 20:31:53 +00:00
|
|
|
vp->v_iflag |= VI_DOOMED;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2005-06-14 20:31:53 +00:00
|
|
|
* Check to see if the vnode is in use. If so, we have to call
|
|
|
|
* VOP_CLOSE() and VOP_INACTIVE().
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-06-14 20:31:53 +00:00
|
|
|
active = vp->v_usecount;
|
2005-03-29 10:02:48 +00:00
|
|
|
oweinact = (vp->v_iflag & VI_OWEINACT);
|
2005-03-13 11:54:28 +00:00
|
|
|
VI_UNLOCK(vp);
|
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
|
|
|
*/
|
2006-03-08 23:43:39 +00:00
|
|
|
mp = NULL;
|
2005-03-27 07:53:13 +00:00
|
|
|
if (!TAILQ_EMPTY(&vp->v_bufobj.bo_dirty.bv_hd))
|
2006-03-08 23:43:39 +00:00
|
|
|
(void) vn_start_secondary_write(vp, &mp, V_WAIT);
|
2005-01-24 22:22:02 +00:00
|
|
|
if (vinvalbuf(vp, V_SAVE, td, 0, 0) != 0)
|
|
|
|
vinvalbuf(vp, 0, td, 0, 0);
|
2000-07-04 03:23:29 +00:00
|
|
|
|
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
|
2005-03-13 11:54:28 +00:00
|
|
|
* deactivated before being reclaimed.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-03-29 10:02:48 +00:00
|
|
|
if (active)
|
2005-01-24 22:22:02 +00:00
|
|
|
VOP_CLOSE(vp, FNONBLOCK, NOCRED, td);
|
2005-03-29 10:02:48 +00:00
|
|
|
if (oweinact || active) {
|
2002-12-29 18:30:49 +00:00
|
|
|
VI_LOCK(vp);
|
2005-03-13 11:54:28 +00:00
|
|
|
if ((vp->v_iflag & VI_DOINGINACT) == 0)
|
|
|
|
vinactive(vp, td);
|
2002-12-29 18:30:49 +00:00
|
|
|
VI_UNLOCK(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Reclaim the vnode.
|
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
if (VOP_RECLAIM(vp, td))
|
2005-03-13 11:54:28 +00:00
|
|
|
panic("vgone: cannot reclaim");
|
2006-03-08 23:43:39 +00:00
|
|
|
if (mp != NULL)
|
|
|
|
vn_finished_secondary_write(mp);
|
2005-02-17 10:28:58 +00:00
|
|
|
VNASSERT(vp->v_object == NULL, vp,
|
2005-02-07 07:48:03 +00:00
|
|
|
("vop_reclaim left v_object vp=%p, tag=%s", vp, vp->v_tag));
|
2003-10-05 02:48:04 +00:00
|
|
|
/*
|
|
|
|
* Delete from old mount point vnode list.
|
|
|
|
*/
|
2004-07-04 08:52:35 +00:00
|
|
|
delmntque(vp);
|
1997-02-10 02:22:35 +00:00
|
|
|
cache_purge(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2005-06-14 20:31:53 +00:00
|
|
|
* Done with purge, reset to the standard lock and invalidate
|
|
|
|
* the vnode.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-06-14 20:31:53 +00:00
|
|
|
VI_LOCK(vp);
|
2002-10-14 19:44:51 +00:00
|
|
|
vp->v_vnlock = &vp->v_lock;
|
2004-12-01 23:16:38 +00:00
|
|
|
vp->v_op = &dead_vnodeops;
|
2002-09-14 09:02:28 +00:00
|
|
|
vp->v_tag = "none";
|
2005-03-13 11:54:28 +00:00
|
|
|
vp->v_type = VBAD;
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
vcount(struct vnode *vp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int count;
|
|
|
|
|
2004-09-23 07:17:41 +00:00
|
|
|
dev_lock();
|
2002-10-24 19:38:56 +00:00
|
|
|
count = vp->v_rdev->si_usecount;
|
2004-09-23 07:17:41 +00:00
|
|
|
dev_unlock();
|
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
|
|
|
/*
|
2004-06-16 09:47:26 +00:00
|
|
|
* Same as above, but using the struct cdev *as argument
|
2000-02-07 23:05:40 +00:00
|
|
|
*/
|
|
|
|
int
|
2006-01-21 19:42:10 +00:00
|
|
|
count_dev(struct cdev *dev)
|
2000-02-07 23:05:40 +00:00
|
|
|
{
|
2003-10-17 11:56:48 +00:00
|
|
|
int count;
|
2000-02-07 23:05:40 +00:00
|
|
|
|
2004-09-23 07:17:41 +00:00
|
|
|
dev_lock();
|
2003-10-17 11:56:48 +00:00
|
|
|
count = dev->si_usecount;
|
2004-09-23 07:17:41 +00:00
|
|
|
dev_unlock();
|
2003-10-17 11:56:48 +00:00
|
|
|
return(count);
|
2000-02-07 23:05:40 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Print out a description of a vnode.
|
|
|
|
*/
|
|
|
|
static char *typename[] =
|
2006-01-09 20:42:19 +00:00
|
|
|
{"VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD",
|
|
|
|
"VMARKER"};
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
2005-01-24 13:58:08 +00:00
|
|
|
vn_printf(struct vnode *vp, const char *fmt, ...)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-01-24 13:58:08 +00:00
|
|
|
va_list ap;
|
2007-08-13 21:23:30 +00:00
|
|
|
char buf[256], buf2[16];
|
|
|
|
u_long flags;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2005-01-24 13:58:08 +00:00
|
|
|
va_start(ap, fmt);
|
|
|
|
vprintf(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
printf("%p: ", (void *)vp);
|
|
|
|
printf("tag %s, type %s\n", vp->v_tag, typename[vp->v_type]);
|
|
|
|
printf(" usecount %d, writecount %d, refcount %d mountedhere %p\n",
|
2004-12-03 12:09:34 +00:00
|
|
|
vp->v_usecount, vp->v_writecount, vp->v_holdcnt, vp->v_mountedhere);
|
1994-05-24 10:09:53 +00:00
|
|
|
buf[0] = '\0';
|
2005-01-24 13:58:08 +00:00
|
|
|
buf[1] = '\0';
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_vflag & VV_ROOT)
|
2007-08-13 21:23:30 +00:00
|
|
|
strlcat(buf, "|VV_ROOT", sizeof(buf));
|
|
|
|
if (vp->v_vflag & VV_ISTTY)
|
|
|
|
strlcat(buf, "|VV_ISTTY", sizeof(buf));
|
|
|
|
if (vp->v_vflag & VV_NOSYNC)
|
|
|
|
strlcat(buf, "|VV_NOSYNC", sizeof(buf));
|
|
|
|
if (vp->v_vflag & VV_CACHEDLABEL)
|
|
|
|
strlcat(buf, "|VV_CACHEDLABEL", sizeof(buf));
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_vflag & VV_TEXT)
|
2007-08-13 21:23:30 +00:00
|
|
|
strlcat(buf, "|VV_TEXT", sizeof(buf));
|
|
|
|
if (vp->v_vflag & VV_COPYONWRITE)
|
|
|
|
strlcat(buf, "|VV_COPYONWRITE", sizeof(buf));
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_vflag & VV_SYSTEM)
|
2007-08-13 21:23:30 +00:00
|
|
|
strlcat(buf, "|VV_SYSTEM", sizeof(buf));
|
|
|
|
if (vp->v_vflag & VV_PROCDEP)
|
|
|
|
strlcat(buf, "|VV_PROCDEP", sizeof(buf));
|
|
|
|
if (vp->v_vflag & VV_NOKNOTE)
|
|
|
|
strlcat(buf, "|VV_NOKNOTE", sizeof(buf));
|
2006-10-31 21:48:54 +00:00
|
|
|
if (vp->v_vflag & VV_DELETED)
|
2007-08-13 21:23:30 +00:00
|
|
|
strlcat(buf, "|VV_DELETED", sizeof(buf));
|
|
|
|
if (vp->v_vflag & VV_MD)
|
|
|
|
strlcat(buf, "|VV_MD", sizeof(buf));
|
|
|
|
flags = vp->v_vflag & ~(VV_ROOT | VV_ISTTY | VV_NOSYNC |
|
|
|
|
VV_CACHEDLABEL | VV_TEXT | VV_COPYONWRITE | VV_SYSTEM | VV_PROCDEP |
|
|
|
|
VV_NOKNOTE | VV_DELETED | VV_MD);
|
|
|
|
if (flags != 0) {
|
|
|
|
snprintf(buf2, sizeof(buf2), "|VV(0x%lx)", flags);
|
|
|
|
strlcat(buf, buf2, sizeof(buf));
|
|
|
|
}
|
|
|
|
if (vp->v_iflag & VI_MOUNT)
|
|
|
|
strlcat(buf, "|VI_MOUNT", sizeof(buf));
|
|
|
|
if (vp->v_iflag & VI_AGE)
|
|
|
|
strlcat(buf, "|VI_AGE", sizeof(buf));
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_iflag & VI_DOOMED)
|
2007-08-13 21:23:30 +00:00
|
|
|
strlcat(buf, "|VI_DOOMED", sizeof(buf));
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_iflag & VI_FREE)
|
2007-08-13 21:23:30 +00:00
|
|
|
strlcat(buf, "|VI_FREE", sizeof(buf));
|
|
|
|
if (vp->v_iflag & VI_OBJDIRTY)
|
|
|
|
strlcat(buf, "|VI_OBJDIRTY", sizeof(buf));
|
|
|
|
if (vp->v_iflag & VI_DOINGINACT)
|
|
|
|
strlcat(buf, "|VI_DOINGINACT", sizeof(buf));
|
|
|
|
if (vp->v_iflag & VI_OWEINACT)
|
|
|
|
strlcat(buf, "|VI_OWEINACT", sizeof(buf));
|
|
|
|
flags = vp->v_iflag & ~(VI_MOUNT | VI_AGE | VI_DOOMED | VI_FREE |
|
|
|
|
VI_OBJDIRTY | VI_DOINGINACT | VI_OWEINACT);
|
|
|
|
if (flags != 0) {
|
|
|
|
snprintf(buf2, sizeof(buf2), "|VI(0x%lx)", flags);
|
|
|
|
strlcat(buf, buf2, sizeof(buf));
|
|
|
|
}
|
2005-01-24 13:58:08 +00:00
|
|
|
printf(" flags (%s)\n", buf + 1);
|
2004-12-03 12:09:34 +00:00
|
|
|
if (mtx_owned(VI_MTX(vp)))
|
|
|
|
printf(" VI_LOCKed");
|
2005-03-27 07:52:12 +00:00
|
|
|
if (vp->v_object != NULL)
|
2005-03-13 11:54:28 +00:00
|
|
|
printf(" v_object %p ref %d pages %d\n",
|
|
|
|
vp->v_object, vp->v_object->ref_count,
|
|
|
|
vp->v_object->resident_page_count);
|
2005-01-24 13:58:08 +00:00
|
|
|
printf(" ");
|
2002-10-14 03:20:36 +00:00
|
|
|
lockmgr_printinfo(vp->v_vnlock);
|
2002-09-18 20:42:04 +00:00
|
|
|
printf("\n");
|
2003-03-03 19:15:40 +00:00
|
|
|
if (vp->v_data != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
VOP_PRINT(vp);
|
|
|
|
}
|
|
|
|
|
1995-04-16 11:33:33 +00:00
|
|
|
#ifdef DDB
|
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
|
|
|
{
|
1997-02-25 19:33:23 +00:00
|
|
|
struct mount *mp, *nmp;
|
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-05-12 14:37:47 +00:00
|
|
|
/*
|
|
|
|
* Note: because this is DDB, we can't obey the locking semantics
|
|
|
|
* for these structures, which means we could catch an inconsistent
|
|
|
|
* state and dereference a nasty pointer. Not much to be done
|
|
|
|
* about that.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
printf("Locked vnodes\n");
|
1999-11-20 10:00:46 +00:00
|
|
|
for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
|
2003-05-12 14:37:47 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
2001-10-23 01:21:29 +00:00
|
|
|
TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes) {
|
2006-03-02 21:31:15 +00:00
|
|
|
if (vp->v_type != VMARKER && VOP_ISLOCKED(vp, NULL))
|
2005-02-10 08:55:08 +00:00
|
|
|
vprint("", vp);
|
1997-02-25 19:33:23 +00:00
|
|
|
}
|
1999-11-20 10:00:46 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
2006-09-04 22:15:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Show details about the given vnode.
|
|
|
|
*/
|
|
|
|
DB_SHOW_COMMAND(vnode, db_show_vnode)
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
|
|
|
|
|
|
|
if (!have_addr)
|
|
|
|
return;
|
|
|
|
vp = (struct vnode *)addr;
|
|
|
|
vn_printf(vp, "vnode ");
|
|
|
|
}
|
|
|
|
#endif /* DDB */
|
1994-05-24 10:09:53 +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
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2004-04-11 21:09:22 +00:00
|
|
|
/*
|
|
|
|
* Top level filesystem related information gathering.
|
|
|
|
*/
|
- 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
|
|
|
static int
|
|
|
|
sysctl_vfs_conflist(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct vfsconf *vfsp;
|
2004-07-27 22:32:01 +00:00
|
|
|
struct xvfsconf xvfsp;
|
|
|
|
int error;
|
- 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
|
|
|
|
2004-07-27 22:32:01 +00:00
|
|
|
error = 0;
|
|
|
|
TAILQ_FOREACH(vfsp, &vfsconf, vfc_list) {
|
2005-05-06 02:50:00 +00:00
|
|
|
bzero(&xvfsp, sizeof(xvfsp));
|
2004-07-27 22:32:01 +00:00
|
|
|
vfsconf2x(vfsp, &xvfsp);
|
|
|
|
error = SYSCTL_OUT(req, &xvfsp, sizeof xvfsp);
|
|
|
|
if (error)
|
|
|
|
break;
|
- 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
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_vfs, OID_AUTO, conflist, CTLFLAG_RD, NULL, 0, sysctl_vfs_conflist,
|
|
|
|
"S,xvfsconf", "List of all configured filesystems");
|
|
|
|
|
2004-04-11 21:09:22 +00:00
|
|
|
#ifndef BURN_BRIDGES
|
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 */
|
2004-07-27 22:32:01 +00:00
|
|
|
TAILQ_FOREACH(vfsp, &vfsconf, vfc_list)
|
1997-03-03 12:58:20 +00:00
|
|
|
if (vfsp->vfc_typenum == name[2])
|
|
|
|
break;
|
|
|
|
if (vfsp == NULL)
|
|
|
|
return (EOPNOTSUPP);
|
2005-05-06 02:50:00 +00:00
|
|
|
bzero(&xvfsp, sizeof(xvfsp));
|
- 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
|
|
|
|
2005-02-10 12:28:58 +00:00
|
|
|
static SYSCTL_NODE(_vfs, VFS_GENERIC, generic, CTLFLAG_RD | CTLFLAG_SKIP,
|
|
|
|
vfs_sysctl, "Generic filesystem");
|
1997-03-04 18:31:56 +00:00
|
|
|
|
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
|
|
|
|
2004-07-27 22:32:01 +00:00
|
|
|
TAILQ_FOREACH(vfsp, &vfsconf, vfc_list) {
|
2005-05-06 02:50:00 +00:00
|
|
|
bzero(&ovfs, sizeof(ovfs));
|
1997-03-02 11:06:22 +00:00
|
|
|
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 */
|
2004-04-11 21:09:22 +00:00
|
|
|
#endif /* !BURN_BRIDGES */
|
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
|
|
|
|
2004-02-26 00:27:04 +00:00
|
|
|
error = sysctl_wire_old_buffer(req, 0);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
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;
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_ILOCK(mp);
|
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;
|
2005-03-30 03:01:36 +00:00
|
|
|
xvn[n].xv_id = 0; /* XXX compat */
|
2002-07-31 12:24:35 +00:00
|
|
|
#define XV_COPY(field) xvn[n].xv_##field = vp->v_##field
|
|
|
|
XV_COPY(usecount);
|
|
|
|
XV_COPY(writecount);
|
|
|
|
XV_COPY(holdcnt);
|
|
|
|
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:
|
|
|
|
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
|
|
|
}
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_IUNLOCK(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);
|
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
|
|
|
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
vfs_unmountall(void)
|
1997-02-10 02:22:35 +00:00
|
|
|
{
|
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;
|
|
|
|
|
2005-05-02 02:07:55 +00:00
|
|
|
KASSERT(curthread != NULL, ("vfs_unmountall: NULL curthread"));
|
|
|
|
td = curthread;
|
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);
|
2005-08-20 17:12:47 +00:00
|
|
|
/*
|
|
|
|
* XXX: Due to the way in which we mount the root
|
|
|
|
* file system off of devfs, devfs will generate a
|
|
|
|
* "busy" warning when we try to unmount it before
|
|
|
|
* the root. Don't print a warning as a result in
|
|
|
|
* order to avoid false positive errors that may
|
|
|
|
* cause needless upset.
|
|
|
|
*/
|
|
|
|
if (strcmp(mp->mnt_vfc->vfc_name, "devfs") != 0) {
|
|
|
|
printf("unmount of %s failed (",
|
|
|
|
mp->mnt_stat.f_mntonname);
|
|
|
|
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)
|
|
|
|
{
|
2006-01-09 20:42:19 +00:00
|
|
|
struct vnode *vp, *mvp;
|
1998-04-18 06:26:16 +00:00
|
|
|
struct vm_object *obj;
|
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
|
|
|
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_ILOCK(mp);
|
2006-01-09 20:42:19 +00:00
|
|
|
MNT_VNODE_FOREACH(vp, mp, mvp) {
|
2002-09-25 02:22:21 +00:00
|
|
|
VI_LOCK(vp);
|
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)) {
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
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);
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_ILOCK(mp);
|
2002-09-25 02:22:21 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-01-25 00:40:01 +00:00
|
|
|
obj = vp->v_object;
|
|
|
|
if (obj != NULL) {
|
2003-04-24 04:31:25 +00:00
|
|
|
VM_OBJECT_LOCK(obj);
|
2001-05-19 01:28:09 +00:00
|
|
|
vm_object_page_clean(obj, 0, 0,
|
|
|
|
flags == MNT_WAIT ?
|
|
|
|
OBJPC_SYNC : OBJPC_NOSYNC);
|
2003-04-24 04:31:25 +00:00
|
|
|
VM_OBJECT_UNLOCK(obj);
|
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);
|
|
|
|
}
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_ILOCK(mp);
|
2002-09-25 02:22:21 +00:00
|
|
|
} else
|
|
|
|
VI_UNLOCK(vp);
|
1995-05-21 21:39:31 +00:00
|
|
|
}
|
2003-11-05 04:30:08 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
1995-05-21 21:39:31 +00:00
|
|
|
}
|
1996-08-21 21:56:23 +00:00
|
|
|
|
2000-09-22 12:22:36 +00:00
|
|
|
/*
|
|
|
|
* Mark a vnode as free, putting it up for recycling.
|
|
|
|
*/
|
2005-03-15 14:38:16 +00:00
|
|
|
static void
|
2004-10-22 08:47:20 +00:00
|
|
|
vfree(struct vnode *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
|
|
|
{
|
2004-01-05 19:04:29 +00:00
|
|
|
|
2005-06-11 01:16:46 +00:00
|
|
|
CTR1(KTR_VFS, "vfree vp %p", vp);
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "vfree");
|
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);
|
2005-06-11 01:16:46 +00:00
|
|
|
VNASSERT(vp->v_op != NULL, vp, ("vfree: vnode already reclaimed."));
|
2005-02-17 10:28:58 +00:00
|
|
|
VNASSERT((vp->v_iflag & VI_FREE) == 0, vp, ("vnode already free"));
|
2005-03-13 11:54:28 +00:00
|
|
|
VNASSERT(VSHOULDFREE(vp), vp, ("vfree: freeing when we shouldn't"));
|
2005-06-16 04:41:42 +00:00
|
|
|
VNASSERT((vp->v_iflag & VI_DOOMED) == 0, vp,
|
|
|
|
("vfree: Freeing doomed vnode"));
|
|
|
|
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++;
|
2005-06-16 04:41:42 +00:00
|
|
|
vp->v_iflag &= ~VI_AGE;
|
2002-08-04 10:29:36 +00:00
|
|
|
vp->v_iflag |= VI_FREE;
|
2005-04-30 11:22:40 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
*/
|
2005-02-10 12:28:58 +00:00
|
|
|
static void
|
2004-10-22 08:47:20 +00:00
|
|
|
vbusy(struct vnode *vp)
|
1997-08-31 07:32:39 +00:00
|
|
|
{
|
2005-06-11 01:16:46 +00:00
|
|
|
CTR1(KTR_VFS, "vbusy vp %p", vp);
|
2002-09-26 04:48:44 +00:00
|
|
|
ASSERT_VI_LOCKED(vp, "vbusy");
|
2005-02-17 10:28:58 +00:00
|
|
|
VNASSERT((vp->v_iflag & VI_FREE) != 0, vp, ("vnode not free"));
|
2005-06-11 01:16:46 +00:00
|
|
|
VNASSERT(vp->v_op != NULL, vp, ("vbusy: vnode already reclaimed."));
|
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--;
|
2005-03-29 10:02:48 +00:00
|
|
|
vp->v_iflag &= ~(VI_FREE|VI_AGE);
|
2005-06-16 04:41:42 +00:00
|
|
|
mtx_unlock(&vnode_free_list_mtx);
|
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
|
|
|
|
2004-01-05 19:04:29 +00:00
|
|
|
/*
|
|
|
|
* Initalize per-vnode helper structure to hold poll-related state.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
v_addpollinfo(struct vnode *vp)
|
|
|
|
{
|
2004-08-11 01:27:53 +00:00
|
|
|
struct vpollinfo *vi;
|
2004-01-05 19:04:29 +00:00
|
|
|
|
2004-08-11 01:27:53 +00:00
|
|
|
vi = uma_zalloc(vnodepoll_zone, M_WAITOK);
|
|
|
|
if (vp->v_pollinfo != NULL) {
|
|
|
|
uma_zfree(vnodepoll_zone, vi);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
vp->v_pollinfo = vi;
|
2004-01-05 19:04:29 +00:00
|
|
|
mtx_init(&vp->v_pollinfo->vpi_lock, "vnode pollinfo", NULL, MTX_DEF);
|
2005-07-01 16:28:32 +00:00
|
|
|
knlist_init(&vp->v_pollinfo->vpi_selinfo.si_note, vp, vfs_knllock,
|
|
|
|
vfs_knlunlock, vfs_knllocked);
|
2004-01-05 19:04:29 +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
|
2006-01-21 19:42:10 +00:00
|
|
|
vn_pollrecord(struct vnode *vp, struct thread *td, int events)
|
1997-12-15 03:09:59 +00:00
|
|
|
{
|
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;
|
|
|
|
}
|
|
|
|
|
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 *);
|
1998-03-08 09:59:44 +00:00
|
|
|
|
2004-12-01 23:16:38 +00:00
|
|
|
static struct vop_vector sync_vnodeops = {
|
|
|
|
.vop_bypass = VOP_EOPNOTSUPP,
|
|
|
|
.vop_close = sync_close, /* close */
|
|
|
|
.vop_fsync = sync_fsync, /* fsync */
|
|
|
|
.vop_inactive = sync_inactive, /* inactive */
|
|
|
|
.vop_reclaim = sync_reclaim, /* reclaim */
|
2007-05-18 13:02:13 +00:00
|
|
|
.vop_lock1 = vop_stdlock, /* lock */
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_unlock = vop_stdunlock, /* unlock */
|
|
|
|
.vop_islocked = vop_stdislocked, /* islocked */
|
1998-03-08 09:59:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a new filesystem syncer vnode for the specified mount point.
|
|
|
|
*/
|
|
|
|
int
|
2006-01-21 19:42:10 +00:00
|
|
|
vfs_allocate_syncvnode(struct mount *mp)
|
1998-03-08 09:59:44 +00:00
|
|
|
{
|
|
|
|
struct vnode *vp;
|
|
|
|
static long start, incr, next;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* Allocate a new vnode */
|
2004-12-01 23:16:38 +00:00
|
|
|
if ((error = getnewvnode("syncer", mp, &sync_vnodeops, &vp)) != 0) {
|
1998-03-08 09:59:44 +00:00
|
|
|
mp->mnt_syncer = NULL;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
vp->v_type = VNON;
|
2007-03-13 01:50:27 +00:00
|
|
|
error = insmntque(vp, mp);
|
|
|
|
if (error != 0)
|
|
|
|
panic("vfs_allocate_syncvnode: insmntque failed");
|
1998-03-08 09:59:44 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
2004-10-27 08:05:02 +00:00
|
|
|
vn_syncer_add_to_worklist(&vp->v_bufobj,
|
|
|
|
syncdelay > 0 ? next % syncdelay : 0);
|
2004-07-01 23:59:19 +00:00
|
|
|
/* XXX - vn_syncer_add_to_worklist() also grabs and drops sync_mtx. */
|
|
|
|
mtx_lock(&sync_mtx);
|
|
|
|
sync_vnode_count++;
|
|
|
|
mtx_unlock(&sync_mtx);
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
sync_fsync(struct vop_fsync_args *ap)
|
1998-03-08 09:59:44 +00:00
|
|
|
{
|
|
|
|
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;
|
2006-09-26 04:15:59 +00:00
|
|
|
int error;
|
2004-10-27 08:05:02 +00:00
|
|
|
struct bufobj *bo;
|
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.
|
|
|
|
*/
|
2004-10-27 08:05:02 +00:00
|
|
|
bo = &syncvp->v_bufobj;
|
|
|
|
BO_LOCK(bo);
|
|
|
|
vn_syncer_add_to_worklist(bo, syncdelay);
|
|
|
|
BO_UNLOCK(bo);
|
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);
|
|
|
|
}
|
2006-09-26 04:12:49 +00:00
|
|
|
MNT_ILOCK(mp);
|
2006-09-26 04:15:59 +00:00
|
|
|
mp->mnt_noasync++;
|
|
|
|
mp->mnt_kern_flag &= ~MNTK_ASYNC;
|
2006-09-26 04:12:49 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
1998-04-16 03:31:26 +00:00
|
|
|
vfs_msync(mp, MNT_NOWAIT);
|
2005-01-11 07:36:22 +00:00
|
|
|
error = VFS_SYNC(mp, MNT_LAZY, td);
|
2006-09-26 04:12:49 +00:00
|
|
|
MNT_ILOCK(mp);
|
2006-09-26 04:15:59 +00:00
|
|
|
mp->mnt_noasync--;
|
|
|
|
if ((mp->mnt_flag & MNT_ASYNC) != 0 && mp->mnt_noasync == 0)
|
|
|
|
mp->mnt_kern_flag |= MNTK_ASYNC;
|
2006-09-26 04:12:49 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
sync_inactive(struct vop_inactive_args *ap)
|
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
|
|
|
*
|
2003-09-19 23:52:06 +00:00
|
|
|
* Modifications to the worklist must be protected by sync_mtx.
|
1998-03-08 09:59:44 +00:00
|
|
|
*/
|
1998-12-21 23:38:33 +00:00
|
|
|
static int
|
2006-01-21 19:42:10 +00:00
|
|
|
sync_reclaim(struct vop_reclaim_args *ap)
|
1998-03-08 09:59:44 +00:00
|
|
|
{
|
|
|
|
struct vnode *vp = ap->a_vp;
|
2004-10-27 08:05:02 +00:00
|
|
|
struct bufobj *bo;
|
1998-03-08 09:59:44 +00:00
|
|
|
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_LOCK(vp);
|
2004-10-27 08:05:02 +00:00
|
|
|
bo = &vp->v_bufobj;
|
2003-09-19 23:52:06 +00:00
|
|
|
vp->v_mount->mnt_syncer = NULL;
|
2004-10-27 08:05:02 +00:00
|
|
|
if (bo->bo_flag & BO_ONWORKLST) {
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_lock(&sync_mtx);
|
2004-10-27 08:05:02 +00:00
|
|
|
LIST_REMOVE(bo, bo_synclist);
|
2007-04-10 15:29:37 +00:00
|
|
|
syncer_worklist_len--;
|
2004-07-01 23:59:19 +00:00
|
|
|
sync_vnode_count--;
|
2002-09-25 02:22:21 +00:00
|
|
|
mtx_unlock(&sync_mtx);
|
2004-10-27 08:05:02 +00:00
|
|
|
bo->bo_flag &= ~BO_ONWORKLST;
|
1998-03-08 09:59:44 +00:00
|
|
|
}
|
2002-08-04 10:29:36 +00:00
|
|
|
VI_UNLOCK(vp);
|
1998-03-08 09:59:44 +00:00
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1999-08-25 12:24:39 +00:00
|
|
|
/*
|
|
|
|
* Check if vnode represents a disk device
|
|
|
|
*/
|
|
|
|
int
|
2006-01-21 19:42:10 +00:00
|
|
|
vn_isdisk(struct vnode *vp, int *errp)
|
1999-08-25 12:24:39 +00:00
|
|
|
{
|
2003-10-12 14:04:39 +00:00
|
|
|
int error;
|
2000-09-05 21:09:56 +00:00
|
|
|
|
2003-10-12 14:04:39 +00:00
|
|
|
error = 0;
|
2004-09-24 06:16:08 +00:00
|
|
|
dev_lock();
|
2003-10-12 14:04:39 +00:00
|
|
|
if (vp->v_type != VCHR)
|
|
|
|
error = ENOTBLK;
|
|
|
|
else if (vp->v_rdev == NULL)
|
|
|
|
error = ENXIO;
|
2004-09-24 06:16:08 +00:00
|
|
|
else if (vp->v_rdev->si_devsw == NULL)
|
|
|
|
error = ENXIO;
|
|
|
|
else if (!(vp->v_rdev->si_devsw->d_flags & D_DISK))
|
2003-10-12 14:04:39 +00:00
|
|
|
error = ENOTBLK;
|
2004-09-24 06:16:08 +00:00
|
|
|
dev_unlock();
|
2000-01-10 12:04:27 +00:00
|
|
|
if (errp != NULL)
|
2003-10-12 14:04:39 +00:00
|
|
|
*errp = error;
|
|
|
|
return (error == 0);
|
1999-08-25 12:24:39 +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.
|
2006-08-06 10:43:35 +00:00
|
|
|
*
|
|
|
|
* The ifdef'd CAPABILITIES version is here for reference, but is not
|
|
|
|
* actually used.
|
2000-09-20 17:18:12 +00:00
|
|
|
*/
|
2000-08-20 08:36:26 +00:00
|
|
|
int
|
2006-01-21 19:42:10 +00:00
|
|
|
vaccess(enum vtype type, mode_t file_mode, uid_t file_uid, gid_t file_gid,
|
|
|
|
mode_t acc_mode, struct ucred *cred, int *privused)
|
2000-08-20 08:36:26 +00:00
|
|
|
{
|
2000-08-29 14:45:49 +00:00
|
|
|
mode_t dac_granted;
|
2006-11-06 13:42:10 +00:00
|
|
|
mode_t priv_granted;
|
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:
|
|
|
|
/*
|
2006-11-06 13:42:10 +00:00
|
|
|
* Build a privilege mask to determine if the set of privileges
|
2000-08-29 14:45:49 +00:00
|
|
|
* satisfies the requirements when combined with the granted mask
|
2006-11-06 13:42:10 +00:00
|
|
|
* from above. For each privilege, if the privilege is required,
|
|
|
|
* bitwise or the request type onto the priv_granted mask.
|
2000-08-29 14:45:49 +00:00
|
|
|
*/
|
2006-11-06 13:42:10 +00:00
|
|
|
priv_granted = 0;
|
2001-11-02 15:16:59 +00:00
|
|
|
|
|
|
|
if (type == VDIR) {
|
|
|
|
/*
|
2006-11-06 13:42:10 +00:00
|
|
|
* For directories, use PRIV_VFS_LOOKUP to satisfy VEXEC
|
|
|
|
* requests, instead of PRIV_VFS_EXEC.
|
2001-11-02 15:16:59 +00:00
|
|
|
*/
|
|
|
|
if ((acc_mode & VEXEC) && ((dac_granted & VEXEC) == 0) &&
|
2007-06-12 00:12:01 +00:00
|
|
|
!priv_check_cred(cred, PRIV_VFS_LOOKUP, 0))
|
2006-11-06 13:42:10 +00:00
|
|
|
priv_granted |= VEXEC;
|
2001-11-02 15:16:59 +00:00
|
|
|
} else {
|
|
|
|
if ((acc_mode & VEXEC) && ((dac_granted & VEXEC) == 0) &&
|
2007-06-12 00:12:01 +00:00
|
|
|
!priv_check_cred(cred, PRIV_VFS_EXEC, 0))
|
2006-11-06 13:42:10 +00:00
|
|
|
priv_granted |= VEXEC;
|
2001-11-02 15:16:59 +00:00
|
|
|
}
|
2000-08-29 14:45:49 +00:00
|
|
|
|
|
|
|
if ((acc_mode & VREAD) && ((dac_granted & VREAD) == 0) &&
|
2007-06-12 00:12:01 +00:00
|
|
|
!priv_check_cred(cred, PRIV_VFS_READ, 0))
|
2006-11-06 13:42:10 +00:00
|
|
|
priv_granted |= VREAD;
|
2000-08-29 14:45:49 +00:00
|
|
|
|
|
|
|
if ((acc_mode & VWRITE) && ((dac_granted & VWRITE) == 0) &&
|
2007-06-12 00:12:01 +00:00
|
|
|
!priv_check_cred(cred, PRIV_VFS_WRITE, 0))
|
2006-11-06 13:42:10 +00:00
|
|
|
priv_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) &&
|
2007-06-12 00:12:01 +00:00
|
|
|
!priv_check_cred(cred, PRIV_VFS_ADMIN, 0))
|
2006-11-06 13:42:10 +00:00
|
|
|
priv_granted |= VADMIN;
|
2000-10-19 07:53:59 +00:00
|
|
|
|
2006-11-06 13:42:10 +00:00
|
|
|
if ((acc_mode & (priv_granted | dac_granted)) == acc_mode) {
|
2000-08-29 14:45:49 +00:00
|
|
|
/* XXX audit: privilege used */
|
|
|
|
if (privused != NULL)
|
|
|
|
*privused = 1;
|
|
|
|
return (0);
|
|
|
|
}
|
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
|
2006-01-21 19:42:10 +00:00
|
|
|
extattr_check_cred(struct vnode *vp, int attrnamespace, struct ucred *cred,
|
|
|
|
struct thread *td, int access)
|
2002-09-05 20:38:57 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
/*
|
2006-11-06 13:42:10 +00:00
|
|
|
* Do not allow privileged processes in jail to directly manipulate
|
|
|
|
* system attributes.
|
2002-09-05 20:38:57 +00:00
|
|
|
*/
|
|
|
|
switch (attrnamespace) {
|
|
|
|
case EXTATTR_NAMESPACE_SYSTEM:
|
|
|
|
/* Potentially should be: return (EPERM); */
|
2006-11-06 13:42:10 +00:00
|
|
|
return (priv_check_cred(cred, PRIV_VFS_EXTATTR_SYSTEM, 0));
|
2002-09-05 20:38:57 +00:00
|
|
|
case EXTATTR_NAMESPACE_USER:
|
|
|
|
return (VOP_ACCESS(vp, access, cred, td));
|
|
|
|
default:
|
|
|
|
return (EPERM);
|
|
|
|
}
|
|
|
|
}
|
2004-01-05 19:04:29 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG_VFS_LOCKS
|
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
|
|
|
|
int vfs_badlock_ddb = 1; /* Drop into debugger on violation. */
|
2004-07-21 07:13:14 +00:00
|
|
|
SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_ddb, CTLFLAG_RW, &vfs_badlock_ddb, 0, "");
|
|
|
|
|
2004-01-05 23:40:46 +00:00
|
|
|
int vfs_badlock_mutex = 1; /* Check for interlock across VOPs. */
|
2004-07-21 07:13:14 +00:00
|
|
|
SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_mutex, CTLFLAG_RW, &vfs_badlock_mutex, 0, "");
|
|
|
|
|
2004-01-05 19:04:29 +00:00
|
|
|
int vfs_badlock_print = 1; /* Print lock violations. */
|
2004-07-21 07:13:14 +00:00
|
|
|
SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_print, CTLFLAG_RW, &vfs_badlock_print, 0, "");
|
|
|
|
|
|
|
|
#ifdef KDB
|
|
|
|
int vfs_badlock_backtrace = 1; /* Print backtrace at lock violations. */
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_backtrace, CTLFLAG_RW, &vfs_badlock_backtrace, 0, "");
|
|
|
|
#endif
|
2004-01-05 19:04:29 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
vfs_badlock(const char *msg, const char *str, struct vnode *vp)
|
|
|
|
{
|
|
|
|
|
2004-07-21 07:13:14 +00:00
|
|
|
#ifdef KDB
|
|
|
|
if (vfs_badlock_backtrace)
|
|
|
|
kdb_backtrace();
|
|
|
|
#endif
|
2004-01-05 19:04:29 +00:00
|
|
|
if (vfs_badlock_print)
|
|
|
|
printf("%s: %p %s\n", str, (void *)vp, msg);
|
|
|
|
if (vfs_badlock_ddb)
|
2004-07-10 21:47:53 +00:00
|
|
|
kdb_enter("lock violation");
|
2004-01-05 19:04:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vi_locked(struct vnode *vp, const char *str)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (vfs_badlock_mutex && !mtx_owned(VI_MTX(vp)))
|
|
|
|
vfs_badlock("interlock is not locked but should be", str, vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vi_unlocked(struct vnode *vp, const char *str)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (vfs_badlock_mutex && mtx_owned(VI_MTX(vp)))
|
|
|
|
vfs_badlock("interlock is locked but should not be", str, vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vop_locked(struct vnode *vp, const char *str)
|
|
|
|
{
|
|
|
|
|
2005-03-13 11:54:28 +00:00
|
|
|
if (vp && !IGNORE_LOCK(vp) && VOP_ISLOCKED(vp, NULL) == 0)
|
2004-01-05 19:04:29 +00:00
|
|
|
vfs_badlock("is not locked but should be", str, vp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
assert_vop_unlocked(struct vnode *vp, const 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, const char *str)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (vp && !IGNORE_LOCK(vp) &&
|
|
|
|
VOP_ISLOCKED(vp, curthread) != LK_EXCLUSIVE)
|
|
|
|
vfs_badlock("is not exclusive locked but should be", str, vp);
|
|
|
|
}
|
|
|
|
|
2005-04-11 15:17:06 +00:00
|
|
|
#if 0
|
2004-01-05 19:04:29 +00:00
|
|
|
void
|
|
|
|
assert_vop_elocked_other(struct vnode *vp, const 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, const char *str)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (vp && !IGNORE_LOCK(vp) &&
|
|
|
|
VOP_ISLOCKED(vp, curthread) != LK_SHARED)
|
|
|
|
vfs_badlock("is not locked shared but should be", str, vp);
|
|
|
|
}
|
|
|
|
#endif /* 0 */
|
2005-06-09 20:20:31 +00:00
|
|
|
#endif /* DEBUG_VFS_LOCKS */
|
2004-01-05 19:04:29 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
vop_rename_pre(void *ap)
|
|
|
|
{
|
|
|
|
struct vop_rename_args *a = ap;
|
|
|
|
|
2005-06-09 20:20:31 +00:00
|
|
|
#ifdef DEBUG_VFS_LOCKS
|
2004-01-05 19:04:29 +00:00
|
|
|
if (a->a_tvp)
|
|
|
|
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");
|
|
|
|
|
|
|
|
/* Check the source (from). */
|
2006-03-19 20:14:46 +00:00
|
|
|
if (a->a_tdvp != a->a_fdvp && a->a_tvp != a->a_fdvp)
|
2004-01-05 19:04:29 +00:00
|
|
|
ASSERT_VOP_UNLOCKED(a->a_fdvp, "vop_rename: fdvp locked");
|
|
|
|
if (a->a_tvp != a->a_fvp)
|
2006-11-04 23:57:02 +00:00
|
|
|
ASSERT_VOP_UNLOCKED(a->a_fvp, "vop_rename: fvp locked");
|
2004-01-05 19:04:29 +00:00
|
|
|
|
|
|
|
/* Check the target. */
|
|
|
|
if (a->a_tvp)
|
|
|
|
ASSERT_VOP_LOCKED(a->a_tvp, "vop_rename: tvp not locked");
|
|
|
|
ASSERT_VOP_LOCKED(a->a_tdvp, "vop_rename: tdvp not locked");
|
2005-06-09 20:20:31 +00:00
|
|
|
#endif
|
|
|
|
if (a->a_tdvp != a->a_fdvp)
|
2005-08-28 23:00:11 +00:00
|
|
|
vhold(a->a_fdvp);
|
2005-06-09 20:20:31 +00:00
|
|
|
if (a->a_tvp != a->a_fvp)
|
|
|
|
vhold(a->a_fvp);
|
|
|
|
vhold(a->a_tdvp);
|
|
|
|
if (a->a_tvp)
|
|
|
|
vhold(a->a_tvp);
|
2004-01-05 19:04:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_strategy_pre(void *ap)
|
|
|
|
{
|
2005-06-09 20:20:31 +00:00
|
|
|
#ifdef DEBUG_VFS_LOCKS
|
2004-01-05 23:40:46 +00:00
|
|
|
struct vop_strategy_args *a;
|
2004-01-05 19:04:29 +00:00
|
|
|
struct buf *bp;
|
|
|
|
|
2004-01-05 23:40:46 +00:00
|
|
|
a = ap;
|
2004-01-05 19:04:29 +00:00
|
|
|
bp = a->a_bp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cluster ops lock their component buffers but not the IO container.
|
|
|
|
*/
|
|
|
|
if ((bp->b_flags & B_CLUSTER) != 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (BUF_REFCNT(bp) < 1) {
|
|
|
|
if (vfs_badlock_print)
|
|
|
|
printf(
|
2004-01-05 23:40:46 +00:00
|
|
|
"VOP_STRATEGY: bp is not locked but should be\n");
|
2004-01-05 19:04:29 +00:00
|
|
|
if (vfs_badlock_ddb)
|
2004-07-10 21:47:53 +00:00
|
|
|
kdb_enter("lock violation");
|
2004-01-05 19:04:29 +00:00
|
|
|
}
|
2005-06-09 20:20:31 +00:00
|
|
|
#endif
|
2004-01-05 19:04:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_lookup_pre(void *ap)
|
|
|
|
{
|
2005-06-09 20:20:31 +00:00
|
|
|
#ifdef DEBUG_VFS_LOCKS
|
2004-01-05 23:40:46 +00:00
|
|
|
struct vop_lookup_args *a;
|
2004-01-05 19:04:29 +00:00
|
|
|
struct vnode *dvp;
|
|
|
|
|
2004-01-05 23:40:46 +00:00
|
|
|
a = ap;
|
2004-01-05 19:04:29 +00:00
|
|
|
dvp = a->a_dvp;
|
|
|
|
ASSERT_VI_UNLOCKED(dvp, "VOP_LOOKUP");
|
|
|
|
ASSERT_VOP_LOCKED(dvp, "VOP_LOOKUP");
|
2005-06-09 20:20:31 +00:00
|
|
|
#endif
|
2004-01-05 19:04:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_lookup_post(void *ap, int rc)
|
|
|
|
{
|
2005-06-09 20:20:31 +00:00
|
|
|
#ifdef DEBUG_VFS_LOCKS
|
2004-01-05 23:40:46 +00:00
|
|
|
struct vop_lookup_args *a;
|
2004-01-05 19:04:29 +00:00
|
|
|
struct vnode *dvp;
|
|
|
|
struct vnode *vp;
|
|
|
|
|
2004-01-05 23:40:46 +00:00
|
|
|
a = ap;
|
2004-01-05 19:04:29 +00:00
|
|
|
dvp = a->a_dvp;
|
|
|
|
vp = *(a->a_vpp);
|
|
|
|
|
|
|
|
ASSERT_VI_UNLOCKED(dvp, "VOP_LOOKUP");
|
2005-04-13 10:57:53 +00:00
|
|
|
ASSERT_VOP_LOCKED(dvp, "VOP_LOOKUP");
|
2005-03-28 09:25:25 +00:00
|
|
|
|
|
|
|
if (!rc)
|
|
|
|
ASSERT_VOP_LOCKED(vp, "VOP_LOOKUP (child)");
|
2005-06-09 20:20:31 +00:00
|
|
|
#endif
|
2004-01-05 19:04:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_lock_pre(void *ap)
|
|
|
|
{
|
2005-06-09 20:20:31 +00:00
|
|
|
#ifdef DEBUG_VFS_LOCKS
|
2007-05-18 13:02:13 +00:00
|
|
|
struct vop_lock1_args *a = ap;
|
2004-01-05 19:04:29 +00:00
|
|
|
|
|
|
|
if ((a->a_flags & LK_INTERLOCK) == 0)
|
|
|
|
ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
|
|
|
|
else
|
|
|
|
ASSERT_VI_LOCKED(a->a_vp, "VOP_LOCK");
|
2005-06-09 20:20:31 +00:00
|
|
|
#endif
|
2004-01-05 19:04:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_lock_post(void *ap, int rc)
|
|
|
|
{
|
2005-06-09 20:20:31 +00:00
|
|
|
#ifdef DEBUG_VFS_LOCKS
|
2007-05-18 13:02:13 +00:00
|
|
|
struct vop_lock1_args *a = ap;
|
2004-01-05 19:04:29 +00:00
|
|
|
|
|
|
|
ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
|
|
|
|
if (rc == 0)
|
|
|
|
ASSERT_VOP_LOCKED(a->a_vp, "VOP_LOCK");
|
2005-06-09 20:20:31 +00:00
|
|
|
#endif
|
2004-01-05 19:04:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_unlock_pre(void *ap)
|
|
|
|
{
|
2005-06-09 20:20:31 +00:00
|
|
|
#ifdef DEBUG_VFS_LOCKS
|
2004-01-05 19:04:29 +00:00
|
|
|
struct vop_unlock_args *a = ap;
|
|
|
|
|
|
|
|
if (a->a_flags & LK_INTERLOCK)
|
|
|
|
ASSERT_VI_LOCKED(a->a_vp, "VOP_UNLOCK");
|
|
|
|
ASSERT_VOP_LOCKED(a->a_vp, "VOP_UNLOCK");
|
2005-06-09 20:20:31 +00:00
|
|
|
#endif
|
2004-01-05 19:04:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_unlock_post(void *ap, int rc)
|
|
|
|
{
|
2005-06-09 20:20:31 +00:00
|
|
|
#ifdef DEBUG_VFS_LOCKS
|
2004-01-05 19:04:29 +00:00
|
|
|
struct vop_unlock_args *a = ap;
|
|
|
|
|
|
|
|
if (a->a_flags & LK_INTERLOCK)
|
|
|
|
ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNLOCK");
|
2005-06-09 20:20:31 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_create_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_create_args *a = ap;
|
|
|
|
|
|
|
|
if (!rc)
|
2007-04-10 15:29:37 +00:00
|
|
|
VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
|
2005-06-09 20:20:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_link_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_link_args *a = ap;
|
2007-04-10 15:29:37 +00:00
|
|
|
|
2005-06-09 20:20:31 +00:00
|
|
|
if (!rc) {
|
2007-04-10 15:29:37 +00:00
|
|
|
VFS_KNOTE_LOCKED(a->a_vp, NOTE_LINK);
|
2005-07-01 16:28:32 +00:00
|
|
|
VFS_KNOTE_LOCKED(a->a_tdvp, NOTE_WRITE);
|
2005-06-09 20:20:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_mkdir_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_mkdir_args *a = ap;
|
|
|
|
|
|
|
|
if (!rc)
|
2005-07-01 16:28:32 +00:00
|
|
|
VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE | NOTE_LINK);
|
2005-06-09 20:20:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_mknod_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_mknod_args *a = ap;
|
|
|
|
|
|
|
|
if (!rc)
|
2005-07-01 16:28:32 +00:00
|
|
|
VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
|
2005-06-09 20:20:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_remove_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_remove_args *a = ap;
|
|
|
|
|
|
|
|
if (!rc) {
|
2005-07-01 16:28:32 +00:00
|
|
|
VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
|
|
|
|
VFS_KNOTE_LOCKED(a->a_vp, NOTE_DELETE);
|
2005-06-09 20:20:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_rename_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_rename_args *a = ap;
|
|
|
|
|
|
|
|
if (!rc) {
|
2005-07-01 16:28:32 +00:00
|
|
|
VFS_KNOTE_UNLOCKED(a->a_fdvp, NOTE_WRITE);
|
|
|
|
VFS_KNOTE_UNLOCKED(a->a_tdvp, NOTE_WRITE);
|
|
|
|
VFS_KNOTE_UNLOCKED(a->a_fvp, NOTE_RENAME);
|
2005-06-09 20:20:31 +00:00
|
|
|
if (a->a_tvp)
|
2005-07-01 16:28:32 +00:00
|
|
|
VFS_KNOTE_UNLOCKED(a->a_tvp, NOTE_DELETE);
|
2005-06-09 20:20:31 +00:00
|
|
|
}
|
|
|
|
if (a->a_tdvp != a->a_fdvp)
|
|
|
|
vdrop(a->a_fdvp);
|
|
|
|
if (a->a_tvp != a->a_fvp)
|
|
|
|
vdrop(a->a_fvp);
|
|
|
|
vdrop(a->a_tdvp);
|
|
|
|
if (a->a_tvp)
|
|
|
|
vdrop(a->a_tvp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_rmdir_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_rmdir_args *a = ap;
|
|
|
|
|
|
|
|
if (!rc) {
|
2005-07-01 16:28:32 +00:00
|
|
|
VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE | NOTE_LINK);
|
|
|
|
VFS_KNOTE_LOCKED(a->a_vp, NOTE_DELETE);
|
2005-06-09 20:20:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_setattr_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_setattr_args *a = ap;
|
|
|
|
|
|
|
|
if (!rc)
|
2005-07-01 16:28:32 +00:00
|
|
|
VFS_KNOTE_LOCKED(a->a_vp, NOTE_ATTRIB);
|
2005-06-09 20:20:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vop_symlink_post(void *ap, int rc)
|
|
|
|
{
|
|
|
|
struct vop_symlink_args *a = ap;
|
2007-04-10 15:29:37 +00:00
|
|
|
|
2005-06-09 20:20:31 +00:00
|
|
|
if (!rc)
|
2005-07-01 16:28:32 +00:00
|
|
|
VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
|
2004-01-05 19:04:29 +00:00
|
|
|
}
|
2004-07-04 10:52:54 +00:00
|
|
|
|
2004-08-15 06:24:42 +00:00
|
|
|
static struct knlist fs_knlist;
|
|
|
|
|
|
|
|
static void
|
|
|
|
vfs_event_init(void *arg)
|
|
|
|
{
|
2005-07-01 16:28:32 +00:00
|
|
|
knlist_init(&fs_knlist, NULL, NULL, NULL, NULL);
|
2004-08-15 06:24:42 +00:00
|
|
|
}
|
|
|
|
/* XXX - correct order? */
|
|
|
|
SYSINIT(vfs_knlist, SI_SUB_VFS, SI_ORDER_ANY, vfs_event_init, NULL);
|
2004-07-04 10:52:54 +00:00
|
|
|
|
|
|
|
void
|
2004-07-06 09:12:03 +00:00
|
|
|
vfs_event_signal(fsid_t *fsid, u_int32_t event, intptr_t data __unused)
|
2004-07-04 10:52:54 +00:00
|
|
|
{
|
|
|
|
|
2004-08-15 06:24:42 +00:00
|
|
|
KNOTE_UNLOCKED(&fs_knlist, event);
|
2004-07-04 10:52:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int filt_fsattach(struct knote *kn);
|
|
|
|
static void filt_fsdetach(struct knote *kn);
|
|
|
|
static int filt_fsevent(struct knote *kn, long hint);
|
|
|
|
|
|
|
|
struct filterops fs_filtops =
|
|
|
|
{ 0, filt_fsattach, filt_fsdetach, filt_fsevent };
|
|
|
|
|
|
|
|
static int
|
|
|
|
filt_fsattach(struct knote *kn)
|
|
|
|
{
|
|
|
|
|
|
|
|
kn->kn_flags |= EV_CLEAR;
|
2004-08-15 06:24:42 +00:00
|
|
|
knlist_add(&fs_knlist, kn, 0);
|
2004-07-04 10:52:54 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
filt_fsdetach(struct knote *kn)
|
|
|
|
{
|
|
|
|
|
2004-08-15 06:24:42 +00:00
|
|
|
knlist_remove(&fs_knlist, kn, 0);
|
2004-07-04 10:52:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
filt_fsevent(struct knote *kn, long hint)
|
|
|
|
{
|
|
|
|
|
|
|
|
kn->kn_fflags |= hint;
|
|
|
|
return (kn->kn_fflags != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
sysctl_vfs_ctl(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct vfsidctl vc;
|
|
|
|
int error;
|
|
|
|
struct mount *mp;
|
|
|
|
|
|
|
|
error = SYSCTL_IN(req, &vc, sizeof(vc));
|
|
|
|
if (error)
|
|
|
|
return (error);
|
2004-07-04 20:21:58 +00:00
|
|
|
if (vc.vc_vers != VFS_CTL_VERS1)
|
|
|
|
return (EINVAL);
|
2004-07-04 10:52:54 +00:00
|
|
|
mp = vfs_getvfs(&vc.vc_fsid);
|
|
|
|
if (mp == NULL)
|
|
|
|
return (ENOENT);
|
2004-07-04 20:21:58 +00:00
|
|
|
/* ensure that a specific sysctl goes to the right filesystem. */
|
|
|
|
if (strcmp(vc.vc_fstypename, "*") != 0 &&
|
|
|
|
strcmp(vc.vc_fstypename, mp->mnt_vfc->vfc_name) != 0) {
|
2006-03-31 03:53:25 +00:00
|
|
|
vfs_rel(mp);
|
2004-07-04 20:21:58 +00:00
|
|
|
return (EINVAL);
|
|
|
|
}
|
2004-07-04 10:52:54 +00:00
|
|
|
VCTLTOREQ(&vc, req);
|
2006-03-31 03:53:25 +00:00
|
|
|
error = VFS_SYSCTL(mp, vc.vc_op, req);
|
|
|
|
vfs_rel(mp);
|
|
|
|
return (error);
|
2004-07-04 10:52:54 +00:00
|
|
|
}
|
|
|
|
|
2007-04-10 15:29:37 +00:00
|
|
|
SYSCTL_PROC(_vfs, OID_AUTO, ctl, CTLFLAG_WR, NULL, 0, sysctl_vfs_ctl, "",
|
|
|
|
"Sysctl by fsid");
|
2004-09-07 09:17:05 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Function to initialize a va_filerev field sensibly.
|
|
|
|
* XXX: Wouldn't a random number make a lot more sense ??
|
|
|
|
*/
|
|
|
|
u_quad_t
|
|
|
|
init_va_filerev(void)
|
|
|
|
{
|
|
|
|
struct bintime bt;
|
|
|
|
|
|
|
|
getbinuptime(&bt);
|
|
|
|
return (((u_quad_t)bt.sec << 32LL) | (bt.frac >> 32LL));
|
|
|
|
}
|
2005-06-09 20:20:31 +00:00
|
|
|
|
|
|
|
static int filt_vfsread(struct knote *kn, long hint);
|
|
|
|
static int filt_vfswrite(struct knote *kn, long hint);
|
|
|
|
static int filt_vfsvnode(struct knote *kn, long hint);
|
|
|
|
static void filt_vfsdetach(struct knote *kn);
|
|
|
|
static struct filterops vfsread_filtops =
|
|
|
|
{ 1, NULL, filt_vfsdetach, filt_vfsread };
|
|
|
|
static struct filterops vfswrite_filtops =
|
|
|
|
{ 1, NULL, filt_vfsdetach, filt_vfswrite };
|
|
|
|
static struct filterops vfsvnode_filtops =
|
|
|
|
{ 1, NULL, filt_vfsdetach, filt_vfsvnode };
|
|
|
|
|
2005-07-01 16:28:32 +00:00
|
|
|
static void
|
|
|
|
vfs_knllock(void *arg)
|
|
|
|
{
|
|
|
|
struct vnode *vp = arg;
|
|
|
|
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curthread);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
vfs_knlunlock(void *arg)
|
|
|
|
{
|
|
|
|
struct vnode *vp = arg;
|
|
|
|
|
|
|
|
VOP_UNLOCK(vp, 0, curthread);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vfs_knllocked(void *arg)
|
|
|
|
{
|
|
|
|
struct vnode *vp = arg;
|
|
|
|
|
|
|
|
return (VOP_ISLOCKED(vp, curthread) == LK_EXCLUSIVE);
|
|
|
|
}
|
|
|
|
|
2005-06-09 20:20:31 +00:00
|
|
|
int
|
|
|
|
vfs_kqfilter(struct vop_kqfilter_args *ap)
|
|
|
|
{
|
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct knote *kn = ap->a_kn;
|
2007-04-10 15:29:37 +00:00
|
|
|
struct knlist *knl;
|
2005-06-09 20:20:31 +00:00
|
|
|
|
|
|
|
switch (kn->kn_filter) {
|
|
|
|
case EVFILT_READ:
|
|
|
|
kn->kn_fop = &vfsread_filtops;
|
|
|
|
break;
|
|
|
|
case EVFILT_WRITE:
|
|
|
|
kn->kn_fop = &vfswrite_filtops;
|
|
|
|
break;
|
|
|
|
case EVFILT_VNODE:
|
|
|
|
kn->kn_fop = &vfsvnode_filtops;
|
|
|
|
break;
|
|
|
|
default:
|
2005-09-12 19:22:37 +00:00
|
|
|
return (EINVAL);
|
2005-06-09 20:20:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
kn->kn_hook = (caddr_t)vp;
|
|
|
|
|
|
|
|
if (vp->v_pollinfo == NULL)
|
|
|
|
v_addpollinfo(vp);
|
|
|
|
if (vp->v_pollinfo == NULL)
|
|
|
|
return (ENOMEM);
|
2005-07-01 16:28:32 +00:00
|
|
|
knl = &vp->v_pollinfo->vpi_selinfo.si_note;
|
|
|
|
knlist_add(knl, kn, 0);
|
2005-06-09 20:20:31 +00:00
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Detach knote from vnode
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
filt_vfsdetach(struct knote *kn)
|
|
|
|
{
|
|
|
|
struct vnode *vp = (struct vnode *)kn->kn_hook;
|
|
|
|
|
|
|
|
KASSERT(vp->v_pollinfo != NULL, ("Missing v_pollinfo"));
|
|
|
|
knlist_remove(&vp->v_pollinfo->vpi_selinfo.si_note, kn, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
filt_vfsread(struct knote *kn, long hint)
|
|
|
|
{
|
|
|
|
struct vnode *vp = (struct vnode *)kn->kn_hook;
|
|
|
|
struct vattr va;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* filesystem is gone, so set the EOF flag and schedule
|
|
|
|
* the knote for deletion.
|
|
|
|
*/
|
|
|
|
if (hint == NOTE_REVOKE) {
|
|
|
|
kn->kn_flags |= (EV_EOF | EV_ONESHOT);
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
2007-04-10 15:29:37 +00:00
|
|
|
if (VOP_GETATTR(vp, &va, curthread->td_ucred, curthread))
|
2005-06-09 20:20:31 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
kn->kn_data = va.va_size - kn->kn_fp->f_offset;
|
|
|
|
return (kn->kn_data != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
filt_vfswrite(struct knote *kn, long hint)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* filesystem is gone, so set the EOF flag and schedule
|
|
|
|
* the knote for deletion.
|
|
|
|
*/
|
|
|
|
if (hint == NOTE_REVOKE)
|
|
|
|
kn->kn_flags |= (EV_EOF | EV_ONESHOT);
|
|
|
|
|
|
|
|
kn->kn_data = 0;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
filt_vfsvnode(struct knote *kn, long hint)
|
|
|
|
{
|
|
|
|
if (kn->kn_sfflags & hint)
|
|
|
|
kn->kn_fflags |= hint;
|
|
|
|
if (hint == NOTE_REVOKE) {
|
|
|
|
kn->kn_flags |= EV_EOF;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
return (kn->kn_fflags != 0);
|
|
|
|
}
|
2005-09-12 08:46:07 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
vfs_read_dirent(struct vop_readdir_args *ap, struct dirent *dp, off_t off)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (dp->d_reclen > ap->a_uio->uio_resid)
|
|
|
|
return (ENAMETOOLONG);
|
|
|
|
error = uiomove(dp, dp->d_reclen, ap->a_uio);
|
|
|
|
if (error) {
|
|
|
|
if (ap->a_ncookies != NULL) {
|
|
|
|
if (ap->a_cookies != NULL)
|
|
|
|
free(ap->a_cookies, M_TEMP);
|
|
|
|
ap->a_cookies = NULL;
|
|
|
|
*ap->a_ncookies = 0;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
if (ap->a_ncookies == NULL)
|
|
|
|
return (0);
|
2005-11-09 22:03:50 +00:00
|
|
|
|
|
|
|
KASSERT(ap->a_cookies,
|
|
|
|
("NULL ap->a_cookies value with non-NULL ap->a_ncookies!"));
|
|
|
|
|
2005-09-12 08:46:07 +00:00
|
|
|
*ap->a_cookies = realloc(*ap->a_cookies,
|
|
|
|
(*ap->a_ncookies + 1) * sizeof(u_long), M_TEMP, M_WAITOK | M_ZERO);
|
|
|
|
(*ap->a_cookies)[*ap->a_ncookies] = off;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2005-10-12 06:56:00 +00:00
|
|
|
/*
|
|
|
|
* Mark for update the access time of the file if the filesystem
|
|
|
|
* supports VA_MARK_ATIME. This functionality is used by execve
|
|
|
|
* and mmap, so we want to avoid the synchronous I/O implied by
|
|
|
|
* directly setting va_atime for the sake of efficiency.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
vfs_mark_atime(struct vnode *vp, struct thread *td)
|
|
|
|
{
|
|
|
|
struct vattr atimeattr;
|
|
|
|
|
|
|
|
if ((vp->v_mount->mnt_flag & (MNT_NOATIME | MNT_RDONLY)) == 0) {
|
|
|
|
VATTR_NULL(&atimeattr);
|
|
|
|
atimeattr.va_vaflags |= VA_MARK_ATIME;
|
|
|
|
(void)VOP_SETATTR(vp, &atimeattr, td->td_ucred, td);
|
|
|
|
}
|
|
|
|
}
|