0d94caffca
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
377 lines
11 KiB
C
377 lines
11 KiB
C
/*
|
|
* Copyright (c) 1986, 1989, 1991, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* @(#)lfs_inode.c 8.5 (Berkeley) 12/30/93
|
|
* $Id: lfs_inode.c,v 1.5 1995/01/04 23:46:31 gibbs Exp $
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/file.h>
|
|
#include <sys/buf.h>
|
|
#include <sys/vnode.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/malloc.h>
|
|
|
|
#include <vm/vm.h>
|
|
|
|
#include <ufs/ufs/quota.h>
|
|
#include <ufs/ufs/inode.h>
|
|
#include <ufs/ufs/ufsmount.h>
|
|
#include <ufs/ufs/ufs_extern.h>
|
|
|
|
#include <ufs/lfs/lfs.h>
|
|
#include <ufs/lfs/lfs_extern.h>
|
|
|
|
int
|
|
lfs_init()
|
|
{
|
|
return (ufs_init());
|
|
}
|
|
|
|
/* Search a block for a specific dinode. */
|
|
struct dinode *
|
|
lfs_ifind(fs, ino, dip)
|
|
struct lfs *fs;
|
|
ino_t ino;
|
|
register struct dinode *dip;
|
|
{
|
|
register int cnt;
|
|
register struct dinode *ldip;
|
|
|
|
for (cnt = INOPB(fs), ldip = dip + (cnt - 1); cnt--; --ldip)
|
|
if (ldip->di_inumber == ino)
|
|
return (ldip);
|
|
|
|
panic("lfs_ifind: dinode %u not found", ino);
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
int
|
|
lfs_update(ap)
|
|
struct vop_update_args /* {
|
|
struct vnode *a_vp;
|
|
struct timeval *a_access;
|
|
struct timeval *a_modify;
|
|
int a_waitfor;
|
|
} */ *ap;
|
|
{
|
|
struct vnode *vp = ap->a_vp;
|
|
struct inode *ip;
|
|
int error;
|
|
|
|
if (vp->v_mount->mnt_flag & MNT_RDONLY){
|
|
return (0);
|
|
}
|
|
ip = VTOI(vp);
|
|
/* XXX
|
|
* We used to just return here. Now we make sure to check if
|
|
* we were called by lfs_fsync, since in this case, the inode
|
|
* may have been written to disk without all buffers connected
|
|
* with the vnode being flushed. It seems really suspicious
|
|
* that this could happen since from what I understand of the
|
|
* intended semantics, one of these flags should be set if there
|
|
* are still dirty buffers. Compare to how ffs_fsync/ffs_update
|
|
* work together and you'll see what I mean.
|
|
*/
|
|
if (((ip->i_flag & (IN_ACCESS|IN_CHANGE|IN_MODIFIED|IN_UPDATE)) == 0)
|
|
&& (vp->v_dirtyblkhd.lh_first == NULL))
|
|
return(0);
|
|
|
|
if (ip->i_flag & IN_ACCESS)
|
|
ip->i_atime.ts_sec = ap->a_access->tv_sec;
|
|
if (ip->i_flag & IN_UPDATE) {
|
|
ip->i_mtime.ts_sec = ap->a_modify->tv_sec;
|
|
(ip)->i_modrev++;
|
|
}
|
|
if (ip->i_flag & IN_CHANGE)
|
|
ip->i_ctime.ts_sec = time.tv_sec;
|
|
ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE);
|
|
|
|
if (!(ip->i_flag & IN_MODIFIED))
|
|
++(VFSTOUFS(vp->v_mount)->um_lfs->lfs_uinodes);
|
|
ip->i_flag |= IN_MODIFIED;
|
|
|
|
/* If sync, push back the vnode and any dirty blocks it may have. */
|
|
error = (ap->a_waitfor & LFS_SYNC ? lfs_vflush(vp) : 0);
|
|
if(ap->a_waitfor & LFS_SYNC && vp->v_dirtyblkhd.lh_first != NULL)
|
|
panic("lfs_update: dirty bufs");
|
|
return( error );
|
|
|
|
}
|
|
|
|
/* Update segment usage information when removing a block. */
|
|
#define UPDATE_SEGUSE \
|
|
if (lastseg != -1) { \
|
|
LFS_SEGENTRY(sup, fs, lastseg, sup_bp); \
|
|
if ((num << fs->lfs_bshift) > sup->su_nbytes) \
|
|
panic("lfs_truncate: negative bytes in segment %d\n", \
|
|
lastseg); \
|
|
sup->su_nbytes -= num << fs->lfs_bshift; \
|
|
e1 = VOP_BWRITE(sup_bp); \
|
|
blocksreleased += num; \
|
|
}
|
|
|
|
#define SEGDEC { \
|
|
if (daddr != 0) { \
|
|
if (lastseg != (seg = datosn(fs, daddr))) { \
|
|
UPDATE_SEGUSE; \
|
|
num = 1; \
|
|
lastseg = seg; \
|
|
} else \
|
|
++num; \
|
|
} \
|
|
}
|
|
|
|
/*
|
|
* Truncate the inode ip to at most length size. Update segment usage
|
|
* table information.
|
|
*/
|
|
/* ARGSUSED */
|
|
int
|
|
lfs_truncate(ap)
|
|
struct vop_truncate_args /* {
|
|
struct vnode *a_vp;
|
|
off_t a_length;
|
|
int a_flags;
|
|
struct ucred *a_cred;
|
|
struct proc *a_p;
|
|
} */ *ap;
|
|
{
|
|
register struct indir *inp;
|
|
register int i;
|
|
register daddr_t *daddrp;
|
|
register struct vnode *vp = ap->a_vp;
|
|
off_t length = ap->a_length;
|
|
struct buf *bp, *sup_bp;
|
|
struct timeval tv;
|
|
struct ifile *ifp;
|
|
struct inode *ip;
|
|
struct lfs *fs;
|
|
struct indir a[NIADDR + 2], a_end[NIADDR + 2];
|
|
SEGUSE *sup;
|
|
daddr_t daddr, lastblock, lbn, olastblock;
|
|
long off, a_released, blocksreleased, i_released;
|
|
int e1, e2, depth, lastseg, num, offset, seg, size;
|
|
|
|
ip = VTOI(vp);
|
|
tv = time;
|
|
if (vp->v_type == VLNK && vp->v_mount->mnt_maxsymlinklen > 0) {
|
|
#ifdef DIAGNOSTIC
|
|
if (length != 0)
|
|
panic("lfs_truncate: partial truncate of symlink");
|
|
#endif
|
|
bzero((char *)&ip->i_shortlink, (u_int)ip->i_size);
|
|
ip->i_size = 0;
|
|
ip->i_flag |= IN_CHANGE | IN_UPDATE;
|
|
return (VOP_UPDATE(vp, &tv, &tv, 0));
|
|
}
|
|
vnode_pager_setsize(vp, (u_long)length);
|
|
|
|
fs = ip->i_lfs;
|
|
|
|
/* If length is larger than the file, just update the times. */
|
|
if (ip->i_size <= length) {
|
|
ip->i_flag |= IN_CHANGE | IN_UPDATE;
|
|
return (VOP_UPDATE(vp, &tv, &tv, 0));
|
|
}
|
|
|
|
/*
|
|
* Calculate index into inode's block list of last direct and indirect
|
|
* blocks (if any) which we want to keep. Lastblock is 0 when the
|
|
* file is truncated to 0.
|
|
*/
|
|
lastblock = lblkno(fs, length + fs->lfs_bsize - 1);
|
|
olastblock = lblkno(fs, ip->i_size + fs->lfs_bsize - 1) - 1;
|
|
|
|
/*
|
|
* Update the size of the file. If the file is not being truncated to
|
|
* a block boundry, the contents of the partial block following the end
|
|
* of the file must be zero'ed in case it ever become accessable again
|
|
* because of subsequent file growth.
|
|
*/
|
|
offset = blkoff(fs, length);
|
|
if (offset == 0)
|
|
ip->i_size = length;
|
|
else {
|
|
lbn = lblkno(fs, length);
|
|
#ifdef QUOTA
|
|
if (e1 = getinoquota(ip))
|
|
return (e1);
|
|
#endif
|
|
if (e1 = bread(vp, lbn, fs->lfs_bsize, NOCRED, &bp))
|
|
return (e1);
|
|
ip->i_size = length;
|
|
size = blksize(fs);
|
|
bzero((char *)bp->b_data + offset, (u_int)(size - offset));
|
|
allocbuf(bp, size, 0);
|
|
if (e1 = VOP_BWRITE(bp))
|
|
return (e1);
|
|
}
|
|
/*
|
|
* Modify sup->su_nbyte counters for each deleted block; keep track
|
|
* of number of blocks removed for ip->i_blocks.
|
|
*/
|
|
blocksreleased = 0;
|
|
num = 0;
|
|
lastseg = -1;
|
|
|
|
for (lbn = olastblock; lbn >= lastblock;) {
|
|
/* XXX use run length from bmap array to make this faster */
|
|
ufs_bmaparray(vp, lbn, &daddr, a, &depth, NULL);
|
|
if (lbn == olastblock)
|
|
for (i = NIADDR + 2; i--;)
|
|
a_end[i] = a[i];
|
|
switch (depth) {
|
|
case 0: /* Direct block. */
|
|
daddr = ip->i_db[lbn];
|
|
SEGDEC;
|
|
ip->i_db[lbn] = 0;
|
|
--lbn;
|
|
break;
|
|
#ifdef DIAGNOSTIC
|
|
case 1: /* An indirect block. */
|
|
panic("lfs_truncate: ufs_bmaparray returned depth 1");
|
|
/* NOTREACHED */
|
|
#endif
|
|
default: /* Chain of indirect blocks. */
|
|
inp = a + --depth;
|
|
if (inp->in_off > 0 && lbn != lastblock) {
|
|
lbn -= inp->in_off < lbn - lastblock ?
|
|
inp->in_off : lbn - lastblock;
|
|
break;
|
|
}
|
|
for (; depth && (inp->in_off == 0 || lbn == lastblock);
|
|
--inp, --depth) {
|
|
if (bread(vp,
|
|
inp->in_lbn, fs->lfs_bsize, NOCRED, &bp))
|
|
panic("lfs_truncate: bread bno %d",
|
|
inp->in_lbn);
|
|
daddrp = (daddr_t *)bp->b_data + inp->in_off;
|
|
for (i = inp->in_off;
|
|
i++ <= a_end[depth].in_off;) {
|
|
daddr = *daddrp++;
|
|
SEGDEC;
|
|
}
|
|
a_end[depth].in_off = NINDIR(fs) - 1;
|
|
if (inp->in_off == 0)
|
|
brelse (bp);
|
|
else {
|
|
bzero((daddr_t *)bp->b_data +
|
|
inp->in_off, fs->lfs_bsize -
|
|
inp->in_off * sizeof(daddr_t));
|
|
if (e1 = VOP_BWRITE(bp))
|
|
return (e1);
|
|
}
|
|
}
|
|
if (depth == 0 && a[1].in_off == 0) {
|
|
off = a[0].in_off;
|
|
daddr = ip->i_ib[off];
|
|
SEGDEC;
|
|
ip->i_ib[off] = 0;
|
|
}
|
|
if (lbn == lastblock || lbn <= NDADDR)
|
|
--lbn;
|
|
else {
|
|
lbn -= NINDIR(fs);
|
|
if (lbn < lastblock)
|
|
lbn = lastblock;
|
|
}
|
|
}
|
|
}
|
|
UPDATE_SEGUSE;
|
|
|
|
/* If truncating the file to 0, update the version number. */
|
|
if (length == 0) {
|
|
LFS_IENTRY(ifp, fs, ip->i_number, bp);
|
|
++ifp->if_version;
|
|
(void) VOP_BWRITE(bp);
|
|
}
|
|
|
|
#ifdef DIAGNOSTIC
|
|
if (ip->i_blocks < fsbtodb(fs, blocksreleased)) {
|
|
printf("lfs_truncate: block count < 0\n");
|
|
blocksreleased = ip->i_blocks;
|
|
}
|
|
#endif
|
|
ip->i_blocks -= fsbtodb(fs, blocksreleased);
|
|
fs->lfs_bfree += fsbtodb(fs, blocksreleased);
|
|
ip->i_flag |= IN_CHANGE | IN_UPDATE;
|
|
/*
|
|
* Traverse dirty block list counting number of dirty buffers
|
|
* that are being deleted out of the cache, so that the lfs_avail
|
|
* field can be updated.
|
|
*/
|
|
a_released = 0;
|
|
i_released = 0;
|
|
for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = bp->b_vnbufs.le_next)
|
|
if (bp->b_flags & B_LOCKED) {
|
|
++a_released;
|
|
/*
|
|
* XXX
|
|
* When buffers are created in the cache, their block
|
|
* number is set equal to their logical block number.
|
|
* If that is still true, we are assuming that the
|
|
* blocks are new (not yet on disk) and weren't
|
|
* counted above. However, there is a slight chance
|
|
* that a block's disk address is equal to its logical
|
|
* block number in which case, we'll get an overcounting
|
|
* here.
|
|
*/
|
|
if (bp->b_blkno == bp->b_lblkno)
|
|
++i_released;
|
|
}
|
|
blocksreleased = fsbtodb(fs, i_released);
|
|
#ifdef DIAGNOSTIC
|
|
if (blocksreleased > ip->i_blocks) {
|
|
printf("lfs_inode: Warning! %s\n",
|
|
"more blocks released from inode than are in inode");
|
|
blocksreleased = ip->i_blocks;
|
|
}
|
|
#endif
|
|
fs->lfs_bfree += blocksreleased;
|
|
ip->i_blocks -= blocksreleased;
|
|
#ifdef DIAGNOSTIC
|
|
if (length == 0 && ip->i_blocks != 0)
|
|
printf("lfs_inode: Warning! %s%ld%s\n",
|
|
"Truncation to zero, but ", ip->i_blocks,
|
|
" blocks left on inode");
|
|
#endif
|
|
fs->lfs_avail += fsbtodb(fs, a_released);
|
|
e1 = vinvalbuf(vp, (length > 0) ? V_SAVE : 0, ap->a_cred, ap->a_p,
|
|
0, 0);
|
|
e2 = VOP_UPDATE(vp, &tv, &tv, 0);
|
|
return (e1 ? e1 : e2 ? e2 : 0);
|
|
}
|