From nobody Thu Sep 11 23:23:43 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 561AFC83F17 for ; Mon, 28 Aug 2023 10:42:41 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231759AbjH1KmG (ORCPT ); Mon, 28 Aug 2023 06:42:06 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34754 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231800AbjH1Klh (ORCPT ); Mon, 28 Aug 2023 06:41:37 -0400 Received: from mx0b-001ae601.pphosted.com (mx0a-001ae601.pphosted.com [67.231.149.25]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B04C0119; Mon, 28 Aug 2023 03:41:34 -0700 (PDT) Received: from pps.filterd (m0077473.ppops.net [127.0.0.1]) by mx0a-001ae601.pphosted.com (8.17.1.22/8.17.1.22) with ESMTP id 37SABUFw018563; Mon, 28 Aug 2023 05:41:14 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cirrus.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding:content-type; s= PODMain02222019; bh=VtqyJzlmhyeo6IMIXuB6Vo1smMPZ7UgzIWxHNDjZaMQ=; b= ndArB+nzfTj4QJPSSbtxgGtln8IKHO2cJyU4CCUdQBgUWm2YR3El2/KwBUrrmHqq Urt1HJdt4V84oluBDgbJCQ5Q63LXsQA2u6OlVXxmbeOr2DAdksWszeCV6c90cPFL vMUueVBQaBXm3YxnTmgzCws72f+PY4nx+B95zTnR1A117wnSOHfLfOXr6xR7FXLd A4CkMjow1rr7SYcaOI3UsjLyDDGqSp+iHvU16l8V0pHLmxlL3YGafJrad9u9psMX XOLn07SYRjjVMtdVOS81GtxIV6Ef7FRNXlogv5UYKrW0E6HmsiRhKFJawkf0eB3P Fy6Of0Cxbg+6ZcqQf5Cj+w== Received: from ediex01.ad.cirrus.com ([84.19.233.68]) by mx0a-001ae601.pphosted.com (PPS) with ESMTPS id 3sqesya0ma-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 28 Aug 2023 05:41:14 -0500 (CDT) Received: from ediex02.ad.cirrus.com (198.61.84.81) by ediex01.ad.cirrus.com (198.61.84.80) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.37; Mon, 28 Aug 2023 11:41:12 +0100 Received: from ediswmail.ad.cirrus.com (198.61.86.93) by anon-ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server id 15.2.1118.37 via Frontend Transport; Mon, 28 Aug 2023 11:41:12 +0100 Received: from edi-sw-dsktp-006.ad.cirrus.com (edi-sw-dsktp-006.ad.cirrus.com [198.90.251.75]) by ediswmail.ad.cirrus.com (Postfix) with ESMTP id 04DD246B; Mon, 28 Aug 2023 10:41:12 +0000 (UTC) From: Richard Fitzgerald To: , , CC: , , , , "Richard Fitzgerald" Subject: [PATCH v6 01/10] kunit: string-stream: Don't create a fragment for empty strings Date: Mon, 28 Aug 2023 11:41:02 +0100 Message-ID: <20230828104111.2394344-2-rf@opensource.cirrus.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230828104111.2394344-1-rf@opensource.cirrus.com> References: <20230828104111.2394344-1-rf@opensource.cirrus.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: QS0wt-dqUX8evyjAJifpW2JVSXWhYBHn X-Proofpoint-GUID: QS0wt-dqUX8evyjAJifpW2JVSXWhYBHn X-Proofpoint-Spam-Reason: safe Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" If the result of the formatted string is an empty string just return instead of creating an empty fragment. Signed-off-by: Richard Fitzgerald Reviewed-by: Rae Moar Reviewed-by: David Gow --- lib/kunit/string-stream.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/lib/kunit/string-stream.c b/lib/kunit/string-stream.c index cc32743c1171..ed24d86af9f5 100644 --- a/lib/kunit/string-stream.c +++ b/lib/kunit/string-stream.c @@ -50,11 +50,17 @@ int string_stream_vadd(struct string_stream *stream, /* Make a copy because `vsnprintf` could change it */ va_copy(args_for_counting, args); =20 - /* Need space for null byte. */ - len =3D vsnprintf(NULL, 0, fmt, args_for_counting) + 1; + /* Evaluate length of formatted string */ + len =3D vsnprintf(NULL, 0, fmt, args_for_counting); =20 va_end(args_for_counting); =20 + if (len =3D=3D 0) + return 0; + + /* Need space for null byte. */ + len++; + frag_container =3D alloc_string_stream_fragment(stream->test, len, stream->gfp); --=20 2.30.2 From nobody Thu Sep 11 23:23:43 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D11FDC83F20 for ; Mon, 28 Aug 2023 10:42:42 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231904AbjH1KmP (ORCPT ); Mon, 28 Aug 2023 06:42:15 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34784 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231809AbjH1Klk (ORCPT ); Mon, 28 Aug 2023 06:41:40 -0400 Received: from mx0b-001ae601.pphosted.com (mx0a-001ae601.pphosted.com [67.231.149.25]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B0526129; Mon, 28 Aug 2023 03:41:34 -0700 (PDT) Received: from pps.filterd (m0077473.ppops.net [127.0.0.1]) by mx0a-001ae601.pphosted.com (8.17.1.22/8.17.1.22) with ESMTP id 37SABUFx018563; Mon, 28 Aug 2023 05:41:15 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cirrus.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding:content-type; s= PODMain02222019; bh=hkwy294lupPOL2YYqX0ssxsBL/zSbqvwE4IyREsyy6c=; b= atjXtuF3j72bzuPxWHnyxdpyaBhNCHWNK8sAKrLIRNu4wDsxbe5soP3gJWsE/VX8 KOzDRXMd//vOOI5COOiYUpwsb5top2ja1ossQB/qfZKyr2V1HNlnZWyapVR5z1dS 8eHY2nff7Qof43memquJcSXhyjojMEaJRKn5KNsilaJOORjUn8bBcZ0JQ1hZLUuU elFKlRdQ9F7Jns5TQI7FoHIcxEXUj47ZrK7EM1TLYGPlzRW75Y6Wj3BXViYwhzat I/Vns5YlIvo9RxnS4MimqPkUeiXMSsJ3D2uzMQlB2i5XJ9nx8pwwRtd1EyaQpQ4K ERLEMoHA77D69h745W17fA== Received: from ediex01.ad.cirrus.com ([84.19.233.68]) by mx0a-001ae601.pphosted.com (PPS) with ESMTPS id 3sqesya0ma-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 28 Aug 2023 05:41:15 -0500 (CDT) Received: from ediex02.ad.cirrus.com (198.61.84.81) by ediex01.ad.cirrus.com (198.61.84.80) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.37; Mon, 28 Aug 2023 11:41:12 +0100 Received: from ediswmail.ad.cirrus.com (198.61.86.93) by anon-ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server id 15.2.1118.37 via Frontend Transport; Mon, 28 Aug 2023 11:41:12 +0100 Received: from edi-sw-dsktp-006.ad.cirrus.com (edi-sw-dsktp-006.ad.cirrus.com [198.90.251.75]) by ediswmail.ad.cirrus.com (Postfix) with ESMTP id 1896F3575; Mon, 28 Aug 2023 10:41:12 +0000 (UTC) From: Richard Fitzgerald To: , , CC: , , , , "Richard Fitzgerald" Subject: [PATCH v6 02/10] kunit: string-stream: Improve testing of string_stream Date: Mon, 28 Aug 2023 11:41:03 +0100 Message-ID: <20230828104111.2394344-3-rf@opensource.cirrus.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230828104111.2394344-1-rf@opensource.cirrus.com> References: <20230828104111.2394344-1-rf@opensource.cirrus.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: Rj-cGndtFWH4S_TrbM8nRKyb1fd1D-6V X-Proofpoint-GUID: Rj-cGndtFWH4S_TrbM8nRKyb1fd1D-6V X-Proofpoint-Spam-Reason: safe Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Replace the minimal tests with more-thorough testing. string_stream_init_test() tests that struct string_stream is initialized correctly. string_stream_line_add_test() adds a series of numbered lines and checks that the resulting string contains all the lines. string_stream_variable_length_line_test() adds a large number of lines of varying length to create many fragments, then tests that all lines are present. string_stream_append_test() tests various cases of using string_stream_append() to append the content of one stream to another. Adds string_stream_append_empty_string_test() to test that adding an empty string to a string_stream doesn't create a new empty fragment. Signed-off-by: Richard Fitzgerald Reviewed-by: Rae Moar Reviewed-by: David Gow --- Changes since v5: - Avoid cast warning when using KUNIT_EXPECT_EQ() on a gfp_t. Instead pass the result of the comparison to KUNIT_EXPECT_TRUE(). While it would be nice to use KUNIT_EXPECT_EQ(), it's probably better to avoid introducing build or sparse warnings. - In string_stream_append_test() rename original_content to stream1_content_before_append. --- lib/kunit/string-stream-test.c | 233 ++++++++++++++++++++++++++++++--- 1 file changed, 217 insertions(+), 16 deletions(-) diff --git a/lib/kunit/string-stream-test.c b/lib/kunit/string-stream-test.c index 110f3a993250..7e17307ca78c 100644 --- a/lib/kunit/string-stream-test.c +++ b/lib/kunit/string-stream-test.c @@ -11,38 +11,239 @@ =20 #include "string-stream.h" =20 -static void string_stream_test_empty_on_creation(struct kunit *test) +static char *get_concatenated_string(struct kunit *test, struct string_str= eam *stream) { - struct string_stream *stream =3D alloc_string_stream(test, GFP_KERNEL); + char *str =3D string_stream_get_string(stream); =20 + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, str); + + return str; +} + +/* string_stream object is initialized correctly. */ +static void string_stream_init_test(struct kunit *test) +{ + struct string_stream *stream; + + stream =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + KUNIT_EXPECT_EQ(test, stream->length, 0); + KUNIT_EXPECT_TRUE(test, list_empty(&stream->fragments)); + KUNIT_EXPECT_PTR_EQ(test, stream->test, test); + KUNIT_EXPECT_TRUE(test, (stream->gfp =3D=3D GFP_KERNEL)); KUNIT_EXPECT_TRUE(test, string_stream_is_empty(stream)); } =20 -static void string_stream_test_not_empty_after_add(struct kunit *test) +/* + * Add a series of lines to a string_stream. Check that all lines + * appear in the correct order and no characters are dropped. + */ +static void string_stream_line_add_test(struct kunit *test) { - struct string_stream *stream =3D alloc_string_stream(test, GFP_KERNEL); + struct string_stream *stream; + char line[60]; + char *concat_string, *pos, *string_end; + size_t len, total_len; + int num_lines, i; =20 - string_stream_add(stream, "Foo"); + stream =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); =20 - KUNIT_EXPECT_FALSE(test, string_stream_is_empty(stream)); + /* Add series of sequence numbered lines */ + total_len =3D 0; + for (i =3D 0; i < 100; ++i) { + len =3D snprintf(line, sizeof(line), + "The quick brown fox jumps over the lazy penguin %d\n", i); + + /* Sanity-check that our test string isn't truncated */ + KUNIT_ASSERT_LT(test, len, sizeof(line)); + + string_stream_add(stream, line); + total_len +=3D len; + } + num_lines =3D i; + + concat_string =3D get_concatenated_string(test, stream); + KUNIT_EXPECT_NOT_ERR_OR_NULL(test, concat_string); + KUNIT_EXPECT_EQ(test, strlen(concat_string), total_len); + + /* + * Split the concatenated string at the newlines and check that + * all the original added strings are present. + */ + pos =3D concat_string; + for (i =3D 0; i < num_lines; ++i) { + string_end =3D strchr(pos, '\n'); + KUNIT_EXPECT_NOT_NULL(test, string_end); + + /* Convert to NULL-terminated string */ + *string_end =3D '\0'; + + snprintf(line, sizeof(line), + "The quick brown fox jumps over the lazy penguin %d", i); + KUNIT_EXPECT_STREQ(test, pos, line); + + pos =3D string_end + 1; + } + + /* There shouldn't be any more data after this */ + KUNIT_EXPECT_EQ(test, strlen(pos), 0); } =20 -static void string_stream_test_get_string(struct kunit *test) +/* Add a series of lines of variable length to a string_stream. */ +static void string_stream_variable_length_line_test(struct kunit *test) { - struct string_stream *stream =3D alloc_string_stream(test, GFP_KERNEL); - char *output; + static const char line[] =3D + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" + " 0123456789!$%^&*()_-+=3D{}[]:;@'~#<>,.?/|"; + struct string_stream *stream; + struct rnd_state rnd; + char *concat_string, *pos, *string_end; + size_t offset, total_len; + int num_lines, i; =20 - string_stream_add(stream, "Foo"); - string_stream_add(stream, " %s", "bar"); + stream =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); =20 - output =3D string_stream_get_string(stream); - KUNIT_ASSERT_STREQ(test, output, "Foo bar"); + /* + * Log many lines of varying lengths until we have created + * many fragments. + * The "randomness" must be repeatable. + */ + prandom_seed_state(&rnd, 3141592653589793238ULL); + total_len =3D 0; + for (i =3D 0; i < 100; ++i) { + offset =3D prandom_u32_state(&rnd) % (sizeof(line) - 1); + string_stream_add(stream, "%s\n", &line[offset]); + total_len +=3D sizeof(line) - offset; + } + num_lines =3D i; + + concat_string =3D get_concatenated_string(test, stream); + KUNIT_EXPECT_NOT_ERR_OR_NULL(test, concat_string); + KUNIT_EXPECT_EQ(test, strlen(concat_string), total_len); + + /* + * Split the concatenated string at the newlines and check that + * all the original added strings are present. + */ + prandom_seed_state(&rnd, 3141592653589793238ULL); + pos =3D concat_string; + for (i =3D 0; i < num_lines; ++i) { + string_end =3D strchr(pos, '\n'); + KUNIT_EXPECT_NOT_NULL(test, string_end); + + /* Convert to NULL-terminated string */ + *string_end =3D '\0'; + + offset =3D prandom_u32_state(&rnd) % (sizeof(line) - 1); + KUNIT_EXPECT_STREQ(test, pos, &line[offset]); + + pos =3D string_end + 1; + } + + /* There shouldn't be any more data after this */ + KUNIT_EXPECT_EQ(test, strlen(pos), 0); +} + +/* Appending the content of one string stream to another. */ +static void string_stream_append_test(struct kunit *test) +{ + static const char * const strings_1[] =3D { + "one", "two", "three", "four", "five", "six", + "seven", "eight", "nine", "ten", + }; + static const char * const strings_2[] =3D { + "Apple", "Pear", "Orange", "Banana", "Grape", "Apricot", + }; + struct string_stream *stream_1, *stream_2; + const char *stream1_content_before_append, *stream_2_content; + char *combined_content; + size_t combined_length; + int i; + + stream_1 =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_1); + + stream_2 =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_2); + + /* Append content of empty stream to empty stream */ + string_stream_append(stream_1, stream_2); + KUNIT_EXPECT_EQ(test, strlen(get_concatenated_string(test, stream_1)), 0); + + /* Add some data to stream_1 */ + for (i =3D 0; i < ARRAY_SIZE(strings_1); ++i) + string_stream_add(stream_1, "%s\n", strings_1[i]); + + stream1_content_before_append =3D get_concatenated_string(test, stream_1); + + /* Append content of empty stream to non-empty stream */ + string_stream_append(stream_1, stream_2); + KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), + stream1_content_before_append); + + /* Add some data to stream_2 */ + for (i =3D 0; i < ARRAY_SIZE(strings_2); ++i) + string_stream_add(stream_2, "%s\n", strings_2[i]); + + /* Append content of non-empty stream to non-empty stream */ + string_stream_append(stream_1, stream_2); + + /* + * End result should be the original content of stream_1 plus + * the content of stream_2. + */ + stream_2_content =3D get_concatenated_string(test, stream_2); + combined_length =3D strlen(stream1_content_before_append) + strlen(stream= _2_content); + combined_length++; /* for terminating \0 */ + combined_content =3D kunit_kmalloc(test, combined_length, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, combined_content); + snprintf(combined_content, combined_length, "%s%s", + stream1_content_before_append, stream_2_content); + + KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), combine= d_content); + + /* Append content of non-empty stream to empty stream */ + string_stream_destroy(stream_1); + + stream_1 =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_1); + + string_stream_append(stream_1, stream_2); + KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), stream_= 2_content); +} + +/* Adding an empty string should not create a fragment. */ +static void string_stream_append_empty_string_test(struct kunit *test) +{ + struct string_stream *stream; + int original_frag_count; + + stream =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + /* Formatted empty string */ + string_stream_add(stream, "%s", ""); + KUNIT_EXPECT_TRUE(test, string_stream_is_empty(stream)); + KUNIT_EXPECT_TRUE(test, list_empty(&stream->fragments)); + + /* Adding an empty string to a non-empty stream */ + string_stream_add(stream, "Add this line"); + original_frag_count =3D list_count_nodes(&stream->fragments); + + string_stream_add(stream, "%s", ""); + KUNIT_EXPECT_EQ(test, list_count_nodes(&stream->fragments), original_frag= _count); + KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream), "Add this= line"); } =20 static struct kunit_case string_stream_test_cases[] =3D { - KUNIT_CASE(string_stream_test_empty_on_creation), - KUNIT_CASE(string_stream_test_not_empty_after_add), - KUNIT_CASE(string_stream_test_get_string), + KUNIT_CASE(string_stream_init_test), + KUNIT_CASE(string_stream_line_add_test), + KUNIT_CASE(string_stream_variable_length_line_test), + KUNIT_CASE(string_stream_append_test), + KUNIT_CASE(string_stream_append_empty_string_test), {} }; =20 --=20 2.30.2 From nobody Thu Sep 11 23:23:43 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id C1F84C83F21 for ; Mon, 28 Aug 2023 10:42:42 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231807AbjH1KmJ (ORCPT ); Mon, 28 Aug 2023 06:42:09 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34736 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231791AbjH1Klh (ORCPT ); Mon, 28 Aug 2023 06:41:37 -0400 Received: from mx0b-001ae601.pphosted.com (mx0a-001ae601.pphosted.com [67.231.149.25]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id ACFAA115; Mon, 28 Aug 2023 03:41:34 -0700 (PDT) Received: from pps.filterd (m0077473.ppops.net [127.0.0.1]) by mx0a-001ae601.pphosted.com (8.17.1.22/8.17.1.22) with ESMTP id 37SABUG0018563; Mon, 28 Aug 2023 05:41:16 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cirrus.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding:content-type; s= PODMain02222019; bh=IsHcCogZc9nE42h+SI2xzyi4lTBdJGLSQUlVKBv73fs=; b= WToMHWgPd4AyrJRaj7ZCeF0zVt9k/GDSrVDzmnKw2ITdLjsg71CUugcoR59w72x5 HRqp0KFrJwpwrpMtCF/++/F9MDfxF2iYsgvqscF59/nC0fb4qf8Th4kE8rUaMybw a0DNNi9Oxhh+vaWHwW8zwhVtoA/MJmBlrt+rbtuN0JVZMe/bZNrpD9vtwrXy1MNt POprDI8h3Go8t8NqL9Qy3uzLG3BOhecg1dmhABW1FqIDdpH0Zj2Vx7a+dFsUuutS 8fzGch14p4zlI/3GwiQz4x0VUc9LTWSb1KUV/bdZKnfNBkzdXqvO2/BLsFPSbNhq DcNkbb2CuiquTDZv3Q1imQ== Received: from ediex01.ad.cirrus.com ([84.19.233.68]) by mx0a-001ae601.pphosted.com (PPS) with ESMTPS id 3sqesya0ma-3 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 28 Aug 2023 05:41:15 -0500 (CDT) Received: from ediex02.ad.cirrus.com (198.61.84.81) by ediex01.ad.cirrus.com (198.61.84.80) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.37; Mon, 28 Aug 2023 11:41:12 +0100 Received: from ediswmail.ad.cirrus.com (198.61.86.93) by anon-ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server id 15.2.1118.37 via Frontend Transport; Mon, 28 Aug 2023 11:41:12 +0100 Received: from edi-sw-dsktp-006.ad.cirrus.com (edi-sw-dsktp-006.ad.cirrus.com [198.90.251.75]) by ediswmail.ad.cirrus.com (Postfix) with ESMTP id 29A86357C; Mon, 28 Aug 2023 10:41:12 +0000 (UTC) From: Richard Fitzgerald To: , , CC: , , , , "Richard Fitzgerald" Subject: [PATCH v6 03/10] kunit: string-stream: Add option to make all lines end with newline Date: Mon, 28 Aug 2023 11:41:04 +0100 Message-ID: <20230828104111.2394344-4-rf@opensource.cirrus.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230828104111.2394344-1-rf@opensource.cirrus.com> References: <20230828104111.2394344-1-rf@opensource.cirrus.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: t6JTTp5vQFjgRnY7pKLnr4HSlagLmyCM X-Proofpoint-GUID: t6JTTp5vQFjgRnY7pKLnr4HSlagLmyCM X-Proofpoint-Spam-Reason: safe Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add an optional feature to string_stream that will append a newline to any added string that does not already end with a newline. The purpose of this is so that string_stream can be used to collect log lines. This is enabled/disabled by calling string_stream_set_append_newlines(). Signed-off-by: Richard Fitzgerald Reviewed-by: Rae Moar Reviewed-by: David Gow --- lib/kunit/string-stream.c | 28 +++++++++++++++++++++------- lib/kunit/string-stream.h | 7 +++++++ 2 files changed, 28 insertions(+), 7 deletions(-) diff --git a/lib/kunit/string-stream.c b/lib/kunit/string-stream.c index ed24d86af9f5..1dcf6513b692 100644 --- a/lib/kunit/string-stream.c +++ b/lib/kunit/string-stream.c @@ -44,32 +44,46 @@ int string_stream_vadd(struct string_stream *stream, va_list args) { struct string_stream_fragment *frag_container; - int len; + int buf_len, result_len; va_list args_for_counting; =20 /* Make a copy because `vsnprintf` could change it */ va_copy(args_for_counting, args); =20 /* Evaluate length of formatted string */ - len =3D vsnprintf(NULL, 0, fmt, args_for_counting); + buf_len =3D vsnprintf(NULL, 0, fmt, args_for_counting); =20 va_end(args_for_counting); =20 - if (len =3D=3D 0) + if (buf_len =3D=3D 0) return 0; =20 + /* Reserve one extra for possible appended newline. */ + if (stream->append_newlines) + buf_len++; + /* Need space for null byte. */ - len++; + buf_len++; =20 frag_container =3D alloc_string_stream_fragment(stream->test, - len, + buf_len, stream->gfp); if (IS_ERR(frag_container)) return PTR_ERR(frag_container); =20 - len =3D vsnprintf(frag_container->fragment, len, fmt, args); + if (stream->append_newlines) { + /* Don't include reserved newline byte in writeable length. */ + result_len =3D vsnprintf(frag_container->fragment, buf_len - 1, fmt, arg= s); + + /* Append newline if necessary. */ + if (frag_container->fragment[result_len - 1] !=3D '\n') + result_len =3D strlcat(frag_container->fragment, "\n", buf_len); + } else { + result_len =3D vsnprintf(frag_container->fragment, buf_len, fmt, args); + } + spin_lock(&stream->lock); - stream->length +=3D len; + stream->length +=3D result_len; list_add_tail(&frag_container->node, &stream->fragments); spin_unlock(&stream->lock); =20 diff --git a/lib/kunit/string-stream.h b/lib/kunit/string-stream.h index b669f9a75a94..048930bf97f0 100644 --- a/lib/kunit/string-stream.h +++ b/lib/kunit/string-stream.h @@ -25,6 +25,7 @@ struct string_stream { spinlock_t lock; struct kunit *test; gfp_t gfp; + bool append_newlines; }; =20 struct kunit; @@ -47,4 +48,10 @@ bool string_stream_is_empty(struct string_stream *stream= ); =20 void string_stream_destroy(struct string_stream *stream); =20 +static inline void string_stream_set_append_newlines(struct string_stream = *stream, + bool append_newlines) +{ + stream->append_newlines =3D append_newlines; +} + #endif /* _KUNIT_STRING_STREAM_H */ --=20 2.30.2 From nobody Thu Sep 11 23:23:43 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 71753C83F23 for ; Mon, 28 Aug 2023 10:42:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231725AbjH1Klc (ORCPT ); Mon, 28 Aug 2023 06:41:32 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47568 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231839AbjH1Kl3 (ORCPT ); Mon, 28 Aug 2023 06:41:29 -0400 Received: from mx0b-001ae601.pphosted.com (mx0b-001ae601.pphosted.com [67.231.152.168]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CEF0B10D; Mon, 28 Aug 2023 03:41:26 -0700 (PDT) Received: from pps.filterd (m0077474.ppops.net [127.0.0.1]) by mx0b-001ae601.pphosted.com (8.17.1.22/8.17.1.22) with ESMTP id 37SABuZ6031648; Mon, 28 Aug 2023 05:41:14 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cirrus.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding:content-type; s= PODMain02222019; bh=RkZ8xCcZ3UMTGogkeydC7OX2TEr2MncOm2cw4C1tpFU=; b= Cs6bmFuPk1hNLC+BomMoX9EjNgMc19YxA9GAtebXTBCyPqPhM+GA+SAw85eerWXm vBvH6n10N6gvlvjV8QfiIOCOmmOIT8KkT+QLud+VFnNo8onrBjo2dKwO1RvziW0I IlVCddsXA8qByBbRnx9uahfSbsSkpkiyWXZ+Kou3+4s+OqA6Oza05jg74cfpDsav W76mahzOYRhfwmeb8HsfDBIaK2Mku6j3mV6ABHKhYRVe79/DvXj9Xp24Ulp+IcJs Eq/GmBNus5t/Do0i7fFQEOqK9TkFN13iomYsk2WFE7lP6nQHjOsKrdATchVmpFag 2lHRhSg1uugRMeS6Osrg4Q== Received: from ediex02.ad.cirrus.com ([84.19.233.68]) by mx0b-001ae601.pphosted.com (PPS) with ESMTPS id 3sqdtj1my9-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 28 Aug 2023 05:41:14 -0500 (CDT) Received: from ediex02.ad.cirrus.com (198.61.84.81) by ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.37; Mon, 28 Aug 2023 11:41:12 +0100 Received: from ediswmail.ad.cirrus.com (198.61.86.93) by anon-ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server id 15.2.1118.37 via Frontend Transport; Mon, 28 Aug 2023 11:41:12 +0100 Received: from edi-sw-dsktp-006.ad.cirrus.com (edi-sw-dsktp-006.ad.cirrus.com [198.90.251.75]) by ediswmail.ad.cirrus.com (Postfix) with ESMTP id 3B90746B; Mon, 28 Aug 2023 10:41:12 +0000 (UTC) From: Richard Fitzgerald To: , , CC: , , , , "Richard Fitzgerald" Subject: [PATCH v6 04/10] kunit: string-stream-test: Add cases for string_stream newline appending Date: Mon, 28 Aug 2023 11:41:05 +0100 Message-ID: <20230828104111.2394344-5-rf@opensource.cirrus.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230828104111.2394344-1-rf@opensource.cirrus.com> References: <20230828104111.2394344-1-rf@opensource.cirrus.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: F6mP4e2phWsvW7AoK6LOWJHWyYx-b_w7 X-Proofpoint-GUID: F6mP4e2phWsvW7AoK6LOWJHWyYx-b_w7 X-Proofpoint-Spam-Reason: safe Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add test cases for testing the string_stream feature that appends a newline to strings that do not already end with a newline. string_stream_no_auto_newline_test() tests with this feature disabled. Newlines should not be added or dropped. string_stream_auto_newline_test() tests with this feature enabled. Newlines should be added to lines that do not end with a newline. string_stream_append_auto_newline_test() tests appending the content of one stream to another stream when the target stream has newline appending enabled. Signed-off-by: Richard Fitzgerald Reviewed-by: Rae Moar Reviewed-by: David Gow --- lib/kunit/string-stream-test.c | 93 ++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) diff --git a/lib/kunit/string-stream-test.c b/lib/kunit/string-stream-test.c index 7e17307ca78c..f117c4b7389b 100644 --- a/lib/kunit/string-stream-test.c +++ b/lib/kunit/string-stream-test.c @@ -32,6 +32,7 @@ static void string_stream_init_test(struct kunit *test) KUNIT_EXPECT_TRUE(test, list_empty(&stream->fragments)); KUNIT_EXPECT_PTR_EQ(test, stream->test, test); KUNIT_EXPECT_TRUE(test, (stream->gfp =3D=3D GFP_KERNEL)); + KUNIT_EXPECT_FALSE(test, stream->append_newlines); KUNIT_EXPECT_TRUE(test, string_stream_is_empty(stream)); } =20 @@ -215,6 +216,45 @@ static void string_stream_append_test(struct kunit *te= st) KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), stream_= 2_content); } =20 +/* Appending the content of one string stream to one with auto-newlining. = */ +static void string_stream_append_auto_newline_test(struct kunit *test) +{ + struct string_stream *stream_1, *stream_2; + + /* Stream 1 has newline appending enabled */ + stream_1 =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_1); + string_stream_set_append_newlines(stream_1, true); + KUNIT_EXPECT_TRUE(test, stream_1->append_newlines); + + /* Stream 2 does not append newlines */ + stream_2 =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_2); + + /* Appending a stream with a newline should not add another newline */ + string_stream_add(stream_1, "Original string\n"); + string_stream_add(stream_2, "Appended content\n"); + string_stream_add(stream_2, "More stuff\n"); + string_stream_append(stream_1, stream_2); + KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), + "Original string\nAppended content\nMore stuff\n"); + + string_stream_destroy(stream_2); + stream_2 =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_2); + + /* + * Appending a stream without newline should add a final newline. + * The appended string_stream is treated as a single string so newlines + * should not be inserted between fragments. + */ + string_stream_add(stream_2, "Another"); + string_stream_add(stream_2, "And again"); + string_stream_append(stream_1, stream_2); + KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), + "Original string\nAppended content\nMore stuff\nAnotherAnd again\n"); +} + /* Adding an empty string should not create a fragment. */ static void string_stream_append_empty_string_test(struct kunit *test) { @@ -238,12 +278,65 @@ static void string_stream_append_empty_string_test(st= ruct kunit *test) KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream), "Add this= line"); } =20 +/* Adding strings without automatic newline appending */ +static void string_stream_no_auto_newline_test(struct kunit *test) +{ + struct string_stream *stream; + + stream =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + /* + * Add some strings with and without newlines. All formatted newlines + * should be preserved. It should not add any extra newlines. + */ + string_stream_add(stream, "One"); + string_stream_add(stream, "Two\n"); + string_stream_add(stream, "%s\n", "Three"); + string_stream_add(stream, "%s", "Four\n"); + string_stream_add(stream, "Five\n%s", "Six"); + string_stream_add(stream, "Seven\n\n"); + string_stream_add(stream, "Eight"); + KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream), + "OneTwo\nThree\nFour\nFive\nSixSeven\n\nEight"); +} + +/* Adding strings with automatic newline appending */ +static void string_stream_auto_newline_test(struct kunit *test) +{ + struct string_stream *stream; + + stream =3D alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + string_stream_set_append_newlines(stream, true); + KUNIT_EXPECT_TRUE(test, stream->append_newlines); + + /* + * Add some strings with and without newlines. Newlines should + * be appended to lines that do not end with \n, but newlines + * resulting from the formatting should not be changed. + */ + string_stream_add(stream, "One"); + string_stream_add(stream, "Two\n"); + string_stream_add(stream, "%s\n", "Three"); + string_stream_add(stream, "%s", "Four\n"); + string_stream_add(stream, "Five\n%s", "Six"); + string_stream_add(stream, "Seven\n\n"); + string_stream_add(stream, "Eight"); + KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream), + "One\nTwo\nThree\nFour\nFive\nSix\nSeven\n\nEight\n"); +} + static struct kunit_case string_stream_test_cases[] =3D { KUNIT_CASE(string_stream_init_test), KUNIT_CASE(string_stream_line_add_test), KUNIT_CASE(string_stream_variable_length_line_test), KUNIT_CASE(string_stream_append_test), + KUNIT_CASE(string_stream_append_auto_newline_test), KUNIT_CASE(string_stream_append_empty_string_test), + KUNIT_CASE(string_stream_no_auto_newline_test), + KUNIT_CASE(string_stream_auto_newline_test), {} }; =20 --=20 2.30.2 From nobody Thu Sep 11 23:23:43 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id F0D79C83F24 for ; Mon, 28 Aug 2023 10:42:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231911AbjH1KmQ (ORCPT ); Mon, 28 Aug 2023 06:42:16 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34800 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231804AbjH1Klj (ORCPT ); Mon, 28 Aug 2023 06:41:39 -0400 Received: from mx0b-001ae601.pphosted.com (mx0a-001ae601.pphosted.com [67.231.149.25]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A981CB9; Mon, 28 Aug 2023 03:41:35 -0700 (PDT) Received: from pps.filterd (m0077473.ppops.net [127.0.0.1]) by mx0a-001ae601.pphosted.com (8.17.1.22/8.17.1.22) with ESMTP id 37SABUG1018563; Mon, 28 Aug 2023 05:41:17 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cirrus.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding:content-type; s= PODMain02222019; bh=MruAHJU2cpboKux7PAcM0znPrqfaNXl6UI4/jH4wtCs=; b= cCCZKS9vW11uQFoQrr5EFNGm1Mx/tYxY7iXrVsB2hO4XCiI6Zq8hdusLdlQR9xS8 q/sQggYqlIbIZl1riZJXvK3viSWcDaYrHDVph+YYv/SZ6egPcvnUDT7rXbfPNmRT cq+BJJbZG1IWHO7/cFj/L6q0y+2yYDUt0jvpmIRgKtoDQTHsn2lZknd7lxD+bNeQ QsmuUVdfwyRWa8+f6coc+g+TBOl6gvFai1wqUiKNMxHUeJ7Qes5odVjiEmI4Ikqb YX2WXeg9Do0t284viDWRplzN9X2zdiP/DVnbH6WR/ykkU5ola2FS96EUIrTFoBVF GRPsYrKxuabilNXgxKZw1A== Received: from ediex01.ad.cirrus.com ([84.19.233.68]) by mx0a-001ae601.pphosted.com (PPS) with ESMTPS id 3sqesya0ma-4 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 28 Aug 2023 05:41:16 -0500 (CDT) Received: from ediex02.ad.cirrus.com (198.61.84.81) by ediex01.ad.cirrus.com (198.61.84.80) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.37; Mon, 28 Aug 2023 11:41:12 +0100 Received: from ediswmail.ad.cirrus.com (198.61.86.93) by anon-ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server id 15.2.1118.37 via Frontend Transport; Mon, 28 Aug 2023 11:41:12 +0100 Received: from edi-sw-dsktp-006.ad.cirrus.com (edi-sw-dsktp-006.ad.cirrus.com [198.90.251.75]) by ediswmail.ad.cirrus.com (Postfix) with ESMTP id 53D3111AA; Mon, 28 Aug 2023 10:41:12 +0000 (UTC) From: Richard Fitzgerald To: , , CC: , , , , "Richard Fitzgerald" Subject: [PATCH v6 05/10] kunit: Don't use a managed alloc in is_literal() Date: Mon, 28 Aug 2023 11:41:06 +0100 Message-ID: <20230828104111.2394344-6-rf@opensource.cirrus.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230828104111.2394344-1-rf@opensource.cirrus.com> References: <20230828104111.2394344-1-rf@opensource.cirrus.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: udxFeyF1CwLIV4ZzE7QIvD9nWV4sgIfe X-Proofpoint-GUID: udxFeyF1CwLIV4ZzE7QIvD9nWV4sgIfe X-Proofpoint-Spam-Reason: safe Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" There is no need to use a test-managed alloc in is_literal(). The function frees the temporary buffer before returning. This removes the only use of the test and gfp members of struct string_stream outside of the string_stream implementation. Signed-off-by: Richard Fitzgerald Reviewed-by: David Gow --- lib/kunit/assert.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/lib/kunit/assert.c b/lib/kunit/assert.c index 05a09652f5a1..dd1d633d0fe2 100644 --- a/lib/kunit/assert.c +++ b/lib/kunit/assert.c @@ -89,8 +89,7 @@ void kunit_ptr_not_err_assert_format(const struct kunit_a= ssert *assert, EXPORT_SYMBOL_GPL(kunit_ptr_not_err_assert_format); =20 /* Checks if `text` is a literal representing `value`, e.g. "5" and 5 */ -static bool is_literal(struct kunit *test, const char *text, long long val= ue, - gfp_t gfp) +static bool is_literal(const char *text, long long value) { char *buffer; int len; @@ -100,14 +99,15 @@ static bool is_literal(struct kunit *test, const char = *text, long long value, if (strlen(text) !=3D len) return false; =20 - buffer =3D kunit_kmalloc(test, len+1, gfp); + buffer =3D kmalloc(len+1, GFP_KERNEL); if (!buffer) return false; =20 snprintf(buffer, len+1, "%lld", value); ret =3D strncmp(buffer, text, len) =3D=3D 0; =20 - kunit_kfree(test, buffer); + kfree(buffer); + return ret; } =20 @@ -125,14 +125,12 @@ void kunit_binary_assert_format(const struct kunit_as= sert *assert, binary_assert->text->left_text, binary_assert->text->operation, binary_assert->text->right_text); - if (!is_literal(stream->test, binary_assert->text->left_text, - binary_assert->left_value, stream->gfp)) + if (!is_literal(binary_assert->text->left_text, binary_assert->left_value= )) string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s =3D=3D %lld (0x%ll= x)\n", binary_assert->text->left_text, binary_assert->left_value, binary_assert->left_value); - if (!is_literal(stream->test, binary_assert->text->right_text, - binary_assert->right_value, stream->gfp)) + if (!is_literal(binary_assert->text->right_text, binary_assert->right_val= ue)) string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s =3D=3D %lld (0x%ll= x)", binary_assert->text->right_text, binary_assert->right_value, --=20 2.30.2 From nobody Thu Sep 11 23:23:43 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5A6B8C83F28 for ; Mon, 28 Aug 2023 10:42:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231822AbjH1KmN (ORCPT ); Mon, 28 Aug 2023 06:42:13 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34764 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231805AbjH1Klj (ORCPT ); Mon, 28 Aug 2023 06:41:39 -0400 Received: from mx0b-001ae601.pphosted.com (mx0a-001ae601.pphosted.com [67.231.149.25]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4C9B0115; Mon, 28 Aug 2023 03:41:36 -0700 (PDT) Received: from pps.filterd (m0077473.ppops.net [127.0.0.1]) by mx0a-001ae601.pphosted.com (8.17.1.22/8.17.1.22) with ESMTP id 37SABUG3018563; Mon, 28 Aug 2023 05:41:18 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cirrus.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding:content-type; s= PODMain02222019; bh=H7DBADs1tbBK945kUqOgdIIVn1T7TgWLx0folmF96bs=; b= YMDXLut+Umgxd/k1mBZS79uZsa8NRZbZBEyOMoQumoYanQC/9dm38PPG+OB0v0pc MzMLgrNL8VzULkTARflYDv5/fHmpAkie1/W8IEx5it5oTGbf7921m6fPR2af1fLN jXNeAOptZyR5ixvT+exc5fs8gq7ZksO70mtV3ezNG21fGzY81VeUEsFPXOD5JHMO xmd7AqRC96ub/0B1R4bITd4MvM3JlvLltLoPhg1jSJii3k6OK46snTQiwzU8QmWb AkEyNeCX8P3rcvkbUhD36+iXokI6otf5ydEHsYoga/tUcUJKhI4COgslE9I6uUm8 YGJ25DfdAQSiVDeGiI5G8g== Received: from ediex01.ad.cirrus.com ([84.19.233.68]) by mx0a-001ae601.pphosted.com (PPS) with ESMTPS id 3sqesya0ma-5 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 28 Aug 2023 05:41:17 -0500 (CDT) Received: from ediex02.ad.cirrus.com (198.61.84.81) by ediex01.ad.cirrus.com (198.61.84.80) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.37; Mon, 28 Aug 2023 11:41:12 +0100 Received: from ediswmail.ad.cirrus.com (198.61.86.93) by anon-ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server id 15.2.1118.37 via Frontend Transport; Mon, 28 Aug 2023 11:41:12 +0100 Received: from edi-sw-dsktp-006.ad.cirrus.com (edi-sw-dsktp-006.ad.cirrus.com [198.90.251.75]) by ediswmail.ad.cirrus.com (Postfix) with ESMTP id 67218357D; Mon, 28 Aug 2023 10:41:12 +0000 (UTC) From: Richard Fitzgerald To: , , CC: , , , , "Richard Fitzgerald" Subject: [PATCH v6 06/10] kunit: string-stream: Add kunit_alloc_string_stream() Date: Mon, 28 Aug 2023 11:41:07 +0100 Message-ID: <20230828104111.2394344-7-rf@opensource.cirrus.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230828104111.2394344-1-rf@opensource.cirrus.com> References: <20230828104111.2394344-1-rf@opensource.cirrus.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: -_qrISrWRIo-_EhaIhQ74xWoWGeQOBy4 X-Proofpoint-GUID: -_qrISrWRIo-_EhaIhQ74xWoWGeQOBy4 X-Proofpoint-Spam-Reason: safe Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add function kunit_alloc_string_stream() to do a resource-managed allocation of a string stream, and corresponding kunit_free_string_stream() to free the resource-managed stream. This is preparing for decoupling the string_stream implementation from struct kunit, to reduce the amount of code churn when that happens. Currently: - kunit_alloc_string_stream() only calls alloc_string_stream(). - kunit_free_string_stream() takes a struct kunit* which isn't used yet. Callers of the old alloc_string_stream() and string_stream_destroy() are all requesting a managed allocation so have been changed to use the new functions. alloc_string_stream() has been temporarily made static because its current behavior has been replaced with kunit_alloc_string_stream(). Signed-off-by: Richard Fitzgerald Reviewed-by: David Gow --- lib/kunit/string-stream-test.c | 28 ++++++++++++++-------------- lib/kunit/string-stream.c | 12 +++++++++++- lib/kunit/string-stream.h | 3 ++- lib/kunit/test.c | 4 ++-- 4 files changed, 29 insertions(+), 18 deletions(-) diff --git a/lib/kunit/string-stream-test.c b/lib/kunit/string-stream-test.c index f117c4b7389b..46b18e940b73 100644 --- a/lib/kunit/string-stream-test.c +++ b/lib/kunit/string-stream-test.c @@ -25,7 +25,7 @@ static void string_stream_init_test(struct kunit *test) { struct string_stream *stream; =20 - stream =3D alloc_string_stream(test, GFP_KERNEL); + stream =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); =20 KUNIT_EXPECT_EQ(test, stream->length, 0); @@ -48,7 +48,7 @@ static void string_stream_line_add_test(struct kunit *tes= t) size_t len, total_len; int num_lines, i; =20 - stream =3D alloc_string_stream(test, GFP_KERNEL); + stream =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); =20 /* Add series of sequence numbered lines */ @@ -104,7 +104,7 @@ static void string_stream_variable_length_line_test(str= uct kunit *test) size_t offset, total_len; int num_lines, i; =20 - stream =3D alloc_string_stream(test, GFP_KERNEL); + stream =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); =20 /* @@ -164,10 +164,10 @@ static void string_stream_append_test(struct kunit *t= est) size_t combined_length; int i; =20 - stream_1 =3D alloc_string_stream(test, GFP_KERNEL); + stream_1 =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_1); =20 - stream_2 =3D alloc_string_stream(test, GFP_KERNEL); + stream_2 =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_2); =20 /* Append content of empty stream to empty stream */ @@ -207,9 +207,9 @@ static void string_stream_append_test(struct kunit *tes= t) KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), combine= d_content); =20 /* Append content of non-empty stream to empty stream */ - string_stream_destroy(stream_1); + kunit_free_string_stream(test, stream_1); =20 - stream_1 =3D alloc_string_stream(test, GFP_KERNEL); + stream_1 =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_1); =20 string_stream_append(stream_1, stream_2); @@ -222,13 +222,13 @@ static void string_stream_append_auto_newline_test(st= ruct kunit *test) struct string_stream *stream_1, *stream_2; =20 /* Stream 1 has newline appending enabled */ - stream_1 =3D alloc_string_stream(test, GFP_KERNEL); + stream_1 =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_1); string_stream_set_append_newlines(stream_1, true); KUNIT_EXPECT_TRUE(test, stream_1->append_newlines); =20 /* Stream 2 does not append newlines */ - stream_2 =3D alloc_string_stream(test, GFP_KERNEL); + stream_2 =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_2); =20 /* Appending a stream with a newline should not add another newline */ @@ -239,8 +239,8 @@ static void string_stream_append_auto_newline_test(stru= ct kunit *test) KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), "Original string\nAppended content\nMore stuff\n"); =20 - string_stream_destroy(stream_2); - stream_2 =3D alloc_string_stream(test, GFP_KERNEL); + kunit_free_string_stream(test, stream_2); + stream_2 =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_2); =20 /* @@ -261,7 +261,7 @@ static void string_stream_append_empty_string_test(stru= ct kunit *test) struct string_stream *stream; int original_frag_count; =20 - stream =3D alloc_string_stream(test, GFP_KERNEL); + stream =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); =20 /* Formatted empty string */ @@ -283,7 +283,7 @@ static void string_stream_no_auto_newline_test(struct k= unit *test) { struct string_stream *stream; =20 - stream =3D alloc_string_stream(test, GFP_KERNEL); + stream =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); =20 /* @@ -306,7 +306,7 @@ static void string_stream_auto_newline_test(struct kuni= t *test) { struct string_stream *stream; =20 - stream =3D alloc_string_stream(test, GFP_KERNEL); + stream =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); =20 string_stream_set_append_newlines(stream, true); diff --git a/lib/kunit/string-stream.c b/lib/kunit/string-stream.c index 1dcf6513b692..12ecf15e1f6b 100644 --- a/lib/kunit/string-stream.c +++ b/lib/kunit/string-stream.c @@ -153,7 +153,7 @@ bool string_stream_is_empty(struct string_stream *strea= m) return list_empty(&stream->fragments); } =20 -struct string_stream *alloc_string_stream(struct kunit *test, gfp_t gfp) +static struct string_stream *alloc_string_stream(struct kunit *test, gfp_t= gfp) { struct string_stream *stream; =20 @@ -173,3 +173,13 @@ void string_stream_destroy(struct string_stream *strea= m) { string_stream_clear(stream); } + +struct string_stream *kunit_alloc_string_stream(struct kunit *test, gfp_t = gfp) +{ + return alloc_string_stream(test, gfp); +} + +void kunit_free_string_stream(struct kunit *test, struct string_stream *st= ream) +{ + string_stream_destroy(stream); +} diff --git a/lib/kunit/string-stream.h b/lib/kunit/string-stream.h index 048930bf97f0..3e70ee9d66e9 100644 --- a/lib/kunit/string-stream.h +++ b/lib/kunit/string-stream.h @@ -30,7 +30,8 @@ struct string_stream { =20 struct kunit; =20 -struct string_stream *alloc_string_stream(struct kunit *test, gfp_t gfp); +struct string_stream *kunit_alloc_string_stream(struct kunit *test, gfp_t = gfp); +void kunit_free_string_stream(struct kunit *test, struct string_stream *st= ream); =20 int __printf(2, 3) string_stream_add(struct string_stream *stream, const char *fmt, ...); diff --git a/lib/kunit/test.c b/lib/kunit/test.c index 49698a168437..93d9225d61e3 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -308,7 +308,7 @@ static void kunit_fail(struct kunit *test, const struct= kunit_loc *loc, =20 kunit_set_failure(test); =20 - stream =3D alloc_string_stream(test, GFP_KERNEL); + stream =3D kunit_alloc_string_stream(test, GFP_KERNEL); if (IS_ERR(stream)) { WARN(true, "Could not allocate stream to print failed assertion in %s:%d\n", @@ -322,7 +322,7 @@ static void kunit_fail(struct kunit *test, const struct= kunit_loc *loc, =20 kunit_print_string_stream(test, stream); =20 - string_stream_destroy(stream); + kunit_free_string_stream(test, stream); } =20 void __noreturn __kunit_abort(struct kunit *test) --=20 2.30.2 From nobody Thu Sep 11 23:23:43 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4C04FC83F21 for ; Mon, 28 Aug 2023 10:42:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231795AbjH1Klh (ORCPT ); Mon, 28 Aug 2023 06:41:37 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47594 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231842AbjH1Kla (ORCPT ); Mon, 28 Aug 2023 06:41:30 -0400 Received: from mx0b-001ae601.pphosted.com (mx0b-001ae601.pphosted.com [67.231.152.168]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 670EA125; Mon, 28 Aug 2023 03:41:27 -0700 (PDT) Received: from pps.filterd (m0077474.ppops.net [127.0.0.1]) by mx0b-001ae601.pphosted.com (8.17.1.22/8.17.1.22) with ESMTP id 37SABuZ7031648; Mon, 28 Aug 2023 05:41:15 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cirrus.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding:content-type; s= PODMain02222019; bh=9OtwqOhPZr8PO9U1ma88NU4k5foCF9o7cBA7JnYYFTc=; b= R+1ihIbNSq6IQlcbt9LCgrW+x5/Pv5UGA2OIsYq0wlAjVhfzJizrUFLXkb39ZeNr UGsQn8eX27wVbb5GWZucKDqiRpdqF5vdn+Lz6F6BUVmqt4Yc24Ma/sdSv9sp/FTo YFwSe2gnbtlX/xN1T++8HLp0qM+b8IB6Pd/kCBwhDV7Xa8wX3BGLaDvyo6injJUc YKsavAUUhq22iqvPN71EiTe+alrGcHqq668WPsDE6nChuwqVcpqaE7n2yDMi1egZ RPT5F59AoPHH/a5HT+31fhO19bhO9V7zlRaSTuZzYXX7RpbKqEDpjaZPXtktQDsl i8H4LP8cjkSfrTVT7Jrg5A== Received: from ediex02.ad.cirrus.com ([84.19.233.68]) by mx0b-001ae601.pphosted.com (PPS) with ESMTPS id 3sqdtj1my9-3 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 28 Aug 2023 05:41:15 -0500 (CDT) Received: from ediex02.ad.cirrus.com (198.61.84.81) by ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.37; Mon, 28 Aug 2023 11:41:12 +0100 Received: from ediswmail.ad.cirrus.com (198.61.86.93) by anon-ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server id 15.2.1118.37 via Frontend Transport; Mon, 28 Aug 2023 11:41:12 +0100 Received: from edi-sw-dsktp-006.ad.cirrus.com (edi-sw-dsktp-006.ad.cirrus.com [198.90.251.75]) by ediswmail.ad.cirrus.com (Postfix) with ESMTP id 804B246B; Mon, 28 Aug 2023 10:41:12 +0000 (UTC) From: Richard Fitzgerald To: , , CC: , , , , "Richard Fitzgerald" Subject: [PATCH v6 07/10] kunit: string-stream: Decouple string_stream from kunit Date: Mon, 28 Aug 2023 11:41:08 +0100 Message-ID: <20230828104111.2394344-8-rf@opensource.cirrus.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230828104111.2394344-1-rf@opensource.cirrus.com> References: <20230828104111.2394344-1-rf@opensource.cirrus.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: rOnsPD4nr-9qwruXVjMgJTexQSKxy9H1 X-Proofpoint-GUID: rOnsPD4nr-9qwruXVjMgJTexQSKxy9H1 X-Proofpoint-Spam-Reason: safe Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Re-work string_stream so that it is not tied to a struct kunit. This is to allow using it for the log of struct kunit_suite. Instead of resource-managing individual allocations the whole string_stream can be resource-managed, if required. alloc_string_stream() now allocates a string stream that is not resource-managed. string_stream_destroy() now works on an unmanaged string_stream allocated by alloc_string_stream() and frees the entire string_stream (previously it only freed the fragments). string_stream_clear() has been made public for callers that want to free the fragments without destroying the string_stream. For resource-managed allocations use kunit_alloc_string_stream() and kunit_free_string_stream(). In addition to this, string_stream_get_string() now returns an unmanaged buffer that the caller must kfree(). Signed-off-by: Richard Fitzgerald Reviewed-by: David Gow --- Changes since v5: - Make string_stream_clear() public (in v5 this was done in patch #8). - In string-stream-test.c add a wrapper for kfree() to prevent a cast warning when calling kunit_add_action(). --- lib/kunit/string-stream-test.c | 8 ++++- lib/kunit/string-stream.c | 61 ++++++++++++++++++++++------------ lib/kunit/string-stream.h | 6 +++- lib/kunit/test.c | 2 +- 4 files changed, 53 insertions(+), 24 deletions(-) diff --git a/lib/kunit/string-stream-test.c b/lib/kunit/string-stream-test.c index 46b18e940b73..58ba1ef5207f 100644 --- a/lib/kunit/string-stream-test.c +++ b/lib/kunit/string-stream-test.c @@ -11,11 +11,18 @@ =20 #include "string-stream.h" =20 +/* This avoids a cast warning if kfree() is passed direct to kunit_add_act= ion(). */ +static void kfree_wrapper(void *p) +{ + kfree(p); +} + static char *get_concatenated_string(struct kunit *test, struct string_str= eam *stream) { char *str =3D string_stream_get_string(stream); =20 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, str); + kunit_add_action(test, kfree_wrapper, (void *)str); =20 return str; } @@ -30,7 +37,6 @@ static void string_stream_init_test(struct kunit *test) =20 KUNIT_EXPECT_EQ(test, stream->length, 0); KUNIT_EXPECT_TRUE(test, list_empty(&stream->fragments)); - KUNIT_EXPECT_PTR_EQ(test, stream->test, test); KUNIT_EXPECT_TRUE(test, (stream->gfp =3D=3D GFP_KERNEL)); KUNIT_EXPECT_FALSE(test, stream->append_newlines); KUNIT_EXPECT_TRUE(test, string_stream_is_empty(stream)); diff --git a/lib/kunit/string-stream.c b/lib/kunit/string-stream.c index 12ecf15e1f6b..64abceb7b716 100644 --- a/lib/kunit/string-stream.c +++ b/lib/kunit/string-stream.c @@ -13,30 +13,28 @@ #include "string-stream.h" =20 =20 -static struct string_stream_fragment *alloc_string_stream_fragment( - struct kunit *test, int len, gfp_t gfp) +static struct string_stream_fragment *alloc_string_stream_fragment(int len= , gfp_t gfp) { struct string_stream_fragment *frag; =20 - frag =3D kunit_kzalloc(test, sizeof(*frag), gfp); + frag =3D kzalloc(sizeof(*frag), gfp); if (!frag) return ERR_PTR(-ENOMEM); =20 - frag->fragment =3D kunit_kmalloc(test, len, gfp); + frag->fragment =3D kmalloc(len, gfp); if (!frag->fragment) { - kunit_kfree(test, frag); + kfree(frag); return ERR_PTR(-ENOMEM); } =20 return frag; } =20 -static void string_stream_fragment_destroy(struct kunit *test, - struct string_stream_fragment *frag) +static void string_stream_fragment_destroy(struct string_stream_fragment *= frag) { list_del(&frag->node); - kunit_kfree(test, frag->fragment); - kunit_kfree(test, frag); + kfree(frag->fragment); + kfree(frag); } =20 int string_stream_vadd(struct string_stream *stream, @@ -65,9 +63,7 @@ int string_stream_vadd(struct string_stream *stream, /* Need space for null byte. */ buf_len++; =20 - frag_container =3D alloc_string_stream_fragment(stream->test, - buf_len, - stream->gfp); + frag_container =3D alloc_string_stream_fragment(buf_len, stream->gfp); if (IS_ERR(frag_container)) return PTR_ERR(frag_container); =20 @@ -102,7 +98,7 @@ int string_stream_add(struct string_stream *stream, cons= t char *fmt, ...) return result; } =20 -static void string_stream_clear(struct string_stream *stream) +void string_stream_clear(struct string_stream *stream) { struct string_stream_fragment *frag_container, *frag_container_safe; =20 @@ -111,7 +107,7 @@ static void string_stream_clear(struct string_stream *s= tream) frag_container_safe, &stream->fragments, node) { - string_stream_fragment_destroy(stream->test, frag_container); + string_stream_fragment_destroy(frag_container); } stream->length =3D 0; spin_unlock(&stream->lock); @@ -123,7 +119,7 @@ char *string_stream_get_string(struct string_stream *st= ream) size_t buf_len =3D stream->length + 1; /* +1 for null byte. */ char *buf; =20 - buf =3D kunit_kzalloc(stream->test, buf_len, stream->gfp); + buf =3D kzalloc(buf_len, stream->gfp); if (!buf) return NULL; =20 @@ -139,13 +135,17 @@ int string_stream_append(struct string_stream *stream, struct string_stream *other) { const char *other_content; + int ret; =20 other_content =3D string_stream_get_string(other); =20 if (!other_content) return -ENOMEM; =20 - return string_stream_add(stream, other_content); + ret =3D string_stream_add(stream, other_content); + kfree(other_content); + + return ret; } =20 bool string_stream_is_empty(struct string_stream *stream) @@ -153,16 +153,15 @@ bool string_stream_is_empty(struct string_stream *str= eam) return list_empty(&stream->fragments); } =20 -static struct string_stream *alloc_string_stream(struct kunit *test, gfp_t= gfp) +struct string_stream *alloc_string_stream(gfp_t gfp) { struct string_stream *stream; =20 - stream =3D kunit_kzalloc(test, sizeof(*stream), gfp); + stream =3D kzalloc(sizeof(*stream), gfp); if (!stream) return ERR_PTR(-ENOMEM); =20 stream->gfp =3D gfp; - stream->test =3D test; INIT_LIST_HEAD(&stream->fragments); spin_lock_init(&stream->lock); =20 @@ -171,15 +170,35 @@ static struct string_stream *alloc_string_stream(stru= ct kunit *test, gfp_t gfp) =20 void string_stream_destroy(struct string_stream *stream) { + if (!stream) + return; + string_stream_clear(stream); + kfree(stream); +} + +static void resource_free_string_stream(void *p) +{ + struct string_stream *stream =3D p; + + string_stream_destroy(stream); } =20 struct string_stream *kunit_alloc_string_stream(struct kunit *test, gfp_t = gfp) { - return alloc_string_stream(test, gfp); + struct string_stream *stream; + + stream =3D alloc_string_stream(gfp); + if (IS_ERR(stream)) + return stream; + + if (kunit_add_action_or_reset(test, resource_free_string_stream, stream) = !=3D 0) + return ERR_PTR(-ENOMEM); + + return stream; } =20 void kunit_free_string_stream(struct kunit *test, struct string_stream *st= ream) { - string_stream_destroy(stream); + kunit_release_action(test, resource_free_string_stream, (void *)stream); } diff --git a/lib/kunit/string-stream.h b/lib/kunit/string-stream.h index 3e70ee9d66e9..7be2450c7079 100644 --- a/lib/kunit/string-stream.h +++ b/lib/kunit/string-stream.h @@ -23,7 +23,6 @@ struct string_stream { struct list_head fragments; /* length and fragments are protected by this lock */ spinlock_t lock; - struct kunit *test; gfp_t gfp; bool append_newlines; }; @@ -33,6 +32,9 @@ struct kunit; struct string_stream *kunit_alloc_string_stream(struct kunit *test, gfp_t = gfp); void kunit_free_string_stream(struct kunit *test, struct string_stream *st= ream); =20 +struct string_stream *alloc_string_stream(gfp_t gfp); +void free_string_stream(struct string_stream *stream); + int __printf(2, 3) string_stream_add(struct string_stream *stream, const char *fmt, ...); =20 @@ -40,6 +42,8 @@ int __printf(2, 0) string_stream_vadd(struct string_strea= m *stream, const char *fmt, va_list args); =20 +void string_stream_clear(struct string_stream *stream); + char *string_stream_get_string(struct string_stream *stream); =20 int string_stream_append(struct string_stream *stream, diff --git a/lib/kunit/test.c b/lib/kunit/test.c index 93d9225d61e3..2ad45a4ac06a 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -296,7 +296,7 @@ static void kunit_print_string_stream(struct kunit *tes= t, kunit_err(test, "\n"); } else { kunit_err(test, "%s", buf); - kunit_kfree(test, buf); + kfree(buf); } } =20 --=20 2.30.2 From nobody Thu Sep 11 23:23:43 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 25AF1C71153 for ; Mon, 28 Aug 2023 10:42:44 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231929AbjH1KmS (ORCPT ); Mon, 28 Aug 2023 06:42:18 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58972 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231825AbjH1Klo (ORCPT ); Mon, 28 Aug 2023 06:41:44 -0400 Received: from mx0b-001ae601.pphosted.com (mx0a-001ae601.pphosted.com [67.231.149.25]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3D98E125; Mon, 28 Aug 2023 03:41:41 -0700 (PDT) Received: from pps.filterd (m0077473.ppops.net [127.0.0.1]) by mx0a-001ae601.pphosted.com (8.17.1.22/8.17.1.22) with ESMTP id 37SABUG4018563; Mon, 28 Aug 2023 05:41:19 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cirrus.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding:content-type; s= PODMain02222019; bh=2BeZdx0R5mjwkTKHjS/B8TSLJ4ce9zQ2GwfW/Ob+iNs=; b= pLxQn4ANzgFjpvekhCfymBXh4j0FIuTGiCpXdl4mVHFLUMASvhwvns6WTQF8BK+m QMZ8wUC+i00e1AM8XzZaBFFoS4n666FEhxMQNj3BB2tZs4zI+93pzLR3fNO6UKDn V2FoHdwa7hQCursIqiM4XAN0h5LFWoS1FkApZ3zIDJw/VTL1vp/T1BC2zb76wtXW UClNnwwMsimOX9so0kvKZk8OtGJPKID2/o4f6Y3wVMnOLxRF6BnzDCvdq90lFO3R ooqKkX9HOe1sM8/r9hsadPQqtIt3ztfRgszMQrXo//xhqbpBTLf313jUt3vGpnvy RikmZI4IADXLIsCvCGtryg== Received: from ediex01.ad.cirrus.com ([84.19.233.68]) by mx0a-001ae601.pphosted.com (PPS) with ESMTPS id 3sqesya0ma-6 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 28 Aug 2023 05:41:18 -0500 (CDT) Received: from ediex02.ad.cirrus.com (198.61.84.81) by ediex01.ad.cirrus.com (198.61.84.80) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.37; Mon, 28 Aug 2023 11:41:12 +0100 Received: from ediswmail.ad.cirrus.com (198.61.86.93) by anon-ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server id 15.2.1118.37 via Frontend Transport; Mon, 28 Aug 2023 11:41:12 +0100 Received: from edi-sw-dsktp-006.ad.cirrus.com (edi-sw-dsktp-006.ad.cirrus.com [198.90.251.75]) by ediswmail.ad.cirrus.com (Postfix) with ESMTP id 9123911AA; Mon, 28 Aug 2023 10:41:12 +0000 (UTC) From: Richard Fitzgerald To: , , CC: , , , , "Richard Fitzgerald" Subject: [PATCH v6 08/10] kunit: string-stream: Add tests for freeing resource-managed string_stream Date: Mon, 28 Aug 2023 11:41:09 +0100 Message-ID: <20230828104111.2394344-9-rf@opensource.cirrus.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230828104111.2394344-1-rf@opensource.cirrus.com> References: <20230828104111.2394344-1-rf@opensource.cirrus.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: HIb2PW5LhgA9JrP-1QxGM-brbI1hoRbC X-Proofpoint-GUID: HIb2PW5LhgA9JrP-1QxGM-brbI1hoRbC X-Proofpoint-Spam-Reason: safe Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" string_stream_managed_free_test() allocates a resource-managed string_stream and tests that kunit_free_string_stream() calls string_stream_destroy(). string_stream_resource_free_test() allocates a resource-managed string_stream and tests that string_stream_destroy() is called when the test resources are cleaned up. The old string_stream_init_test() has been split into two tests, one for kunit_alloc_string_stream() and the other for alloc_string_stream(). Signed-off-by: Richard Fitzgerald --- Changes since v5: - Fix memory leak when calling the redirected string_stream_destroy_stub(). --- lib/kunit/string-stream-test.c | 147 +++++++++++++++++++++++++++++++-- lib/kunit/string-stream.c | 3 + 2 files changed, 145 insertions(+), 5 deletions(-) diff --git a/lib/kunit/string-stream-test.c b/lib/kunit/string-stream-test.c index 58ba1ef5207f..b759974d9cec 100644 --- a/lib/kunit/string-stream-test.c +++ b/lib/kunit/string-stream-test.c @@ -6,17 +6,33 @@ * Author: Brendan Higgins */ =20 +#include #include #include =20 #include "string-stream.h" =20 -/* This avoids a cast warning if kfree() is passed direct to kunit_add_act= ion(). */ +struct string_stream_test_priv { + /* For testing resource-managed free. */ + struct string_stream *expected_free_stream; + bool stream_was_freed; + bool stream_free_again; +}; + +/* Avoids a cast warning if kfree() is passed direct to kunit_add_action()= . */ static void kfree_wrapper(void *p) { kfree(p); } =20 +/* Avoids a cast warning if string_stream_destroy() is passed direct to ku= nit_add_action(). */ +static void cleanup_raw_stream(void *p) +{ + struct string_stream *stream =3D p; + + string_stream_destroy(stream); +} + static char *get_concatenated_string(struct kunit *test, struct string_str= eam *stream) { char *str =3D string_stream_get_string(stream); @@ -27,11 +43,12 @@ static char *get_concatenated_string(struct kunit *test= , struct string_stream *s return str; } =20 -/* string_stream object is initialized correctly. */ -static void string_stream_init_test(struct kunit *test) +/* Managed string_stream object is initialized correctly. */ +static void string_stream_managed_init_test(struct kunit *test) { struct string_stream *stream; =20 + /* Resource-managed initialization. */ stream =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); =20 @@ -42,6 +59,109 @@ static void string_stream_init_test(struct kunit *test) KUNIT_EXPECT_TRUE(test, string_stream_is_empty(stream)); } =20 +/* Unmanaged string_stream object is initialized correctly. */ +static void string_stream_unmanaged_init_test(struct kunit *test) +{ + struct string_stream *stream; + + stream =3D alloc_string_stream(GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + kunit_add_action(test, cleanup_raw_stream, stream); + + KUNIT_EXPECT_EQ(test, stream->length, 0); + KUNIT_EXPECT_TRUE(test, list_empty(&stream->fragments)); + KUNIT_EXPECT_EQ(test, stream->gfp, GFP_KERNEL); + KUNIT_EXPECT_FALSE(test, stream->append_newlines); + + KUNIT_EXPECT_TRUE(test, string_stream_is_empty(stream)); +} + +static void string_stream_destroy_stub(struct string_stream *stream) +{ + struct kunit *fake_test =3D kunit_get_current_test(); + struct string_stream_test_priv *priv =3D fake_test->priv; + + /* The kunit could own string_streams other than the one we are testing. = */ + if (stream =3D=3D priv->expected_free_stream) { + if (priv->stream_was_freed) + priv->stream_free_again =3D true; + else + priv->stream_was_freed =3D true; + } + + /* + * Calling string_stream_destroy() will only call this function again + * because the redirection stub is still active. + * Avoid calling deactivate_static_stub() or changing current->kunit_test + * during cleanup. + */ + string_stream_clear(stream); + kfree(stream); +} + +/* kunit_free_string_stream() calls string_stream_desrtoy() */ +static void string_stream_managed_free_test(struct kunit *test) +{ + struct string_stream_test_priv *priv =3D test->priv; + + priv->expected_free_stream =3D NULL; + priv->stream_was_freed =3D false; + priv->stream_free_again =3D false; + + kunit_activate_static_stub(test, + string_stream_destroy, + string_stream_destroy_stub); + + priv->expected_free_stream =3D kunit_alloc_string_stream(test, GFP_KERNEL= ); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->expected_free_stream); + + /* This should call the stub function. */ + kunit_free_string_stream(test, priv->expected_free_stream); + + KUNIT_EXPECT_TRUE(test, priv->stream_was_freed); + KUNIT_EXPECT_FALSE(test, priv->stream_free_again); +} + +/* string_stream object is freed when test is cleaned up. */ +static void string_stream_resource_free_test(struct kunit *test) +{ + struct string_stream_test_priv *priv =3D test->priv; + struct kunit *fake_test; + + fake_test =3D kunit_kzalloc(test, sizeof(*fake_test), GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fake_test); + + kunit_init_test(fake_test, "string_stream_fake_test", NULL); + fake_test->priv =3D priv; + + /* + * Activate stub before creating string_stream so the + * string_stream will be cleaned up first. + */ + priv->expected_free_stream =3D NULL; + priv->stream_was_freed =3D false; + priv->stream_free_again =3D false; + + kunit_activate_static_stub(fake_test, + string_stream_destroy, + string_stream_destroy_stub); + + priv->expected_free_stream =3D kunit_alloc_string_stream(fake_test, GFP_K= ERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->expected_free_stream); + + /* Set current->kunit_test to fake_test so the static stub will be called= . */ + current->kunit_test =3D fake_test; + + /* Cleanup test - the stub function should be called */ + kunit_cleanup(fake_test); + + /* Set current->kunit_test back to current test. */ + current->kunit_test =3D test; + + KUNIT_EXPECT_TRUE(test, priv->stream_was_freed); + KUNIT_EXPECT_FALSE(test, priv->stream_free_again); +} + /* * Add a series of lines to a string_stream. Check that all lines * appear in the correct order and no characters are dropped. @@ -334,8 +454,24 @@ static void string_stream_auto_newline_test(struct kun= it *test) "One\nTwo\nThree\nFour\nFive\nSix\nSeven\n\nEight\n"); } =20 +static int string_stream_test_init(struct kunit *test) +{ + struct string_stream_test_priv *priv; + + priv =3D kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + test->priv =3D priv; + + return 0; +} + static struct kunit_case string_stream_test_cases[] =3D { - KUNIT_CASE(string_stream_init_test), + KUNIT_CASE(string_stream_managed_init_test), + KUNIT_CASE(string_stream_unmanaged_init_test), + KUNIT_CASE(string_stream_managed_free_test), + KUNIT_CASE(string_stream_resource_free_test), KUNIT_CASE(string_stream_line_add_test), KUNIT_CASE(string_stream_variable_length_line_test), KUNIT_CASE(string_stream_append_test), @@ -348,6 +484,7 @@ static struct kunit_case string_stream_test_cases[] =3D= { =20 static struct kunit_suite string_stream_test_suite =3D { .name =3D "string-stream-test", - .test_cases =3D string_stream_test_cases + .test_cases =3D string_stream_test_cases, + .init =3D string_stream_test_init, }; kunit_test_suites(&string_stream_test_suite); diff --git a/lib/kunit/string-stream.c b/lib/kunit/string-stream.c index 64abceb7b716..a6f3616c2048 100644 --- a/lib/kunit/string-stream.c +++ b/lib/kunit/string-stream.c @@ -6,6 +6,7 @@ * Author: Brendan Higgins */ =20 +#include #include #include #include @@ -170,6 +171,8 @@ struct string_stream *alloc_string_stream(gfp_t gfp) =20 void string_stream_destroy(struct string_stream *stream) { + KUNIT_STATIC_STUB_REDIRECT(string_stream_destroy, stream); + if (!stream) return; =20 --=20 2.30.2 From nobody Thu Sep 11 23:23:43 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6A0E5C83F19 for ; Mon, 28 Aug 2023 10:42:03 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231748AbjH1Kle (ORCPT ); Mon, 28 Aug 2023 06:41:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47552 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231838AbjH1Kl2 (ORCPT ); Mon, 28 Aug 2023 06:41:28 -0400 Received: from mx0b-001ae601.pphosted.com (mx0b-001ae601.pphosted.com [67.231.152.168]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4B671AB; Mon, 28 Aug 2023 03:41:25 -0700 (PDT) Received: from pps.filterd (m0077474.ppops.net [127.0.0.1]) by mx0b-001ae601.pphosted.com (8.17.1.22/8.17.1.22) with ESMTP id 37SABuZ8031648; Mon, 28 Aug 2023 05:41:16 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cirrus.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding:content-type; s= PODMain02222019; bh=GUaPP2YRIZ0xUYgdQg91XqEzoFzD5UaxZhlhGEotQHo=; b= MJbc17GwKm/pTxhXxYt4eAzfxGWeu2cUbqeWslyE9wM8mrigDX1PnrYTqe7FqAEo MhNoKoJ6QKczARfGC8m5sRuTbHcgRabDN9qon8MZKsDj52uHk0p/KShecIFj6hbs u9UCYYv2Eu/IDpDllq7qLgQOAatmX4qo/lSTxQUwFX5wggHq+Qt26QK6zRDUvZGg QLMCo6x2ir4Z15GfffN3MCn8V21DE7s17Ny4lbap0rcANmZUksdpD9yJPs0fEns0 oz+4/cdBgBwK0P9eVy2cuoEP7qD2uqRh0/aCck/7bX5IelJg0nfwt/i3VhIoA/2f 5DzlN477BOk1PLAUwYKCkg== Received: from ediex02.ad.cirrus.com ([84.19.233.68]) by mx0b-001ae601.pphosted.com (PPS) with ESMTPS id 3sqdtj1my9-4 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 28 Aug 2023 05:41:15 -0500 (CDT) Received: from ediex02.ad.cirrus.com (198.61.84.81) by ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.37; Mon, 28 Aug 2023 11:41:12 +0100 Received: from ediswmail.ad.cirrus.com (198.61.86.93) by anon-ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server id 15.2.1118.37 via Frontend Transport; Mon, 28 Aug 2023 11:41:12 +0100 Received: from edi-sw-dsktp-006.ad.cirrus.com (edi-sw-dsktp-006.ad.cirrus.com [198.90.251.75]) by ediswmail.ad.cirrus.com (Postfix) with ESMTP id A1E17357C; Mon, 28 Aug 2023 10:41:12 +0000 (UTC) From: Richard Fitzgerald To: , , CC: , , , , "Richard Fitzgerald" Subject: [PATCH v6 09/10] kunit: Use string_stream for test log Date: Mon, 28 Aug 2023 11:41:10 +0100 Message-ID: <20230828104111.2394344-10-rf@opensource.cirrus.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230828104111.2394344-1-rf@opensource.cirrus.com> References: <20230828104111.2394344-1-rf@opensource.cirrus.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: 85l9qx5SWPGvQGb7VnLJy7jkSi-AvWhj X-Proofpoint-GUID: 85l9qx5SWPGvQGb7VnLJy7jkSi-AvWhj X-Proofpoint-Spam-Reason: safe Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Replace the fixed-size log buffer with a string_stream so that the log can grow as lines are added. The existing kunit log tests have been updated for using a string_stream as the log. No new test have been added because there are already tests for the underlying string_stream. As the log tests now depend on string_stream functions they cannot build when kunit-test is a module. They have been surrounded by a #if to replace them with skipping version when the test is build as a module. Though this isn't pretty, it avoids moving code to another file while that code is also being changed. Signed-off-by: Richard Fitzgerald Reviewed-by: David Gow --- Changes since V5: - In kunit-test.c: add wrapper function around kfree() to prevent cast warning when calling kunit_add_action(). - Fix unused variable warning in kunit_log_test() when built as a module. --- include/kunit/test.h | 14 +++++------ lib/kunit/debugfs.c | 36 +++++++++++++++++---------- lib/kunit/kunit-test.c | 56 +++++++++++++++++++++++++++++++++++------- lib/kunit/test.c | 44 ++++----------------------------- 4 files changed, 81 insertions(+), 69 deletions(-) diff --git a/include/kunit/test.h b/include/kunit/test.h index d33114097d0d..b915a0fe93c0 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -32,9 +32,7 @@ DECLARE_STATIC_KEY_FALSE(kunit_running); =20 struct kunit; - -/* Size of log associated with test. */ -#define KUNIT_LOG_SIZE 2048 +struct string_stream; =20 /* Maximum size of parameter description string. */ #define KUNIT_PARAM_DESC_SIZE 128 @@ -132,7 +130,7 @@ struct kunit_case { /* private: internal use only. */ enum kunit_status status; char *module_name; - char *log; + struct string_stream *log; }; =20 static inline char *kunit_status_to_ok_not_ok(enum kunit_status status) @@ -252,7 +250,7 @@ struct kunit_suite { /* private: internal use only */ char status_comment[KUNIT_STATUS_COMMENT_SIZE]; struct dentry *debugfs; - char *log; + struct string_stream *log; int suite_init_err; }; =20 @@ -278,7 +276,7 @@ struct kunit { =20 /* private: internal use only. */ const char *name; /* Read only after initialization! */ - char *log; /* Points at case log after initialization */ + struct string_stream *log; /* Points at case log after initialization */ struct kunit_try_catch try_catch; /* param_value is the current parameter value for a test case. */ const void *param_value; @@ -314,7 +312,7 @@ const char *kunit_filter_glob(void); char *kunit_filter(void); char *kunit_filter_action(void); =20 -void kunit_init_test(struct kunit *test, const char *name, char *log); +void kunit_init_test(struct kunit *test, const char *name, struct string_s= tream *log); =20 int kunit_run_tests(struct kunit_suite *suite); =20 @@ -472,7 +470,7 @@ static inline void *kunit_kcalloc(struct kunit *test, s= ize_t n, size_t size, gfp =20 void kunit_cleanup(struct kunit *test); =20 -void __printf(2, 3) kunit_log_append(char *log, const char *fmt, ...); +void __printf(2, 3) kunit_log_append(struct string_stream *log, const char= *fmt, ...); =20 /** * kunit_mark_skipped() - Marks @test_or_suite as skipped diff --git a/lib/kunit/debugfs.c b/lib/kunit/debugfs.c index 22c5c496a68f..270d185737e6 100644 --- a/lib/kunit/debugfs.c +++ b/lib/kunit/debugfs.c @@ -37,14 +37,21 @@ void kunit_debugfs_init(void) debugfs_rootdir =3D debugfs_create_dir(KUNIT_DEBUGFS_ROOT, NULL); } =20 -static void debugfs_print_result(struct seq_file *seq, - struct kunit_suite *suite, - struct kunit_case *test_case) +static void debugfs_print_result(struct seq_file *seq, struct string_strea= m *log) { - if (!test_case || !test_case->log) + struct string_stream_fragment *frag_container; + + if (!log) return; =20 - seq_printf(seq, "%s", test_case->log); + /* + * Walk the fragments so we don't need to allocate a temporary + * buffer to hold the entire string. + */ + spin_lock(&log->lock); + list_for_each_entry(frag_container, &log->fragments, node) + seq_printf(seq, "%s", frag_container->fragment); + spin_unlock(&log->lock); } =20 /* @@ -69,10 +76,9 @@ static int debugfs_print_results(struct seq_file *seq, v= oid *v) seq_printf(seq, KUNIT_SUBTEST_INDENT "1..%zd\n", kunit_suite_num_test_cas= es(suite)); =20 kunit_suite_for_each_test_case(suite, test_case) - debugfs_print_result(seq, suite, test_case); + debugfs_print_result(seq, test_case->log); =20 - if (suite->log) - seq_printf(seq, "%s", suite->log); + debugfs_print_result(seq, suite->log); =20 seq_printf(seq, "%s %d %s\n", kunit_status_to_ok_not_ok(success), 1, suite->name); @@ -105,9 +111,13 @@ void kunit_debugfs_create_suite(struct kunit_suite *su= ite) struct kunit_case *test_case; =20 /* Allocate logs before creating debugfs representation. */ - suite->log =3D kzalloc(KUNIT_LOG_SIZE, GFP_KERNEL); - kunit_suite_for_each_test_case(suite, test_case) - test_case->log =3D kzalloc(KUNIT_LOG_SIZE, GFP_KERNEL); + suite->log =3D alloc_string_stream(GFP_KERNEL); + string_stream_set_append_newlines(suite->log, true); + + kunit_suite_for_each_test_case(suite, test_case) { + test_case->log =3D alloc_string_stream(GFP_KERNEL); + string_stream_set_append_newlines(test_case->log, true); + } =20 suite->debugfs =3D debugfs_create_dir(suite->name, debugfs_rootdir); =20 @@ -121,7 +131,7 @@ void kunit_debugfs_destroy_suite(struct kunit_suite *su= ite) struct kunit_case *test_case; =20 debugfs_remove_recursive(suite->debugfs); - kfree(suite->log); + string_stream_destroy(suite->log); kunit_suite_for_each_test_case(suite, test_case) - kfree(test_case->log); + string_stream_destroy(test_case->log); } diff --git a/lib/kunit/kunit-test.c b/lib/kunit/kunit-test.c index 83d8e90ca7a2..99d2a3a528e1 100644 --- a/lib/kunit/kunit-test.c +++ b/lib/kunit/kunit-test.c @@ -8,6 +8,7 @@ #include #include =20 +#include "string-stream.h" #include "try-catch-impl.h" =20 struct kunit_try_catch_test_context { @@ -530,12 +531,27 @@ static struct kunit_suite kunit_resource_test_suite = =3D { .test_cases =3D kunit_resource_test_cases, }; =20 +/* + * Log tests call string_stream functions, which aren't exported. So only + * build this code if this test is built-in. + */ +#if IS_BUILTIN(CONFIG_KUNIT_TEST) + +/* This avoids a cast warning if kfree() is passed direct to kunit_add_act= ion(). */ +static void kfree_wrapper(void *p) +{ + kfree(p); +} + static void kunit_log_test(struct kunit *test) { struct kunit_suite suite; - - suite.log =3D kunit_kzalloc(test, KUNIT_LOG_SIZE, GFP_KERNEL); +#ifdef CONFIG_KUNIT_DEBUGFS + char *full_log; +#endif + suite.log =3D kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, suite.log); + string_stream_set_append_newlines(suite.log, true); =20 kunit_log(KERN_INFO, test, "put this in log."); kunit_log(KERN_INFO, test, "this too."); @@ -543,14 +559,21 @@ static void kunit_log_test(struct kunit *test) kunit_log(KERN_INFO, &suite, "along with this."); =20 #ifdef CONFIG_KUNIT_DEBUGFS + KUNIT_EXPECT_TRUE(test, test->log->append_newlines); + + full_log =3D string_stream_get_string(test->log); + kunit_add_action(test, (kunit_action_t *)kfree, full_log); KUNIT_EXPECT_NOT_ERR_OR_NULL(test, - strstr(test->log, "put this in log.")); + strstr(full_log, "put this in log.")); KUNIT_EXPECT_NOT_ERR_OR_NULL(test, - strstr(test->log, "this too.")); + strstr(full_log, "this too.")); + + full_log =3D string_stream_get_string(suite.log); + kunit_add_action(test, kfree_wrapper, full_log); KUNIT_EXPECT_NOT_ERR_OR_NULL(test, - strstr(suite.log, "add to suite log.")); + strstr(full_log, "add to suite log.")); KUNIT_EXPECT_NOT_ERR_OR_NULL(test, - strstr(suite.log, "along with this.")); + strstr(full_log, "along with this.")); #else KUNIT_EXPECT_NULL(test, test->log); #endif @@ -558,15 +581,30 @@ static void kunit_log_test(struct kunit *test) =20 static void kunit_log_newline_test(struct kunit *test) { + char *full_log; + kunit_info(test, "Add newline\n"); if (test->log) { - KUNIT_ASSERT_NOT_NULL_MSG(test, strstr(test->log, "Add newline\n"), - "Missing log line, full log:\n%s", test->log); - KUNIT_EXPECT_NULL(test, strstr(test->log, "Add newline\n\n")); + full_log =3D string_stream_get_string(test->log); + kunit_add_action(test, kfree_wrapper, full_log); + KUNIT_ASSERT_NOT_NULL_MSG(test, strstr(full_log, "Add newline\n"), + "Missing log line, full log:\n%s", full_log); + KUNIT_EXPECT_NULL(test, strstr(full_log, "Add newline\n\n")); } else { kunit_skip(test, "only useful when debugfs is enabled"); } } +#else +static void kunit_log_test(struct kunit *test) +{ + kunit_skip(test, "Log tests only run when built-in"); +} + +static void kunit_log_newline_test(struct kunit *test) +{ + kunit_skip(test, "Log tests only run when built-in"); +} +#endif /* IS_BUILTIN(CONFIG_KUNIT_TEST) */ =20 static struct kunit_case kunit_log_test_cases[] =3D { KUNIT_CASE(kunit_log_test), diff --git a/lib/kunit/test.c b/lib/kunit/test.c index 2ad45a4ac06a..b153808ff1ec 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -109,51 +109,17 @@ static void kunit_print_test_stats(struct kunit *test, stats.total); } =20 -/** - * kunit_log_newline() - Add newline to the end of log if one is not - * already present. - * @log: The log to add the newline to. - */ -static void kunit_log_newline(char *log) -{ - int log_len, len_left; - - log_len =3D strlen(log); - len_left =3D KUNIT_LOG_SIZE - log_len - 1; - - if (log_len > 0 && log[log_len - 1] !=3D '\n') - strncat(log, "\n", len_left); -} - -/* - * Append formatted message to log, size of which is limited to - * KUNIT_LOG_SIZE bytes (including null terminating byte). - */ -void kunit_log_append(char *log, const char *fmt, ...) +/* Append formatted message to log. */ +void kunit_log_append(struct string_stream *log, const char *fmt, ...) { va_list args; - int len, log_len, len_left; =20 if (!log) return; =20 - log_len =3D strlen(log); - len_left =3D KUNIT_LOG_SIZE - log_len - 1; - if (len_left <=3D 0) - return; - - /* Evaluate length of line to add to log */ va_start(args, fmt); - len =3D vsnprintf(NULL, 0, fmt, args) + 1; + string_stream_vadd(log, fmt, args); va_end(args); - - /* Print formatted line to the log */ - va_start(args, fmt); - vsnprintf(log + log_len, min(len, len_left), fmt, args); - va_end(args); - - /* Add newline to end of log if not already present. */ - kunit_log_newline(log); } EXPORT_SYMBOL_GPL(kunit_log_append); =20 @@ -359,14 +325,14 @@ void __kunit_do_failed_assertion(struct kunit *test, } EXPORT_SYMBOL_GPL(__kunit_do_failed_assertion); =20 -void kunit_init_test(struct kunit *test, const char *name, char *log) +void kunit_init_test(struct kunit *test, const char *name, struct string_s= tream *log) { spin_lock_init(&test->lock); INIT_LIST_HEAD(&test->resources); test->name =3D name; test->log =3D log; if (test->log) - test->log[0] =3D '\0'; + string_stream_clear(log); test->status =3D KUNIT_SUCCESS; test->status_comment[0] =3D '\0'; } --=20 2.30.2 From nobody Thu Sep 11 23:23:43 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2A8B0C83F13 for ; Mon, 28 Aug 2023 10:42:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231948AbjH1KmV (ORCPT ); Mon, 28 Aug 2023 06:42:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58990 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231829AbjH1Klp (ORCPT ); Mon, 28 Aug 2023 06:41:45 -0400 Received: from mx0b-001ae601.pphosted.com (mx0a-001ae601.pphosted.com [67.231.149.25]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 930D8129; Mon, 28 Aug 2023 03:41:42 -0700 (PDT) Received: from pps.filterd (m0077473.ppops.net [127.0.0.1]) by mx0a-001ae601.pphosted.com (8.17.1.22/8.17.1.22) with ESMTP id 37SABUG5018563; Mon, 28 Aug 2023 05:41:19 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cirrus.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding:content-type; s= PODMain02222019; bh=KmV5S8qj6Tc2ww0hbmelZFHm8B9ZWDJTwvDRPAsLDzE=; b= R0NOu2ONi20AxMtbH0MxHgRzJ6AQB5vsvKNhWNzzip/OTw4NJuqNc7rPBwugg/hy HpLmi7z7pwWp5WYVnAXKXlHBZH/UfKRcSsqrAWjhKQkJrzW1MkVaWOYcCF0VEABG FoLZyLC5HDK024NyFcF7pYziuJaxgXCoX58wekfnwpLCbLG5xe34a0wQDCvcOdo1 IFGiUpCa+c117WPO64lzmTFpo8EOibqgrgfuCgtXQZ7Wu6BY1SrGqdZfjzdvVKsN z6MxjG2CU6Eq7/vdl+0jUoDIKRrihjYK/p4jLAeFziSbchAwxyxpBpsw8LGE3CW5 tppt9qiVSbO/zJNbPx/3bA== Received: from ediex01.ad.cirrus.com ([84.19.233.68]) by mx0a-001ae601.pphosted.com (PPS) with ESMTPS id 3sqesya0ma-7 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 28 Aug 2023 05:41:19 -0500 (CDT) Received: from ediex02.ad.cirrus.com (198.61.84.81) by ediex01.ad.cirrus.com (198.61.84.80) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.37; Mon, 28 Aug 2023 11:41:12 +0100 Received: from ediswmail.ad.cirrus.com (198.61.86.93) by anon-ediex02.ad.cirrus.com (198.61.84.81) with Microsoft SMTP Server id 15.2.1118.37 via Frontend Transport; Mon, 28 Aug 2023 11:41:12 +0100 Received: from edi-sw-dsktp-006.ad.cirrus.com (edi-sw-dsktp-006.ad.cirrus.com [198.90.251.75]) by ediswmail.ad.cirrus.com (Postfix) with ESMTP id B28EA46B; Mon, 28 Aug 2023 10:41:12 +0000 (UTC) From: Richard Fitzgerald To: , , CC: , , , , "Richard Fitzgerald" Subject: [PATCH v6 10/10] kunit: string-stream: Test performance of string_stream Date: Mon, 28 Aug 2023 11:41:11 +0100 Message-ID: <20230828104111.2394344-11-rf@opensource.cirrus.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230828104111.2394344-1-rf@opensource.cirrus.com> References: <20230828104111.2394344-1-rf@opensource.cirrus.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: tWHCraKBcov5GvPimHJoSSGYn2B8nEND X-Proofpoint-GUID: tWHCraKBcov5GvPimHJoSSGYn2B8nEND X-Proofpoint-Spam-Reason: safe Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add a test of the speed and memory use of string_stream. string_stream_performance_test() doesn't actually "test" anything (it cannot fail unless the system has run out of allocatable memory) but it measures the speed and memory consumption of the string_stream and reports the result. This allows changes in the string_stream implementation to be compared. Signed-off-by: Richard Fitzgerald Reviewed-by: David Gow --- lib/kunit/string-stream-test.c | 54 ++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/lib/kunit/string-stream-test.c b/lib/kunit/string-stream-test.c index b759974d9cec..06822766f29a 100644 --- a/lib/kunit/string-stream-test.c +++ b/lib/kunit/string-stream-test.c @@ -8,7 +8,9 @@ =20 #include #include +#include #include +#include =20 #include "string-stream.h" =20 @@ -454,6 +456,57 @@ static void string_stream_auto_newline_test(struct kun= it *test) "One\nTwo\nThree\nFour\nFive\nSix\nSeven\n\nEight\n"); } =20 +/* + * This doesn't actually "test" anything. It reports time taken + * and memory used for logging a large number of lines. + */ +static void string_stream_performance_test(struct kunit *test) +{ + struct string_stream_fragment *frag_container; + struct string_stream *stream; + char test_line[101]; + ktime_t start_time, end_time; + size_t len, bytes_requested, actual_bytes_used, total_string_length; + int offset, i; + + stream =3D kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + memset(test_line, 'x', sizeof(test_line) - 1); + test_line[sizeof(test_line) - 1] =3D '\0'; + + start_time =3D ktime_get(); + for (i =3D 0; i < 10000; i++) { + offset =3D i % (sizeof(test_line) - 1); + string_stream_add(stream, "%s: %d\n", &test_line[offset], i); + } + end_time =3D ktime_get(); + + /* + * Calculate memory used. This doesn't include invisible + * overhead due to kernel allocator fragment size rounding. + */ + bytes_requested =3D sizeof(*stream); + actual_bytes_used =3D ksize(stream); + total_string_length =3D 0; + + list_for_each_entry(frag_container, &stream->fragments, node) { + bytes_requested +=3D sizeof(*frag_container); + actual_bytes_used +=3D ksize(frag_container); + + len =3D strlen(frag_container->fragment); + total_string_length +=3D len; + bytes_requested +=3D len + 1; /* +1 for '\0' */ + actual_bytes_used +=3D ksize(frag_container->fragment); + } + + kunit_info(test, "Time elapsed: %lld us\n", + ktime_us_delta(end_time, start_time)); + kunit_info(test, "Total string length: %zu\n", total_string_length); + kunit_info(test, "Bytes requested: %zu\n", bytes_requested); + kunit_info(test, "Actual bytes allocated: %zu\n", actual_bytes_used); +} + static int string_stream_test_init(struct kunit *test) { struct string_stream_test_priv *priv; @@ -479,6 +532,7 @@ static struct kunit_case string_stream_test_cases[] =3D= { KUNIT_CASE(string_stream_append_empty_string_test), KUNIT_CASE(string_stream_no_auto_newline_test), KUNIT_CASE(string_stream_auto_newline_test), + KUNIT_CASE(string_stream_performance_test), {} }; =20 --=20 2.30.2