* [PATCH v2 1/2] iio: test: iio-test-format: check that nothing is written past the string
2026-11-02 8:33 [PATCH v2 0/2] iio: test: iio-test-format: char format test and overrun checks Raffaele Tranfaglia via B4 Relay
@ 2026-11-02 8:33 ` Raffaele Tranfaglia via B4 Relay
2026-11-02 8:33 ` [PATCH v2 2/2] iio: test: iio-test-format: add test case for char format Raffaele Tranfaglia via B4 Relay
1 sibling, 0 replies; 3+ messages in thread
From: Raffaele Tranfaglia via B4 Relay @ 2026-11-02 8:33 UTC (permalink / raw)
To: Rodrigo Alencar, Jonathan Cameron, David Lechner, Nuno Sá,
Andy Shevchenko
Cc: linux-iio, linux-kernel, Raffaele Tranfaglia, Andy Shevchenko
From: Raffaele Tranfaglia <raffaele.tranfaglia@gmail.com>
IIO_TEST_FORMAT_EXPECT_EQ() compares the buffer only up to the first NUL
character. It does not notice if iio_format_value() writes past the end
of the formatted string, and it cannot check output that contains a NUL.
Poison the buffer before each call. Check the expected bytes, including
the NUL terminator, with KUNIT_EXPECT_MEMEQ(), and check that the rest of
the page still holds the poison value. Take the expected length from the
string literal instead of calling strlen() on the buffer.
Suggested-by: Andy Shevchenko <andriy.shevchenko@intel.com>
Signed-off-by: Raffaele Tranfaglia <raffaele.tranfaglia@gmail.com>
---
drivers/iio/test/iio-test-format.c | 50 +++++++++++++++++++++++++-------------
1 file changed, 33 insertions(+), 17 deletions(-)
diff --git a/drivers/iio/test/iio-test-format.c b/drivers/iio/test/iio-test-format.c
index e5d0a2ac4670..35b30420d995 100644
--- a/drivers/iio/test/iio-test-format.c
+++ b/drivers/iio/test/iio-test-format.c
@@ -6,20 +6,42 @@
#include <kunit/test.h>
#include <linux/iio/iio.h>
+#include <linux/string.h>
-#define IIO_TEST_FORMAT_EXPECT_EQ(_test, _buf, _ret, _val) do { \
- KUNIT_EXPECT_EQ(_test, strlen(_buf), _ret); \
- KUNIT_EXPECT_STREQ(_test, (_buf), (_val)); \
+#define IIO_TEST_FORMAT_POISON 0x5a
+
+/*
+ * Check the formatted string including its NUL terminator, and that nothing
+ * beyond it was written. _val must be a string literal. The buffer is poisoned
+ * again afterwards for the next check.
+ */
+#define IIO_TEST_FORMAT_EXPECT_EQ(_test, _buf, _ret, _val) do { \
+ KUNIT_EXPECT_EQ(_test, _ret, (ssize_t)sizeof(_val) - 1); \
+ KUNIT_EXPECT_MEMEQ(_test, _buf, _val, sizeof(_val)); \
+ KUNIT_EXPECT_NULL(_test, memchr_inv((_buf) + sizeof(_val), \
+ IIO_TEST_FORMAT_POISON, \
+ PAGE_SIZE - sizeof(_val))); \
+ memset(_buf, IIO_TEST_FORMAT_POISON, PAGE_SIZE); \
} while (0)
+static char *iio_test_format_alloc_buf(struct kunit *test)
+{
+ char *buf;
+
+ buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
+ memset(buf, IIO_TEST_FORMAT_POISON, PAGE_SIZE);
+
+ return buf;
+}
+
static void iio_test_iio_format_value_integer(struct kunit *test)
{
char *buf;
int val;
int ret;
- buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
- KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
+ buf = iio_test_format_alloc_buf(test);
val = 42;
ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
@@ -48,8 +70,7 @@ static void iio_test_iio_format_value_fixedpoint(struct kunit *test)
char *buf;
int ret;
- buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
- KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
+ buf = iio_test_format_alloc_buf(test);
/* positive >= 1 */
values[0] = 1;
@@ -109,8 +130,7 @@ static void iio_test_iio_format_value_fractional(struct kunit *test)
char *buf;
int ret;
- buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
- KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
+ buf = iio_test_format_alloc_buf(test);
/* positive < 1 */
values[0] = 1;
@@ -149,8 +169,7 @@ static void iio_test_iio_format_value_fractional_log2(struct kunit *test)
char *buf;
int ret;
- buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
- KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
+ buf = iio_test_format_alloc_buf(test);
/* positive < 1 */
values[0] = 123;
@@ -189,8 +208,7 @@ static void iio_test_iio_format_value_multiple(struct kunit *test)
char *buf;
int ret;
- buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
- KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
+ buf = iio_test_format_alloc_buf(test);
ret = iio_format_value(buf, IIO_VAL_INT_MULTIPLE,
ARRAY_SIZE(values), values);
@@ -203,8 +221,7 @@ static void iio_test_iio_format_value_integer_64(struct kunit *test)
char *buf;
int ret;
- buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
- KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
+ buf = iio_test_format_alloc_buf(test);
iio_val_s64_decompose(24, &values[0], &values[1]);
ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
@@ -241,8 +258,7 @@ static void iio_test_iio_format_value_decimal_64(struct kunit *test)
char *buf;
int ret;
- buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
- KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
+ buf = iio_test_format_alloc_buf(test);
/* DECIMAL64_MILLI: positive >= 1, value 1.234 */
iio_val_s64_decompose(1234, &values[0], &values[1]);
--
2.56.0
^ permalink raw reply [flat|nested] 3+ messages in thread* [PATCH v2 2/2] iio: test: iio-test-format: add test case for char format
2026-11-02 8:33 [PATCH v2 0/2] iio: test: iio-test-format: char format test and overrun checks Raffaele Tranfaglia via B4 Relay
2026-11-02 8:33 ` [PATCH v2 1/2] iio: test: iio-test-format: check that nothing is written past the string Raffaele Tranfaglia via B4 Relay
@ 2026-11-02 8:33 ` Raffaele Tranfaglia via B4 Relay
1 sibling, 0 replies; 3+ messages in thread
From: Raffaele Tranfaglia via B4 Relay @ 2026-11-02 8:33 UTC (permalink / raw)
To: Rodrigo Alencar, Jonathan Cameron, David Lechner, Nuno Sá,
Andy Shevchenko
Cc: linux-iio, linux-kernel, Raffaele Tranfaglia
From: Raffaele Tranfaglia <raffaele.tranfaglia@gmail.com>
IIO_VAL_CHAR is used by thermocouple drivers to report the
thermocouple type, but iio_format_value() has no test for it.
Add a test case covering printable, special and non-printable
characters, a NUL character, and values that do not fit in a char.
Signed-off-by: Raffaele Tranfaglia <raffaele.tranfaglia@gmail.com>
---
drivers/iio/test/iio-test-format.c | 67 ++++++++++++++++++++++++++++++++++++++
1 file changed, 67 insertions(+)
diff --git a/drivers/iio/test/iio-test-format.c b/drivers/iio/test/iio-test-format.c
index 35b30420d995..0faafa09f32b 100644
--- a/drivers/iio/test/iio-test-format.c
+++ b/drivers/iio/test/iio-test-format.c
@@ -215,6 +215,72 @@ static void iio_test_iio_format_value_multiple(struct kunit *test)
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1 -2 3 -4 5 \n");
}
+static void iio_test_iio_format_value_char(struct kunit *test)
+{
+ char *buf;
+ int val;
+ int ret;
+
+ buf = iio_test_format_alloc_buf(test);
+
+ /* Printable characters, e.g. a thermocouple type */
+ val = 'K';
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "K\n");
+
+ val = 'j';
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "j\n");
+
+ val = '0';
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0\n");
+
+ /* Special characters are printed as is */
+ val = ' ';
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "\x20\n");
+
+ val = '%';
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "%\n");
+
+ val = '\\';
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "\\\n");
+
+ /* Non-printable characters are printed as is */
+ val = '\n';
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "\n\n");
+
+ val = '\t';
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "\t\n");
+
+ val = 0x7f;
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "\x7f\n");
+
+ val = 0xff;
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "\xff\n");
+
+ /* A NUL character is emitted and counted like any other */
+ val = '\0';
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "\0\n");
+
+ /* Only the low byte of the value is used */
+ val = 0x100 + 'K';
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "K\n");
+
+ val = -1;
+ ret = iio_format_value(buf, IIO_VAL_CHAR, 1, &val);
+ IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "\xff\n");
+}
+
static void iio_test_iio_format_value_integer_64(struct kunit *test)
{
int values[2];
@@ -324,6 +390,7 @@ static struct kunit_case iio_format_test_cases[] = {
KUNIT_CASE(iio_test_iio_format_value_fractional),
KUNIT_CASE(iio_test_iio_format_value_fractional_log2),
KUNIT_CASE(iio_test_iio_format_value_multiple),
+ KUNIT_CASE(iio_test_iio_format_value_char),
KUNIT_CASE(iio_test_iio_format_value_integer_64),
KUNIT_CASE(iio_test_iio_format_value_decimal_64),
{ }
--
2.56.0
^ permalink raw reply [flat|nested] 3+ messages in thread