This commit adds basic support for the UFS2 filesystem. The UFS2

filesystem expands the inode to 256 bytes to make space for 64-bit
block pointers. It also adds a file-creation time field, an ability
to use jumbo blocks per inode to allow extent like pointer density,
and space for extended attributes (up to twice the filesystem block
size worth of attributes, e.g., on a 16K filesystem, there is space
for 32K of attributes). UFS2 fully supports and runs existing UFS1
filesystems. New filesystems built using newfs can be built in either
UFS1 or UFS2 format using the -O option. In this commit UFS1 is
the default format, so if you want to build UFS2 format filesystems,
you must specify -O 2. This default will be changed to UFS2 when
UFS2 proves itself to be stable. In this commit the boot code for
reading UFS2 filesystems is not compiled (see /sys/boot/common/ufsread.c)
as there is insufficient space in the boot block. Once the size of the
boot block is increased, this code can be defined.

Things to note: the definition of SBSIZE has changed to SBLOCKSIZE.
The header file <ufs/ufs/dinode.h> must be included before
<ufs/ffs/fs.h> so as to get the definitions of ufs2_daddr_t and
ufs_lbn_t.

Still TODO:
Verify that the first level bootstraps work for all the architectures.
Convert the utility ffsinfo to understand UFS2 and test growfs.
Add support for the extended attribute storage. Update soft updates
to ensure integrity of extended attribute storage. Switch the
current extended attribute interfaces to use the extended attribute
storage. Add the extent like functionality (framework is there,
but is currently never used).

Sponsored by: DARPA & NAI Labs.
Reviewed by:	Poul-Henning Kamp <phk@freebsd.org>

1 files changed, 399 insertions, 43 deletions

diff --git a/sys/ufs/ffs/ffs_balloc.c b/sys/ufs/ffs/ffs_balloc.c
index b2e3595..6b00abd 100644
--- a/sys/ufs/ffs/ffs_balloc.c
+++ b/sys/ufs/ffs/ffs_balloc.c
@@ -1,4 +1,16 @@
 /*
+ * Copyright (c) 2002 Networks Associates Technology, Inc.
+ * All rights reserved.
+ *
+ * This software was developed for the FreeBSD Project by Marshall
+ * Kirk McKusick and Network Associates Laboratories, the Security
+ * Research Division of Network Associates, Inc. under DARPA/SPAWAR
+ * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
+ * research program
+ *
+ * Copyright (c) 1982, 1989, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
  * Copyright (c) 1982, 1986, 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  *
@@ -53,60 +65,402 @@
  * 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.
+ * This is the allocation strategy for UFS1. Below is
+ * the allocation strategy for UFS2.
+ */
+int
+ffs_balloc_ufs1(struct vnode *vp, off_t startoffset, int size,
+    struct ucred *cred, int flags, struct buf **bpp)
+{
+	struct inode *ip;
+	ufs_lbn_t lbn, lastlbn;
+	struct fs *fs;
+	ufs1_daddr_t nb;
+	struct buf *bp, *nbp;
+	struct indir indirs[NIADDR + 2];
+	int deallocated, osize, nsize, num, i, error;
+	ufs2_daddr_t newb;
+	ufs1_daddr_t *bap, pref;
+	ufs1_daddr_t *allocib, *blkp, *allocblk, allociblk[NIADDR + 1];
+	int unwindidx = -1;
+	struct thread *td = curthread;	/* XXX */
+
+	ip = VTOI(vp);
+	fs = ip->i_fs;
+	lbn = lblkno(fs, startoffset);
+	size = blkoff(fs, startoffset) + size;
+	if (size > fs->fs_bsize)
+		panic("ffs_balloc_ufs1: blk too big");
+	*bpp = NULL;
+	if (lbn < 0)
+		return (EFBIG);
+
+	/*
+	 * If the next write will extend the file into a new block,
+	 * and the file is currently composed of a fragment
+	 * this fragment has to be extended to be a full block.
+	 */
+	lastlbn = lblkno(fs, ip->i_size);
+	if (lastlbn < NDADDR && lastlbn < lbn) {
+		nb = lastlbn;
+		osize = blksize(fs, ip, nb);
+		if (osize < fs->fs_bsize && osize > 0) {
+			error = ffs_realloccg(ip, nb,
+				ffs_blkpref_ufs1(ip, lastlbn, (int)nb,
+				    &ip->i_din1->di_db[0]),
+				osize, (int)fs->fs_bsize, cred, &bp);
+			if (error)
+				return (error);
+			if (DOINGSOFTDEP(vp))
+				softdep_setup_allocdirect(ip, nb,
+				    dbtofsb(fs, bp->b_blkno),
+				    ip->i_din1->di_db[nb],
+				    fs->fs_bsize, osize, bp);
+			ip->i_size = smalllblktosize(fs, nb + 1);
+			ip->i_din1->di_size = ip->i_size;
+			ip->i_din1->di_db[nb] = dbtofsb(fs, bp->b_blkno);
+			ip->i_flag |= IN_CHANGE | IN_UPDATE;
+			if (flags & B_SYNC)
+				bwrite(bp);
+			else
+				bawrite(bp);
+		}
+	}
+	/*
+	 * The first NDADDR blocks are direct blocks
+	 */
+	if (lbn < NDADDR) {
+		if (flags & B_METAONLY)
+			panic("ffs_balloc_ufs1: B_METAONLY for direct block");
+		nb = ip->i_din1->di_db[lbn];
+		if (nb != 0 && ip->i_size >= smalllblktosize(fs, lbn + 1)) {
+			error = bread(vp, lbn, fs->fs_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 {
+				error = ffs_realloccg(ip, lbn,
+				    ffs_blkpref_ufs1(ip, lbn, (int)lbn,
+					&ip->i_din1->di_db[0]),
+				    osize, nsize, cred, &bp);
+				if (error)
+					return (error);
+				if (DOINGSOFTDEP(vp))
+					softdep_setup_allocdirect(ip, lbn,
+					    dbtofsb(fs, bp->b_blkno), nb,
+					    nsize, osize, bp);
+			}
+		} else {
+			if (ip->i_size < smalllblktosize(fs, lbn + 1))
+				nsize = fragroundup(fs, size);
+			else
+				nsize = fs->fs_bsize;
+			error = ffs_alloc(ip, lbn,
+			    ffs_blkpref_ufs1(ip, lbn, (int)lbn,
+				&ip->i_din1->di_db[0]),
+			    nsize, cred, &newb);
+			if (error)
+				return (error);
+			bp = getblk(vp, lbn, nsize, 0, 0);
+			bp->b_blkno = fsbtodb(fs, newb);
+			if (flags & B_CLRBUF)
+				vfs_bio_clrbuf(bp);
+			if (DOINGSOFTDEP(vp))
+				softdep_setup_allocdirect(ip, lbn, newb, 0,
+				    nsize, 0, bp);
+		}
+		ip->i_din1->di_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 = ufs_getlbns(vp, lbn, indirs, &num)) != 0)
+		return(error);
+#ifdef DIAGNOSTIC
+	if (num < 1)
+		panic ("ffs_balloc_ufs1: ufs_getlbns returned indirect block");
+#endif
+	/*
+	 * Fetch the first indirect block allocating if necessary.
+	 */
+	--num;
+	nb = ip->i_din1->di_ib[indirs[0].in_off];
+	allocib = NULL;
+	allocblk = allociblk;
+	if (nb == 0) {
+		pref = ffs_blkpref_ufs1(ip, lbn, 0, (ufs1_daddr_t *)0);
+	        if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,
+		    cred, &newb)) != 0)
+			return (error);
+		nb = newb;
+		*allocblk++ = nb;
+		bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0);
+		bp->b_blkno = fsbtodb(fs, nb);
+		vfs_bio_clrbuf(bp);
+		if (DOINGSOFTDEP(vp)) {
+			softdep_setup_allocdirect(ip, NDADDR + indirs[0].in_off,
+			    newb, 0, fs->fs_bsize, 0, bp);
+			bdwrite(bp);
+		} else {
+			/*
+			 * Write synchronously so that indirect blocks
+			 * never point at garbage.
+			 */
+			if (DOINGASYNC(vp))
+				bdwrite(bp);
+			else if ((error = bwrite(bp)) != 0)
+				goto fail;
+		}
+		allocib = &ip->i_din1->di_ib[indirs[0].in_off];
+		*allocib = nb;
+		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->fs_bsize, NOCRED, &bp);
+		if (error) {
+			brelse(bp);
+			goto fail;
+		}
+		bap = (ufs1_daddr_t *)bp->b_data;
+		nb = bap[indirs[i].in_off];
+		if (i == num)
+			break;
+		i += 1;
+		if (nb != 0) {
+			bqrelse(bp);
+			continue;
+		}
+		if (pref == 0)
+			pref = ffs_blkpref_ufs1(ip, lbn, 0, (ufs1_daddr_t *)0);
+		if ((error =
+		    ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred, &newb)) != 0) {
+			brelse(bp);
+			goto fail;
+		}
+		nb = newb;
+		*allocblk++ = nb;
+		nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0);
+		nbp->b_blkno = fsbtodb(fs, nb);
+		vfs_bio_clrbuf(nbp);
+		if (DOINGSOFTDEP(vp)) {
+			softdep_setup_allocindir_meta(nbp, ip, bp,
+			    indirs[i - 1].in_off, nb);
+			bdwrite(nbp);
+		} else {
+			/*
+			 * Write synchronously so that indirect blocks
+			 * never point at garbage.
+			 */
+			if ((error = bwrite(nbp)) != 0) {
+				brelse(bp);
+				goto fail;
+			}
+		}
+		bap[indirs[i - 1].in_off] = nb;
+		if (allocib == NULL && unwindidx < 0)
+			unwindidx = i - 1;
+		/*
+		 * If required, write synchronously, otherwise use
+		 * delayed write.
+		 */
+		if (flags & B_SYNC) {
+			bwrite(bp);
+		} else {
+			if (bp->b_bufsize == fs->fs_bsize)
+				bp->b_flags |= B_CLUSTEROK;
+			bdwrite(bp);
+		}
+	}
+	/*
+	 * If asked only for the indirect block, then return it.
+	 */
+	if (flags & B_METAONLY) {
+		*bpp = bp;
+		return (0);
+	}
+	/*
+	 * Get the data block, allocating if necessary.
+	 */
+	if (nb == 0) {
+		pref = ffs_blkpref_ufs1(ip, lbn, indirs[i].in_off, &bap[0]);
+		error = ffs_alloc(ip,
+		    lbn, pref, (int)fs->fs_bsize, cred, &newb);
+		if (error) {
+			brelse(bp);
+			goto fail;
+		}
+		nb = newb;
+		*allocblk++ = nb;
+		nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
+		nbp->b_blkno = fsbtodb(fs, nb);
+		if (flags & B_CLRBUF)
+			vfs_bio_clrbuf(nbp);
+		if (DOINGSOFTDEP(vp))
+			softdep_setup_allocindir_page(ip, lbn, bp,
+			    indirs[i].in_off, nb, 0, nbp);
+		bap[indirs[i].in_off] = nb;
+		/*
+		 * If required, write synchronously, otherwise use
+		 * delayed write.
+		 */
+		if (flags & B_SYNC) {
+			bwrite(bp);
+		} else {
+			if (bp->b_bufsize == fs->fs_bsize)
+				bp->b_flags |= B_CLUSTEROK;
+			bdwrite(bp);
+		}
+		*bpp = nbp;
+		return (0);
+	}
+	brelse(bp);
+	if (flags & B_CLRBUF) {
+		error = bread(vp, lbn, (int)fs->fs_bsize, NOCRED, &nbp);
+		if (error) {
+			brelse(nbp);
+			goto fail;
+		}
+	} else {
+		nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
+		nbp->b_blkno = fsbtodb(fs, nb);
+	}
+	*bpp = nbp;
+	return (0);
+fail:
+	/*
+	 * If we have failed part way through block allocation, we
+	 * have to deallocate any indirect blocks that we have allocated.
+	 * We have to fsync the file before we start to get rid of all
+	 * of its dependencies so that we do not leave them dangling.
+	 * We have to sync it at the end so that the soft updates code
+	 * does not find any untracked changes. Although this is really
+	 * slow, running out of disk space is not expected to be a common
+	 * occurence. The error return from fsync is ignored as we already
+	 * have an error to return to the user.
+	 */
+	(void) VOP_FSYNC(vp, cred, MNT_WAIT, td);
+	for (deallocated = 0, blkp = allociblk; blkp < allocblk; blkp++) {
+		ffs_blkfree(fs, ip->i_devvp, *blkp, fs->fs_bsize, ip->i_number);
+		deallocated += fs->fs_bsize;
+	}
+	if (allocib != NULL) {
+		*allocib = 0;
+	} else if (unwindidx >= 0) {
+		int r;
+
+		r = bread(vp, indirs[unwindidx].in_lbn, 
+		    (int)fs->fs_bsize, NOCRED, &bp);
+		if (r) {
+			panic("Could not unwind indirect block, error %d", r);
+			brelse(bp);
+		} else {
+			bap = (ufs1_daddr_t *)bp->b_data;
+			bap[indirs[unwindidx].in_off] = 0;
+			if (flags & B_SYNC) {
+				bwrite(bp);
+			} else {
+				if (bp->b_bufsize == fs->fs_bsize)
+					bp->b_flags |= B_CLUSTEROK;
+				bdwrite(bp);
+			}
+		}
+	}
+	if (deallocated) {
+#ifdef QUOTA
+		/*
+		 * Restore user's disk quota because allocation failed.
+		 */
+		(void) chkdq(ip, -btodb(deallocated), cred, FORCE);
+#endif
+		ip->i_din1->di_blocks -= btodb(deallocated);
+		ip->i_flag |= IN_CHANGE | IN_UPDATE;
+	}
+	(void) VOP_FSYNC(vp, cred, MNT_WAIT, td);
+	return (error);
+}
+
+/*
+ * Balloc defines the structure of file system storage
+ * by allocating the physical blocks on a device given
+ * the inode and the logical block number in a file.
+ * This is the allocation strategy for UFS2. Above is
+ * the allocation strategy for UFS1.
  */
 int
-ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
-    struct ucred *a_cred, int a_flags, struct buf **a_bpp)
+ffs_balloc_ufs2(struct vnode *vp, off_t startoffset, int size,
+    struct ucred *cred, int flags, struct buf **bpp)
 {
 	struct inode *ip;
-	ufs_daddr_t lbn;
-	int size;
-	struct ucred *cred;
-	int flags;
+	ufs_lbn_t lbn, lastlbn;
 	struct fs *fs;
-	ufs_daddr_t nb;
 	struct buf *bp, *nbp;
-	struct vnode *vp;
 	struct indir indirs[NIADDR + 2];
-	ufs_daddr_t newb, *bap, pref;
+	ufs2_daddr_t nb, newb, *bap, pref;
+	ufs2_daddr_t *allocib, *blkp, *allocblk, allociblk[NIADDR + 1];
 	int deallocated, osize, nsize, num, i, error;
-	ufs_daddr_t *allocib, *blkp, *allocblk, allociblk[NIADDR + 1];
 	int unwindidx = -1;
 	struct thread *td = curthread;	/* XXX */
 
-	vp = a_vp;
 	ip = VTOI(vp);
 	fs = ip->i_fs;
-	lbn = lblkno(fs, a_startoffset);
-	size = blkoff(fs, a_startoffset) + a_size;
+	lbn = lblkno(fs, startoffset);
+	size = blkoff(fs, startoffset) + size;
 	if (size > fs->fs_bsize)
-		panic("ffs_balloc: blk too big");
-	*a_bpp = NULL;
+		panic("ffs_balloc_ufs2: blk too big");
+	*bpp = NULL;
 	if (lbn < 0)
 		return (EFBIG);
-	cred = a_cred;
-	flags = a_flags;
 
 	/*
 	 * If the next write will extend the file into a new block,
 	 * and the file is currently composed of a fragment
 	 * this fragment has to be extended to be a full block.
 	 */
-	nb = lblkno(fs, ip->i_size);
-	if (nb < NDADDR && nb < lbn) {
+	lastlbn = lblkno(fs, ip->i_size);
+	if (lastlbn < NDADDR && lastlbn < lbn) {
+		nb = lastlbn;
 		osize = blksize(fs, ip, nb);
 		if (osize < fs->fs_bsize && osize > 0) {
 			error = ffs_realloccg(ip, nb,
-				ffs_blkpref(ip, nb, (int)nb, &ip->i_db[0]),
+				ffs_blkpref_ufs2(ip, lastlbn, (int)nb,
+				    &ip->i_din2->di_db[0]),
 				osize, (int)fs->fs_bsize, cred, &bp);
 			if (error)
 				return (error);
 			if (DOINGSOFTDEP(vp))
 				softdep_setup_allocdirect(ip, nb,
-				    dbtofsb(fs, bp->b_blkno), ip->i_db[nb],
+				    dbtofsb(fs, bp->b_blkno),
+				    ip->i_din2->di_db[nb],
 				    fs->fs_bsize, osize, bp);
 			ip->i_size = smalllblktosize(fs, nb + 1);
-			ip->i_db[nb] = dbtofsb(fs, bp->b_blkno);
+			ip->i_din2->di_size = ip->i_size;
+			ip->i_din2->di_db[nb] = dbtofsb(fs, bp->b_blkno);
 			ip->i_flag |= IN_CHANGE | IN_UPDATE;
 			if (flags & B_SYNC)
 				bwrite(bp);
@@ -119,8 +473,8 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 	 */
 	if (lbn < NDADDR) {
 		if (flags & B_METAONLY)
-			panic("ffs_balloc: B_METAONLY for direct block");
-		nb = ip->i_db[lbn];
+			panic("ffs_balloc_ufs2: B_METAONLY for direct block");
+		nb = ip->i_din2->di_db[lbn];
 		if (nb != 0 && ip->i_size >= smalllblktosize(fs, lbn + 1)) {
 			error = bread(vp, lbn, fs->fs_bsize, NOCRED, &bp);
 			if (error) {
@@ -128,7 +482,7 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 				return (error);
 			}
 			bp->b_blkno = fsbtodb(fs, nb);
-			*a_bpp = bp;
+			*bpp = bp;
 			return (0);
 		}
 		if (nb != 0) {
@@ -146,8 +500,9 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 				bp->b_blkno = fsbtodb(fs, nb);
 			} else {
 				error = ffs_realloccg(ip, lbn,
-				    ffs_blkpref(ip, lbn, (int)lbn,
-					&ip->i_db[0]), osize, nsize, cred, &bp);
+				    ffs_blkpref_ufs2(ip, lbn, (int)lbn,
+					&ip->i_din2->di_db[0]),
+				    osize, nsize, cred, &bp);
 				if (error)
 					return (error);
 				if (DOINGSOFTDEP(vp))
@@ -161,7 +516,8 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 			else
 				nsize = fs->fs_bsize;
 			error = ffs_alloc(ip, lbn,
-			    ffs_blkpref(ip, lbn, (int)lbn, &ip->i_db[0]),
+			    ffs_blkpref_ufs2(ip, lbn, (int)lbn,
+				&ip->i_din2->di_db[0]),
 			    nsize, cred, &newb);
 			if (error)
 				return (error);
@@ -173,9 +529,9 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 				softdep_setup_allocdirect(ip, lbn, newb, 0,
 				    nsize, 0, bp);
 		}
-		ip->i_db[lbn] = dbtofsb(fs, bp->b_blkno);
+		ip->i_din2->di_db[lbn] = dbtofsb(fs, bp->b_blkno);
 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
-		*a_bpp = bp;
+		*bpp = bp;
 		return (0);
 	}
 	/*
@@ -186,17 +542,17 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 		return(error);
 #ifdef DIAGNOSTIC
 	if (num < 1)
-		panic ("ffs_balloc: ufs_bmaparray returned indirect block");
+		panic ("ffs_balloc_ufs2: ufs_getlbns returned indirect block");
 #endif
 	/*
 	 * Fetch the first indirect block allocating if necessary.
 	 */
 	--num;
-	nb = ip->i_ib[indirs[0].in_off];
+	nb = ip->i_din2->di_ib[indirs[0].in_off];
 	allocib = NULL;
 	allocblk = allociblk;
 	if (nb == 0) {
-		pref = ffs_blkpref(ip, lbn, 0, (ufs_daddr_t *)0);
+		pref = ffs_blkpref_ufs2(ip, lbn, 0, (ufs2_daddr_t *)0);
 	        if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,
 		    cred, &newb)) != 0)
 			return (error);
@@ -219,7 +575,7 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 			else if ((error = bwrite(bp)) != 0)
 				goto fail;
 		}
-		allocib = &ip->i_ib[indirs[0].in_off];
+		allocib = &ip->i_din2->di_ib[indirs[0].in_off];
 		*allocib = nb;
 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
 	}
@@ -233,7 +589,7 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 			brelse(bp);
 			goto fail;
 		}
-		bap = (ufs_daddr_t *)bp->b_data;
+		bap = (ufs2_daddr_t *)bp->b_data;
 		nb = bap[indirs[i].in_off];
 		if (i == num)
 			break;
@@ -243,7 +599,7 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 			continue;
 		}
 		if (pref == 0)
-			pref = ffs_blkpref(ip, lbn, 0, (ufs_daddr_t *)0);
+			pref = ffs_blkpref_ufs2(ip, lbn, 0, (ufs2_daddr_t *)0);
 		if ((error =
 		    ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred, &newb)) != 0) {
 			brelse(bp);
@@ -287,14 +643,14 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 	 * If asked only for the indirect block, then return it.
 	 */
 	if (flags & B_METAONLY) {
-		*a_bpp = bp;
+		*bpp = bp;
 		return (0);
 	}
 	/*
 	 * Get the data block, allocating if necessary.
 	 */
 	if (nb == 0) {
-		pref = ffs_blkpref(ip, lbn, indirs[i].in_off, &bap[0]);
+		pref = ffs_blkpref_ufs2(ip, lbn, indirs[i].in_off, &bap[0]);
 		error = ffs_alloc(ip,
 		    lbn, pref, (int)fs->fs_bsize, cred, &newb);
 		if (error) {
@@ -322,7 +678,7 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 				bp->b_flags |= B_CLUSTEROK;
 			bdwrite(bp);
 		}
-		*a_bpp = nbp;
+		*bpp = nbp;
 		return (0);
 	}
 	brelse(bp);
@@ -336,7 +692,7 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size,
 		nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
 		nbp->b_blkno = fsbtodb(fs, nb);
 	}
-	*a_bpp = nbp;
+	*bpp = nbp;
 	return (0);
 fail:
 	/*
@@ -366,7 +722,7 @@ fail:
 			panic("Could not unwind indirect block, error %d", r);
 			brelse(bp);
 		} else {
-			bap = (ufs_daddr_t *)bp->b_data;
+			bap = (ufs2_daddr_t *)bp->b_data;
 			bap[indirs[unwindidx].in_off] = 0;
 			if (flags & B_SYNC) {
 				bwrite(bp);
@@ -382,9 +738,9 @@ fail:
 		/*
 		 * Restore user's disk quota because allocation failed.
 		 */
-		(void) chkdq(ip, (long)-btodb(deallocated), cred, FORCE);
+		(void) chkdq(ip, -btodb(deallocated), cred, FORCE);
 #endif
-		ip->i_blocks -= btodb(deallocated);
+		ip->i_din2->di_blocks -= btodb(deallocated);
 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
 	}
 	(void) VOP_FSYNC(vp, cred, MNT_WAIT, td);