From: "Pratyush Yadav (Google)" <pratyush@kernel.org>
Add some helper functions that will be used by memfd tests. This moves
some of the complexity out of the test itself, which results in better
test readability and less code duplication.
Signed-off-by: Pratyush Yadav <ptyadav@amazon.de>
Signed-off-by: Pratyush Yadav (Google) <pratyush@kernel.org>
---
.../selftests/liveupdate/luo_test_utils.c | 175 +++++++++++++++++-
.../selftests/liveupdate/luo_test_utils.h | 9 +
2 files changed, 183 insertions(+), 1 deletion(-)
diff --git a/tools/testing/selftests/liveupdate/luo_test_utils.c b/tools/testing/selftests/liveupdate/luo_test_utils.c
index 3c8721c505df..45ace3697ee6 100644
--- a/tools/testing/selftests/liveupdate/luo_test_utils.c
+++ b/tools/testing/selftests/liveupdate/luo_test_utils.c
@@ -1,8 +1,12 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
- * Copyright (c) 2025, Google LLC.
+ * Copyright (c) 2025-2026, Google LLC.
* Pasha Tatashin <pasha.tatashin@soleen.com>
+ * Pratyush Yadav (Google) <pratyush@kernel.org>
+ *
+ * Copyright (C) 2025 Amazon.com Inc. or its affiliates.
+ * Pratyush Yadav <ptyadav@amazon.de>
*/
#define _GNU_SOURCE
@@ -23,6 +27,175 @@
#include "luo_test_utils.h"
+/* Read exactly specified size from fd. Any less results in error. */
+int read_size(int fd, char *buffer, size_t size)
+{
+ size_t remain = size;
+ ssize_t bytes_read;
+
+ while (remain) {
+ bytes_read = read(fd, buffer, remain);
+ if (bytes_read == 0)
+ return -ENODATA;
+ if (bytes_read < 0)
+ return -errno;
+
+ remain -= bytes_read;
+ }
+
+ return 0;
+}
+
+/* Write exactly specified size from fd. Any less results in error. */
+int write_size(int fd, const char *buffer, size_t size)
+{
+ size_t remain = size;
+ ssize_t written;
+
+ while (remain) {
+ written = write(fd, buffer, remain);
+ if (written == 0)
+ return -EIO;
+ if (written < 0)
+ return -errno;
+
+ remain -= written;
+ }
+
+ return 0;
+}
+
+int generate_random_data(char *buffer, size_t size)
+{
+ int fd, ret;
+
+ fd = open("/dev/urandom", O_RDONLY);
+ if (fd < 0)
+ return -errno;
+
+ ret = read_size(fd, buffer, size);
+ close(fd);
+ return ret;
+}
+
+int save_test_data(const char *filename, const char *buffer, size_t size)
+{
+ int fd, ret;
+
+ fd = open(filename, O_RDWR | O_CREAT, 0666);
+ if (fd < 0)
+ return -errno;
+
+ ret = write_size(fd, buffer, size);
+ fsync(fd);
+ close(fd);
+ return ret;
+}
+
+int load_test_data(const char *filename, char *buffer, size_t size)
+{
+ int fd, ret;
+
+ fd = open(filename, O_RDONLY);
+ if (fd < 0)
+ return -errno;
+
+ ret = read_size(fd, buffer, size);
+ close(fd);
+ return ret;
+}
+
+/* Create and initialize a memfd with random data. */
+int create_random_memfd(const char *memfd_name, char *buffer, size_t size)
+{
+ int fd;
+ int ret;
+
+ fd = memfd_create(memfd_name, 0);
+ if (fd < 0)
+ return -errno;
+
+ ret = generate_random_data(buffer, size);
+ if (ret < 0) {
+ close(fd);
+ return ret;
+ }
+
+ if (write_size(fd, buffer, size) < 0) {
+ close(fd);
+ return -errno;
+ }
+
+ /* Reset file position to beginning */
+ if (lseek(fd, 0, SEEK_SET) < 0) {
+ close(fd);
+ return -errno;
+ }
+
+ return fd;
+}
+
+/*
+ * Make sure fd contains expected data up to size. Returns 0 on success, 1 on
+ * data mismatch, -errno on error.
+ */
+int verify_fd_content(int fd, const char *expected_data, size_t size)
+{
+ char *buffer;
+ int ret;
+
+ buffer = malloc(size);
+ if (!buffer)
+ return -ENOMEM;
+
+ /* Reset file position to beginning */
+ if (lseek(fd, 0, SEEK_SET) < 0) {
+ ret = -errno;
+ goto out;
+ }
+
+ ret = read_size(fd, buffer, size);
+ if (ret < 0)
+ goto out;
+
+ if (memcmp(buffer, expected_data, size) != 0) {
+ ret = 1;
+ goto out;
+ }
+
+ ret = 0;
+
+out:
+ free(buffer);
+ return ret;
+}
+
+/*
+ * Verify fd content using mmap. Returns 0 on success, 1 on data mismatch,
+ * -errno on error.
+ */
+int verify_fd_content_mmap(int fd, const char *expected_data, size_t size)
+{
+ char *mapped_mem;
+ int ret;
+
+ mapped_mem = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
+ if (mapped_mem == MAP_FAILED)
+ return -errno;
+
+ /* ret = memcmp(mapped_mem, expected_data, size) ? 1 : 0; */
+ ret = 0;
+ for (size_t i = 0; i < size; i++) {
+ if (mapped_mem[i] != expected_data[i]) {
+ ret = 1;
+ break;
+ }
+ }
+
+ munmap(mapped_mem, size);
+ return ret;
+}
+
int luo_open_device(void)
{
return open(LUO_DEVICE, O_RDWR);
diff --git a/tools/testing/selftests/liveupdate/luo_test_utils.h b/tools/testing/selftests/liveupdate/luo_test_utils.h
index 90099bf49577..d1b85703708b 100644
--- a/tools/testing/selftests/liveupdate/luo_test_utils.h
+++ b/tools/testing/selftests/liveupdate/luo_test_utils.h
@@ -35,6 +35,15 @@ void restore_and_read_stage(int state_session_fd, int token, int *stage);
void daemonize_and_wait(void);
+int read_size(int fd, char *buffer, size_t size);
+int write_size(int fd, const char *buffer, size_t size);
+int generate_random_data(char *buffer, size_t size);
+int save_test_data(const char *filename, const char *buffer, size_t size);
+int load_test_data(const char *filename, char *buffer, size_t size);
+int create_random_memfd(const char *memfd_name, char *buffer, size_t size);
+int verify_fd_content(int fd, const char *expected_data, size_t size);
+int verify_fd_content_mmap(int fd, const char *expected_data, size_t size);
+
typedef void (*luo_test_stage1_fn)(int luo_fd);
typedef void (*luo_test_stage2_fn)(int luo_fd, int state_session_fd);
--
2.53.0.473.g4a7958ca14-googOn Mon, Mar 09, 2026 at 11:54:35AM +0000, Pratyush Yadav wrote: > From: "Pratyush Yadav (Google)" <pratyush@kernel.org> > > Add some helper functions that will be used by memfd tests. This moves > some of the complexity out of the test itself, which results in better > test readability and less code duplication. > > Signed-off-by: Pratyush Yadav <ptyadav@amazon.de> > Signed-off-by: Pratyush Yadav (Google) <pratyush@kernel.org> > --- > .../selftests/liveupdate/luo_test_utils.c | 175 +++++++++++++++++- > .../selftests/liveupdate/luo_test_utils.h | 9 + > 2 files changed, 183 insertions(+), 1 deletion(-) > > diff --git a/tools/testing/selftests/liveupdate/luo_test_utils.c b/tools/testing/selftests/liveupdate/luo_test_utils.c > index 3c8721c505df..45ace3697ee6 100644 ... > +/* > + * Make sure fd contains expected data up to size. Returns 0 on success, 1 on > + * data mismatch, -errno on error. > + */ > +int verify_fd_content(int fd, const char *expected_data, size_t size) Maybe verify_fd_content_read() to match _mmap()? WIth this and write_size() and read_size() fixed Reviewed-by: Mike Rapoport (Microsoft) <rppt@kernel.org> -- Sincerely yours, Mike.
On Mon, Mar 09, 2026 at 11:54:35AM +0000, Pratyush Yadav wrote:
> From: "Pratyush Yadav (Google)" <pratyush@kernel.org>
>
> Add some helper functions that will be used by memfd tests. This moves
> some of the complexity out of the test itself, which results in better
> test readability and less code duplication.
>
> Signed-off-by: Pratyush Yadav <ptyadav@amazon.de>
> Signed-off-by: Pratyush Yadav (Google) <pratyush@kernel.org>
> ---
> .../selftests/liveupdate/luo_test_utils.c | 175 +++++++++++++++++-
> .../selftests/liveupdate/luo_test_utils.h | 9 +
> 2 files changed, 183 insertions(+), 1 deletion(-)
Some review comments from an LLM that make sense to me as well :)
> diff --git a/tools/testing/selftests/liveupdate/luo_test_utils.c b/tools/testing/selftests/liveupdate/luo_test_utils.c
> --- a/tools/testing/selftests/liveupdate/luo_test_utils.c
> +++ b/tools/testing/selftests/liveupdate/luo_test_utils.c
[ ... ]
> +/* Read exactly specified size from fd. Any less results in error. */
> +int read_size(int fd, char *buffer, size_t size)
> +{
> + size_t remain = size;
> + ssize_t bytes_read;
> +
> + while (remain) {
> + bytes_read = read(fd, buffer, remain);
> + if (bytes_read == 0)
> + return -ENODATA;
> + if (bytes_read < 0)
> + return -errno;
> +
> + remain -= bytes_read;
> + }
Should the buffer pointer be advanced after each read()? As written,
if read() returns a partial result, the next iteration reads into the
same position, overwriting the data just read. Something like
buffer += bytes_read after remain -= bytes_read seems to be missing.
This is exercised by generate_random_data() which reads from
/dev/urandom, where partial reads are possible for large requests.
> +/* Write exactly specified size from fd. Any less results in error. */
> +int write_size(int fd, const char *buffer, size_t size)
> +{
> + size_t remain = size;
> + ssize_t written;
> +
> + while (remain) {
> + written = write(fd, buffer, remain);
> + if (written == 0)
> + return -EIO;
> + if (written < 0)
> + return -errno;
> +
> + remain -= written;
> + }
Same issue here: buffer is not advanced after each write(), so on a
partial write the same initial bytes would be re-sent instead of
continuing from where the previous write left off.
--
Sincerely yours,
Mike.
On Tue, Mar 17 2026, Mike Rapoport wrote:
> On Mon, Mar 09, 2026 at 11:54:35AM +0000, Pratyush Yadav wrote:
>> From: "Pratyush Yadav (Google)" <pratyush@kernel.org>
>>
>> Add some helper functions that will be used by memfd tests. This moves
>> some of the complexity out of the test itself, which results in better
>> test readability and less code duplication.
>>
>> Signed-off-by: Pratyush Yadav <ptyadav@amazon.de>
>> Signed-off-by: Pratyush Yadav (Google) <pratyush@kernel.org>
>> ---
>> .../selftests/liveupdate/luo_test_utils.c | 175 +++++++++++++++++-
>> .../selftests/liveupdate/luo_test_utils.h | 9 +
>> 2 files changed, 183 insertions(+), 1 deletion(-)
>
> Some review comments from an LLM that make sense to me as well :)
>
>> diff --git a/tools/testing/selftests/liveupdate/luo_test_utils.c b/tools/testing/selftests/liveupdate/luo_test_utils.c
>> --- a/tools/testing/selftests/liveupdate/luo_test_utils.c
>> +++ b/tools/testing/selftests/liveupdate/luo_test_utils.c
>
> [ ... ]
>
>> +/* Read exactly specified size from fd. Any less results in error. */
>> +int read_size(int fd, char *buffer, size_t size)
>> +{
>> + size_t remain = size;
>> + ssize_t bytes_read;
>> +
>> + while (remain) {
>> + bytes_read = read(fd, buffer, remain);
>> + if (bytes_read == 0)
>> + return -ENODATA;
>> + if (bytes_read < 0)
>> + return -errno;
>> +
>> + remain -= bytes_read;
>> + }
>
> Should the buffer pointer be advanced after each read()? As written,
> if read() returns a partial result, the next iteration reads into the
> same position, overwriting the data just read. Something like
> buffer += bytes_read after remain -= bytes_read seems to be missing.
>
> This is exercised by generate_random_data() which reads from
> /dev/urandom, where partial reads are possible for large requests.
>
>> +/* Write exactly specified size from fd. Any less results in error. */
>> +int write_size(int fd, const char *buffer, size_t size)
>> +{
>> + size_t remain = size;
>> + ssize_t written;
>> +
>> + while (remain) {
>> + written = write(fd, buffer, remain);
>> + if (written == 0)
>> + return -EIO;
>> + if (written < 0)
>> + return -errno;
>> +
>> + remain -= written;
>> + }
>
> Same issue here: buffer is not advanced after each write(), so on a
> partial write the same initial bytes would be re-sent instead of
> continuing from where the previous write left off.
Yeah, good catch on both. Will fix.
--
Regards,
Pratyush Yadav
© 2016 - 2026 Red Hat, Inc.