Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
1bf2d8180e
NetBSD/sys/ufs/lfs/lfs_syscalls.c
yamt 4370be165c add a XXX comment
2002-12-21 05:35:54 +00:00

1255 lines
33 KiB
C
Raw Blame History

/* $NetBSD: lfs_syscalls.c,v 1.76 2002/12/21 05:35:54 yamt Exp $ */
/*-
* Copyright (c) 1999, 2000 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Konrad E. Schroder <perseant@hhhh.org>.
*
* 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 NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/
/*-
* Copyright (c) 1991, 1993, 1994
* 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_syscalls.c 8.10 (Berkeley) 5/14/95
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_syscalls.c,v 1.76 2002/12/21 05:35:54 yamt Exp $");
#define LFS /* for prototypes in syscallargs.h */
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/buf.h>
#include <sys/mount.h>
#include <sys/vnode.h>
#include <sys/malloc.h>
#include <sys/kernel.h>
#include <sys/syscallargs.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>
/* Max block count for lfs_markv() */
#define MARKV_MAXBLKCNT 65536
struct buf *lfs_fakebuf(struct lfs *, struct vnode *, int, size_t, caddr_t);
int lfs_fasthashget(dev_t, ino_t, struct vnode **);
int debug_cleaner = 0;
int clean_vnlocked = 0;
int clean_inlocked = 0;
int verbose_debug = 0;
pid_t lfs_cleaner_pid = 0;
/*
* Definitions for the buffer free lists.
*/
#define BQUEUES 4 /* number of free buffer queues */
#define BQ_LOCKED 0 /* super-blocks &c */
#define BQ_LRU 1 /* lru, useful buffers */
#define BQ_AGE 2 /* rubbish */
#define BQ_EMPTY 3 /* buffer headers with no memory */
extern TAILQ_HEAD(bqueues, buf) bufqueues[BQUEUES];
#define LFS_FORCE_WRITE UNASSIGNED
#define LFS_VREF_THRESHOLD 128
static int lfs_bmapv(struct proc *, fsid_t *, BLOCK_INFO *, int);
static int lfs_markv(struct proc *, fsid_t *, BLOCK_INFO *, int);
static void lfs_fakebuf_iodone(struct buf *);
/*
* sys_lfs_markv:
*
* This will mark inodes and blocks dirty, so they are written into the log.
* It will block until all the blocks have been written. The segment create
* time passed in the block_info and inode_info structures is used to decide
* if the data is valid for each block (in case some process dirtied a block
* or inode that is being cleaned between the determination that a block is
* live and the lfs_markv call).
*
* 0 on success
* -1/errno is return on error.
*/
#ifdef USE_64BIT_SYSCALLS
int
sys_lfs_markv(struct proc *p, void *v, register_t *retval)
{
struct sys_lfs_markv_args /* {
syscallarg(fsid_t *) fsidp;
syscallarg(struct block_info *) blkiov;
syscallarg(int) blkcnt;
} */ *uap = v;
BLOCK_INFO *blkiov;
int blkcnt, error;
fsid_t fsid;
if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
return (error);
if ((error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t))) != 0)
return (error);
blkcnt = SCARG(uap, blkcnt);
if ((u_int) blkcnt > MARKV_MAXBLKCNT)
return (EINVAL);
blkiov = malloc(blkcnt * sizeof(BLOCK_INFO), M_SEGMENT, M_WAITOK);
if ((error = copyin(SCARG(uap, blkiov), blkiov,
blkcnt * sizeof(BLOCK_INFO))) != 0)
goto out;
if ((error = lfs_markv(p, &fsid, blkiov, blkcnt)) == 0)
copyout(blkiov, SCARG(uap, blkiov),
blkcnt * sizeof(BLOCK_INFO));
out:
free(blkiov, M_SEGMENT);
return error;
}
#else
int
sys_lfs_markv(struct proc *p, void *v, register_t *retval)
{
struct sys_lfs_markv_args /* {
syscallarg(fsid_t *) fsidp;
syscallarg(struct block_info *) blkiov;
syscallarg(int) blkcnt;
} */ *uap = v;
BLOCK_INFO *blkiov;
BLOCK_INFO_15 *blkiov15;
int i, blkcnt, error;
fsid_t fsid;
if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
return (error);
if ((error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t))) != 0)
return (error);
blkcnt = SCARG(uap, blkcnt);
if ((u_int) blkcnt > MARKV_MAXBLKCNT)
return (EINVAL);
blkiov = malloc(blkcnt * sizeof(BLOCK_INFO), M_SEGMENT, M_WAITOK);
blkiov15 = malloc(blkcnt * sizeof(BLOCK_INFO_15), M_SEGMENT, M_WAITOK);
if ((error = copyin(SCARG(uap, blkiov), blkiov15,
blkcnt * sizeof(BLOCK_INFO_15))) != 0)
goto out;
for (i = 0; i < blkcnt; i++) {
blkiov[i].bi_inode = blkiov15[i].bi_inode;
blkiov[i].bi_lbn = blkiov15[i].bi_lbn;
blkiov[i].bi_daddr = blkiov15[i].bi_daddr;
blkiov[i].bi_segcreate = blkiov15[i].bi_segcreate;
blkiov[i].bi_version = blkiov15[i].bi_version;
blkiov[i].bi_bp = blkiov15[i].bi_bp;
blkiov[i].bi_size = blkiov15[i].bi_size;
}
if ((error = lfs_markv(p, &fsid, blkiov, blkcnt)) == 0) {
for (i = 0; i < blkcnt; i++) {
blkiov15[i].bi_inode = blkiov[i].bi_inode;
blkiov15[i].bi_lbn = blkiov[i].bi_lbn;
blkiov15[i].bi_daddr = blkiov[i].bi_daddr;
blkiov15[i].bi_segcreate = blkiov[i].bi_segcreate;
blkiov15[i].bi_version = blkiov[i].bi_version;
blkiov15[i].bi_bp = blkiov[i].bi_bp;
blkiov15[i].bi_size = blkiov[i].bi_size;
}
copyout(blkiov15, SCARG(uap, blkiov),
blkcnt * sizeof(BLOCK_INFO_15));
}
out:
free(blkiov, M_SEGMENT);
free(blkiov15, M_SEGMENT);
return error;
}
#endif
static int
lfs_markv(struct proc *p, fsid_t *fsidp, BLOCK_INFO *blkiov, int blkcnt)
{
BLOCK_INFO *blkp;
IFILE *ifp;
struct buf *bp, *nbp;
struct inode *ip = NULL;
struct lfs *fs;
struct mount *mntp;
struct vnode *vp;
#ifdef DEBUG_LFS
int vputc = 0, iwritten = 0;
#endif
ino_t lastino;
ufs_daddr_t b_daddr, v_daddr;
int cnt, error;
int do_again = 0;
int s;
#ifdef CHECK_COPYIN
int i;
#endif /* CHECK_COPYIN */
int numrefed = 0;
ino_t maxino;
size_t obsize;
if ((mntp = vfs_getvfs(fsidp)) == NULL)
return (ENOENT);
fs = VFSTOUFS(mntp)->um_lfs;
maxino = (fragstoblks(fs, fsbtofrags(fs, VTOI(fs->lfs_ivnode)->i_ffs_blocks)) -
fs->lfs_cleansz - fs->lfs_segtabsz) * fs->lfs_ifpb;
cnt = blkcnt;
if ((error = vfs_busy(mntp, LK_NOWAIT, NULL)) != 0)
return (error);
/*
* This seglock is just to prevent the fact that we might have to sleep
* from allowing the possibility that our blocks might become
* invalid.
*
* It is also important to note here that unless we specify SEGM_CKP,
* any Ifile blocks that we might be asked to clean will never get
* to the disk.
*/
lfs_seglock(fs, SEGM_CLEAN | SEGM_CKP | SEGM_SYNC);
/* Mark blocks/inodes dirty. */
error = 0;
#ifdef DEBUG_LFS
/* Run through and count the inodes */
lastino = LFS_UNUSED_INUM;
for (blkp = blkiov; cnt--; ++blkp) {
if (lastino != blkp->bi_inode) {
lastino = blkp->bi_inode;
vputc++;
}
}
cnt = blkcnt;
printf("[%d/",vputc);
iwritten = 0;
#endif /* DEBUG_LFS */
/* these were inside the initialization for the for loop */
v_daddr = LFS_UNUSED_DADDR;
lastino = LFS_UNUSED_INUM;
for (blkp = blkiov; cnt--; ++blkp)
{
if (blkp->bi_daddr == LFS_FORCE_WRITE)
printf("lfs_markv: warning: force-writing ino %d lbn %d\n",
blkp->bi_inode, blkp->bi_lbn);
/* Bounds-check incoming data, avoid panic for failed VGET */
if (blkp->bi_inode <= 0 || blkp->bi_inode >= maxino) {
error = EINVAL;
goto again;
}
/*
* Get the IFILE entry (only once) and see if the file still
* exists.
*/
if (lastino != blkp->bi_inode) {
/*
* Finish the old file, if there was one. The presence
* of a usable vnode in vp is signaled by a valid v_daddr.
*/
if (v_daddr != LFS_UNUSED_DADDR) {
#ifdef DEBUG_LFS
if (ip->i_flag & (IN_MODIFIED|IN_CLEANING))
iwritten++;
#endif
lfs_vunref(vp);
numrefed--;
}
/*
* Start a new file
*/
lastino = blkp->bi_inode;
if (blkp->bi_inode == LFS_IFILE_INUM)
v_daddr = fs->lfs_idaddr;
else {
LFS_IENTRY(ifp, fs, blkp->bi_inode, bp);
/* XXX fix for force write */
v_daddr = ifp->if_daddr;
brelse(bp);
}
/* Don't force-write the ifile */
if (blkp->bi_inode == LFS_IFILE_INUM
&& blkp->bi_daddr == LFS_FORCE_WRITE)
{
continue;
}
if (v_daddr == LFS_UNUSED_DADDR
&& blkp->bi_daddr != LFS_FORCE_WRITE)
{
continue;
}
/* Get the vnode/inode. */
error = lfs_fastvget(mntp, blkp->bi_inode, v_daddr,
&vp,
(blkp->bi_lbn == LFS_UNUSED_LBN
? blkp->bi_bp
: NULL));
if (!error) {
numrefed++;
}
if (error) {
#ifdef DEBUG_LFS
printf("lfs_markv: lfs_fastvget failed with %d (ino %d, segment %d)\n",
error, blkp->bi_inode,
dtosn(fs, blkp->bi_daddr));
#endif /* DEBUG_LFS */
/*
* If we got EAGAIN, that means that the
* Inode was locked. This is
* recoverable: just clean the rest of
* this segment, and let the cleaner try
* again with another. (When the
* cleaner runs again, this segment will
* sort high on the list, since it is
* now almost entirely empty.) But, we
* still set v_daddr = LFS_UNUSED_ADDR
* so as not to test this over and over
* again.
*/
if (error == EAGAIN) {
error = 0;
do_again++;
}
#ifdef DIAGNOSTIC
else if (error != ENOENT)
panic("lfs_markv VFS_VGET FAILED");
#endif
/* lastino = LFS_UNUSED_INUM; */
v_daddr = LFS_UNUSED_DADDR;
vp = NULL;
ip = NULL;
continue;
}
ip = VTOI(vp);
} else if (v_daddr == LFS_UNUSED_DADDR) {
/*
* This can only happen if the vnode is dead (or
* in any case we can't get it...e.g., it is
* inlocked). Keep going.
*/
continue;
}
/* Past this point we are guaranteed that vp, ip are valid. */
/* If this BLOCK_INFO didn't contain a block, keep going. */
if (blkp->bi_lbn == LFS_UNUSED_LBN) {
/* XXX need to make sure that the inode gets written in this case */
/* XXX but only write the inode if it's the right one */
if (blkp->bi_inode != LFS_IFILE_INUM) {
LFS_IENTRY(ifp, fs, blkp->bi_inode, bp);
if (ifp->if_daddr == blkp->bi_daddr
|| blkp->bi_daddr == LFS_FORCE_WRITE)
{
LFS_SET_UINO(ip, IN_CLEANING);
}
brelse(bp);
}
continue;
}
b_daddr = 0;
if (blkp->bi_daddr != LFS_FORCE_WRITE) {
if (VOP_BMAP(vp, blkp->bi_lbn, NULL, &b_daddr, NULL) ||
dbtofsb(fs, b_daddr) != blkp->bi_daddr)
{
if (dtosn(fs,dbtofsb(fs, b_daddr))
== dtosn(fs,blkp->bi_daddr))
{
printf("lfs_markv: wrong da same seg: %x vs %x\n",
blkp->bi_daddr, dbtofsb(fs, b_daddr));
}
do_again++;
continue;
}
}
/*
* Check block sizes. The blocks being cleaned come from
* disk, so they should have the same size as their on-disk
* counterparts.
*/
if (blkp->bi_lbn >= 0)
obsize = blksize(fs, ip, blkp->bi_lbn);
else
obsize = fs->lfs_bsize;
/* Check for fragment size change */
if (blkp->bi_lbn >= 0 && blkp->bi_lbn < NDADDR) {
obsize = ip->i_lfs_fragsize[blkp->bi_lbn];
}
if (obsize != blkp->bi_size) {
printf("lfs_markv: ino %d lbn %d wrong size (%ld != %d), try again\n",
blkp->bi_inode, blkp->bi_lbn,
(long) obsize, blkp->bi_size);
do_again++;
continue;
}
/*
* If we get to here, then we are keeping the block. If
* it is an indirect block, we want to actually put it
* in the buffer cache so that it can be updated in the
* finish_meta section. If it's not, we need to
* allocate a fake buffer so that writeseg can perform
* the copyin and write the buffer.
*/
if (ip->i_number != LFS_IFILE_INUM && blkp->bi_lbn >= 0) {
/* Data Block */
bp = lfs_fakebuf(fs, vp, blkp->bi_lbn,
blkp->bi_size, blkp->bi_bp);
/* Pretend we used bread() to get it */
bp->b_blkno = fsbtodb(fs, blkp->bi_daddr);
} else {
/* Indirect block or ifile */
if (blkp->bi_size != fs->lfs_bsize &&
ip->i_number != LFS_IFILE_INUM)
panic("lfs_markv: partial indirect block?"
" size=%d\n", blkp->bi_size);
bp = getblk(vp, blkp->bi_lbn, blkp->bi_size, 0, 0);
if (!(bp->b_flags & (B_DONE|B_DELWRI))) { /* B_CACHE */
/*
* The block in question was not found
* in the cache; i.e., the block that
* getblk() returned is empty. So, we
* can (and should) copy in the
* contents, because we've already
* determined that this was the right
* version of this block on disk.
*
* And, it can't have changed underneath
* us, because we have the segment lock.
*/
error = copyin(blkp->bi_bp, bp->b_data, blkp->bi_size);
if (error)
goto err2;
}
}
if ((error = lfs_bwrite_ext(bp,BW_CLEAN)) != 0)
goto err2;
}
/*
* Finish the old file, if there was one
*/
if (v_daddr != LFS_UNUSED_DADDR) {
#ifdef DEBUG_LFS
if (ip->i_flag & (IN_MODIFIED|IN_CLEANING))
iwritten++;
#endif
lfs_vunref(vp);
numrefed--;
}
#ifdef DEBUG_LFS
printf("%d]",iwritten);
if (numrefed != 0) {
panic("lfs_markv: numrefed=%d", numrefed);
}
#endif
/*
* The last write has to be SEGM_SYNC, because of calling semantics.
* It also has to be SEGM_CKP, because otherwise we could write
* over the newly cleaned data contained in a checkpoint, and then
* we'd be unhappy at recovery time.
*/
lfs_segwrite(mntp, SEGM_CLEAN | SEGM_CKP | SEGM_SYNC);
lfs_segunlock(fs);
vfs_unbusy(mntp);
if (error)
return (error);
else if (do_again)
return EAGAIN;
return 0;
err2:
printf("lfs_markv err2\n");
lfs_vunref(vp);
--numrefed;
/* Free up fakebuffers -- have to take these from the LOCKED list */
again:
s = splbio();
for (bp = bufqueues[BQ_LOCKED].tqh_first; bp; bp = nbp) {
nbp = bp->b_freelist.tqe_next;
if (bp->b_flags & B_CALL) {
if (bp->b_flags & B_BUSY) { /* not bloody likely */
bp->b_flags |= B_WANTED;
tsleep(bp, PRIBIO+1, "markv", 0);
splx(s);
goto again;
}
if (bp->b_flags & B_DELWRI)
fs->lfs_avail += btofsb(fs, bp->b_bcount);
bremfree(bp);
splx(s);
brelse(bp);
s = splbio();
}
}
splx(s);
lfs_segunlock(fs);
vfs_unbusy(mntp);
#ifdef DEBUG_LFS
if (numrefed != 0) {
panic("lfs_markv: numrefed=%d", numrefed);
}
#endif
return (error);
}
/*
* sys_lfs_bmapv:
*
* This will fill in the current disk address for arrays of blocks.
*
* 0 on success
* -1/errno is return on error.
*/
#ifdef USE_64BIT_SYSCALLS
int
sys_lfs_bmapv(struct proc *p, void *v, register_t *retval)
{
struct sys_lfs_bmapv_args /* {
syscallarg(fsid_t *) fsidp;
syscallarg(struct block_info *) blkiov;
syscallarg(int) blkcnt;
} */ *uap = v;
BLOCK_INFO *blkiov;
int blkcnt, error;
fsid_t fsid;
if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
return (error);
if ((error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t))) != 0)
return (error);
blkcnt = SCARG(uap, blkcnt);
if ((u_int) blkcnt > SIZE_T_MAX / sizeof(BLOCK_INFO))
return (EINVAL);
blkiov = malloc(blkcnt * sizeof(BLOCK_INFO), M_SEGMENT, M_WAITOK);
if ((error = copyin(SCARG(uap, blkiov), blkiov,
blkcnt * sizeof(BLOCK_INFO))) != 0)
goto out;
if ((error = lfs_bmapv(p, &fsid, blkiov, blkcnt)) == 0)
copyout(blkiov, SCARG(uap, blkiov),
blkcnt * sizeof(BLOCK_INFO));
out:
free(blkiov, M_SEGMENT);
return error;
}
#else
int
sys_lfs_bmapv(struct proc *p, void *v, register_t *retval)
{
struct sys_lfs_bmapv_args /* {
syscallarg(fsid_t *) fsidp;
syscallarg(struct block_info *) blkiov;
syscallarg(int) blkcnt;
} */ *uap = v;
BLOCK_INFO *blkiov;
BLOCK_INFO_15 *blkiov15;
int i, blkcnt, error;
fsid_t fsid;
if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
return (error);
if ((error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t))) != 0)
return (error);
blkcnt = SCARG(uap, blkcnt);
if ((u_int) blkcnt > SIZE_T_MAX / sizeof(BLOCK_INFO))
return (EINVAL);
blkiov = malloc(blkcnt * sizeof(BLOCK_INFO), M_SEGMENT, M_WAITOK);
blkiov15 = malloc(blkcnt * sizeof(BLOCK_INFO_15), M_SEGMENT, M_WAITOK);
if ((error = copyin(SCARG(uap, blkiov), blkiov15,
blkcnt * sizeof(BLOCK_INFO_15))) != 0)
goto out;
for (i = 0; i < blkcnt; i++) {
blkiov[i].bi_inode = blkiov15[i].bi_inode;
blkiov[i].bi_lbn = blkiov15[i].bi_lbn;
blkiov[i].bi_daddr = blkiov15[i].bi_daddr;
blkiov[i].bi_segcreate = blkiov15[i].bi_segcreate;
blkiov[i].bi_version = blkiov15[i].bi_version;
blkiov[i].bi_bp = blkiov15[i].bi_bp;
blkiov[i].bi_size = blkiov15[i].bi_size;
}
if ((error = lfs_bmapv(p, &fsid, blkiov, blkcnt)) == 0) {
for (i = 0; i < blkcnt; i++) {
blkiov15[i].bi_inode = blkiov[i].bi_inode;
blkiov15[i].bi_lbn = blkiov[i].bi_lbn;
blkiov15[i].bi_daddr = blkiov[i].bi_daddr;
blkiov15[i].bi_segcreate = blkiov[i].bi_segcreate;
blkiov15[i].bi_version = blkiov[i].bi_version;
blkiov15[i].bi_bp = blkiov[i].bi_bp;
blkiov15[i].bi_size = blkiov[i].bi_size;
}
copyout(blkiov15, SCARG(uap, blkiov),
blkcnt * sizeof(BLOCK_INFO_15));
}
out:
free(blkiov, M_SEGMENT);
free(blkiov15, M_SEGMENT);
return error;
}
#endif
static int
lfs_bmapv(struct proc *p, fsid_t *fsidp, BLOCK_INFO *blkiov, int blkcnt)
{
BLOCK_INFO *blkp;
IFILE *ifp;
struct buf *bp;
struct inode *ip = NULL;
struct lfs *fs;
struct mount *mntp;
struct ufsmount *ump;
struct vnode *vp;
ino_t lastino;
ufs_daddr_t v_daddr;
int cnt, error;
int numrefed = 0;
lfs_cleaner_pid = p->p_pid;
if ((mntp = vfs_getvfs(fsidp)) == NULL)
return (ENOENT);
ump = VFSTOUFS(mntp);
if ((error = vfs_busy(mntp, LK_NOWAIT, NULL)) != 0)
return (error);
cnt = blkcnt;
fs = VFSTOUFS(mntp)->um_lfs;
error = 0;
/* these were inside the initialization for the for loop */
v_daddr = LFS_UNUSED_DADDR;
lastino = LFS_UNUSED_INUM;
for (blkp = blkiov; cnt--; ++blkp)
{
/*
* Get the IFILE entry (only once) and see if the file still
* exists.
*/
if (lastino != blkp->bi_inode) {
/*
* Finish the old file, if there was one. The presence
* of a usable vnode in vp is signaled by a valid
* v_daddr.
*/
if (v_daddr != LFS_UNUSED_DADDR) {
lfs_vunref(vp);
numrefed--;
}
/*
* Start a new file
*/
lastino = blkp->bi_inode;
if (blkp->bi_inode == LFS_IFILE_INUM)
v_daddr = fs->lfs_idaddr;
else {
LFS_IENTRY(ifp, fs, blkp->bi_inode, bp);
v_daddr = ifp->if_daddr;
brelse(bp);
}
if (v_daddr == LFS_UNUSED_DADDR) {
blkp->bi_daddr = LFS_UNUSED_DADDR;
continue;
}
/*
* A regular call to VFS_VGET could deadlock
* here. Instead, we try an unlocked access.
*/
vp = ufs_ihashlookup(ump->um_dev, blkp->bi_inode);
if (vp != NULL && !(vp->v_flag & VXLOCK)) {
ip = VTOI(vp);
if (lfs_vref(vp)) {
v_daddr = LFS_UNUSED_DADDR;
continue;
}
numrefed++;
} else {
error = VFS_VGET(mntp, blkp->bi_inode, &vp);
if (error) {
#ifdef DEBUG_LFS
printf("lfs_bmapv: vget of ino %d failed with %d",blkp->bi_inode,error);
#endif
v_daddr = LFS_UNUSED_DADDR;
continue;
} else {
KASSERT(VOP_ISLOCKED(vp));
VOP_UNLOCK(vp, 0);
numrefed++;
}
}
ip = VTOI(vp);
} else if (v_daddr == LFS_UNUSED_DADDR) {
/*
* This can only happen if the vnode is dead.
* Keep going. Note that we DO NOT set the
* bi_addr to anything -- if we failed to get
* the vnode, for example, we want to assume
* conservatively that all of its blocks *are*
* located in the segment in question.
* lfs_markv will throw them out if we are
* wrong.
*/
/* blkp->bi_daddr = LFS_UNUSED_DADDR; */
continue;
}
/* Past this point we are guaranteed that vp, ip are valid. */
if (blkp->bi_lbn == LFS_UNUSED_LBN) {
/*
* We just want the inode address, which is
* conveniently in v_daddr.
*/
blkp->bi_daddr = v_daddr;
} else {
error = VOP_BMAP(vp, blkp->bi_lbn, NULL,
&(blkp->bi_daddr), NULL);
if (error)
{
blkp->bi_daddr = LFS_UNUSED_DADDR;
continue;
}
blkp->bi_daddr = dbtofsb(fs, blkp->bi_daddr);
/* Fill in the block size, too */
if (blkp->bi_lbn >= 0)
blkp->bi_size = blksize(fs, ip, blkp->bi_lbn);
else
blkp->bi_size = fs->lfs_bsize;
}
}
/*
* Finish the old file, if there was one. The presence
* of a usable vnode in vp is signaled by a valid v_daddr.
*/
if (v_daddr != LFS_UNUSED_DADDR) {
lfs_vunref(vp);
numrefed--;
}
#ifdef DEBUG_LFS
if (numrefed != 0) {
panic("lfs_bmapv: numrefed=%d", numrefed);
}
#endif
vfs_unbusy(mntp);
return 0;
}
/*
* sys_lfs_segclean:
*
* Mark the segment clean.
*
* 0 on success
* -1/errno is return on error.
*/
int
sys_lfs_segclean(struct proc *p, void *v, register_t *retval)
{
struct sys_lfs_segclean_args /* {
syscallarg(fsid_t *) fsidp;
syscallarg(u_long) segment;
} */ *uap = v;
CLEANERINFO *cip;
SEGUSE *sup;
struct buf *bp;
struct mount *mntp;
struct lfs *fs;
fsid_t fsid;
int error;
unsigned long segnum;
if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
return (error);
if ((error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t))) != 0)
return (error);
if ((mntp = vfs_getvfs(&fsid)) == NULL)
return (ENOENT);
fs = VFSTOUFS(mntp)->um_lfs;
segnum = SCARG(uap, segment);
if (dtosn(fs, fs->lfs_curseg) == segnum)
return (EBUSY);
if ((error = vfs_busy(mntp, LK_NOWAIT, NULL)) != 0)
return (error);
#ifdef LFS_AGGRESSIVE_SEGLOCK
lfs_seglock(fs, SEGM_PROT);
#endif
LFS_SEGENTRY(sup, fs, segnum, bp);
if (sup->su_nbytes) {
printf("lfs_segclean: not cleaning segment %lu: %d live bytes\n",
segnum, sup->su_nbytes);
brelse(bp);
#ifdef LFS_AGGRESSIVE_SEGLOCK
lfs_segunlock(fs);
#endif
vfs_unbusy(mntp);
return (EBUSY);
}
if (sup->su_flags & SEGUSE_ACTIVE) {
brelse(bp);
#ifdef LFS_AGGRESSIVE_SEGLOCK
lfs_segunlock(fs);
#endif
vfs_unbusy(mntp);
return (EBUSY);
}
if (!(sup->su_flags & SEGUSE_DIRTY)) {
brelse(bp);
#ifdef LFS_AGGRESSIVE_SEGLOCK
lfs_segunlock(fs);
#endif
vfs_unbusy(mntp);
return (EALREADY);
}
fs->lfs_avail += segtod(fs, 1);
if (sup->su_flags & SEGUSE_SUPERBLOCK)
fs->lfs_avail -= btofsb(fs, LFS_SBPAD);
if (fs->lfs_version > 1 && segnum == 0 &&
fs->lfs_start < btofsb(fs, LFS_LABELPAD))
fs->lfs_avail -= btofsb(fs, LFS_LABELPAD) - fs->lfs_start;
fs->lfs_bfree += sup->su_nsums * btofsb(fs, fs->lfs_sumsize) +
btofsb(fs, sup->su_ninos * fs->lfs_ibsize);
fs->lfs_dmeta -= sup->su_nsums * btofsb(fs, fs->lfs_sumsize) +
btofsb(fs, sup->su_ninos * fs->lfs_ibsize);
if (fs->lfs_dmeta < 0)
fs->lfs_dmeta = 0;
sup->su_flags &= ~SEGUSE_DIRTY;
(void) LFS_BWRITE_LOG(bp);
LFS_CLEANERINFO(cip, fs, bp);
++cip->clean;
--cip->dirty;
fs->lfs_nclean = cip->clean;
cip->bfree = fs->lfs_bfree;
cip->avail = fs->lfs_avail - fs->lfs_ravail;
(void) LFS_BWRITE_LOG(bp);
wakeup(&fs->lfs_avail);
#ifdef LFS_AGGRESSIVE_SEGLOCK
lfs_segunlock(fs);
#endif
vfs_unbusy(mntp);
return (0);
}
/*
* sys_lfs_segwait:
*
* This will block until a segment in file system fsid is written. A timeout
* in milliseconds may be specified which will awake the cleaner automatically.
* An fsid of -1 means any file system, and a timeout of 0 means forever.
*
* 0 on success
* 1 on timeout
* -1/errno is return on error.
*/
int
sys_lfs_segwait(struct proc *p, void *v, register_t *retval)
{
struct sys_lfs_segwait_args /* {
syscallarg(fsid_t *) fsidp;
syscallarg(struct timeval *) tv;
} */ *uap = v;
struct mount *mntp;
struct timeval atv;
fsid_t fsid;
void *addr;
u_long timeout;
int error, s;
if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) {
return (error);
}
if ((error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t))) != 0)
return (error);
if ((mntp = vfs_getvfs(&fsid)) == NULL)
addr = &lfs_allclean_wakeup;
else
addr = &VFSTOUFS(mntp)->um_lfs->lfs_nextseg;
if (SCARG(uap, tv)) {
error = copyin(SCARG(uap, tv), &atv, sizeof(struct timeval));
if (error)
return (error);
if (itimerfix(&atv))
return (EINVAL);
/*
* XXX THIS COULD SLEEP FOREVER IF TIMEOUT IS {0,0}!
* XXX IS THAT WHAT IS INTENDED?
*/
s = splclock();
timeradd(&atv, &time, &atv);
timeout = hzto(&atv);
splx(s);
} else
timeout = 0;
error = tsleep(addr, PCATCH | PUSER, "segment", timeout);
return (error == ERESTART ? EINTR : 0);
}
/*
* VFS_VGET call specialized for the cleaner. The cleaner already knows the
* daddr from the ifile, so don't look it up again. If the cleaner is
* processing IINFO structures, it may have the ondisk inode already, so
* don't go retrieving it again.
*
* we lfs_vref, and it is the caller's responsibility to lfs_vunref
* when finished.
*/
extern struct lock ufs_hashlock;
int
lfs_fasthashget(dev_t dev, ino_t ino, struct vnode **vpp)
{
struct inode *ip;
/*
* This is playing fast and loose. Someone may have the inode
* locked, in which case they are going to be distinctly unhappy
* if we trash something.
*/
if ((*vpp = ufs_ihashlookup(dev, ino)) != NULL) {
if ((*vpp)->v_flag & VXLOCK) {
printf("lfs_fastvget: vnode VXLOCKed for ino %d\n",
ino);
clean_vnlocked++;
#ifdef LFS_EAGAIN_FAIL
return EAGAIN;
#endif
}
ip = VTOI(*vpp);
if (lfs_vref(*vpp)) {
clean_inlocked++;
return EAGAIN;
}
} else
*vpp = NULL;
return (0);
}
int
lfs_fastvget(struct mount *mp, ino_t ino, ufs_daddr_t daddr, struct vnode **vpp, struct dinode *dinp)
{
struct inode *ip;
struct dinode *dip;
struct vnode *vp;
struct ufsmount *ump;
dev_t dev;
int i, error, retries;
struct buf *bp;
struct lfs *fs;
ump = VFSTOUFS(mp);
dev = ump->um_dev;
fs = ump->um_lfs;
/*
* Wait until the filesystem is fully mounted before allowing vget
* to complete. This prevents possible problems with roll-forward.
*/
while (fs->lfs_flags & LFS_NOTYET) {
tsleep(&fs->lfs_flags, PRIBIO+1, "lfs_fnotyet", 0);
}
/*
* This is playing fast and loose. Someone may have the inode
* locked, in which case they are going to be distinctly unhappy
* if we trash something.
*/
error = lfs_fasthashget(dev, ino, vpp);
if (error != 0 || *vpp != NULL)
return (error);
if ((error = getnewvnode(VT_LFS, mp, lfs_vnodeop_p, &vp)) != 0) {
*vpp = NULL;
return (error);
}
do {
error = lfs_fasthashget(dev, ino, vpp);
if (error != 0 || *vpp != NULL) {
ungetnewvnode(vp);
return (error);
}
} while (lockmgr(&ufs_hashlock, LK_EXCLUSIVE|LK_SLEEPFAIL, 0));
/* Allocate new vnode/inode. */
lfs_vcreate(mp, ino, vp);
/*
* Put it onto its hash chain and lock it so that other requests for
* this inode will block if they arrive while we are sleeping waiting
* for old data structures to be purged or for the contents of the
* disk portion of this inode to be read.
*/
ip = VTOI(vp);
ufs_ihashins(ip);
lockmgr(&ufs_hashlock, LK_RELEASE, 0);
/*
* XXX
* This may not need to be here, logically it should go down with
* the i_devvp initialization.
* Ask Kirk.
*/
ip->i_lfs = fs;
/* Read in the disk contents for the inode, copy into the inode. */
if (dinp) {
error = copyin(dinp, &ip->i_din.ffs_din, DINODE_SIZE);
if (error) {
printf("lfs_fastvget: dinode copyin failed for ino %d\n", ino);
ufs_ihashrem(ip);
/* Unlock and discard unneeded inode. */
lockmgr(&vp->v_lock, LK_RELEASE, &vp->v_interlock);
lfs_vunref(vp);
*vpp = NULL;
return (error);
}
if (ip->i_number != ino)
panic("lfs_fastvget: I was fed the wrong inode!");
} else {
retries = 0;
again:
error = bread(ump->um_devvp, fsbtodb(fs, daddr), fs->lfs_ibsize,
NOCRED, &bp);
if (error) {
printf("lfs_fastvget: bread failed with %d\n",error);
/*
* The inode does not contain anything useful, so it
* would be misleading to leave it on its hash chain.
* Iput() will return it to the free list.
*/
ufs_ihashrem(ip);
/* Unlock and discard unneeded inode. */
lockmgr(&vp->v_lock, LK_RELEASE, &vp->v_interlock);
lfs_vunref(vp);
brelse(bp);
*vpp = NULL;
return (error);
}
dip = lfs_ifind(ump->um_lfs, ino, bp);
if (dip == NULL) {
/* Assume write has not completed yet; try again */
bp->b_flags |= B_INVAL;
brelse(bp);
++retries;
if (retries > LFS_IFIND_RETRIES)
panic("lfs_fastvget: dinode not found");
printf("lfs_fastvget: dinode not found, retrying...\n");
goto again;
}
ip->i_din.ffs_din = *dip;
brelse(bp);
}
ip->i_ffs_effnlink = ip->i_ffs_nlink;
ip->i_lfs_effnblks = ip->i_ffs_blocks;
ip->i_lfs_osize = ip->i_ffs_size;
memset(ip->i_lfs_fragsize, 0, NDADDR * sizeof(*ip->i_lfs_fragsize));
for (i = 0; i < NDADDR; i++)
if (ip->i_ffs_db[i] != 0)
ip->i_lfs_fragsize[i] = blksize(fs, ip, i);
/*
* Initialize the vnode from the inode, check for aliases. In all
* cases re-init ip, the underlying vnode/inode may have changed.
*/
ufs_vinit(mp, lfs_specop_p, lfs_fifoop_p, &vp);
#ifdef DEBUG_LFS
if (vp->v_type == VNON) {
printf("lfs_fastvget: ino %d is type VNON! (ifmt=%o, dinp=%p)\n",
ip->i_number, (ip->i_ffs_mode & IFMT) >> 12, dinp);
lfs_dump_dinode(&ip->i_din.ffs_din);
#ifdef DDB
Debugger();
#endif
}
#endif /* DEBUG_LFS */
/*
* Finish inode initialization now that aliasing has been resolved.
*/
genfs_node_init(vp, &lfs_genfsops);
ip->i_devvp = ump->um_devvp;
VREF(ip->i_devvp);
*vpp = vp;
KASSERT(VOP_ISLOCKED(vp));
VOP_UNLOCK(vp, 0);
uvm_vnp_setsize(vp, ip->i_ffs_size);
return (0);
}
static void
lfs_fakebuf_iodone(struct buf *bp)
{
struct buf *obp = bp->b_saveaddr;
if (!(obp->b_flags & (B_DELWRI | B_DONE)))
obp->b_flags |= B_INVAL;
brelse(obp);
lfs_callback(bp);
}
struct buf *
lfs_fakebuf(struct lfs *fs, struct vnode *vp, int lbn, size_t size, caddr_t uaddr)
{
struct buf *bp;
int error;
struct buf *obp;
KASSERT(VTOI(vp)->i_number != LFS_IFILE_INUM);
/*
* make corresponding buffer busy to avoid
* reading blocks that isn't written yet.
* it's needed because we'll update metadatas in lfs_updatemeta
* before data pointed by them is actually written to disk.
*
* XXX no need to allocbuf.
*
* XXX this can cause buf starvation.
*/
obp = getblk(vp, lbn, size, 0, 0);
if (obp == NULL)
panic("lfs_fakebuf: getblk failed");
#ifndef ALLOW_VFLUSH_CORRUPTION
bp = lfs_newbuf(VTOI(vp)->i_lfs, vp, lbn, size);
error = copyin(uaddr, bp->b_data, size);
if (error) {
lfs_freebuf(bp);
return NULL;
}
bp->b_saveaddr = obp;
KDASSERT(bp->b_iodone == lfs_callback);
bp->b_iodone = lfs_fakebuf_iodone;
#ifdef DIAGNOSTIC
if (obp->b_flags & B_GATHERED)
panic("lfs_fakebuf: gathered bp: %p, ino=%u, lbn=%d",
bp, VTOI(vp)->i_number, lbn);
#endif
#else
bp = lfs_newbuf(VTOI(vp)->i_lfs, vp, lbn, 0);
bp->b_flags |= B_INVAL;
bp->b_saveaddr = uaddr;
#endif
#if 0
bp->b_saveaddr = (caddr_t)fs;
++fs->lfs_iocount;
#endif
bp->b_bufsize = size;
bp->b_bcount = size;
return (bp);
}
Reference in New Issue View Git Blame Copy Permalink