/*
* 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
ffs_indirtrunc(struct inode *ip, ufs_daddr_t lbn, ufs_daddr_t dbn,
ufs_daddr_t lastbn, int level, long *countp)
{
int i;
struct buf *bp;
struct fs *fs = ip->i_fs;
ufs_daddr_t *bap;
struct vnode *vp;
ufs_daddr_t *copy = NULL, nb, nlbn, last;
long blkcount, factor;
int nblocks, blocksreleased = 0;
int error = 0, allerror = 0;
/*
* 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 *= NINDIR(fs);
last = lastbn;
if (lastbn > 0)
last /= factor;
nblocks = btodb(fs->fs_bsize);
/*
* 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 bio_offset field
* explicitly instead of letting bread do everything for us.
*/
vp = ITOV(ip);
bp = getblk(vp, lblktodoff(fs, lbn), (int)fs->fs_bsize, 0, 0);
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags &= ~(B_ERROR|B_INVAL);
bp->b_cmd = BUF_CMD_READ;
if (bp->b_bcount > bp->b_bufsize)
panic("ffs_indirtrunc: bad buffer size");
/*
* BIO is bio2 which chains back to bio1. We wait
* on bio1.
*/
bp->b_bio2.bio_offset = dbtodoff(fs, dbn);
bp->b_bio1.bio_done = biodone_sync;
bp->b_bio1.bio_flags |= BIO_SYNC;
vfs_busy_pages(vp, bp);
/*
* Access the block device layer using the device vnode
* and the translated block number (bio2) instead of the
* file vnode (vp) and logical block number (bio1).
*
* Even though we are bypassing the vnode layer, we still
* want the vnode state to indicate that an I/O on its behalf
* is in progress.
*/
bio_start_transaction(&bp->b_bio1, &vp->v_track_read);
vn_strategy(ip->i_devvp, &bp->b_bio2);
error = biowait(&bp->b_bio1, "biord");
}
if (error) {
brelse(bp);
*countp = 0;
return (error);
}
bap = (ufs_daddr_t *)bp->b_data;
if (lastbn != -1) {
copy = kmalloc(fs->fs_bsize, M_TEMP, M_WAITOK);
bcopy((caddr_t)bap, (caddr_t)copy, (uint)fs->fs_bsize);
bzero((caddr_t)&bap[last + 1],
(uint)(NINDIR(fs) - (last + 1)) * sizeof (ufs_daddr_t));
if (DOINGASYNC(vp)) {
bawrite(bp);
} else {
error = bwrite(bp);
if (error)
allerror = error;
}
bap = copy;
}
/*
* Recursively free totally unused blocks.
*/
for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;
i--, nlbn += factor) {
nb = bap[i];
if (nb == 0)
continue;
if (level > SINGLE) {
if ((error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
(ufs_daddr_t)-1, level - 1, &blkcount)) != 0)
allerror = error;
blocksreleased += blkcount;
}
ffs_blkfree(ip, nb, fs->fs_bsize);
blocksreleased += nblocks;
}
/*
* Recursively free last partial block.
*/
if (level > SINGLE && lastbn >= 0) {
last = lastbn % factor;
nb = bap[i];
if (nb != 0) {
error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
last, level - 1, &blkcount);
if (error)
allerror = error;
blocksreleased += blkcount;
}
}
if (copy != NULL) {
kfree(copy, M_TEMP);
} else {
bp->b_flags |= B_INVAL | B_NOCACHE;
brelse(bp);
}
*countp = blocksreleased;
return (allerror);
}
static int
ffs_rawread_readahead(struct vnode *vp, caddr_t udata, off_t loffset,
size_t len, struct buf *bp)
{
int error;
int iolen;
int blockoff;
int bsize;
struct vnode *dp;
int bforwards;
bsize = vp->v_mount->mnt_stat.f_iosize;
/*
* Make sure it fits into the pbuf
*/
iolen = (int)(intptr_t)udata & PAGE_MASK;
if (len + iolen > bp->b_kvasize) {
len = bp->b_kvasize;
if (iolen != 0)
len -= PAGE_SIZE;
}
/*
* Raw disk address is in bio2, but we wait for it to
* chain to bio1.
*/
bp->b_flags &= ~B_ERROR;
bp->b_loffset = loffset;
bp->b_bio2.bio_offset = NOOFFSET;
bp->b_bio1.bio_done = biodone_sync;
bp->b_bio1.bio_flags |= BIO_SYNC;
blockoff = (loffset % bsize) / DEV_BSIZE;
error = VOP_BMAP(vp, bp->b_loffset, &bp->b_bio2.bio_offset,
&bforwards, NULL, BUF_CMD_READ);
if (error != 0)
return error;
dp = VTOI(vp)->i_devvp;
if (bp->b_bio2.bio_offset == NOOFFSET) {
/*
* Fill holes with NULs to preserve semantics
*/
if (len + blockoff * DEV_BSIZE > bsize)
len = bsize - blockoff * DEV_BSIZE;
if (vmapbuf(bp, udata, len) < 0)
return EFAULT;
lwkt_user_yield();
bzero(bp->b_data, bp->b_bcount);
/* Mark operation completed (similar to bufdone()) */
bp->b_resid = 0;
return 0;
}
if (len + blockoff * DEV_BSIZE > bforwards)
len = bforwards - blockoff * DEV_BSIZE;
bp->b_bio2.bio_offset += blockoff * DEV_BSIZE;
if (vmapbuf(bp, udata, len) < 0)
return EFAULT;
/*
* Access the block device layer using the device vnode (dp) and
* the translated block number (bio2) instead of the logical block
* number (bio1).
*
* Even though we are bypassing the vnode layer, we still
* want the vnode state to indicate that an I/O on its behalf
* is in progress.
*/
bp->b_cmd = BUF_CMD_READ;
bio_start_transaction(&bp->b_bio1, &vp->v_track_read);
vn_strategy(dp, &bp->b_bio2);
return 0;
}
