Exemplo n.º 1
0
/*
 * ext2_reallocblks(struct vnode *a_vp, struct cluster_save *a_buflist)
 */
int
ext2_reallocblks(struct vop_reallocblks_args *ap)
{
#ifndef FANCY_REALLOC
/* kprintf("ext2_reallocblks not implemented\n"); */
return ENOSPC;
#else

	struct ext2_sb_info *fs;
	struct inode *ip;
	struct vnode *vp;
	struct buf *sbp, *ebp;
	daddr_t *bap, *sbap, *ebap;
	struct cluster_save *buflist;
	daddr_t start_lbn, end_lbn, soff, eoff, newblk, blkno;
	struct indir start_ap[NIADDR + 1], end_ap[NIADDR + 1], *idp;
	int i, len, start_lvl, end_lvl, pref, ssize;

	vp = ap->a_vp;
	ip = VTOI(vp);
	fs = ip->i_e2fs;
#ifdef UNKLAR
	if (fs->fs_contigsumsize <= 0)
		return (ENOSPC);
#endif
	buflist = ap->a_buflist;
	len = buflist->bs_nchildren;
	start_lbn = lblkno(fs, buflist->bs_children[0]->b_loffset);
	end_lbn = start_lbn + len - 1;
#if DIAGNOSTIC
	for (i = 1; i < len; i++) {
		if (buflist->bs_children[i]->b_loffset != lblktodoff(fs, start_lbn) + lblktodoff(fs, i))
			panic("ext2_reallocblks: non-cluster");
	}
#endif
	/*
	 * If the latest allocation is in a new block group, assume that
	 * the filesystem has decided to move and do not force it back to
	 * the previous block group.
	 */
	if (dtog(fs, dofftofsb(fs, buflist->bs_children[0]->b_bio2.bio_offset)) !=
	    dtog(fs, dofftofsb(fs, buflist->bs_children[len - 1]->b_bio2.bio_offset)))
		return (ENOSPC);
	if (ext2_getlbns(vp, start_lbn, start_ap, &start_lvl) ||
	    ext2_getlbns(vp, end_lbn, end_ap, &end_lvl))
		return (ENOSPC);
	/*
	 * Get the starting offset and block map for the first block.
	 */
	if (start_lvl == 0) {
		sbap = &ip->i_db[0];
		soff = start_lbn;
	} else {
		idp = &start_ap[start_lvl - 1];
		if (bread(vp, lblktodoff(fs, idp->in_lbn), (int)fs->s_blocksize, NOCRED, &sbp)) {
			brelse(sbp);
			return (ENOSPC);
		}
		sbap = (daddr_t *)sbp->b_data;
		soff = idp->in_off;
	}
	/*
	 * Find the preferred location for the cluster.
	 */
	pref = ext2_blkpref(ip, start_lbn, soff, sbap);
	/*
	 * If the block range spans two block maps, get the second map.
	 */
	if (end_lvl == 0 || (idp = &end_ap[end_lvl - 1])->in_off + 1 >= len) {
		ssize = len;
	} else {
#if DIAGNOSTIC
		if (start_ap[start_lvl-1].in_lbn == idp->in_lbn)
			panic("ext2_reallocblk: start == end");
#endif
		ssize = len - (idp->in_off + 1);
		if (bread(vp, lblktodoff(fs, idp->in_lbn), (int)fs->s_blocksize, NOCRED, &ebp))
			goto fail;
		ebap = (daddr_t *)ebp->b_data;
	}
	/*
	 * Search the block map looking for an allocation of the desired size.
	 */
	if ((newblk = (daddr_t)ext2_hashalloc(ip, dtog(fs, pref), (long)pref,
	    len, (u_long (*)())ext2_clusteralloc)) == 0)
		goto fail;
	/*
	 * We have found a new contiguous block.
	 *
	 * First we have to replace the old block pointers with the new
	 * block pointers in the inode and indirect blocks associated
	 * with the file.
	 */
	blkno = newblk;
	for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->s_frags_per_block) {
		if (i == ssize)
			bap = ebap;
#if DIAGNOSTIC
		if (buflist->bs_children[i]->b_bio2.bio_offset != fsbtodoff(fs, *bap))
			panic("ext2_reallocblks: alloc mismatch");
#endif
		*bap++ = blkno;
	}
	/*
	 * Next we must write out the modified inode and indirect blocks.
	 * For strict correctness, the writes should be synchronous since
	 * the old block values may have been written to disk. In practise
	 * they are almost never written, but if we are concerned about
	 * strict correctness, the `doasyncfree' flag should be set to zero.
	 *
	 * The test on `doasyncfree' should be changed to test a flag
	 * that shows whether the associated buffers and inodes have
	 * been written. The flag should be set when the cluster is
	 * started and cleared whenever the buffer or inode is flushed.
	 * We can then check below to see if it is set, and do the
	 * synchronous write only when it has been cleared.
	 */
	if (sbap != &ip->i_db[0]) {
		if (doasyncfree)
			bdwrite(sbp);
		else
			bwrite(sbp);
	} else {
		ip->i_flag |= IN_CHANGE | IN_UPDATE;
		if (!doasyncfree)
			EXT2_UPDATE(vp, 1);
	}
	if (ssize < len)
		if (doasyncfree)
			bdwrite(ebp);
		else
			bwrite(ebp);
	/*
	 * Last, free the old blocks and assign the new blocks to the buffers.
	 */
	for (blkno = newblk, i = 0; i < len; i++, blkno += fs->s_frags_per_block) {
		ext2_blkfree(ip, dofftofsb(fs, buflist->bs_children[i]->b_bio2.bio_offset),
		    fs->s_blocksize);
		buflist->bs_children[i]->b_bio2.bio_offset = fsbtodoff(fs, blkno);
	}
	return (0);

fail:
	if (ssize < len)
		brelse(ebp);
	if (sbap != &ip->i_db[0])
		brelse(sbp);
	return (ENOSPC);

#endif /* FANCY_REALLOC */
}
Exemplo n.º 2
0
/*
 * Balloc defines the structure of filesystem storage
 * by allocating the physical blocks on a device given
 * the inode and the logical block number in a file.
 */
int
ext2_balloc(struct inode *ip, e2fs_lbn_t lbn, int size, struct ucred *cred,
    struct buf **bpp, int flags)
{
	struct m_ext2fs *fs;
	struct ext2mount *ump;
	struct buf *bp, *nbp;
	struct vnode *vp = ITOV(ip);
	struct indir indirs[NIADDR + 2];
	e4fs_daddr_t nb, newb;
	e2fs_daddr_t *bap, pref;
	int osize, nsize, num, i, error;

	*bpp = NULL;
	if (lbn < 0)
		return (EFBIG);
	fs = ip->i_e2fs;
	ump = ip->i_ump;

	/*
	 * check if this is a sequential block allocation. 
	 * If so, increment next_alloc fields to allow ext2_blkpref 
	 * to make a good guess
	 */
	if (lbn == ip->i_next_alloc_block + 1) {
		ip->i_next_alloc_block++;
		ip->i_next_alloc_goal++;
	}

	/*
	 * The first NDADDR blocks are direct blocks
	 */
	if (lbn < NDADDR) {
		nb = ip->i_db[lbn];
		/* no new block is to be allocated, and no need to expand
		   the file */
		if (nb != 0 && ip->i_size >= (lbn + 1) * fs->e2fs_bsize) {
			error = bread(vp, lbn, fs->e2fs_bsize, NOCRED, &bp);
			if (error) {
				brelse(bp);
				return (error);
			}
			bp->b_blkno = fsbtodb(fs, nb);
			*bpp = bp;
			return (0);
		}
		if (nb != 0) {
			/*
			 * Consider need to reallocate a fragment.
			 */
			osize = fragroundup(fs, blkoff(fs, ip->i_size));
			nsize = fragroundup(fs, size);
			if (nsize <= osize) {
				error = bread(vp, lbn, osize, NOCRED, &bp);
				if (error) {
					brelse(bp);
					return (error);
				}
				bp->b_blkno = fsbtodb(fs, nb);
			} else {
			/* Godmar thinks: this shouldn't happen w/o fragments */
				printf("nsize %d(%d) > osize %d(%d) nb %d\n", 
					(int)nsize, (int)size, (int)osize, 
					(int)ip->i_size, (int)nb);
				panic(
				    "ext2_balloc: Something is terribly wrong");
/*
 * please note there haven't been any changes from here on -
 * FFS seems to work.
 */
			}
		} else {
			if (ip->i_size < (lbn + 1) * fs->e2fs_bsize)
				nsize = fragroundup(fs, size);
			else
				nsize = fs->e2fs_bsize;
			EXT2_LOCK(ump);
			error = ext2_alloc(ip, lbn,
			    ext2_blkpref(ip, lbn, (int)lbn, &ip->i_db[0], 0),
			    nsize, cred, &newb);
			if (error)
				return (error);
			bp = getblk(vp, lbn, nsize, 0, 0, 0);
			bp->b_blkno = fsbtodb(fs, newb);
			if (flags & BA_CLRBUF)
				vfs_bio_clrbuf(bp);
		}
		ip->i_db[lbn] = dbtofsb(fs, bp->b_blkno);
		ip->i_flag |= IN_CHANGE | IN_UPDATE;
		*bpp = bp;
		return (0);
	}
	/*
	 * Determine the number of levels of indirection.
	 */
	pref = 0;
	if ((error = ext2_getlbns(vp, lbn, indirs, &num)) != 0)
		return (error);
#ifdef INVARIANTS
	if (num < 1)
		panic ("ext2_balloc: ext2_getlbns returned indirect block");
#endif
	/*
	 * Fetch the first indirect block allocating if necessary.
	 */
	--num;
	nb = ip->i_ib[indirs[0].in_off];
	if (nb == 0) {
		EXT2_LOCK(ump);
		pref = ext2_blkpref(ip, lbn, indirs[0].in_off + 
					     EXT2_NDIR_BLOCKS, &ip->i_db[0], 0);
		if ((error = ext2_alloc(ip, lbn, pref, fs->e2fs_bsize, cred,
			&newb)))
			return (error);
		nb = newb;
		bp = getblk(vp, indirs[1].in_lbn, fs->e2fs_bsize, 0, 0, 0);
		bp->b_blkno = fsbtodb(fs, newb);
		vfs_bio_clrbuf(bp);
		/*
		 * Write synchronously so that indirect blocks
		 * never point at garbage.
		 */
		if ((error = bwrite(bp)) != 0) {
			ext2_blkfree(ip, nb, fs->e2fs_bsize);
			return (error);
		}
		ip->i_ib[indirs[0].in_off] = newb;
		ip->i_flag |= IN_CHANGE | IN_UPDATE;
	}
	/*
	 * Fetch through the indirect blocks, allocating as necessary.
	 */
	for (i = 1;;) {
		error = bread(vp,
		    indirs[i].in_lbn, (int)fs->e2fs_bsize, NOCRED, &bp);
		if (error) {
			brelse(bp);
			return (error);
		}
		bap = (e2fs_daddr_t *)bp->b_data;
		nb = bap[indirs[i].in_off];
		if (i == num)
			break;
		i += 1;
		if (nb != 0) {
			bqrelse(bp);
			continue;
		}
		EXT2_LOCK(ump);
		if (pref == 0)
			pref = ext2_blkpref(ip, lbn, indirs[i].in_off, bap,
						bp->b_lblkno);
		error =  ext2_alloc(ip, lbn, pref, (int)fs->e2fs_bsize, cred, &newb);
		if (error) {
			brelse(bp);
			return (error);
		}
		nb = newb;
		nbp = getblk(vp, indirs[i].in_lbn, fs->e2fs_bsize, 0, 0, 0);
		nbp->b_blkno = fsbtodb(fs, nb);
		vfs_bio_clrbuf(nbp);
		/*
		 * Write synchronously so that indirect blocks
		 * never point at garbage.
		 */
		if ((error = bwrite(nbp)) != 0) {
			ext2_blkfree(ip, nb, fs->e2fs_bsize);
			EXT2_UNLOCK(ump);
			brelse(bp);
			return (error);
		}
		bap[indirs[i - 1].in_off] = nb;
		/*
		 * If required, write synchronously, otherwise use
		 * delayed write.
		 */
		if (flags & IO_SYNC) {
			bwrite(bp);
		} else {
			if (bp->b_bufsize == fs->e2fs_bsize)
				bp->b_flags |= B_CLUSTEROK;
			bdwrite(bp);
		}
	}
	/*
	 * Get the data block, allocating if necessary.
	 */
	if (nb == 0) {
		EXT2_LOCK(ump);
		pref = ext2_blkpref(ip, lbn, indirs[i].in_off, &bap[0], 
				bp->b_lblkno);
		if ((error = ext2_alloc(ip,
		    lbn, pref, (int)fs->e2fs_bsize, cred, &newb)) != 0) {
			brelse(bp);
			return (error);
		}
		nb = newb;
		nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0, 0);
		nbp->b_blkno = fsbtodb(fs, nb);
		if (flags & BA_CLRBUF)
			vfs_bio_clrbuf(nbp);
		bap[indirs[i].in_off] = nb;
		/*
		 * If required, write synchronously, otherwise use
		 * delayed write.
		 */
		if (flags & IO_SYNC) {
			bwrite(bp);
		} else {
		if (bp->b_bufsize == fs->e2fs_bsize)
				bp->b_flags |= B_CLUSTEROK;
			bdwrite(bp);
		}
		*bpp = nbp;
		return (0);
	}
	brelse(bp);
	if (flags & BA_CLRBUF) {
		int seqcount = (flags & BA_SEQMASK) >> BA_SEQSHIFT;
		if (seqcount && (vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) {
			error = cluster_read(vp, ip->i_size, lbn,
			    (int)fs->e2fs_bsize, NOCRED,
			    MAXBSIZE, seqcount, 0, &nbp);
		} else {
			error = bread(vp, lbn, (int)fs->e2fs_bsize, NOCRED, &nbp);
		}
		if (error) {
			brelse(nbp);
			return (error);
		}
	} else {
Exemplo n.º 3
0
int
ext2_reallocblks(struct vop_reallocblks_args *ap)
{
    struct m_ext2fs *fs;
    struct inode *ip;
    struct vnode *vp;
    struct buf *sbp, *ebp;
    uint32_t *bap, *sbap, *ebap = 0;
    struct ext2mount *ump;
    struct cluster_save *buflist;
    struct indir start_ap[NIADDR + 1], end_ap[NIADDR + 1], *idp;
    e2fs_lbn_t start_lbn, end_lbn;
    int soff;
    e2fs_daddr_t newblk, blkno;
    int i, len, start_lvl, end_lvl, pref, ssize;

    if (doreallocblks == 0)
        return (ENOSPC);

    vp = ap->a_vp;
    ip = VTOI(vp);
    fs = ip->i_e2fs;
    ump = ip->i_ump;

    if (fs->e2fs_contigsumsize <= 0)
        return (ENOSPC);

    buflist = ap->a_buflist;
    len = buflist->bs_nchildren;
    start_lbn = buflist->bs_children[0]->b_lblkno;
    end_lbn = start_lbn + len - 1;
#ifdef INVARIANTS
    for (i = 1; i < len; i++)
        if (buflist->bs_children[i]->b_lblkno != start_lbn + i)
            panic("ext2_reallocblks: non-cluster");
#endif
    /*
     * If the cluster crosses the boundary for the first indirect
     * block, leave space for the indirect block. Indirect blocks
     * are initially laid out in a position after the last direct
     * block. Block reallocation would usually destroy locality by
     * moving the indirect block out of the way to make room for
     * data blocks if we didn't compensate here. We should also do
     * this for other indirect block boundaries, but it is only
     * important for the first one.
     */
    if (start_lbn < NDADDR && end_lbn >= NDADDR)
        return (ENOSPC);
    /*
     * If the latest allocation is in a new cylinder group, assume that
     * the filesystem has decided to move and do not force it back to
     * the previous cylinder group.
     */
    if (dtog(fs, dbtofsb(fs, buflist->bs_children[0]->b_blkno)) !=
            dtog(fs, dbtofsb(fs, buflist->bs_children[len - 1]->b_blkno)))
        return (ENOSPC);
    if (ext2_getlbns(vp, start_lbn, start_ap, &start_lvl) ||
            ext2_getlbns(vp, end_lbn, end_ap, &end_lvl))
        return (ENOSPC);
    /*
     * Get the starting offset and block map for the first block.
     */
    if (start_lvl == 0) {
        sbap = &ip->i_db[0];
        soff = start_lbn;
    } else {
        idp = &start_ap[start_lvl - 1];
        if (bread(vp, idp->in_lbn, (int)fs->e2fs_bsize, NOCRED, &sbp)) {
            brelse(sbp);
            return (ENOSPC);
        }
        sbap = (u_int *)sbp->b_data;
        soff = idp->in_off;
    }
    /*
     * If the block range spans two block maps, get the second map.
     */
    if (end_lvl == 0 || (idp = &end_ap[end_lvl - 1])->in_off + 1 >= len) {
        ssize = len;
    } else {
#ifdef INVARIANTS
        if (start_ap[start_lvl-1].in_lbn == idp->in_lbn)
            panic("ext2_reallocblks: start == end");
#endif
        ssize = len - (idp->in_off + 1);
        if (bread(vp, idp->in_lbn, (int)fs->e2fs_bsize, NOCRED, &ebp))
            goto fail;
        ebap = (u_int *)ebp->b_data;
    }
    /*
     * Find the preferred location for the cluster.
     */
    EXT2_LOCK(ump);
    pref = ext2_blkpref(ip, start_lbn, soff, sbap, 0);
    /*
     * Search the block map looking for an allocation of the desired size.
     */
    if ((newblk = (e2fs_daddr_t)ext2_hashalloc(ip, dtog(fs, pref), pref,
                  len, ext2_clusteralloc)) == 0) {
        EXT2_UNLOCK(ump);
        goto fail;
    }
    /*
     * We have found a new contiguous block.
     *
     * First we have to replace the old block pointers with the new
     * block pointers in the inode and indirect blocks associated
     * with the file.
     */
#ifdef DEBUG
    printf("realloc: ino %d, lbns %jd-%jd\n\told:", ip->i_number,
           (intmax_t)start_lbn, (intmax_t)end_lbn);
#endif /* DEBUG */
    blkno = newblk;
    for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->e2fs_fpb) {
        if (i == ssize) {
            bap = ebap;
            soff = -i;
        }
#ifdef INVARIANTS
        if (buflist->bs_children[i]->b_blkno != fsbtodb(fs, *bap))
            panic("ext2_reallocblks: alloc mismatch");
#endif
#ifdef DEBUG
        printf(" %d,", *bap);
#endif /* DEBUG */
        *bap++ = blkno;
    }
    /*
     * Next we must write out the modified inode and indirect blocks.
     * For strict correctness, the writes should be synchronous since
     * the old block values may have been written to disk. In practise
     * they are almost never written, but if we are concerned about
     * strict correctness, the `doasyncfree' flag should be set to zero.
     *
     * The test on `doasyncfree' should be changed to test a flag
     * that shows whether the associated buffers and inodes have
     * been written. The flag should be set when the cluster is
     * started and cleared whenever the buffer or inode is flushed.
     * We can then check below to see if it is set, and do the
     * synchronous write only when it has been cleared.
     */
    if (sbap != &ip->i_db[0]) {
        if (doasyncfree)
            bdwrite(sbp);
        else
            bwrite(sbp);
    } else {
        ip->i_flag |= IN_CHANGE | IN_UPDATE;
        if (!doasyncfree)
            ext2_update(vp, 1);
    }
    if (ssize < len) {
        if (doasyncfree)
            bdwrite(ebp);
        else
            bwrite(ebp);
    }
    /*
     * Last, free the old blocks and assign the new blocks to the buffers.
     */
#ifdef DEBUG
    printf("\n\tnew:");
#endif /* DEBUG */
    for (blkno = newblk, i = 0; i < len; i++, blkno += fs->e2fs_fpb) {
        ext2_blkfree(ip, dbtofsb(fs, buflist->bs_children[i]->b_blkno),
                     fs->e2fs_bsize);
        buflist->bs_children[i]->b_blkno = fsbtodb(fs, blkno);
#ifdef DEBUG
        printf(" %d,", blkno);
#endif /* DEBUG */
    }
#ifdef DEBUG
    printf("\n");
#endif /* DEBUG */
    return (0);

fail:
    if (ssize < len)
        brelse(ebp);
    if (sbap != &ip->i_db[0])
        brelse(sbp);
    return (ENOSPC);
}