 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs_accessors.h,v 1.20 2015/09/01 06:12:33 dholland Exp $	*/
+/*	$NetBSD: lfs_accessors.h,v 1.21 2015/09/01 06:13:09 dholland Exp $	*/
 /*  from NetBSD: lfs.h,v 1.165 2015/07/24 06:59:32 dholland Exp  */
 /*  from NetBSD: dinode.h,v 1.22 2013/01/22 09:39:18 dholland Exp  */
 /*  from NetBSD: dir.h,v 1.21 2009/07/22 04:49:19 dholland Exp  */
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 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
 @@ -204,31 +204,26 @@
 /*
  * dinodes
  */
 /*
  * Maximum length of a symlink that can be stored within the inode.
  */
 #define LFS32_MAXSYMLINKLEN	((ULFS_NDADDR + ULFS_NIADDR) * sizeof(int32_t))
 #define LFS64_MAXSYMLINKLEN	((ULFS_NDADDR + ULFS_NIADDR) * sizeof(int64_t))
 #define LFS_MAXSYMLINKLEN(fs) \
 	((fs)->lfs_is64 ? LFS64_MAXSYMLINKLEN : LFS32_MAXSYMLINKLEN)
 /* get rid of this eventually */
 #define ULFS_MAXSYMLINKLEN(ip) \
 	((ip)->i_ump->um_fstype == ULFS1) ? \
 	LFS32_MAXSYMLINKLEN : LFS64_MAXSYMLINKLEN
 #define DINOSIZE(fs) ((fs)->lfs_is64 ? sizeof(struct lfs64_dinode) : sizeof(struct lfs32_dinode))
 #define DINO_IN_BLOCK(fs, base, ix) \
 	((union lfs_dinode *)((char *)(base) + DINOSIZE(fs) * (ix)))
 static __unused inline void
 lfs_copy_dinode(STRUCT_LFS *fs,
     union lfs_dinode *dst, const union lfs_dinode *src)
+{
 	/*
 	 * We can do structure assignment of the structs, but not of
 	 * the whole union, as the union is the size of the (larger)
 	 * 64-bit struct and on a 32-bit fs the upper half of it might

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs_inode.c,v 1.146 2015/09/01 06:08:37 dholland Exp $	*/
+/*	$NetBSD: lfs_inode.c,v 1.147 2015/09/01 06:13:09 dholland Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 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.
 @@ -50,27 +50,27 @@
  * 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_inode.c	8.9 (Berkeley) 5/8/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_inode.c,v 1.146 2015/09/01 06:08:37 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_inode.c,v 1.147 2015/09/01 06:13:09 dholland Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_quota.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/mount.h>
 #include <sys/malloc.h>
 #include <sys/proc.h>
 #include <sys/file.h>
 #include <sys/buf.h>
 #include <sys/vnode.h>
 @@ -716,30 +716,30 @@ lfs_finalize_fs_seguse(struct lfs *fs)
  * 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 */
+	void *bap;
 	bool bap_needs_free;
 	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++)
 @@ -767,82 +767,90 @@ lfs_indirtrunc(struct inode *ip, daddr_t
 		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));
+		 * We still need this block, so copy the data for
-		memset((void *)&bap[last + 1], 0,
+		 * subsequent processing; then in the original block,
-		/* XXX ondisk32 */
+		 * zero out the dying block pointers and send it off.
-		  (u_int)(LFS_NINDIR(fs) - (last + 1)) * sizeof (int32_t));
+		 */
 		bap = lfs_malloc(fs, lfs_sb_getbsize(fs), LFS_NB_IBLOCK);
 		memcpy(bap, bp->b_data, lfs_sb_getbsize(fs));
 		bap_needs_free = true;
 		for (i = last + 1; i < LFS_NINDIR(fs); i++) {
 			lfs_iblock_set(fs, bp->b_data, i, 0);
+		}
 		error = VOP_BWRITE(bp->b_vp, bp);
 		if (error)
 			allerror = error;
-		bap = copy;
+	} else {
 		bap = bp->b_data;
 		bap_needs_free = false;
+	}
 	/*
 	 * Recursively free totally unused blocks.
 	 */
 	for (i = LFS_NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;
 	    i--, nlbn += factor) {
-		nb = bap[i];
+		nb = lfs_iblock_get(fs, 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)
+		if (lfs_iblock_get(fs, bap, i) > 0)
 			real_released += nblocks;
 		blocksreleased += nblocks;
+	}
 	/*
 	 * Recursively free last partial block.
 	 */
 	if (level > SINGLE && lastbn >= 0) {
 		last = lastbn % factor;
-		nb = bap[i];
+		nb = lfs_iblock_get(fs, 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) {
+	if (bap_needs_free) {
-		lfs_free(fs, copy, LFS_NB_IBLOCK);
+		lfs_free(fs, bap, 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;