github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-06 21:58:01 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

seq_buf: Add seq_buf_init_append()

Browse Source 
Several strlcat() call sites being converted to seq_buf need behavior
seq_buf doesn't currently provide. The normal seq_buf_init() always
empties the buffer (sets its "len" to 0) via seq_buf_clear(). Code
migrating from strlcat(buf, ...), which appends to whatever buf already
contains, can't use seq_buf_init() without discarding that existing
content. Add seq_buf_init_append(), which preserves the existing
contents and positions the seq_buf to append after it. A buffer with
no NUL within its size starts out overflowed, as strlcat() treats it
as already truncated. Add KUnit tests for behavior coverage.

Tests passed under qemu on ARCH=x86_64 with GCC 16.2.0 and CONFIG_KASAN=y,
and on big-endian ARCH=s390 with GCC s390x-linux-gnu 16.2.0.

Assisted-by: LLM
Signed-off-by: Bill Wendling <morbo@google.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Co-developed-by: Kees Cook <kees@kernel.org>
Link: https://patch.msgid.link/20261005155708.1471260-9-kees@kernel.org
Signed-off-by: Kees Cook <kees@kernel.org>
This commit is contained in:
Bill Wendling 2026-10-05 08:56:59 -07:00 committed by Kees Cook
parent c8cd1725d2
commit 61ef3f1490
2 changed files with 94 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
include/linux/seq_buf.h
View File

@ -71,6 +71,31 @@ seq_buf_set_overflow(struct seq_buf *s)
s->len = s->size + 1;
}
/**
* seq_buf_init_append - initialize a seq_buf over a buffer that may
* already hold NUL-terminated content
* @s: the seq_buf handle
* @buf: pointer to the (possibly non-empty) buffer
* @size: total size of @buf
*
* Unlike seq_buf_init(), which always starts @buf at len=0, this
* preserves whatever NUL-terminated content @buf already holds and
* positions @s to append after it. Useful for converting code that used
* to append to an existing buffer with strlcat()/scnprintf() and friends.
*
* If @buf holds no NUL within @size, @s starts out overflowed, as
* strlcat() treats such a buffer as already truncated.
*/
static inline void
seq_buf_init_append(struct seq_buf *s, char *buf, unsigned int size)
{
s->buffer = buf;
s->size = size;
s->len = strnlen(buf, size);
if (s->len == size)
seq_buf_set_overflow(s);
}
/*
* How much buffer is left on the seq_buf?
*/

69
lib/tests/seq_buf_kunit.c
View File

@ -28,6 +28,74 @@ static void seq_buf_init_test(struct kunit *test)
KUNIT_EXPECT_EQ(test, seq_buf_strlen(&s), 0);
}
static void seq_buf_init_append_test(struct kunit *test)
{
char buf[32] = "hello";
struct seq_buf s;
/* Initial string contents match. */
seq_buf_init_append(&s, buf, sizeof(buf));
KUNIT_EXPECT_EQ(test, s.size, 32);
KUNIT_EXPECT_EQ(test, s.len, 5);
KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
KUNIT_EXPECT_EQ(test, seq_buf_buffer_left(&s), 32 - 5);
KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 5);
KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello");
KUNIT_EXPECT_EQ(test, seq_buf_strlen(&s), 5);
/* Appending with space works. */
seq_buf_puts(&s, " world");
KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 11);
KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello world");
KUNIT_EXPECT_EQ(test, seq_buf_strlen(&s), 11);
/* No truncation when space for NUL is present. */
seq_buf_init_append(&s, buf, 12);
KUNIT_EXPECT_EQ(test, s.size, 12);
KUNIT_EXPECT_EQ(test, s.len, 11);
KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 11);
KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello world");
KUNIT_EXPECT_EQ(test, seq_buf_strlen(&s), 11);
/*
* No NUL within the size: the content is already truncated, as
* strlcat() would see it, so @s starts out overflowed. The content
* stays, and appending adds nothing.
*/
seq_buf_init_append(&s, buf, 11);
KUNIT_EXPECT_EQ(test, s.size, 11);
KUNIT_EXPECT_TRUE(test, seq_buf_has_overflowed(&s));
KUNIT_EXPECT_EQ(test, seq_buf_buffer_left(&s), 0);
KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 11);
KUNIT_EXPECT_MEMEQ(test, buf, "hello world", 11);
seq_buf_puts(&s, "!");
KUNIT_EXPECT_TRUE(test, seq_buf_has_overflowed(&s));
KUNIT_EXPECT_MEMEQ(test, buf, "hello world", 11);
KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello worl");
KUNIT_EXPECT_EQ(test, seq_buf_strlen(&s), 10);
/*
* The size bounds the scan: the string runs past it, so there is
* no NUL within the size either.
*/
seq_buf_init_append(&s, buf, 5);
KUNIT_EXPECT_EQ(test, s.size, 5);
/* Overflowed at the size; an unbounded scan would find more. */
KUNIT_EXPECT_EQ(test, s.len, 5 + 1);
KUNIT_EXPECT_TRUE(test, seq_buf_has_overflowed(&s));
KUNIT_EXPECT_EQ(test, seq_buf_buffer_left(&s), 0);
KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hell");
/* With no room even for a NUL, @s is overflowed and @buf untouched. */
seq_buf_init_append(&s, buf, 0);
KUNIT_EXPECT_TRUE(test, seq_buf_has_overflowed(&s));
KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 0);
KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "");
KUNIT_EXPECT_EQ(test, buf[0], 'h');
}
static void seq_buf_declare_test(struct kunit *test)
{
DECLARE_SEQ_BUF(s, 24);
@ -669,6 +737,7 @@ static void seq_buf_terminate_test(struct kunit *test)
static struct kunit_case seq_buf_test_cases[] = {
KUNIT_CASE(seq_buf_init_test),
KUNIT_CASE(seq_buf_init_append_test),
KUNIT_CASE(seq_buf_declare_test),
KUNIT_CASE(seq_buf_clear_test),
KUNIT_CASE(seq_buf_puts_test),