Linux Kernel Selftest development
 help / color / mirror / Atom feed
* [PATCH v2 0/2] tpm: Track the response read position internally
@ 2026-11-20 12:16 Rustam Mustafin
  2026-11-20 12:16 ` [PATCH v2 1/2] " Rustam Mustafin
  2026-11-20 12:16 ` [PATCH v2 2/2] selftests: tpm2: test that io_uring reads ignore the file offset Rustam Mustafin
  0 siblings, 2 replies; 6+ messages in thread
From: Rustam Mustafin @ 2026-11-20 12:16 UTC (permalink / raw)
  To: Peter Huewe, Jarkko Sakkinen
  Cc: Jason Gunthorpe, Shuah Khan, Jaewon Yang, linux-integrity,
	linux-kselftest, linux-kernel, Rustam Mustafin

tpm_common_read() uses *off as an index into priv->data_buffer.
nonseekable_open() makes pread() fail, but an IORING_OP_READ request
still reaches tpm_common_read() through loop_rw_iter() with *off set
to sqe->off, and a plain read() racing a write() reaches it with a
stale f_pos. Both allow out-of-bounds reads and zeroing of kernel
memory.

Patch 1 moves the read position into struct file_priv, under
buffer_mutex, and ignores *off.

Patch 2 adds a kselftest: an io_uring read with sqe->off inside the
response buffer must return the whole response from its start.

Blocking io_uring, suggested in the v1 review, is no longer needed for
safety with patch 1; I discuss it in the v1 thread.

Tested in a QEMU guest with swtpm and KASAN: the tpm2 selftests pass
with patch 1, and the new one fails without it.
Claude Opus 5.5 was used in preparing this series.

Changes in v2:
- commit message reworked per review, read()/write() race trace added
- add a kselftest

v1: https://lore.kernel.org/all/20261117104838.2650999-1-rmustafin@cloudlinux.com/

Rustam Mustafin (2):
  tpm: Track the response read position internally
  selftests: tpm2: test that io_uring reads ignore the file offset

 drivers/char/tpm/tpm-dev-common.c        |  11 +-
 drivers/char/tpm/tpm-dev.h               |   1 +
 tools/testing/selftests/tpm2/.gitignore  |   1 +
 tools/testing/selftests/tpm2/Makefile    |   4 +
 tools/testing/selftests/tpm2/tpm_uring.c | 131 +++++++++++++++++++++++
 5 files changed, 143 insertions(+), 5 deletions(-)
 create mode 100644 tools/testing/selftests/tpm2/tpm_uring.c


base-commit: 666539eecdf4db623f5e3c3e55cf9f2dfad24aa4
-- 
2.52.0


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

* [PATCH v2 1/2] tpm: Track the response read position internally
  2026-11-20 12:16 [PATCH v2 0/2] tpm: Track the response read position internally Rustam Mustafin
@ 2026-11-20 12:16 ` Rustam Mustafin
  2026-11-20 12:27   ` Jarkko Sakkinen
  2026-11-20 12:16 ` [PATCH v2 2/2] selftests: tpm2: test that io_uring reads ignore the file offset Rustam Mustafin
  1 sibling, 1 reply; 6+ messages in thread
From: Rustam Mustafin @ 2026-11-20 12:16 UTC (permalink / raw)
  To: Peter Huewe, Jarkko Sakkinen
  Cc: Jason Gunthorpe, Shuah Khan, Jaewon Yang, linux-integrity,
	linux-kselftest, linux-kernel, Rustam Mustafin, stable

tpm_common_read() indexes data_buffer with the caller supplied *off.
A read issued through io_uring reaches the driver with that offset:
loop_rw_iter() passes &ki_pos to ->read(). This allows out-of-bounds
reads and zeroing of kernel memory:

  BUG: KASAN: slab-out-of-bounds in _copy_to_user+0x4b/0x70
  Read of size 16 by task iou-wrk-148/149
  Call Trace:
   _copy_to_user+0x4b/0x70
   tpm_common_read+0x16e/0x2c0
   loop_rw_iter+0x235/0x5a0
   __io_read+0xc6e/0x11a0
   io_read+0x8a/0x180

A plain read() racing a write() reaches the same access: read()
samples f_pos before taking buffer_mutex, so it can consume a new
response from the offset left by the previous one:

  BUG: KASAN: slab-out-of-bounds in _copy_to_user+0x4b/0x70
  Read of size 75 by task trigger/151
  Call Trace:
   _copy_to_user+0x4b/0x70
   tpm_common_read+0x16e/0x2c0
   vfs_read+0x189/0xc00
   ksys_read+0xf9/0x1d0

Replace *off with a read_pos member of struct file_priv. It is only
accessed under buffer_mutex, so the offset passed by the caller no
longer matters.

Fixes: 9488585b21be ("tpm: add support for partial reads")
Cc: stable@vger.kernel.org
Signed-off-by: Rustam Mustafin <rmustafin@cloudlinux.com>
---
 drivers/char/tpm/tpm-dev-common.c | 11 ++++++-----
 drivers/char/tpm/tpm-dev.h        |  1 +
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/drivers/char/tpm/tpm-dev-common.c b/drivers/char/tpm/tpm-dev-common.c
index ee91f456f975..553fc6aca94d 100644
--- a/drivers/char/tpm/tpm-dev-common.c
+++ b/drivers/char/tpm/tpm-dev-common.c
@@ -107,6 +107,7 @@ static void tpm_timeout_work(struct work_struct *work)
 	mutex_lock(&priv->buffer_mutex);
 	priv->response_read = true;
 	priv->response_length = 0;
+	priv->read_pos = 0;
 	memset(priv->data_buffer, 0, sizeof(priv->data_buffer));
 	mutex_unlock(&priv->buffer_mutex);
 	wake_up_interruptible(&priv->async_wait);
@@ -149,21 +150,21 @@ ssize_t tpm_common_read(struct file *file, char __user *buf,
 			goto out;
 		}
 
-		rc = copy_to_user(buf, priv->data_buffer + *off, ret_size);
+		rc = copy_to_user(buf, priv->data_buffer + priv->read_pos, ret_size);
 		if (rc) {
 			memset(priv->data_buffer, 0, TPM_BUFSIZE);
 			priv->response_length = 0;
 			ret_size = -EFAULT;
 		} else {
-			memset(priv->data_buffer + *off, 0, ret_size);
+			memset(priv->data_buffer + priv->read_pos, 0, ret_size);
 			priv->response_length -= ret_size;
-			*off += ret_size;
+			priv->read_pos += ret_size;
 		}
 	}
 
 out:
 	if (!priv->response_length) {
-		*off = 0;
+		priv->read_pos = 0;
 		timer_delete_sync(&priv->user_read_timer);
 		flush = true;
 	}
@@ -214,7 +215,7 @@ ssize_t tpm_common_write(struct file *file, const char __user *buf,
 
 	priv->response_length = 0;
 	priv->response_read = false;
-	*off = 0;
+	priv->read_pos = 0;
 
 	/*
 	 * If in nonblocking mode schedule an async job to send
diff --git a/drivers/char/tpm/tpm-dev.h b/drivers/char/tpm/tpm-dev.h
index f3742bcc73e3..34efb1ffa491 100644
--- a/drivers/char/tpm/tpm-dev.h
+++ b/drivers/char/tpm/tpm-dev.h
@@ -15,6 +15,7 @@ struct file_priv {
 	struct work_struct async_work;
 	wait_queue_head_t async_wait;
 	ssize_t response_length;
+	size_t read_pos;
 	bool response_read;
 	bool command_enqueued;
 
-- 
2.52.0


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

* [PATCH v2 2/2] selftests: tpm2: test that io_uring reads ignore the file offset
  2026-11-20 12:16 [PATCH v2 0/2] tpm: Track the response read position internally Rustam Mustafin
  2026-11-20 12:16 ` [PATCH v2 1/2] " Rustam Mustafin
@ 2026-11-20 12:16 ` Rustam Mustafin
  1 sibling, 0 replies; 6+ messages in thread
From: Rustam Mustafin @ 2026-11-20 12:16 UTC (permalink / raw)
  To: Peter Huewe, Jarkko Sakkinen
  Cc: Jason Gunthorpe, Shuah Khan, Jaewon Yang, linux-integrity,
	linux-kselftest, linux-kernel, Rustam Mustafin

Test that an IORING_OP_READ request on /dev/tpm0 and /dev/tpmrm0
returns the whole pending response from its start, although sqe->off
points past the response header. The offset stays inside
priv->data_buffer, so an unpatched kernel fails the test on the
returned header without an out-of-bounds access.

Signed-off-by: Rustam Mustafin <rmustafin@cloudlinux.com>
---
 tools/testing/selftests/tpm2/.gitignore  |   1 +
 tools/testing/selftests/tpm2/Makefile    |   4 +
 tools/testing/selftests/tpm2/tpm_uring.c | 131 +++++++++++++++++++++++
 3 files changed, 136 insertions(+)
 create mode 100644 tools/testing/selftests/tpm2/tpm_uring.c

diff --git a/tools/testing/selftests/tpm2/.gitignore b/tools/testing/selftests/tpm2/.gitignore
index 6d6165c5e35d..d2324bd0eca2 100644
--- a/tools/testing/selftests/tpm2/.gitignore
+++ b/tools/testing/selftests/tpm2/.gitignore
@@ -1,3 +1,4 @@
 # SPDX-License-Identifier: GPL-2.0-only
 AsyncTest.log
 SpaceTest.log
+tpm_uring
diff --git a/tools/testing/selftests/tpm2/Makefile b/tools/testing/selftests/tpm2/Makefile
index a9bf9459fb25..67f346f4cdef 100644
--- a/tools/testing/selftests/tpm2/Makefile
+++ b/tools/testing/selftests/tpm2/Makefile
@@ -1,4 +1,8 @@
 # SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
+CFLAGS += $(KHDR_INCLUDES) -idirafter ../../../include -Wall
+
+TEST_GEN_PROGS := tpm_uring
+
 include ../lib.mk
 
 TEST_PROGS := test_smoke.sh test_space.sh test_async.sh
diff --git a/tools/testing/selftests/tpm2/tpm_uring.c b/tools/testing/selftests/tpm2/tpm_uring.c
new file mode 100644
index 000000000000..9caa3cba5bf0
--- /dev/null
+++ b/tools/testing/selftests/tpm2/tpm_uring.c
@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
+/*
+ * An io_uring read chooses its own file offset. The TPM character devices
+ * must ignore it and return the response from its start.
+ */
+
+#include <endian.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <io_uring/mini_liburing.h>
+#include "../kselftest.h"
+
+#define RING_ENTRIES	4
+#define BUF_LEN		4096
+#define POLL_TIMEOUT_MS	10000
+#define TPM_VERSION_FILE	"/sys/class/tpm/tpm0/tpm_version_major"
+struct tpm_header {
+	uint16_t tag;
+	uint32_t size;
+	uint32_t return_code;
+} __attribute__((packed));
+
+/* TPM2_GetCapability(TPM_CAP_TPM_PROPERTIES, TPM_PT_FIXED, 1) */
+static const unsigned char cmd[] = {
+	0x80, 0x01,		/* TPM_ST_NO_SESSIONS */
+	0x00, 0x00, 0x00, 0x16,	/* command size */
+	0x00, 0x00, 0x01, 0x7a,	/* TPM_CC_GetCapability */
+	0x00, 0x00, 0x00, 0x06,	/* TPM_CAP_TPM_PROPERTIES */
+	0x00, 0x00, 0x01, 0x00,	/* TPM_PT_FIXED */
+	0x00, 0x00, 0x00, 0x01,	/* property count */
+};
+
+static void test_read(struct io_uring *ring, const char *path)
+{
+	static char buf[BUF_LEN];
+	const struct tpm_header *hdr = (const void *)buf;
+	struct pollfd pfd = { .events = POLLIN };
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int fd, ret, res;
+
+	fd = open(path, O_RDWR);
+	if (fd < 0) {
+		if (errno == ENOENT)
+			ksft_test_result_skip("%s: not present\n", path);
+		else
+			ksft_test_result_fail("%s: open: %s\n", path,
+					      strerror(errno));
+		return;
+	}
+
+	if (write(fd, cmd, sizeof(cmd)) != sizeof(cmd)) {
+		ksft_test_result_fail("%s: write: %s\n", path, strerror(errno));
+		goto out;
+	}
+
+	pfd.fd = fd;
+	if (poll(&pfd, 1, POLL_TIMEOUT_MS) != 1) {
+		ksft_test_result_fail("%s: no response to the command\n", path);
+		goto out;
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	memset(sqe, 0, sizeof(*sqe));
+	sqe->opcode = IORING_OP_READ;
+	sqe->fd = fd;
+	/*
+	 * Inside the response buffer: an unpatched kernel returns the response
+	 * without its header instead of reading out of bounds
+	 */
+	sqe->off = sizeof(*hdr);
+	sqe->addr = (unsigned long)buf;
+	sqe->len = BUF_LEN;
+	ret = io_uring_submit(ring);
+	if (ret != 1) {
+		ksft_test_result_fail("%s: io_uring_submit: %d\n", path, ret);
+		goto out;
+	}
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret) {
+		ksft_test_result_fail("%s: io_uring_wait_cqe: %d\n", path, ret);
+		goto out;
+	}
+	res = cqe->res;
+	io_uring_cqe_seen(ring);
+
+	/* the offset is ignored: the whole response, from its start */
+	ksft_test_result(res >= (int)sizeof(*hdr) &&
+			 be32toh(hdr->size) == res && !hdr->return_code,
+			 "%s: io_uring read %d\n", path, res);
+out:
+	close(fd);
+}
+
+/* the command is TPM2 only; test_smoke.sh skips the same way */
+static int tpm_version_major(void)
+{
+	FILE *f = fopen(TPM_VERSION_FILE, "r");
+	int major = 0;
+
+	if (f) {
+		if (fscanf(f, "%d", &major) != 1)
+			major = 0;
+		fclose(f);
+	}
+	return major;
+}
+
+int main(void)
+{
+	struct io_uring ring;
+
+	ksft_print_header();
+	if (tpm_version_major() != 2)
+		ksft_exit_skip("no TPM 2.0 device\n");
+	if (io_uring_queue_init(RING_ENTRIES, &ring, 0)) {
+		/* not built in, or disabled by kernel.io_uring_disabled */
+		if (errno == ENOSYS || errno == EPERM)
+			ksft_exit_skip("io_uring_setup: %s\n", strerror(errno));
+		ksft_exit_fail_msg("io_uring_queue_init: %s\n", strerror(errno));
+	}
+	ksft_set_plan(2);
+
+	test_read(&ring, "/dev/tpm0");
+	test_read(&ring, "/dev/tpmrm0");
+
+	io_uring_queue_exit(&ring);
+	ksft_finished();
+}
-- 
2.52.0


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

* Re: [PATCH v2 1/2] tpm: Track the response read position internally
  2026-11-20 12:16 ` [PATCH v2 1/2] " Rustam Mustafin
@ 2026-11-20 12:27   ` Jarkko Sakkinen
  2026-11-20 14:28     ` Rustam Mustafin
  0 siblings, 1 reply; 6+ messages in thread
From: Jarkko Sakkinen @ 2026-11-20 12:27 UTC (permalink / raw)
  To: Rustam Mustafin
  Cc: Peter Huewe, Jason Gunthorpe, Shuah Khan, Jaewon Yang,
	linux-integrity, linux-kselftest, linux-kernel, stable

On Fri, Nov 20, 2026 at 07:16:13PM +0700, Rustam Mustafin wrote:
> tpm_common_read() indexes data_buffer with the caller supplied *off.
> A read issued through io_uring reaches the driver with that offset:
> loop_rw_iter() passes &ki_pos to ->read(). This allows out-of-bounds
> reads and zeroing of kernel memory:
> 
>   BUG: KASAN: slab-out-of-bounds in _copy_to_user+0x4b/0x70
>   Read of size 16 by task iou-wrk-148/149
>   Call Trace:
>    _copy_to_user+0x4b/0x70
>    tpm_common_read+0x16e/0x2c0
>    loop_rw_iter+0x235/0x5a0
>    __io_read+0xc6e/0x11a0
>    io_read+0x8a/0x180
> 
> A plain read() racing a write() reaches the same access: read()
> samples f_pos before taking buffer_mutex, so it can consume a new
> response from the offset left by the previous one:
> 
>   BUG: KASAN: slab-out-of-bounds in _copy_to_user+0x4b/0x70
>   Read of size 75 by task trigger/151
>   Call Trace:
>    _copy_to_user+0x4b/0x70
>    tpm_common_read+0x16e/0x2c0
>    vfs_read+0x189/0xc00
>    ksys_read+0xf9/0x1d0
> 
> Replace *off with a read_pos member of struct file_priv. It is only
> accessed under buffer_mutex, so the offset passed by the caller no
> longer matters.
> 
> Fixes: 9488585b21be ("tpm: add support for partial reads")
> Cc: stable@vger.kernel.org
> Signed-off-by: Rustam Mustafin <rmustafin@cloudlinux.com>
> ---

So... why does not this block uring? You are implementing a feature
as a bug fix, or so that it appears.

>  drivers/char/tpm/tpm-dev-common.c | 11 ++++++-----
>  drivers/char/tpm/tpm-dev.h        |  1 +
>  2 files changed, 7 insertions(+), 5 deletions(-)
> 
> diff --git a/drivers/char/tpm/tpm-dev-common.c b/drivers/char/tpm/tpm-dev-common.c
> index ee91f456f975..553fc6aca94d 100644
> --- a/drivers/char/tpm/tpm-dev-common.c
> +++ b/drivers/char/tpm/tpm-dev-common.c
> @@ -107,6 +107,7 @@ static void tpm_timeout_work(struct work_struct *work)
>  	mutex_lock(&priv->buffer_mutex);
>  	priv->response_read = true;
>  	priv->response_length = 0;
> +	priv->read_pos = 0;
>  	memset(priv->data_buffer, 0, sizeof(priv->data_buffer));
>  	mutex_unlock(&priv->buffer_mutex);
>  	wake_up_interruptible(&priv->async_wait);
> @@ -149,21 +150,21 @@ ssize_t tpm_common_read(struct file *file, char __user *buf,
>  			goto out;
>  		}
>  
> -		rc = copy_to_user(buf, priv->data_buffer + *off, ret_size);
> +		rc = copy_to_user(buf, priv->data_buffer + priv->read_pos, ret_size);
>  		if (rc) {
>  			memset(priv->data_buffer, 0, TPM_BUFSIZE);
>  			priv->response_length = 0;
>  			ret_size = -EFAULT;
>  		} else {
> -			memset(priv->data_buffer + *off, 0, ret_size);
> +			memset(priv->data_buffer + priv->read_pos, 0, ret_size);
>  			priv->response_length -= ret_size;
> -			*off += ret_size;
> +			priv->read_pos += ret_size;
>  		}
>  	}
>  
>  out:
>  	if (!priv->response_length) {
> -		*off = 0;
> +		priv->read_pos = 0;
>  		timer_delete_sync(&priv->user_read_timer);
>  		flush = true;
>  	}
> @@ -214,7 +215,7 @@ ssize_t tpm_common_write(struct file *file, const char __user *buf,
>  
>  	priv->response_length = 0;
>  	priv->response_read = false;
> -	*off = 0;
> +	priv->read_pos = 0;
>  
>  	/*
>  	 * If in nonblocking mode schedule an async job to send
> diff --git a/drivers/char/tpm/tpm-dev.h b/drivers/char/tpm/tpm-dev.h
> index f3742bcc73e3..34efb1ffa491 100644
> --- a/drivers/char/tpm/tpm-dev.h
> +++ b/drivers/char/tpm/tpm-dev.h
> @@ -15,6 +15,7 @@ struct file_priv {
>  	struct work_struct async_work;
>  	wait_queue_head_t async_wait;
>  	ssize_t response_length;
> +	size_t read_pos;
>  	bool response_read;
>  	bool command_enqueued;
>  
> -- 
> 2.52.0
> 

Br, Jarkko

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

* Re: [PATCH v2 1/2] tpm: Track the response read position internally
  2026-11-20 12:27   ` Jarkko Sakkinen
@ 2026-11-20 14:28     ` Rustam Mustafin
  2026-11-20 14:50       ` Jarkko Sakkinen
  0 siblings, 1 reply; 6+ messages in thread
From: Rustam Mustafin @ 2026-11-20 14:28 UTC (permalink / raw)
  To: Jarkko Sakkinen
  Cc: Peter Huewe, Jason Gunthorpe, Shuah Khan, Jaewon Yang,
	linux-integrity, linux-kselftest, linux-kernel, stable

On Fri, Nov 20, 2026 at 7:27 PM Jarkko Sakkinen <jarkko@kernel.org> wrote:
> On Fri, Nov 20, 2026 at 07:16:13PM +0700, Rustam Mustafin wrote:
[...]
> So... why does not this block uring? You are implementing a feature
> as a bug fix, or so that it appears.

Patch 1 also fixes a plain read() racing a write() (the second trace),
which does not involve io_uring, so blocking io_uring alone would not
cover it. Patch 1 is small, so it might be easier to backport.

The io_uring block is posted on top of this series:
https://lore.kernel.org/all/20261120142116.1630010-1-rmustafin@cloudlinux.com/

It depends on this series, because the new ->read_iter() would let
vfs_iter_read() callers such as Coda reach tpm_common_read() with
their own offset.

Br,
Rustam

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

* Re: [PATCH v2 1/2] tpm: Track the response read position internally
  2026-11-20 14:28     ` Rustam Mustafin
@ 2026-11-20 14:50       ` Jarkko Sakkinen
  0 siblings, 0 replies; 6+ messages in thread
From: Jarkko Sakkinen @ 2026-11-20 14:50 UTC (permalink / raw)
  To: Rustam Mustafin
  Cc: Peter Huewe, Jason Gunthorpe, Shuah Khan, Jaewon Yang,
	linux-integrity, linux-kselftest, linux-kernel, stable

On Fri, Nov 20, 2026 at 09:28:53PM +0700, Rustam Mustafin wrote:
> On Fri, Nov 20, 2026 at 7:27 PM Jarkko Sakkinen <jarkko@kernel.org> wrote:
> > On Fri, Nov 20, 2026 at 07:16:13PM +0700, Rustam Mustafin wrote:
> [...]
> > So... why does not this block uring? You are implementing a feature
> > as a bug fix, or so that it appears.
> 
> Patch 1 also fixes a plain read() racing a write() (the second trace),
> which does not involve io_uring, so blocking io_uring alone would not
> cover it. Patch 1 is small, so it might be easier to backport.
> 
> The io_uring block is posted on top of this series:
> https://lore.kernel.org/all/20261120142116.1630010-1-rmustafin@cloudlinux.com/
> 
> It depends on this series, because the new ->read_iter() would let
> vfs_iter_read() callers such as Coda reach tpm_common_read() with
> their own offset.

My mishap.

Sorry. I'll look into this soon.

> 
> Br,
> Rustam

Br, Jarkko

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

end of thread, other threads:[~2026-11-20 14:50 UTC | newest]

Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-20 12:16 [PATCH v2 0/2] tpm: Track the response read position internally Rustam Mustafin
2026-11-20 12:16 ` [PATCH v2 1/2] " Rustam Mustafin
2026-11-20 12:27   ` Jarkko Sakkinen
2026-11-20 14:28     ` Rustam Mustafin
2026-11-20 14:50       ` Jarkko Sakkinen
2026-11-20 12:16 ` [PATCH v2 2/2] selftests: tpm2: test that io_uring reads ignore the file offset Rustam Mustafin

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox