* Use the LFS_IFDIRTY flag to keep track of whether the Ifile has

  ungathered changes during checkpoint.  Modify LFS_WRITESEGENTRY and
  make a new LFS_WRITEIENTRY macro to help track this.  Prevents
  an infinite loop in lfs_writeinode, previously caught with a panic.

* Fix a false-positive "negative bytes" panic when writing inodes into
  the same segment they were in before, and consolidate the accounting
  logic into new function lfs_subtract_inode.

* Ensure that we do not clean any inodes that were unavailable during
  the first pass of cleaning, so that we never need to mix cleaning and
  non-cleaning blocks (except for the Ifile) when writing.

* Straighten out the logic in lfs_writefile to make it more readable.

* Include IMNT_WANTRDONLY in tests for closing out writes, not just
  IMNT_UNMOUNT.

* Keep track of whether the kernel cleaner is active on a file system
  with a status flag; use a condvar to synchronously turn this on
  or off.

Author: perseant

sys/ufs/lfs/lfs.h

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs.h,v 1.213 2025/11/06 15:45:32 perseant Exp $	*/
+/*	$NetBSD: lfs.h,v 1.214 2025/12/02 01:23:09 perseant Exp $	*/
 
 /*  from NetBSD: dinode.h,v 1.25 2016/01/22 23:06:10 dholland Exp  */
 /*  from NetBSD: dir.h,v 1.25 2015/09/01 06:16:03 dholland Exp  */
@@ -1140,6 +1140,10 @@ struct lfs {
 	struct lfs_autoclean_params lfs_autoclean;
 	long (*lfs_clean_selector)(struct lfs *, int, SEGUSE *);
 	uint64_t lfs_clean_accum;
+# define LFS_AUTOCLEAN_STATUS_OFF	0
+# define LFS_AUTOCLEAN_STATUS_ON	1
+	int lfs_autoclean_status;
+	kcondvar_t lfs_cleanquitcv; /* condvar for cleaner quit */
 
 	/* Last cleaned segment */
 	uint32_t lfs_lastcleaned;

sys/ufs/lfs/lfs_accessors.h

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_accessors.h,v 1.56 2025/11/19 22:31:52 andvar Exp $	*/
+/*	$NetBSD: lfs_accessors.h,v 1.57 2025/12/02 01:23:09 perseant Exp $	*/
 
 /*  from NetBSD: lfs.h,v 1.165 2015/07/24 06:59:32 dholland Exp  */
 /*  from NetBSD: dinode.h,v 1.25 2016/01/22 23:06:10 dholland Exp  */
@@ -693,6 +693,8 @@ lfs_iblock_set(STRUCT_LFS *fs, void *block, unsigned ix, daddr_t val)
 } while (0)
 
 #define LFS_WRITESEGENTRY(SP, F, IN, BP) do {				\
+	if (((BP)->b_flags & B_GATHERED) == 0)			 	\
+		(F)->lfs_flags |= LFS_IFDIRTY;				\
 	LFS_BWRITE_LOG(BP);						\
 } while (0)
 
@@ -865,6 +867,11 @@ lfs_ii_setblock(STRUCT_LFS *fs, IINFO *iip, uint64_t block)
 		(IP) = (IFILE *)((IFILE_V1 *)(IP) + 1);			\
 	}								\
 } while (0)
+#define LFS_WRITEIENTRY(IP, F, IN, BP) do {				\
+	if (((BP)->b_flags & B_GATHERED) == 0)				\
+		(F)->lfs_flags |= LFS_IFDIRTY;				\
+	LFS_BWRITE_LOG(BP);						\
+} while (0)
 
 #define LFS_DEF_IF_ACCESSOR(type, type32, field) \
 	static __inline type				\
@@ -1006,10 +1013,11 @@ lfs_ci_shiftdirtytoclean(STRUCT_LFS *fs, CLEANERINFO *cip, unsigned num)
 		lfs_ci_setfree_head(FS, CIP, VAL);			\
 		if ((VAL) == LFS_UNUSED_INUM)				\
 			lfs_ci_setfree_tail(FS, CIP, VAL);		\
-		LFS_BWRITE_LOG(BP);					\
 		mutex_enter(&lfs_lock);					\
-		(FS)->lfs_flags |= LFS_IFDIRTY;				\
+		if (((BP)->b_flags & B_GATHERED) == 0)		 	\
+			(FS)->lfs_flags |= LFS_IFDIRTY;			\
 		mutex_exit(&lfs_lock);					\
+		LFS_BWRITE_LOG(BP);					\
 	}								\
 } while (0)
 
@@ -1024,10 +1032,11 @@ lfs_ci_shiftdirtytoclean(STRUCT_LFS *fs, CLEANERINFO *cip, unsigned num)
 	lfs_ci_setfree_tail(FS, CIP, VAL);				\
 	if ((VAL) == LFS_UNUSED_INUM)					\
 		lfs_ci_setfree_head(FS, CIP, VAL);			\
-	LFS_BWRITE_LOG(BP);						\
 	mutex_enter(&lfs_lock);						\
-	(FS)->lfs_flags |= LFS_IFDIRTY;					\
+	if (((BP)->b_flags & B_GATHERED) == 0)				\
+		(FS)->lfs_flags |= LFS_IFDIRTY;				\
 	mutex_exit(&lfs_lock);						\
+	LFS_BWRITE_LOG(BP);						\
 } while (0)
 
 /*

sys/ufs/lfs/lfs_alloc.c

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_alloc.c,v 1.147 2025/11/03 22:21:12 perseant Exp $	*/
+/*	$NetBSD: lfs_alloc.c,v 1.148 2025/12/02 01:23:09 perseant Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003, 2007 The NetBSD Foundation, Inc.
@@ -60,7 +60,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_alloc.c,v 1.147 2025/11/03 22:21:12 perseant Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_alloc.c,v 1.148 2025/12/02 01:23:09 perseant Exp $");
 
 #if defined(_KERNEL_OPT)
 #include "opt_quota.h"
@@ -305,7 +305,7 @@ lfs_valloc(struct vnode *pvp, int mode, kauth_cred_t cred,
 	 */
 	lfs_if_setdaddr(fs, ifp, LFS_ILLEGAL_DADDR);
 	lfs_if_setnextfree(fs, ifp, LFS_UNUSED_INUM);
-	LFS_BWRITE_LOG(bp);
+	LFS_WRITEIENTRY(ifp, fs, *ino, bp);
 
 	if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {
 		/*
@@ -448,7 +448,7 @@ lfs_valloc_fixed(struct lfs *fs, ino_t ino, int vers)
 	lfs_if_setnextfree(fs, ifp, LFS_UNUSED_INUM);
 	/* See comment in lfs_valloc */
 	lfs_if_setdaddr(fs, ifp, LFS_ILLEGAL_DADDR);
-	LFS_BWRITE_LOG(bp);
+	LFS_WRITEIENTRY(ifp, fs, ino, bp);
 
 	if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {
 		int error;
@@ -556,7 +556,6 @@ lfs_freelist_prev(struct lfs *fs, ino_t ino)
 int
 lfs_vfree(struct vnode *vp, ino_t ino, int mode)
 {
-	SEGUSE *sup;
 	CLEANERINFO *cip;
 	struct buf *cbp, *bp;
 	IFILE *ifp;
@@ -569,9 +568,10 @@ lfs_vfree(struct vnode *vp, ino_t ino, int mode)
 	fs = ip->i_lfs;
 	ino = ip->i_number;
 
-	/* XXX: assert not readonly */
-
 	ASSERT_NO_SEGLOCK(fs);
+	KASSERTMSG((ino != LFS_UNUSED_INUM), "inode 0 freed");
+	KASSERT(!fs->lfs_ronly);
+
 	DLOG((DLOG_ALLOC, "lfs_vfree: free ino %lld\n", (long long)ino));
 
 	/* Drain of pending writes */
@@ -668,7 +668,7 @@ lfs_vfree(struct vnode *vp, ino_t ino, int mode)
 		LFS_PUT_HEADFREE(fs, cip, cbp, ino);
 
 		/* write the ifile block */
-		(void) LFS_BWRITE_LOG(bp); /* Ifile */
+		LFS_WRITEIENTRY(ifp, fs, ino, bp);
 #if 0
 	} else {
 		ino_t tino, onf, otail;
@@ -679,7 +679,7 @@ lfs_vfree(struct vnode *vp, ino_t ino, int mode)
 		 * it seems both silly and dangerous.
 		 */
 		lfs_if_setnextfree(fs, ifp, LFS_UNUSED_INUM);
-		(void) LFS_BWRITE_LOG(bp); /* Ifile */
+		LFS_WRITEIENTRY(ifp, fs, ino, bp);
 
 		/*
 		 * Insert on freelist in order.
@@ -704,7 +704,7 @@ lfs_vfree(struct vnode *vp, ino_t ino, int mode)
 			DLOG((DLOG_ALLOC, "lfs_vfree: headfree %lld -> %lld\n",
 			     (long long)nextfree, (long long)ino));
 			/* write the ifile block */
-			LFS_BWRITE_LOG(bp); /* Ifile */
+			LFS_WRITEIENTRY(ifp, fs, ino, bp);
 
 			/* If the list was empty, set tail too */
 			LFS_GET_TAILFREE(fs, cip, cbp, &otail);
@@ -730,14 +730,14 @@ lfs_vfree(struct vnode *vp, ino_t ino, int mode)
 			onf = lfs_if_getnextfree(fs, ifp);
 			lfs_if_setnextfree(fs, ifp, ino);
 			/* write the block */
-			LFS_BWRITE_LOG(bp);	/* Ifile */
+			LFS_WRITEIENTRY(ifp, fs, tino, bp);
 
 			/* load this inode's ifile block */
 			LFS_IENTRY(ifp, fs, ino, bp);
 			/* update the list pointer */
 			lfs_if_setnextfree(fs, ifp, onf);
 			/* write the block */
-			LFS_BWRITE_LOG(bp);	/* Ifile */
+			LFS_WRITEIENTRY(ifp, fs, tino, bp);
 
 			/* If we're last, put us on the tail */
 			if (onf == LFS_UNUSED_INUM) {
@@ -750,27 +750,12 @@ lfs_vfree(struct vnode *vp, ino_t ino, int mode)
 		}
 	}
 #endif
-	/* XXX: shouldn't this check be further up *before* we trash the fs? */
-	KASSERTMSG((ino != LFS_UNUSED_INUM), "inode 0 freed");
 
 	/*
 	 * Update the segment summary for the segment where the on-disk
 	 * copy used to be.
 	 */
-	if (!DADDR_IS_BAD(old_iaddr)) {
-		/* load it */
-		LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, old_iaddr), bp);
-		/* the number of bytes in the segment should not become < 0 */
-		KASSERTMSG((sup->su_nbytes >= DINOSIZE(fs)),
-		    "lfs_vfree: negative byte count"
-		    " (segment %" PRIu32 " short by %d)\n",
-		    lfs_dtosn(fs, old_iaddr),
-		    (int)DINOSIZE(fs) - sup->su_nbytes);
-		/* update the number of bytes in the segment */
-		sup->su_nbytes -= DINOSIZE(fs);
-		/* write the segment entry */
-		LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, old_iaddr), bp); /* Ifile */
-	}
+	lfs_subtract_inode(fs, ip->i_number, old_iaddr);
 
 	/* Set superblock modified bit. */
 	mutex_enter(&lfs_lock);
@@ -889,7 +874,7 @@ lfs_order_freelist(struct lfs *fs, ino_t **orphanp, size_t *norphanp)
 				/* set the list pointer */
 				lfs_if_setnextfree(fs, ifp, ino);
 				/* write the block */
-				LFS_BWRITE_LOG(bp);
+				LFS_WRITEIENTRY(ifp, fs, lastino, bp);
 
 				/* reload this inode's ifile entry */
 				LFS_IENTRY(ifp, fs, ino, bp);
@@ -984,15 +969,18 @@ lfs_orphan(struct lfs *fs, struct vnode *vp)
 	mutex_exit(vp->v_interlock);
 
 	/* If not already done, mark this inode orphaned. */
+	rw_enter(&fs->lfs_fraglock, RW_READER);
 	LFS_IENTRY(ifp, fs, ip->i_number, bp);
 	nextfree = lfs_if_getnextfree(fs, ifp);
 	if (nextfree == LFS_ORPHAN_NEXTFREE(fs)) {
 		brelse(bp, 0);
+		rw_exit(&fs->lfs_fraglock);
 		return;
 	}
 	KASSERT(nextfree == LFS_UNUSED_INUM);
 	lfs_if_setnextfree(fs, ifp, LFS_ORPHAN_NEXTFREE(fs));
-	LFS_BWRITE_LOG(bp);
+	LFS_WRITEIENTRY(ifp, fs, ip->i_number, bp);
+	rw_exit(&fs->lfs_fraglock);
 }
 
 /*
@@ -1057,6 +1045,8 @@ lfs_free_orphans(struct lfs *fs, ino_t *orphan, size_t norphan)
 			    error);
 		vput(vp);
 
+		rw_enter(&fs->lfs_fraglock, RW_READER);
+
 		/* Update the number of bytes in the segment summary.  */
 		LFS_SEGENTRY(sup, fs, segno, bp);
 		KASSERT(sup->su_nbytes >= DINOSIZE(fs));
@@ -1066,7 +1056,9 @@ lfs_free_orphans(struct lfs *fs, ino_t *orphan, size_t norphan)
 		/* Drop the on-disk address.  */
 		LFS_IENTRY(ifp, fs, ino, bp);
 		lfs_if_setdaddr(fs, ifp, LFS_UNUSED_DADDR);
-		LFS_BWRITE_LOG(bp);
+		LFS_WRITEIENTRY(ifp, fs, ino, bp);
+		
+		rw_exit(&fs->lfs_fraglock);
 	}
 
 	if (orphan)

sys/ufs/lfs/lfs_bio.c

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_bio.c,v 1.152 2025/11/03 22:21:12 perseant Exp $	*/
+/*	$NetBSD: lfs_bio.c,v 1.153 2025/12/02 01:23:09 perseant Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003, 2008 The NetBSD Foundation, Inc.
@@ -60,7 +60,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.152 2025/11/03 22:21:12 perseant Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.153 2025/12/02 01:23:09 perseant Exp $");
 
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -777,10 +777,10 @@ lfs_newbuf(struct lfs *fs, struct vnode *vp, daddr_t daddr, size_t size, int typ
 	bp->b_error = 0;
 	bp->b_resid = 0;
 	bp->b_iodone = lfs_free_aiodone;
-	bp->b_cflags |= BC_BUSY | BC_NOCACHE;
 	bp->b_private = fs;
 
 	mutex_enter(&bufcache_lock);
+	bp->b_cflags |= BC_BUSY | BC_NOCACHE;
 	mutex_enter(vp->v_interlock);
 	bgetvp(vp, bp);
 	mutex_exit(vp->v_interlock);
@@ -794,17 +794,17 @@ lfs_freebuf(struct lfs *fs, struct buf *bp)
 {
 	struct vnode *vp;
 
-	if ((vp = bp->b_vp) != NULL) {
-		mutex_enter(&bufcache_lock);
-		mutex_enter(vp->v_interlock);
+	mutex_enter(&bufcache_lock);
+	vp = bp->b_vp;
+	mutex_enter(vp->v_interlock);
+	if (vp != NULL)
 		brelvp(bp);
-		mutex_exit(vp->v_interlock);
-		mutex_exit(&bufcache_lock);
-	}
+	mutex_exit(vp->v_interlock);
 	if (!(bp->b_cflags & BC_INVAL)) { /* BC_INVAL indicates a "fake" buffer */
 		lfs_free(fs, bp->b_data, LFS_NB_UNKNOWN);
 		bp->b_data = NULL;
 	}
+	mutex_exit(&bufcache_lock);
 	putiobuf(bp);
 }
 

sys/ufs/lfs/lfs_extern.h

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_extern.h,v 1.126 2025/11/06 15:45:32 perseant Exp $	*/
+/*	$NetBSD: lfs_extern.h,v 1.127 2025/12/02 01:23:09 perseant Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@@ -226,6 +226,7 @@ int lfs_vflush(struct vnode *);
 int lfs_segwrite(struct mount *, int);
 int lfs_writefile(struct lfs *, struct segment *, struct vnode *);
 int lfs_writeinode(struct lfs *, struct segment *, struct inode *);
+int lfs_subtract_inode(struct lfs *, ino_t, daddr_t);
 int lfs_gatherblock(struct segment *, struct buf *, kmutex_t *);
 int lfs_gather(struct lfs *, struct segment *, struct vnode *, int (*match )(struct lfs *, struct buf *));
 int lfs_ungather(struct lfs *, struct segment *, struct vnode *, int (*match)(struct lfs *, struct buf *));

sys/ufs/lfs/lfs_itimes.c

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_itimes.c,v 1.20 2017/06/10 05:29:36 maya Exp $	*/
+/*	$NetBSD: lfs_itimes.c,v 1.21 2025/12/02 01:23:09 perseant Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@@ -29,7 +29,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_itimes.c,v 1.20 2017/06/10 05:29:36 maya Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_itimes.c,v 1.21 2025/12/02 01:23:09 perseant Exp $");
 
 #include <sys/param.h>
 #include <sys/time.h>
@@ -46,6 +46,7 @@ __KERNEL_RCSID(0, "$NetBSD: lfs_itimes.c,v 1.20 2017/06/10 05:29:36 maya Exp $")
 #else
 #include <ufs/lfs/ulfs_inode.h>
 #include <ufs/lfs/lfs_extern.h>
+#include <ufs/lfs/lfs_kernel.h>
 #include <sys/kauth.h>
 #endif
 
@@ -77,10 +78,20 @@ lfs_itimes(struct inode *ip, const struct timespec *acc,
 			struct buf *ibp;
 			IFILE *ifp;
 
+#ifdef _KERNEL
+			if (!LFS_SEGLOCK_HELD(fs))
+				rw_enter(&fs->lfs_fraglock, RW_READER);
+#endif /* _KERNEL */
 			LFS_IENTRY(ifp, fs, ip->i_number, ibp);
 			lfs_if_setatime_sec(fs, ifp, acc->tv_sec);
 			lfs_if_setatime_nsec(fs, ifp, acc->tv_nsec);
+#ifdef _KERNEL
+			LFS_WRITEIENTRY(ifp, fs, ip->i_number, ibp);
+			if (!LFS_SEGLOCK_HELD(fs))
+				rw_exit(&fs->lfs_fraglock);
+#else /* ! _KERNEL */
 			LFS_BWRITE_LOG(ibp);
+#endif /* ! _KERNEL */
 			mutex_enter(&lfs_lock);
 			fs->lfs_flags |= LFS_IFDIRTY;
 			mutex_exit(&lfs_lock);