uvm_swap compression patch

[Reinoud Zandijk <reinoud%NetBSD.org@localhost>]

Dear folks,

as part of a compressed ram experiment I'd like to try, I've first cleaned up
the current uvm swap support for I noticed that the support for encrypted swap
became distributed and not logical anymore. In the attached patch I've
contracted the encrypted support into the /dev/drum device and removed it from
the specific swap support and callbacks.

I've tested it using read/write on /dev/drum and tested it for swapping on
amd64 using plain and encrypted forms. One point of discussion could be that
writing to /dev/drum from userland could be allowed or not. In the current
patch its allowed.

Any thouhts? I'd like to commit it.

With regards,
Reinoud

Index: sys/uvm/uvm_pager.c
===================================================================
RCS file: /cvsroot/src/sys/uvm/uvm_pager.c,v
retrieving revision 1.136
diff -u -p -r1.136 uvm_pager.c
--- sys/uvm/uvm_pager.c	3 May 2026 16:02:37 -0000	1.136
+++ sys/uvm/uvm_pager.c	1 Jul 2026 18:45:55 -0000
@@ -547,16 +547,6 @@ uvm_aio_aiodone(struct buf *bp)
 		    (uintptr_t)pgs[i], 0, 0);
 	}
 
-#if defined(VMSWAP)
-	if (__predict_false(error != 0) &&
-	    ((pgs[0]->flags & PG_SWAPBACKED) != 0)) {
-		int swslot = uvm_page_swapslot(pgs[0]);
-
-		KASSERT(swslot > 0);
-		uvm_swap_decrypt_pages(swslot, bp->b_data, npages);
-	}
-#endif
-
 	uvm_pagermapout((vaddr_t)bp->b_data, npages);
 
 	uvm_aio_aiodone_pages(pgs, npages, write, error);
Index: sys/uvm/uvm_swap.c
===================================================================
RCS file: /cvsroot/src/sys/uvm/uvm_swap.c,v
retrieving revision 1.233
diff -u -p -r1.233 uvm_swap.c
--- sys/uvm/uvm_swap.c	3 Jun 2026 15:00:06 -0000	1.233
+++ sys/uvm/uvm_swap.c	1 Jul 2026 18:45:55 -0000
@@ -218,6 +218,7 @@ static int uvm_swap_io(struct vm_page **
 static void uvm_swap_genkey(struct swapdev *);
 static void uvm_swap_encryptpage(struct swapdev *, void *, int);
 static void uvm_swap_decryptpage(struct swapdev *, void *, int);
+static void uvm_swap_encrypt_pages(int startslot, void *p, int npages);
 
 /*
  * uvm_swap_init: init the swap system data structures and locks
@@ -1337,38 +1338,47 @@ iobuf_redirect(struct buf *bp, struct vn
 
 struct sw_physio_decrypt_context {
 	void *orig_buf;
-	void *orig_private;
-	void (*orig_iodone)(struct buf *);
 	int swslot;
 };
 
 static void
 sw_physio_decrypt_iodone(struct buf *bp)
 {
-	struct sw_physio_decrypt_context *ctx = bp->b_private;
-	void (*cb)(struct buf *bp) = ctx->orig_iodone;
+	struct sw_physio_decrypt_context *ctx = bp->b_private2;
+	struct buf *mbp = bp->b_private;
 	size_t npages = bp->b_bcount >> PAGE_SHIFT;
 
 	KASSERT(ctx->swslot > 0);
 	KASSERT(npages << PAGE_SHIFT == bp->b_bcount);
+
+	/* always decrypt, we might have written */
+	uvm_swap_decrypt_pages(ctx->swslot, bp->b_data, npages);
+
+	/* copy data if we used a bounce buffer */
 	if (bp->b_error == 0) {
 		if (bp->b_resid == 0) {
-			uvm_swap_decrypt_pages(ctx->swslot, bp->b_data,
-					       npages);
-			memcpy(ctx->orig_buf, (uint8_t *)bp->b_data,
-			       bp->b_bcount);
+			if (bp->b_data != ctx->orig_buf)
+				memcpy(ctx->orig_buf, (uint8_t *)bp->b_data,
+				       bp->b_bcount);
 		} else {
+			/* XXX we could zero the buffer */
 			bp->b_error = EIO;
 		}
 	}
-	kmem_intr_free(bp->b_data, bp->b_bcount);
-	bp->b_data = ctx->orig_buf;
+	/* free optional bounce buffer */
+	if (bp->b_data != ctx->orig_buf)
+		kmem_intr_free(bp->b_data, bp->b_bcount);
+
+	mbp->b_resid = 0;
 	if (bp->b_error != 0) {
-		bp->b_resid = bp->b_bcount;
+		mbp->b_error = bp->b_error;
+		mbp->b_resid = bp->b_bcount;
 	}
-	bp->b_private = ctx->orig_private;
+
 	kmem_intr_free(ctx, sizeof(*ctx));
-	(cb)(bp); /* call the original b_iodone callback */
+	putiobuf(bp);
+
+	biodone(mbp);
 }
 
 /*
@@ -1381,6 +1391,8 @@ swstrategy(struct buf *bp)
 {
 	struct swapdev *sdp;
 	struct vnode *vp;
+	struct buf *nbp = bp;
+	int npages = bp->b_bufsize >> PAGE_SHIFT;
 	int pageno, bn;
 	UVMHIST_FUNC(__func__); UVMHIST_CALLED(pdhist);
 
@@ -1399,10 +1411,9 @@ swstrategy(struct buf *bp)
 	}
 
 	/*
-	 * convert block number to swapdev.   note that swapdev can't
-	 * be yanked out from under us because we are holding resources
-	 * in it (i.e. the blocks we are doing I/O on) or read lock on
-	 * swap_syscall_lock.
+	 * convert block number to swapdev. note that swapdev can't be yanked
+	 * out from under us because we are holding resources in it (i.e. the
+	 * blocks we are doing I/O on) or read lock on swap_syscall_lock.
 	 */
 	pageno = dbtob((int64_t)bp->b_blkno) >> PAGE_SHIFT;
 	mutex_enter(&uvm_swap_data_lock);
@@ -1419,40 +1430,46 @@ swstrategy(struct buf *bp)
 	}
 
 	/*
-	 * B_RAW here implies user i/o on /dev/drum, for which we need
-	 * to handle encryption/decryption here.
-	 * for swap in/out, it's handled by the caller.
+	 * if the swap is encrypted, we encrypt before we write. in the
+	 * callback we ensure its always decrypted (again).
 	 */
-	if ((bp->b_flags & B_RAW) != 0 &&
-	    atomic_load_relaxed(&uvm_swap_encrypt)) {
+	if (atomic_load_relaxed(&uvm_swap_encrypt)) {
 		struct sw_physio_decrypt_context *ctx;
 
-		/*
-		 * we only implement B_READ for now.
-		 *
-		 * REVISIT: what kind of apps needs to write to /dev/drum?
-		 */
-		if ((bp->b_flags & B_READ) == 0) {
-			bp->b_error = ENOTSUP;
+		/* get iobuf for our decryption nestio setup */
+		nbp = getiobuf(bp->b_vp, !uvm_lwp_is_pagedaemon(curlwp));
+		if (nbp == NULL) {
+			bp->b_error = ENOMEM;
 			bp->b_resid = bp->b_bcount;
 			biodone(bp);
+			UVMHIST_LOG(pdhist, "  failed to get iobuf",
+				0, 0, 0, 0);
 			return;
 		}
+		nestiobuf_setup(bp, nbp, 0, bp->b_bcount);
+		nbp->b_blkno = bp->b_blkno;
 
-		/*
-		 * in-place decryption in the userland buffer might
-		 * have non-trivial implications. for simplicity,
-		 * we use a bounce buffer.
-		 */
+		/* keep some context around for callback */
 		ctx = kmem_intr_alloc(sizeof(*ctx), KM_SLEEP);
 		ctx->swslot = dbtob((int64_t)bp->b_blkno) >> PAGE_SHIFT;
 		KASSERT(ctx->swslot > 0);
 		ctx->orig_buf = bp->b_data;
-		ctx->orig_private = bp->b_private;
-		ctx->orig_iodone = bp->b_iodone;
-		bp->b_data = kmem_intr_alloc(bp->b_bcount, KM_SLEEP);
-		bp->b_private = ctx;
-		bp->b_iodone = sw_physio_decrypt_iodone;
+		nbp->b_private2 = ctx;
+		/* redirect our iodone to the decrypt iodone */
+		nbp->b_iodone = sw_physio_decrypt_iodone;
+
+		/*
+		 * in-place decryption in the userland buffer might
+		 * have non-trivial implications. for simplicity,
+		 * we use a bounce buffer. B_RAW here implies user i/o on
+		 * /dev/drum. It gets freed in the callback.
+		 */
+		if (BUF_ISREAD(bp) && (bp->b_flags & B_RAW))
+			nbp->b_data = kmem_intr_alloc(nbp->b_bcount, KM_SLEEP);
+
+		/* encrypt in place when writing */
+		if (BUF_ISWRITE(bp))
+			uvm_swap_encrypt_pages(pageno, bp->b_data, npages);
 	}
 
 	/*
@@ -1486,16 +1503,16 @@ swstrategy(struct buf *bp)
 		 * if we are doing a write, we have to redirect the i/o on
 		 * drum's v_numoutput counter to the swapdev's.
 		 */
-		iobuf_redirect(bp, vp);
-		bp->b_blkno = bn;		/* swapdev block number */
-		VOP_STRATEGY(vp, bp);
+		iobuf_redirect(nbp, vp);
+		nbp->b_blkno = bn;		/* swapdev block number */
+		VOP_STRATEGY(vp, nbp);
 		return;
 
 	case VREG:
 		/*
 		 * delegate to sw_reg_strategy function.
 		 */
-		sw_reg_strategy(sdp, bp, bn);
+		sw_reg_strategy(sdp, nbp, bn);
 		return;
 	}
 	/* NOTREACHED */
@@ -2109,14 +2126,6 @@ uvm_swap_io(struct vm_page **pps, int st
 	kva = uvm_pagermapin(pps, npages, mapinflags);
 
 	/*
-	 * encrypt writes in place if requested
-	 */
-
-	if (write) {
-		uvm_swap_encrypt_pages(startslot, (void *)kva, npages);
-	}
-
-	/*
 	 * fill in the bp/sbp.   we currently route our i/o through
 	 * /dev/drum's vnode [swapdev_vp].
 	 */
@@ -2161,7 +2170,6 @@ uvm_swap_io(struct vm_page **pps, int st
 	/*
 	 * now we start the I/O, and if async, return.
 	 */
-
 	VOP_STRATEGY(swapdev_vp, bp);
 	if (async) {
 		/*
@@ -2180,13 +2188,6 @@ uvm_swap_io(struct vm_page **pps, int st
 	if (error)
 		goto out;
 
-	/*
-	 * decrypt reads in place if needed
-	 */
-
-	if (!write) {
-		uvm_swap_decrypt_pages(startslot, (void *)kva, npages);
-	}
 out:
 	/*
 	 * kill the pager mapping