/*
* Load the appropriate indirect block, and change the appropriate pointer.
* Mark the block dirty. Do segment and avail accounting.
*/
static int
update_meta(struct lfs *fs, ino_t ino, int vers, daddr_t lbn,
daddr_t ndaddr, size_t size, struct lwp *l)
{
int error;
struct vnode *vp;
struct inode *ip;
#ifdef DEBUG
daddr_t odaddr;
struct indir a[NIADDR];
int num;
int i;
#endif /* DEBUG */
struct buf *bp;
SEGUSE *sup;
KASSERT(lbn >= 0); /* no indirect blocks */
if ((error = lfs_rf_valloc(fs, ino, vers, l, &vp)) != 0) {
DLOG((DLOG_RF, "update_meta: ino %d: lfs_rf_valloc"
" returned %d\n", ino, error));
return error;
}
if ((error = lfs_balloc(vp, (lbn << fs->lfs_bshift), size,
NOCRED, 0, &bp)) != 0) {
vput(vp);
return (error);
}
/* No need to write, the block is already on disk */
if (bp->b_oflags & BO_DELWRI) {
LFS_UNLOCK_BUF(bp);
fs->lfs_avail += btofsb(fs, bp->b_bcount);
}
brelse(bp, BC_INVAL);
/*
* Extend the file, if it is not large enough already.
* XXX this is not exactly right, we don't know how much of the
* XXX last block is actually used. We hope that an inode will
* XXX appear later to give the correct size.
*/
ip = VTOI(vp);
if (ip->i_size <= (lbn << fs->lfs_bshift)) {
u_int64_t newsize;
if (lbn < NDADDR)
newsize = ip->i_ffs1_size = (lbn << fs->lfs_bshift) +
(size - fs->lfs_fsize) + 1;
else
newsize = ip->i_ffs1_size = (lbn << fs->lfs_bshift) + 1;
if (ip->i_size < newsize) {
ip->i_size = newsize;
/*
* tell vm our new size for the case the inode won't
* appear later.
*/
uvm_vnp_setsize(vp, newsize);
}
}
lfs_update_single(fs, NULL, vp, lbn, ndaddr, size);
LFS_SEGENTRY(sup, fs, dtosn(fs, ndaddr), bp);
sup->su_nbytes += size;
LFS_WRITESEGENTRY(sup, fs, dtosn(fs, ndaddr), bp);
/* differences here should be due to UNWRITTEN indirect blocks. */
KASSERT((lblkno(fs, ip->i_size) > NDADDR &&
ip->i_lfs_effnblks == ip->i_ffs1_blocks) ||
ip->i_lfs_effnblks >= ip->i_ffs1_blocks);
#ifdef DEBUG
/* Now look again to make sure it worked */
ufs_bmaparray(vp, lbn, &odaddr, &a[0], &num, NULL, NULL);
for (i = num; i > 0; i--) {
if (!a[i].in_exists)
panic("update_meta: absent %d lv indirect block", i);
}
if (dbtofsb(fs, odaddr) != ndaddr)
DLOG((DLOG_RF, "update_meta: failed setting ino %d lbn %"
PRId64 " to %" PRId64 "\n", ino, lbn, ndaddr));
#endif /* DEBUG */
vput(vp);
return 0;
}
/*
* Release blocks associated with the inode ip and stored in the indirect
* block bn. Blocks are free'd in LIFO order up to (but not including)
* lastbn. If level is greater than SINGLE, the block is an indirect block
* and recursive calls to indirtrunc must be used to cleanse other indirect
* blocks.
*
* NB: triple indirect blocks are untested.
*/
static int
lfs_indirtrunc(struct inode *ip, daddr_t lbn, daddr_t dbn,
daddr_t lastbn, int level, daddr_t *countp,
daddr_t *rcountp, long *lastsegp, size_t *bcp)
{
int i;
struct buf *bp;
struct lfs *fs = ip->i_lfs;
int32_t *bap; /* XXX ondisk32 */
struct vnode *vp;
daddr_t nb, nlbn, last;
int32_t *copy = NULL; /* XXX ondisk32 */
daddr_t blkcount, rblkcount, factor;
int nblocks;
daddr_t blocksreleased = 0, real_released = 0;
int error = 0, allerror = 0;
ASSERT_SEGLOCK(fs);
/*
* Calculate index in current block of last
* block to be kept. -1 indicates the entire
* block so we need not calculate the index.
*/
factor = 1;
for (i = SINGLE; i < level; i++)
factor *= LFS_NINDIR(fs);
last = lastbn;
if (lastbn > 0)
last /= factor;
nblocks = lfs_btofsb(fs, lfs_sb_getbsize(fs));
/*
* Get buffer of block pointers, zero those entries corresponding
* to blocks to be free'd, and update on disk copy first. Since
* double(triple) indirect before single(double) indirect, calls
* to bmap on these blocks will fail. However, we already have
* the on disk address, so we have to set the b_blkno field
* explicitly instead of letting bread do everything for us.
*/
vp = ITOV(ip);
bp = getblk(vp, lbn, lfs_sb_getbsize(fs), 0, 0);
if (bp->b_oflags & (BO_DONE | BO_DELWRI)) {
/* Braces must be here in case trace evaluates to nothing. */
trace(TR_BREADHIT, pack(vp, lfs_sb_getbsize(fs)), lbn);
} else {
trace(TR_BREADMISS, pack(vp, lfs_sb_getbsize(fs)), lbn);
curlwp->l_ru.ru_inblock++; /* pay for read */
bp->b_flags |= B_READ;
if (bp->b_bcount > bp->b_bufsize)
panic("lfs_indirtrunc: bad buffer size");
bp->b_blkno = LFS_FSBTODB(fs, dbn);
VOP_STRATEGY(vp, bp);
error = biowait(bp);
}
if (error) {
brelse(bp, 0);
*countp = *rcountp = 0;
return (error);
}
bap = (int32_t *)bp->b_data; /* XXX ondisk32 */
if (lastbn >= 0) {
copy = lfs_malloc(fs, lfs_sb_getbsize(fs), LFS_NB_IBLOCK);
memcpy((void *)copy, (void *)bap, lfs_sb_getbsize(fs));
memset((void *)&bap[last + 1], 0,
/* XXX ondisk32 */
(u_int)(LFS_NINDIR(fs) - (last + 1)) * sizeof (int32_t));
error = VOP_BWRITE(bp->b_vp, bp);
if (error)
allerror = error;
bap = copy;
}
/*
* Recursively free totally unused blocks.
*/
for (i = LFS_NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;
i--, nlbn += factor) {
nb = bap[i];
if (nb == 0)
continue;
if (level > SINGLE) {
error = lfs_indirtrunc(ip, nlbn, nb,
(daddr_t)-1, level - 1,
&blkcount, &rblkcount,
lastsegp, bcp);
if (error)
allerror = error;
blocksreleased += blkcount;
real_released += rblkcount;
}
lfs_blkfree(fs, ip, nb, lfs_sb_getbsize(fs), lastsegp, bcp);
if (bap[i] > 0)
real_released += nblocks;
blocksreleased += nblocks;
}
/*
* Recursively free last partial block.
*/
if (level > SINGLE && lastbn >= 0) {
last = lastbn % factor;
nb = bap[i];
if (nb != 0) {
error = lfs_indirtrunc(ip, nlbn, nb,
last, level - 1, &blkcount,
&rblkcount, lastsegp, bcp);
if (error)
allerror = error;
real_released += rblkcount;
blocksreleased += blkcount;
}
}
if (copy != NULL) {
lfs_free(fs, copy, LFS_NB_IBLOCK);
} else {
mutex_enter(&bufcache_lock);
if (bp->b_oflags & BO_DELWRI) {
LFS_UNLOCK_BUF(bp);
lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));
wakeup(&fs->lfs_availsleep);
}
brelsel(bp, BC_INVAL);
mutex_exit(&bufcache_lock);
}
*countp = blocksreleased;
*rcountp = real_released;
return (allerror);
}
