All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH v2 0/2] vhost: set dirty log bits without pinning pages on x86
@ 2026-11-17  8:33 zhaoguohan
  2026-11-17  8:33 ` [PATCH v2 1/2] " zhaoguohan
  2026-11-17  8:33 ` [PATCH v2 2/2] tools/virtio: add a vhost dirty log test zhaoguohan
  0 siblings, 2 replies; 5+ messages in thread
From: zhaoguohan @ 2026-11-17  8:33 UTC (permalink / raw)
  To: mst, jasowang
  Cc: eperezma, xuanzhuo, tglx, mingo, bp, dave.hansen, x86, hpa, kvm,
	virtualization, netdev, linux-kernel, Khan Zhao

From: Khan Zhao <zhaoguohan@kylinos.cn>

This replaces my v1 with Michael's set_bit_user() from the RFC thread,
plus the userspace test from v1 extended with a cross-page case.

Patch 2 adds tools/virtio/vhost_log_test

Median of five runs of "vhost_log_test --bench", which pushes batches
of 128 descriptors through vhost_test and reports the time per
descriptor (lower is better). "logging enabled" sets
VHOST_VRING_F_LOG, so each descriptor logs two used ring writes (the
used element and used->idx); data buffer logging (VHOST_F_LOG_ALL) is
not exercised. baseline is the same tree without this series.

                      baseline      v2    change
  logging disabled      155.04  158.78     +2.4%
  logging enabled       287.58  189.20    -34.2%

Changes since v1:
 - Patch 1 is now Michael's set_bit_user() with scoped user access,
   replacing my cmpxchg loop and its GUP fallback. I added __label__
   for the efault label so it stays local to the macro.
 - Patch 2: add the cross-page case, use VHOST_PAGE_SIZE from the
   UAPI, and print the bitmap when the cross-page check fails.

v1:  https://lore.kernel.org/all/20261112085631.128819-1-zhaoguohan@kylinos.cn/
RFC: https://lore.kernel.org/all/af7f05bf637337d35fdd10f3e0dbb5e39d7780e7.1794480795.git.mst@redhat.com/

Khan Zhao (1):
  tools/virtio: add a vhost dirty log test

Michael S. Tsirkin (1):
  vhost: set dirty log bits without pinning pages on x86

 arch/x86/include/asm/uaccess.h  |  23 ++
 drivers/vhost/vhost.c           |   7 +
 tools/virtio/.gitignore         |   1 +
 tools/virtio/Makefile           |   7 +-
 tools/virtio/vhost_log_test.c   | 432 ++++++++++++++++++++++++++++++++
 tools/virtio/vhost_log_test.rst |  61 +++++
 6 files changed, 529 insertions(+), 2 deletions(-)
 create mode 100644 tools/virtio/vhost_log_test.c
 create mode 100644 tools/virtio/vhost_log_test.rst


base-commit: 666539eecdf4db623f5e3c3e55cf9f2dfad24aa4
-- 
2.43.0


^ permalink raw reply	[flat|nested] 5+ messages in thread

* [PATCH v2 1/2] vhost: set dirty log bits without pinning pages on x86
  2026-11-17  8:33 [PATCH v2 0/2] vhost: set dirty log bits without pinning pages on x86 zhaoguohan
@ 2026-11-17  8:33 ` zhaoguohan
  2026-11-17  8:44   ` sashiko-bot
  2026-11-17  8:33 ` [PATCH v2 2/2] tools/virtio: add a vhost dirty log test zhaoguohan
  1 sibling, 1 reply; 5+ messages in thread
From: zhaoguohan @ 2026-11-17  8:33 UTC (permalink / raw)
  To: mst, jasowang
  Cc: eperezma, xuanzhuo, tglx, mingo, bp, dave.hansen, x86, hpa, kvm,
	virtualization, netdev, linux-kernel, Khan Zhao

From: "Michael S. Tsirkin" <mst@redhat.com>

vhost had a TODO to replace page pinning with a version
of set_bit that works on userspace memory, since forever.

It is really best to avoid GUP on fast path entirely.
Implement set_bit_user and use it in vhost, to do just that.

Should not be too hard for non-x86 too.

Reported-by: Khan Zhao <zhaoguohan@kylinos.cn>
Link: https://lore.kernel.org/all/20261112085631.128819-1-zhaoguohan@kylinos.cn/
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
[Khan: declare efault with __label__ so it is local to the macro]
Signed-off-by: Khan Zhao <zhaoguohan@kylinos.cn>
---
v2: new in this series; replaces my v1 patch 1. Taken from
    Michael's reply in the RFC thread, with __label__ added for efault.

 arch/x86/include/asm/uaccess.h | 23 +++++++++++++++++++++++
 drivers/vhost/vhost.c          |  7 +++++++
 2 files changed, 30 insertions(+)

diff --git a/arch/x86/include/asm/uaccess.h b/arch/x86/include/asm/uaccess.h
index f4700ad6b5ec..a727ef8084f4 100644
--- a/arch/x86/include/asm/uaccess.h
+++ b/arch/x86/include/asm/uaccess.h
@@ -540,6 +540,29 @@ _label:									\
 	__ret;								\
 							})
 
+/* set_bit() on a byte of user memory; returns -EFAULT on fault. */
+#define set_bit_user(nr, addr)					\
+({									\
+	__label__ efault;						\
+	int __err = -EFAULT;						\
+	u8 __user *__p = (addr);					\
+	scoped_user_rw_access(__p, efault) {				\
+		__err = 0;						\
+		asm volatile("\n"					\
+			     "1: " LOCK_PREFIX "orb %[mask], %[ptr]\n"	\
+			     "2:\n"					\
+			     _ASM_EXTABLE_TYPE_REG(1b, 2b,			\
+						   EX_TYPE_EFAULT_REG,	\
+						   %[errout])		\
+			     : [errout] "+r" (__err),			\
+			       [ptr] "+m" (*__p)			\
+			     : [mask] "q" ((unsigned char)BIT(nr))	\
+			     : "memory", "cc");				\
+	}								\
+efault:									\
+	__err;								\
+})
+
 /*
  * We want the unsafe accessors to always be inlined and use
  * the error labels - thus the macro games.
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index e29f154706da..d426f303c107 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -2527,6 +2527,12 @@ long vhost_dev_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *argp)
 }
 EXPORT_SYMBOL_GPL(vhost_dev_ioctl);
 
+#ifdef CONFIG_X86
+static int set_bit_to_user(int nr, void __user *addr)
+{
+	return set_bit_user(nr, addr);
+}
+#else
 /* TODO: This is really inefficient.  We need something like get_user()
  * (instruction directly accesses the data, with an exception table entry
  * returning -EFAULT). See Documentation/arch/x86/exception-tables.rst.
@@ -2549,6 +2555,7 @@ static int set_bit_to_user(int nr, void __user *addr)
 	unpin_user_pages_dirty_lock(&page, 1, true);
 	return 0;
 }
+#endif /* CONFIG_X86 */
 
 static int log_write(void __user *log_base,
 		     u64 write_address, u64 write_length)
-- 
2.43.0


^ permalink raw reply related	[flat|nested] 5+ messages in thread

* [PATCH v2 2/2] tools/virtio: add a vhost dirty log test
  2026-11-17  8:33 [PATCH v2 0/2] vhost: set dirty log bits without pinning pages on x86 zhaoguohan
  2026-11-17  8:33 ` [PATCH v2 1/2] " zhaoguohan
@ 2026-11-17  8:33 ` zhaoguohan
  2026-11-17  8:44   ` sashiko-bot
  1 sibling, 1 reply; 5+ messages in thread
From: zhaoguohan @ 2026-11-17  8:33 UTC (permalink / raw)
  To: mst, jasowang
  Cc: eperezma, xuanzhuo, tglx, mingo, bp, dave.hansen, x86, hpa, kvm,
	virtualization, netdev, linux-kernel, Khan Zhao

From: Khan Zhao <zhaoguohan@kylinos.cn>

Add vhost_log_test, which exercises used-ring dirty logging through the
existing vhost_test module. It sets a log base with VHOST_SET_LOG_BASE,
enables VHOST_VRING_F_LOG on the ring, submits descriptors and checks
the resulting bitmap from userspace. No new kernel interface is needed.

The test covers:

 - every bit in a byte, repeated sets, and neighbouring bytes being left
   untouched, including the last byte of a page followed by a PROT_NONE
   guard page
 - a used ring write that spans two log pages, with both bits in the
   same bitmap byte and in adjacent bytes
 - a log page that has not been faulted in yet, read-only, PROT_NONE
   and unmapped log pages, and logging after access is restored
 - private (COW) and shared file mappings, checking that the bit reaches
   the file after msync/fsync
 - eight vrings setting different bits of the same byte concurrently,
   with and without a userspace thread atomically fetching and clearing
   that byte
 - two shared mappings of one file page, one of them zapped with
   MADV_DONTNEED each round, so both resident and faulting pages are
   hit

log_used() ignores errors from log_write(), so the fault cases can only
check that nothing crashes, that nothing is written to an inaccessible
log, and that logging works again afterwards.

A --bench mode reports ns per descriptor with logging disabled and
enabled. vhost_log_test.rst describes how to build and run the test.

Assisted-by: Claude:claude-opus-5-5
Signed-off-by: Khan Zhao <zhaoguohan@kylinos.cn>
---
v2: add a used ring write spanning two log pages, use VHOST_PAGE_SIZE
    from the UAPI, and print the bitmap on a cross-page mismatch.

 tools/virtio/.gitignore         |   1 +
 tools/virtio/Makefile           |   7 +-
 tools/virtio/vhost_log_test.c   | 432 ++++++++++++++++++++++++++++++++
 tools/virtio/vhost_log_test.rst |  61 +++++
 4 files changed, 499 insertions(+), 2 deletions(-)
 create mode 100644 tools/virtio/vhost_log_test.c
 create mode 100644 tools/virtio/vhost_log_test.rst

diff --git a/tools/virtio/.gitignore b/tools/virtio/.gitignore
index 7e47b281c442..9f3ebfa2c3b6 100644
--- a/tools/virtio/.gitignore
+++ b/tools/virtio/.gitignore
@@ -2,5 +2,6 @@
 *.d
 virtio_test
 vhost_net_test
+vhost_log_test
 vringh_test
 virtio-trace/trace-agent
diff --git a/tools/virtio/Makefile b/tools/virtio/Makefile
index 2cac5fd4b979..a4af5140a1cd 100644
--- a/tools/virtio/Makefile
+++ b/tools/virtio/Makefile
@@ -1,9 +1,12 @@
 # SPDX-License-Identifier: GPL-2.0
 all: test mod
-test: virtio_test vringh_test vhost_net_test
+test: virtio_test vringh_test vhost_net_test vhost_log_test
 virtio_test: virtio_ring.o virtio_test.o
 vringh_test: vringh_test.o vringh.o virtio_ring.o
 vhost_net_test: virtio_ring.o vhost_net_test.o
+vhost_log_test: vhost_log_test.o
+# This test uses only the userspace API, without the virtio kernel shims.
+vhost_log_test vhost_log_test.o: CFLAGS = -g -O2 -Wall -Wextra -Werror -pthread -I../../usr/include
 
 try-run = $(shell set -e;		\
 	if ($(1)) >/dev/null 2>&1;	\
@@ -52,7 +55,7 @@ oot-clean: OOT_BUILD+=clean
 
 .PHONY: all test mod clean vhost oot oot-clean oot-build
 clean:
-	${RM} *.o vringh_test virtio_test vhost_net_test vhost_test/*.o \
+	${RM} *.o vringh_test virtio_test vhost_net_test vhost_log_test vhost_test/*.o \
               vhost_test/.*.cmd vhost_test/Module.symvers \
               vhost_test/modules.order *.d
 -include *.d
diff --git a/tools/virtio/vhost_log_test.c b/tools/virtio/vhost_log_test.c
new file mode 100644
index 000000000000..065ce7790f00
--- /dev/null
+++ b/tools/virtio/vhost_log_test.c
@@ -0,0 +1,432 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/* Exercise vhost used-ring dirty logging through /dev/vhost-test. */
+#define _GNU_SOURCE
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <linux/vhost.h>
+#include <linux/virtio_ring.h>
+#include <poll.h>
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/eventfd.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <unistd.h>
+#include "../../drivers/vhost/test.h"
+
+#define RING_NUM 128
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+#define PAGE_BYTES VHOST_PAGE_SIZE
+#define CHECK(c) do { \
+	if (!(c)) { \
+		fprintf(stderr, "FAIL line %d: %s (errno=%d: %s)\n", \
+			__LINE__, #c, errno, strerror(errno)); \
+		exit(EXIT_FAILURE); \
+	} \
+} while (0)
+
+struct queue {
+	int fd;
+	int kick;
+	int call;
+	void *ring;
+	void *data;
+	struct vring_desc *desc;
+	struct vring_avail *avail;
+	struct vring_used *used;
+	uint16_t index;
+};
+
+static void *map_pages(size_t size)
+{
+	void *p = mmap(NULL, size, PROT_READ | PROT_WRITE,
+		      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+
+	CHECK(p != MAP_FAILED);
+	return p;
+}
+
+static void log_base(struct queue *q, void *base)
+{
+	uint64_t addr = (uintptr_t)base;
+
+	CHECK(!ioctl(q->fd, VHOST_SET_LOG_BASE, &addr));
+}
+
+static void queue_init_at(struct queue *q, void *bitmap, uint64_t log_addr,
+			  bool logging)
+{
+	struct vhost_vring_state state = { .index = 0, .num = RING_NUM };
+	struct vhost_vring_file file = { .index = 0 };
+	struct vhost_vring_addr addr = { .index = 0 };
+	struct vhost_memory *mem;
+	uint64_t features = 0;
+	unsigned char *scratch;
+	int i, run = 1;
+
+	memset(q, 0, sizeof(*q));
+	q->fd = open("/dev/vhost-test", O_RDWR);
+	CHECK(q->fd >= 0);
+	CHECK(!ioctl(q->fd, VHOST_SET_OWNER, NULL));
+	CHECK(!ioctl(q->fd, VHOST_SET_FEATURES, &features));
+	q->kick = eventfd(0, EFD_NONBLOCK);
+	q->call = eventfd(0, EFD_NONBLOCK);
+	CHECK(q->kick >= 0 && q->call >= 0);
+	q->ring = map_pages(3 * PAGE_BYTES);
+	q->data = map_pages(PAGE_BYTES);
+	q->desc = q->ring;
+	q->avail = q->ring + PAGE_BYTES;
+	q->used = q->ring + 2 * PAGE_BYTES;
+	mem = calloc(1, sizeof(*mem) + sizeof(mem->regions[0]));
+	CHECK(mem);
+	mem->nregions = 1;
+	mem->regions[0].guest_phys_addr = 0;
+	mem->regions[0].userspace_addr = (uintptr_t)q->data;
+	mem->regions[0].memory_size = PAGE_BYTES;
+	CHECK(!ioctl(q->fd, VHOST_SET_MEM_TABLE, mem));
+	free(mem);
+	for (i = 0; i < RING_NUM; i++) {
+		q->desc[i].addr = 0;
+		q->desc[i].len = 1;
+	}
+	CHECK(!ioctl(q->fd, VHOST_SET_VRING_NUM, &state));
+	state.num = 0;
+	CHECK(!ioctl(q->fd, VHOST_SET_VRING_BASE, &state));
+	addr.desc_user_addr = (uintptr_t)q->desc;
+	addr.avail_user_addr = (uintptr_t)q->avail;
+	addr.used_user_addr = (uintptr_t)q->used;
+	addr.flags = logging ? 1U << VHOST_VRING_F_LOG : 0;
+	addr.log_guest_addr = log_addr;
+	CHECK(!ioctl(q->fd, VHOST_SET_VRING_ADDR, &addr));
+	file.fd = q->kick;
+	CHECK(!ioctl(q->fd, VHOST_SET_VRING_KICK, &file));
+	file.fd = q->call;
+	CHECK(!ioctl(q->fd, VHOST_SET_VRING_CALL, &file));
+	/* Starting a queue logs its flags; keep the tested mapping untouched. */
+	scratch = map_pages(PAGE_BYTES);
+	log_base(q, scratch);
+	CHECK(!ioctl(q->fd, VHOST_TEST_RUN, &run));
+	log_base(q, bitmap);
+	CHECK(!munmap(scratch, PAGE_BYTES));
+}
+
+static void queue_init(struct queue *q, void *bitmap, unsigned int bit,
+		       bool logging)
+{
+	queue_init_at(q, bitmap, (uint64_t)bit * PAGE_BYTES, logging);
+}
+
+static void queue_submit(struct queue *q, unsigned int count)
+{
+	uint64_t kick = 1;
+	unsigned int i;
+
+	CHECK(count <= RING_NUM);
+	for (i = 0; i < count; i++)
+		q->avail->ring[(q->index + i) % RING_NUM] = i;
+	q->index += count;
+	__atomic_store_n(&q->avail->idx, q->index, __ATOMIC_RELEASE);
+	CHECK(write(q->kick, &kick, sizeof(kick)) == sizeof(kick));
+}
+
+static void queue_wait(struct queue *q)
+{
+	struct pollfd pfd = { .fd = q->call, .events = POLLIN };
+	uint64_t events;
+
+	/* Completion notification follows the dirty-log stores. */
+	do {
+		CHECK(poll(&pfd, 1, 5000) == 1);
+		CHECK(read(q->call, &events, sizeof(events)) == sizeof(events));
+	} while (__atomic_load_n(&q->used->idx, __ATOMIC_ACQUIRE) != q->index);
+}
+
+static void queue_destroy(struct queue *q)
+{
+	/* Release flushes the worker before freeing any userspace mappings. */
+	CHECK(!close(q->fd));
+	CHECK(!close(q->kick));
+	CHECK(!close(q->call));
+	CHECK(!munmap(q->ring, 3 * PAGE_BYTES));
+	CHECK(!munmap(q->data, PAGE_BYTES));
+}
+
+static void exercise(void *bitmap, unsigned int bit, unsigned int count)
+{
+	struct queue q;
+
+	queue_init(&q, bitmap, bit, true);
+	queue_submit(&q, count);
+	queue_wait(&q);
+	queue_destroy(&q);
+}
+
+static void basic_test(void)
+{
+	unsigned char *p = map_pages(2 * PAGE_BYTES);
+	unsigned int offsets[] = { 0, 1, 7, 63, PAGE_BYTES - 1 };
+	unsigned int i, bit;
+
+	CHECK(!mprotect(p + PAGE_BYTES, PAGE_BYTES, PROT_NONE));
+	for (i = 0; i < ARRAY_SIZE(offsets); i++) {
+		for (bit = 0; bit < 8; bit++) {
+			memset(p, 0, PAGE_BYTES);
+			exercise(p + offsets[i], bit, RING_NUM);
+			CHECK(p[offsets[i]] == (1U << bit));
+			if (offsets[i])
+				CHECK(!p[offsets[i] - 1]);
+			if (offsets[i] + 1 < PAGE_BYTES)
+				CHECK(!p[offsets[i] + 1]);
+			p[offsets[i]] = 0xa5;
+			exercise(p + offsets[i], bit, 1);
+			CHECK(p[offsets[i]] == (0xa5 | (1U << bit)));
+		}
+	}
+	CHECK(!munmap(p, 2 * PAGE_BYTES));
+	puts("PASS bits 0..7, repeated sets, unaligned and guarded page end");
+}
+
+static void cross_page_test(void)
+{
+	unsigned int pages[] = { 1, 8 };
+	unsigned char *p = map_pages(PAGE_BYTES);
+	unsigned char want[2];
+	unsigned int i, n;
+	struct queue q;
+
+	for (i = 0; i < ARRAY_SIZE(pages); i++) {
+		n = pages[i];
+		memset(p, 0, 2);
+		/* used->ring[0] is at offset 4, so it covers pages n - 1 and n. */
+		queue_init_at(&q, p, (uint64_t)n * PAGE_BYTES - 8, true);
+		queue_submit(&q, 1);
+		queue_wait(&q);
+		queue_destroy(&q);
+		memset(want, 0, sizeof(want));
+		want[(n - 1) / 8] |= 1U << ((n - 1) % 8);
+		want[n / 8] |= 1U << (n % 8);
+		if (p[0] != want[0] || p[1] != want[1]) {
+			fprintf(stderr,
+				"FAIL log pages %u/%u: got %02x %02x, want %02x %02x\n",
+				n - 1, n, (unsigned int)p[0], (unsigned int)p[1],
+				(unsigned int)want[0], (unsigned int)want[1]);
+			exit(EXIT_FAILURE);
+		}
+	}
+	CHECK(!munmap(p, PAGE_BYTES));
+	puts("PASS used ring write spanning two log pages");
+}
+
+static void fault_test(void)
+{
+	unsigned char *p = map_pages(PAGE_BYTES);
+	unsigned char resident;
+	struct queue q;
+
+	queue_init(&q, p, 3, true);
+	CHECK(!mincore(p, PAGE_BYTES, &resident));
+	CHECK(!(resident & 1));
+	queue_submit(&q, 1);
+	queue_wait(&q);
+	queue_destroy(&q);
+	CHECK(*p == 8);
+	*p = 0;
+	CHECK(!mprotect(p, PAGE_BYTES, PROT_READ));
+	exercise(p, 2, 1);
+	CHECK(!*p);
+	CHECK(!mprotect(p, PAGE_BYTES, PROT_NONE));
+	exercise(p, 2, 1);
+	CHECK(!mprotect(p, PAGE_BYTES, PROT_READ | PROT_WRITE));
+	exercise(p, 4, 1);
+	CHECK(*p == 16);
+	queue_init(&q, p, 2, true);
+	CHECK(!munmap(p, PAGE_BYTES));
+	queue_submit(&q, 1);
+	queue_wait(&q);
+	queue_destroy(&q);
+	/* Used-ring logging ignores errors; check survival and no bad write. */
+	puts("PASS first touch, readonly, PROT_NONE, unmapped, recovery");
+}
+
+static void file_test(const char *path)
+{
+	unsigned char *p;
+	unsigned char byte;
+	int fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0600);
+
+	CHECK(fd >= 0);
+	CHECK(!ftruncate(fd, PAGE_BYTES));
+	p = mmap(NULL, PAGE_BYTES, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+	CHECK(p != MAP_FAILED);
+	CHECK(!*p);
+	exercise(p, 5, 1);
+	CHECK(*p == 32);
+	CHECK(pread(fd, &byte, 1, 0) == 1);
+	CHECK(!byte);
+	CHECK(!munmap(p, PAGE_BYTES));
+	p = mmap(NULL, PAGE_BYTES, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+	CHECK(p != MAP_FAILED);
+	*p = 0;
+	CHECK(!msync(p, PAGE_BYTES, MS_SYNC));
+	exercise(p, 6, 1);
+	CHECK(*p == 64);
+	CHECK(!msync(p, PAGE_BYTES, MS_SYNC));
+	CHECK(!munmap(p, PAGE_BYTES));
+	CHECK(!fsync(fd));
+	CHECK(!posix_fadvise(fd, 0, PAGE_BYTES, POSIX_FADV_DONTNEED));
+	CHECK(pread(fd, &byte, 1, 0) == 1);
+	CHECK(byte == 64);
+	CHECK(!close(fd));
+	CHECK(!unlink(path));
+	puts("PASS private file COW and shared file sync/re-read");
+}
+
+struct collector {
+	unsigned char *bitmap;
+	bool stop;
+	unsigned char seen;
+};
+
+static void *collect(void *arg)
+{
+	struct collector *c = arg;
+
+	while (!__atomic_load_n(&c->stop, __ATOMIC_ACQUIRE))
+		c->seen |= __atomic_exchange_n(c->bitmap, 0, __ATOMIC_SEQ_CST);
+	return NULL;
+}
+
+static void concurrent_test(void)
+{
+	unsigned char *p = map_pages(PAGE_BYTES);
+	struct queue q[8];
+	struct collector c = { .bitmap = p };
+	pthread_t thread;
+	unsigned int bit, round;
+
+	for (bit = 0; bit < 8; bit++)
+		queue_init(&q[bit], p, bit, true);
+	for (round = 0; round < 1000; round++) {
+		__atomic_store_n(p, 0, __ATOMIC_SEQ_CST);
+		for (bit = 0; bit < 8; bit++)
+			queue_submit(&q[bit], 1);
+		for (bit = 0; bit < 8; bit++)
+			queue_wait(&q[bit]);
+		CHECK(__atomic_load_n(p, __ATOMIC_SEQ_CST) == 255);
+	}
+	for (round = 0; round < 1000; round++) {
+		__atomic_store_n(p, 0, __ATOMIC_SEQ_CST);
+		c.stop = false;
+		c.seen = 0;
+		CHECK(!pthread_create(&thread, NULL, collect, &c));
+		for (bit = 0; bit < 8; bit++)
+			queue_submit(&q[bit], RING_NUM);
+		for (bit = 0; bit < 8; bit++)
+			queue_wait(&q[bit]);
+		__atomic_store_n(&c.stop, true, __ATOMIC_RELEASE);
+		CHECK(!pthread_join(thread, NULL));
+		c.seen |= __atomic_exchange_n(p, 0, __ATOMIC_SEQ_CST);
+		CHECK(c.seen == 255);
+	}
+	for (bit = 0; bit < 8; bit++)
+		queue_destroy(&q[bit]);
+	CHECK(!munmap(p, PAGE_BYTES));
+	puts("PASS eight workers sharing a byte, concurrent atomic collection");
+}
+
+static void alias_test(const char *path)
+{
+	unsigned char *p, *alias;
+	struct queue q[8];
+	unsigned int bit, round;
+	int fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0600);
+
+	CHECK(fd >= 0);
+	CHECK(!ftruncate(fd, PAGE_BYTES));
+	p = mmap(NULL, PAGE_BYTES, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+	alias = mmap(NULL, PAGE_BYTES, PROT_READ | PROT_WRITE, MAP_SHARED,
+		     fd, 0);
+	CHECK(p != MAP_FAILED && alias != MAP_FAILED);
+	for (bit = 0; bit < 8; bit++)
+		queue_init(&q[bit], bit & 1 ? alias : p, bit, true);
+	for (round = 0; round < 1000; round++) {
+		__atomic_store_n(p, 0, __ATOMIC_SEQ_CST);
+		/* Keep one alias writable, and force faults through the other. */
+		CHECK(!madvise(alias, PAGE_BYTES, MADV_DONTNEED));
+		for (bit = 0; bit < 8; bit++)
+			queue_submit(&q[bit], 1);
+		for (bit = 0; bit < 8; bit++)
+			queue_wait(&q[bit]);
+		CHECK(__atomic_load_n(p, __ATOMIC_SEQ_CST) == 255);
+	}
+	for (bit = 0; bit < 8; bit++)
+		queue_destroy(&q[bit]);
+	CHECK(!munmap(p, PAGE_BYTES));
+	CHECK(!munmap(alias, PAGE_BYTES));
+	CHECK(!close(fd));
+	CHECK(!unlink(path));
+	puts("PASS shared-file aliases with repeated PTE faults");
+}
+
+static uint64_t now_ns(void)
+{
+	struct timespec ts;
+
+	CHECK(!clock_gettime(CLOCK_MONOTONIC, &ts));
+	return (uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec;
+}
+
+static void benchmark(bool logging, unsigned int batches)
+{
+	unsigned char *p = map_pages(PAGE_BYTES);
+	struct queue q;
+	uint64_t start, elapsed;
+	unsigned int i;
+
+	*p = 0;
+	queue_init(&q, p, 0, logging);
+	for (i = 0; i < 100; i++) {
+		queue_submit(&q, RING_NUM);
+		queue_wait(&q);
+	}
+	start = now_ns();
+	for (i = 0; i < batches; i++) {
+		queue_submit(&q, RING_NUM);
+		queue_wait(&q);
+	}
+	elapsed = now_ns() - start;
+	queue_destroy(&q);
+	CHECK(*p == (logging ? 1 : 0));
+	printf("BENCH logging=%u descriptors=%u elapsed_ns=%" PRIu64
+	       " ns_per_desc=%.2f\n", logging, batches * RING_NUM,
+	       elapsed, (double)elapsed / (batches * RING_NUM));
+	CHECK(!munmap(p, PAGE_BYTES));
+}
+
+int main(int argc, char **argv)
+{
+	const char *path = argc > 1 ? argv[1] : "/tmp/vhost-log-test";
+
+	CHECK(sysconf(_SC_PAGESIZE) == PAGE_BYTES);
+	if (argc == 2 && !strcmp(argv[1], "--bench")) {
+		benchmark(false, 10000);
+		benchmark(true, 10000);
+		return 0;
+	}
+	basic_test();
+	cross_page_test();
+	fault_test();
+	file_test(path);
+	concurrent_test();
+	alias_test(path);
+	puts("PASS vhost dirty-log regression suite");
+	return 0;
+}
diff --git a/tools/virtio/vhost_log_test.rst b/tools/virtio/vhost_log_test.rst
new file mode 100644
index 000000000000..b990824172c1
--- /dev/null
+++ b/tools/virtio/vhost_log_test.rst
@@ -0,0 +1,61 @@
+.. SPDX-License-Identifier: GPL-2.0-only
+
+Vhost dirty-log regression test
+==============================
+
+``vhost_log_test`` exercises used-ring logging through the existing
+``/dev/vhost-test`` interface. It requires a test kernel with vhost support
+and the ``vhost_test`` module built from ``tools/virtio/vhost_test`` for that
+same kernel. Run it in a disposable VM, with permission to open the device.
+
+Build the userspace executable from the kernel source root::
+
+  make -C tools/virtio vhost_log_test
+
+For a static initramfs executable, use ``LDFLAGS="-static -pthread"`` on a
+clean build. Load ``vhost``, its dependencies, and ``vhost_test`` in the
+guest, then run::
+
+  ./vhost_log_test /mnt/vhost-log-scratch
+
+The path is a disposable scratch file: the test truncates and removes it.
+Use a disk-backed filesystem such as ext4 to exercise file writeback.
+Omitting the path uses ``/tmp/vhost-log-test``. The test uses the vhost UAPI's
+fixed 4 KiB ``VHOST_PAGE_SIZE`` and assumes the native little-endian legacy
+vring layout; runtime coverage is intended for x86.
+
+Keep this as a separate tool from ``virtio_test`` and ``vhost_net_test``.
+It targets used-ring dirty logging through the dedicated ``/dev/vhost-test``
+interface, which those tests do not configure or verify. Folding it into
+either tool would add a separate module/device prerequisite without sharing
+their test setup.
+
+The suite covers every bit within a byte, repeated sets, neighboring-byte
+preservation, unaligned byte addresses, a guarded page end, a used ring
+write that spans two log pages (within one bitmap byte and across two),
+first touch, inaccessible mappings and recovery, private COW, shared-file
+sync/reread, eight workers sharing a byte, and concurrent userspace atomic
+collection.
+The collector checks each of 1000 independent rounds. Another 1000 rounds
+use two aliases of a shared file page and discard one alias's PTEs before
+each round, exercising resident and faulting accesses to the same bitmap.
+
+Used-ring logging currently discards ``log_used()`` errors. Consequently,
+the inaccessible-mapping cases check survival, absence of a successful
+write and recovery; they do not verify userspace-visible ``-EFAULT``.
+The collector verifies that all eight bits were observed in each round,
+not that every repeated dirty event was counted. Alias tests exercise
+fault fallback but do not establish a deterministic instruction ordering.
+These tests do not replace MM race analysis or live migration testing.
+
+Run the benchmark separately::
+
+  taskset -c 0 ./vhost_log_test --bench
+
+Each logging-disabled/enabled measurement warms up with 100 batches,
+then times 10000 batches of 128 descriptors. The result includes queue
+submission, worker execution and completion notification. It measures
+nanoseconds per descriptor, not isolated ``set_bit_to_user()`` latency,
+network throughput or migration time. Keep the kernel configuration and
+VM setup identical, alternate baseline/optimized runs, and report multiple
+samples. Affinity applies to the guest CPU; host CPU placement is separate.
-- 
2.43.0


^ permalink raw reply related	[flat|nested] 5+ messages in thread

* Re: [PATCH v2 1/2] vhost: set dirty log bits without pinning pages on x86
  2026-11-17  8:33 ` [PATCH v2 1/2] " zhaoguohan
@ 2026-11-17  8:44   ` sashiko-bot
  0 siblings, 0 replies; 5+ messages in thread
From: sashiko-bot @ 2026-11-17  8:44 UTC (permalink / raw)
  To: zhaoguohan; +Cc: virtualization, Michael S. Tsirkin, Eugenio Perez

> From: "Michael S. Tsirkin" <mst@redhat.com>
> 
> vhost had a TODO to replace page pinning with a version
> of set_bit that works on userspace memory, since forever.
> 
> It is really best to avoid GUP on fast path entirely.
> Implement set_bit_user and use it in vhost, to do just that.
> 
> Should not be too hard for non-x86 too.
> 
> Reported-by: Khan Zhao <zhaoguohan@kylinos.cn>
> Link: https://lore.kernel.org/all/20261112085631.128819-1-zhaoguohan@kylinos.cn/
> Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
> [Khan: declare efault with __label__ so it is local to the macro]
> Signed-off-by: Khan Zhao <zhaoguohan@kylinos.cn>

Sashiko has reviewed this patch and found no issues.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261117083323.89502-1-zhaoguohan@kylinos.cn?part=1


^ permalink raw reply	[flat|nested] 5+ messages in thread

* Re: [PATCH v2 2/2] tools/virtio: add a vhost dirty log test
  2026-11-17  8:33 ` [PATCH v2 2/2] tools/virtio: add a vhost dirty log test zhaoguohan
@ 2026-11-17  8:44   ` sashiko-bot
  0 siblings, 0 replies; 5+ messages in thread
From: sashiko-bot @ 2026-11-17  8:44 UTC (permalink / raw)
  To: zhaoguohan; +Cc: virtualization, Michael S. Tsirkin, Eugenio Perez

> From: Khan Zhao <zhaoguohan@kylinos.cn>
> 
> Add vhost_log_test, which exercises used-ring dirty logging through the
> existing vhost_test module. It sets a log base with VHOST_SET_LOG_BASE,
> enables VHOST_VRING_F_LOG on the ring, submits descriptors and checks
> the resulting bitmap from userspace. No new kernel interface is needed.
> 
> The test covers:
> 
>  - every bit in a byte, repeated sets, and neighbouring bytes being left
>    untouched, including the last byte of a page followed by a PROT_NONE
>    guard page
>  - a used ring write that spans two log pages, with both bits in the
>    same bitmap byte and in adjacent bytes
>  - a log page that has not been faulted in yet, read-only, PROT_NONE
> [ ... ]
> A --bench mode reports ns per descriptor with logging disabled and
> enabled. vhost_log_test.rst describes how to build and run the test.
> 
> Assisted-by: Claude:claude-opus-5-5
> Signed-off-by: Khan Zhao <zhaoguohan@kylinos.cn>

Sashiko has reviewed this patch and found no issues.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261117083323.89502-1-zhaoguohan@kylinos.cn?part=2


^ permalink raw reply	[flat|nested] 5+ messages in thread

end of thread, other threads:[~2026-11-17  8:44 UTC | newest]

Thread overview: 5+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-17  8:33 [PATCH v2 0/2] vhost: set dirty log bits without pinning pages on x86 zhaoguohan
2026-11-17  8:33 ` [PATCH v2 1/2] " zhaoguohan
2026-11-17  8:44   ` sashiko-bot
2026-11-17  8:33 ` [PATCH v2 2/2] tools/virtio: add a vhost dirty log test zhaoguohan
2026-11-17  8:44   ` sashiko-bot

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.