From patchwork Wed Dec 13 19:44:16 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rae Moar X-Patchwork-Id: 753726 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="jx3AMrlg" Received: from mail-yw1-x114a.google.com (mail-yw1-x114a.google.com [IPv6:2607:f8b0:4864:20::114a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 97E39EB for ; Wed, 13 Dec 2023 11:44:27 -0800 (PST) Received: by mail-yw1-x114a.google.com with SMTP id 00721157ae682-5e27479b6e2so17985587b3.0 for ; Wed, 13 Dec 2023 11:44:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1702496667; x=1703101467; darn=vger.kernel.org; h=cc:to:from:subject:message-id:mime-version:date:from:to:cc:subject :date:message-id:reply-to; bh=PZ3eBLJoXN0Zb334Rc/oMDoovJgn3OQlnIJlBZWmysw=; b=jx3AMrlgOr+eD/lfzdIvqCV046Y6JH+gGEf6Vn29MLPFUx3JjnjEhV5tn/GWk0nd4+ CjNohCdWyRwDnfXoCNc0KRt4yHu+vN8bVqDTEjIiYlcKHpawyST/lWJlGYMxbB8mDEX/ QDAOBYourpvnBtVWQy0RIqhd9kVftn8KRR0g1f3mBPhyvCQINmQdDEXNncYI18KXa69S UkDqRfHMwSHwY5XD3uWntwBw4FM0YGZSdb+EgtBtM1WKgX7EeX8H942euN38tFFeoVv5 ZDO2nSDVBNEkc3ZxpEVLtFOcPa4g5yQhgOQPfz/NzUvvoZxa98rPWadPDC8JvQlyRB2c PLEQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1702496667; x=1703101467; h=cc:to:from:subject:message-id:mime-version:date:x-gm-message-state :from:to:cc:subject:date:message-id:reply-to; bh=PZ3eBLJoXN0Zb334Rc/oMDoovJgn3OQlnIJlBZWmysw=; b=WzwZykile5N2d70C+6Oj33LKlr3cDPLI0fF95YCxqQE/UDtO35KFajKrFx3dBjKfns uQs+ZBrMOvFEdjAuum6vg4gRNtrmZ8PGhHRpe3P7j/JMAxH/ebIcF5TG7hR8mPfCwAaC goHa5x1hq4KScVU753AgEcqNcyERJKemo1TaJ3wpDgB8OIU72GpUGvZbUbA+c/WDwasf bYc4tt+B0z1LHME5Xft+z4U62CkxXCj6bQe5RKVp8NJgschGRZ5j8F1Wh86lwEYx7BQe TvfBt13RimgJVi4nj/9XCS1Is/VSxuyNSqC7ig6QK3AF57zHoIQuMgs9AuI1838oaYk7 gKEw== X-Gm-Message-State: AOJu0Yz0b2W+dLYJwZRoSbB161gWdHm9XWfNDvcT8lLYIkAQOqw+AQ8m kWLUSO9kKg+6Hgtn+Xs6tYVCArIQCQ== X-Google-Smtp-Source: AGHT+IHUpke9zQYYoRhy3jSBDvuiZMWqdS9EZXOxv1azcDgbxZdKFBM1RfilmtUnk9IB8wj22/cc+5W6EQ== X-Received: from rmoar-specialist.c.googlers.com ([fda3:e722:ac3:cc00:2b:7d90:c0a8:45d3]) (user=rmoar job=sendgmr) by 2002:a25:9705:0:b0:db5:45eb:75b0 with SMTP id d5-20020a259705000000b00db545eb75b0mr69766ybo.6.1702496666790; Wed, 13 Dec 2023 11:44:26 -0800 (PST) Date: Wed, 13 Dec 2023 19:44:16 +0000 Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 X-Mailer: git-send-email 2.43.0.472.g3155946c3a-goog Message-ID: <20231213194421.2031671-1-rmoar@google.com> Subject: [PATCH v5 1/6] kunit: move KUNIT_TABLE out of INIT_DATA From: Rae Moar To: shuah@kernel.org, davidgow@google.com, dlatypov@google.com, brendan.higgins@linux.dev, sadiyakazi@google.com Cc: keescook@chromium.org, arnd@arndb.de, linux-kselftest@vger.kernel.org, linux-arch@vger.kernel.org, kunit-dev@googlegroups.com, linux-kernel@vger.kernel.org, Rae Moar Alter the linker section of KUNIT_TABLE to move it out of INIT_DATA and into DATA_DATA. Data for KUnit tests does not need to be in the init section. In order to run tests again after boot the KUnit data cannot be labeled as init data as the kernel could write over it. Add a KUNIT_INIT_TABLE in the next patch for KUnit tests that test init data/functions. Reviewed-by: David Gow Signed-off-by: Rae Moar --- include/asm-generic/vmlinux.lds.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) base-commit: b285ba6f8cc1b2bfece0b4350fdb92c8780bc698 diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index bae0fe4d499b..1107905d37fc 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -370,7 +370,8 @@ BRANCH_PROFILE() \ TRACE_PRINTKS() \ BPF_RAW_TP() \ - TRACEPOINT_STR() + TRACEPOINT_STR() \ + KUNIT_TABLE() /* * Data section helpers @@ -699,8 +700,7 @@ THERMAL_TABLE(governor) \ EARLYCON_TABLE() \ LSM_TABLE() \ - EARLY_LSM_TABLE() \ - KUNIT_TABLE() + EARLY_LSM_TABLE() #define INIT_TEXT \ *(.init.text .init.text.*) \ From patchwork Wed Dec 13 19:44:17 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rae Moar X-Patchwork-Id: 754115 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="mrUJuQvr" Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A2ABBDB for ; Wed, 13 Dec 2023 11:44:29 -0800 (PST) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-5ca2a6f07b6so88096637b3.2 for ; Wed, 13 Dec 2023 11:44:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1702496669; x=1703101469; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=H4TObfz1XUUxLwH4P+ACZXOttJNkOujnn5ZtfX3k7NE=; b=mrUJuQvr5S6HrbxhYtKpNvDO3oXuZ6po6B0Dif+EoCmz9mDEiSQiMWr4YwIFNhrQ2D pyBUXbQM0X46ODwo2dfhbsmMaUr2oKGVYYeWH0l071+3eWOPJJ0b+2t9yIt09524htIl zPy+8YY+ACP63K51D8vG5NS0AMlr8+5HJ6z8m/QHSIImTr8Ws549LzkbG79aYskFViX1 uQAKaejQdtfd0zgfL9+0xsO8cEl+c5wV8Y8k+N4LJaxRTG/qihvV7q446bpzFwtlOxPh iBuu8z7qvZl0pmxmYVcY2RueVGR87HCHLMX4gaEjDbqGY1oAjV+EnDW1cFzYU2g0OvFa xbXA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1702496669; x=1703101469; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=H4TObfz1XUUxLwH4P+ACZXOttJNkOujnn5ZtfX3k7NE=; b=ROIFf1C+1IUEZjgUmuHYWoGMwN6/v4A+1UpDzUsRjyjLnvRjhM1eSr1kdBTN72ERq2 z40u9yDf/96ToWzJq57OmRzw6CqgkqLd4ZNNPdyw7JWT39Bm5dSoVDpMAEXdVzpL92TT oRqO3P0Cypb0n3M/K/hB7psqgeiTK5u9KV0TqnKvgSfi0fCd+eZRXcZksC9m0JHWI371 W2n1Fug81mwOAhfR10JDnqSYxiRGqPDgQ909RoOM7omp5oGZGrn68pmLcOS6P37cuTL7 KaboD/kd2iy3xtzfh2KXnX8cDsbndWxDylXJTgSFnnkC/TjR/47d56u6nHtq6vBw5TEU q33Q== X-Gm-Message-State: AOJu0Yy8nInvUK77m10fUdr0YRyYVyVN6ZayDW4e7qLhPTGXUfWpJh+u DcVKwQXJpJeG1Vf+z+hKF7rUohTgqw== X-Google-Smtp-Source: AGHT+IFC8i63zmTQQu5ER5Ld9i31lO+PjlnVCodbcMq+pmEV0/5euoQT67GZvzG1ZP0xHcCxgPEdQp94kg== X-Received: from rmoar-specialist.c.googlers.com ([fda3:e722:ac3:cc00:2b:7d90:c0a8:45d3]) (user=rmoar job=sendgmr) by 2002:a25:9705:0:b0:db5:45eb:75b0 with SMTP id d5-20020a259705000000b00db545eb75b0mr69769ybo.6.1702496668909; Wed, 13 Dec 2023 11:44:28 -0800 (PST) Date: Wed, 13 Dec 2023 19:44:17 +0000 In-Reply-To: <20231213194421.2031671-1-rmoar@google.com> Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20231213194421.2031671-1-rmoar@google.com> X-Mailer: git-send-email 2.43.0.472.g3155946c3a-goog Message-ID: <20231213194421.2031671-2-rmoar@google.com> Subject: [PATCH v5 2/6] kunit: add KUNIT_INIT_TABLE to init linker section From: Rae Moar To: shuah@kernel.org, davidgow@google.com, dlatypov@google.com, brendan.higgins@linux.dev, sadiyakazi@google.com Cc: keescook@chromium.org, arnd@arndb.de, linux-kselftest@vger.kernel.org, linux-arch@vger.kernel.org, kunit-dev@googlegroups.com, linux-kernel@vger.kernel.org, Rae Moar Add KUNIT_INIT_TABLE to the INIT_DATA linker section. Alter the KUnit macros to create init tests: kunit_test_init_section_suites Update lib/kunit/executor.c to run both the suites in KUNIT_TABLE and KUNIT_INIT_TABLE. Reviewed-by: David Gow Signed-off-by: Rae Moar --- include/asm-generic/vmlinux.lds.h | 9 ++++- include/kunit/test.h | 30 +++++++++------ include/linux/module.h | 2 + kernel/module/main.c | 3 ++ lib/kunit/executor.c | 64 ++++++++++++++++++++++++++++--- lib/kunit/test.c | 26 +++++++++---- 6 files changed, 109 insertions(+), 25 deletions(-) diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index 1107905d37fc..5dd3a61d673d 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -700,7 +700,8 @@ THERMAL_TABLE(governor) \ EARLYCON_TABLE() \ LSM_TABLE() \ - EARLY_LSM_TABLE() + EARLY_LSM_TABLE() \ + KUNIT_INIT_TABLE() #define INIT_TEXT \ *(.init.text .init.text.*) \ @@ -926,6 +927,12 @@ . = ALIGN(8); \ BOUNDED_SECTION_POST_LABEL(.kunit_test_suites, __kunit_suites, _start, _end) +/* Alignment must be consistent with (kunit_suite *) in include/kunit/test.h */ +#define KUNIT_INIT_TABLE() \ + . = ALIGN(8); \ + BOUNDED_SECTION_POST_LABEL(.kunit_init_test_suites, \ + __kunit_init_suites, _start, _end) + #ifdef CONFIG_BLK_DEV_INITRD #define INIT_RAM_FS \ . = ALIGN(4); \ diff --git a/include/kunit/test.h b/include/kunit/test.h index 20ed9f9275c9..fe79cd736e94 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -337,6 +337,9 @@ void __kunit_test_suites_exit(struct kunit_suite **suites, int num_suites); void kunit_exec_run_tests(struct kunit_suite_set *suite_set, bool builtin); void kunit_exec_list_tests(struct kunit_suite_set *suite_set, bool include_attr); +struct kunit_suite_set kunit_merge_suite_sets(struct kunit_suite_set init_suite_set, + struct kunit_suite_set suite_set); + #if IS_BUILTIN(CONFIG_KUNIT) int kunit_run_all_tests(void); #else @@ -371,6 +374,11 @@ static inline int kunit_run_all_tests(void) #define kunit_test_suite(suite) kunit_test_suites(&suite) +#define __kunit_init_test_suites(unique_array, ...) \ + static struct kunit_suite *unique_array[] \ + __aligned(sizeof(struct kunit_suite *)) \ + __used __section(".kunit_init_test_suites") = { __VA_ARGS__ } + /** * kunit_test_init_section_suites() - used to register one or more &struct * kunit_suite containing init functions or @@ -378,21 +386,21 @@ static inline int kunit_run_all_tests(void) * * @__suites: a statically allocated list of &struct kunit_suite. * - * This functions identically as kunit_test_suites() except that it suppresses - * modpost warnings for referencing functions marked __init or data marked - * __initdata; this is OK because currently KUnit only runs tests upon boot - * during the init phase or upon loading a module during the init phase. + * This functions similar to kunit_test_suites() except that it compiles the + * list of suites during init phase. + * + * This macro also suffixes the array and suite declarations it makes with + * _probe; so that modpost suppresses warnings about referencing init data + * for symbols named in this manner. * - * NOTE TO KUNIT DEVS: If we ever allow KUnit tests to be run after boot, these - * tests must be excluded. + * Note: these init tests are not able to be run after boot so there is no + * "run" debugfs file generated for these tests. * - * The only thing this macro does that's different from kunit_test_suites is - * that it suffixes the array and suite declarations it makes with _probe; - * modpost suppresses warnings about referencing init data for symbols named in - * this manner. + * Also, do not mark the suite or test case structs with __initdata because + * they will be used after the init phase with debugfs. */ #define kunit_test_init_section_suites(__suites...) \ - __kunit_test_suites(CONCATENATE(__UNIQUE_ID(array), _probe), \ + __kunit_init_test_suites(CONCATENATE(__UNIQUE_ID(array), _probe), \ ##__suites) #define kunit_test_init_section_suite(suite) \ diff --git a/include/linux/module.h b/include/linux/module.h index a98e188cf37b..9cd0009bd050 100644 --- a/include/linux/module.h +++ b/include/linux/module.h @@ -540,6 +540,8 @@ struct module { struct static_call_site *static_call_sites; #endif #if IS_ENABLED(CONFIG_KUNIT) + int num_kunit_init_suites; + struct kunit_suite **kunit_init_suites; int num_kunit_suites; struct kunit_suite **kunit_suites; #endif diff --git a/kernel/module/main.c b/kernel/module/main.c index 98fedfdb8db5..36681911c05a 100644 --- a/kernel/module/main.c +++ b/kernel/module/main.c @@ -2199,6 +2199,9 @@ static int find_module_sections(struct module *mod, struct load_info *info) mod->kunit_suites = section_objs(info, ".kunit_test_suites", sizeof(*mod->kunit_suites), &mod->num_kunit_suites); + mod->kunit_init_suites = section_objs(info, ".kunit_init_test_suites", + sizeof(*mod->kunit_init_suites), + &mod->num_kunit_init_suites); #endif mod->extable = section_objs(info, "__ex_table", diff --git a/lib/kunit/executor.c b/lib/kunit/executor.c index 1236b3cd2fbb..847329c51e91 100644 --- a/lib/kunit/executor.c +++ b/lib/kunit/executor.c @@ -12,6 +12,8 @@ */ extern struct kunit_suite * const __kunit_suites_start[]; extern struct kunit_suite * const __kunit_suites_end[]; +extern struct kunit_suite * const __kunit_init_suites_start[]; +extern struct kunit_suite * const __kunit_init_suites_end[]; static char *action_param; @@ -292,6 +294,33 @@ void kunit_exec_list_tests(struct kunit_suite_set *suite_set, bool include_attr) } } +struct kunit_suite_set kunit_merge_suite_sets(struct kunit_suite_set init_suite_set, + struct kunit_suite_set suite_set) +{ + struct kunit_suite_set total_suite_set = {NULL, NULL}; + struct kunit_suite **total_suite_start = NULL; + size_t init_num_suites, num_suites, suite_size; + + init_num_suites = init_suite_set.end - init_suite_set.start; + num_suites = suite_set.end - suite_set.start; + suite_size = sizeof(suite_set.start); + + /* Allocate memory for array of all kunit suites */ + total_suite_start = kmalloc_array(init_num_suites + num_suites, suite_size, GFP_KERNEL); + if (!total_suite_start) + return total_suite_set; + + /* Append init suites and then all other kunit suites */ + memcpy(total_suite_start, init_suite_set.start, init_num_suites * suite_size); + memcpy(total_suite_start + init_num_suites, suite_set.start, num_suites * suite_size); + + /* Set kunit suite set start and end */ + total_suite_set.start = total_suite_start; + total_suite_set.end = total_suite_start + (init_num_suites + num_suites); + + return total_suite_set; +} + #if IS_BUILTIN(CONFIG_KUNIT) static char *kunit_shutdown; @@ -313,21 +342,41 @@ static void kunit_handle_shutdown(void) int kunit_run_all_tests(void) { - struct kunit_suite_set suite_set = { + struct kunit_suite_set suite_set = {NULL, NULL}; + struct kunit_suite_set filtered_suite_set = {NULL, NULL}; + struct kunit_suite_set init_suite_set = { + __kunit_init_suites_start, __kunit_init_suites_end, + }; + struct kunit_suite_set normal_suite_set = { __kunit_suites_start, __kunit_suites_end, }; + size_t init_num_suites = init_suite_set.end - init_suite_set.start; int err = 0; + + if (init_num_suites > 0) { + suite_set = kunit_merge_suite_sets(init_suite_set, normal_suite_set); + if (!suite_set.start) + goto out; + } else + suite_set = normal_suite_set; + if (!kunit_enabled()) { pr_info("kunit: disabled\n"); - goto out; + goto free_out; } if (filter_glob_param || filter_param) { - suite_set = kunit_filter_suites(&suite_set, filter_glob_param, + filtered_suite_set = kunit_filter_suites(&suite_set, filter_glob_param, filter_param, filter_action_param, &err); + + /* Free original suite set before using filtered suite set */ + if (init_num_suites > 0) + kfree(suite_set.start); + suite_set = filtered_suite_set; + if (err) { pr_err("kunit executor: error filtering suites: %d\n", err); - goto out; + goto free_out; } } @@ -340,9 +389,12 @@ int kunit_run_all_tests(void) else pr_err("kunit executor: unknown action '%s'\n", action_param); - if (filter_glob_param || filter_param) { /* a copy was made of each suite */ +free_out: + if (filter_glob_param || filter_param) kunit_free_suite_set(suite_set); - } + else if (init_num_suites > 0) + /* Don't use kunit_free_suite_set because suites aren't individually allocated */ + kfree(suite_set.start); out: kunit_handle_shutdown(); diff --git a/lib/kunit/test.c b/lib/kunit/test.c index 0308865194bb..6c082911a85f 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -704,28 +704,40 @@ EXPORT_SYMBOL_GPL(__kunit_test_suites_exit); #ifdef CONFIG_MODULES static void kunit_module_init(struct module *mod) { - struct kunit_suite_set suite_set = { + struct kunit_suite_set suite_set, filtered_set; + struct kunit_suite_set normal_suite_set = { mod->kunit_suites, mod->kunit_suites + mod->num_kunit_suites, }; + struct kunit_suite_set init_suite_set = { + mod->kunit_init_suites, mod->kunit_init_suites + mod->num_kunit_init_suites, + }; const char *action = kunit_action(); int err = 0; - suite_set = kunit_filter_suites(&suite_set, + if (mod->num_kunit_init_suites > 0) + suite_set = kunit_merge_suite_sets(init_suite_set, normal_suite_set); + else + suite_set = normal_suite_set; + + filtered_set = kunit_filter_suites(&suite_set, kunit_filter_glob() ?: "*.*", kunit_filter(), kunit_filter_action(), &err); if (err) pr_err("kunit module: error filtering suites: %d\n", err); - mod->kunit_suites = (struct kunit_suite **)suite_set.start; - mod->num_kunit_suites = suite_set.end - suite_set.start; + mod->kunit_suites = (struct kunit_suite **)filtered_set.start; + mod->num_kunit_suites = filtered_set.end - filtered_set.start; + + if (mod->num_kunit_init_suites > 0) + kfree(suite_set.start); if (!action) - kunit_exec_run_tests(&suite_set, false); + kunit_exec_run_tests(&filtered_set, false); else if (!strcmp(action, "list")) - kunit_exec_list_tests(&suite_set, false); + kunit_exec_list_tests(&filtered_set, false); else if (!strcmp(action, "list_attr")) - kunit_exec_list_tests(&suite_set, true); + kunit_exec_list_tests(&filtered_set, true); else pr_err("kunit: unknown action '%s'\n", action); } From patchwork Wed Dec 13 19:44:18 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rae Moar X-Patchwork-Id: 753725 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="J64rz6hm" Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5089E10A for ; Wed, 13 Dec 2023 11:44:32 -0800 (PST) Received: by mail-yb1-xb49.google.com with SMTP id 3f1490d57ef6-db410931c23so7711437276.2 for ; Wed, 13 Dec 2023 11:44:32 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1702496671; x=1703101471; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=hSasRIKjsrxTOhDGdGR7YDY76bvspnnAtaoJj5GZ1CU=; b=J64rz6hm8t+wrgbJf9JO/yMgfnUZr/TcbVocrNbW93qTBCT8Zuo61B9xT7Mwj5J0qc 5/J+Trw1cMrTo9L/gEcp4zxln4sIuhyeg4kjLkLIYF1ZLmUFjoQCNl/1h/mS2LU8A9Sg 3MrQw7hU/kZ9LxNtlLd7fQpxc2Y8biu/eJfjnJbPqzKx6tKx7/2NskTJGfsn3s8FPBCr XtUyxOxv4dEZG4szdAA7G+c04YlYkcv51CreMwAo3JwR26HAzMkoybXW3gGBW4Iy/kSh vKJX79A77hUHsnGyvJlhxU0So12pwp4JkQzYarOrmodwDK2Nvv84hUIFaT10OEino4LO 7zEA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1702496671; x=1703101471; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=hSasRIKjsrxTOhDGdGR7YDY76bvspnnAtaoJj5GZ1CU=; b=baDWvAw5ASVLYpnNiWkDaGXFdBScQNjjh/Yb09HQ/maV0h16nYFn/AQLM6z0RMhU7c BSDwhIX875xkd7emfKC0FBI3tMy19Dz6Xi0UsBsi3K+qv2I1pbqjCb1cwDkgXdxxm1c7 QFAHAgp2gUAMSXSQ3J/03qndz3AlIIKyNX9Bbo18zM82JA2r/ZgnKbP0IFrPYyKbYXER jx2msTGLkpmKokdRLwvGnMOl07q5AtHmP8dcBOLFT44x78TGhwTRQjTc0oytS79N9rgC ZON2Pwm2Q77T+2t2200HyDAdgxmTKTGcUBOfDBGoJ3pgWECVn8SPyV3pAD+TDpndrB6y jk0Q== X-Gm-Message-State: AOJu0YxjlvAd5rVeenj3KzNFXijRvU4CnpYEL72p7swZfjHIqtwt6nlf n73jmxcyVB1kSQfC6F+86WBO2UGU/g== X-Google-Smtp-Source: AGHT+IFcVvSBccWJoQy13WMx3m6+GFYC5e8qqX0/Qfg0ZBRVrVubmi4U5od99Pkg2fJbBPb7E0ZO/sdi5Q== X-Received: from rmoar-specialist.c.googlers.com ([fda3:e722:ac3:cc00:2b:7d90:c0a8:45d3]) (user=rmoar job=sendgmr) by 2002:a25:ada8:0:b0:dbc:d104:51de with SMTP id z40-20020a25ada8000000b00dbcd10451demr28117ybi.3.1702496671557; Wed, 13 Dec 2023 11:44:31 -0800 (PST) Date: Wed, 13 Dec 2023 19:44:18 +0000 In-Reply-To: <20231213194421.2031671-1-rmoar@google.com> Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20231213194421.2031671-1-rmoar@google.com> X-Mailer: git-send-email 2.43.0.472.g3155946c3a-goog Message-ID: <20231213194421.2031671-3-rmoar@google.com> Subject: [PATCH v5 3/6] kunit: add example suite to test init suites From: Rae Moar To: shuah@kernel.org, davidgow@google.com, dlatypov@google.com, brendan.higgins@linux.dev, sadiyakazi@google.com Cc: keescook@chromium.org, arnd@arndb.de, linux-kselftest@vger.kernel.org, linux-arch@vger.kernel.org, kunit-dev@googlegroups.com, linux-kernel@vger.kernel.org, Rae Moar Add example_init_test_suite to allow for testing the feature of running test suites marked as init to indicate they use init data and/or functions. This suite should always pass and uses a simple init function. This suite can also be used to test the is_init attribute introduced in the next patch. Signed-off-by: Rae Moar Reviewed-by: David Gow --- Changes since v4: - Mark test as __init and then set cases as __refdata to supress modpost warnings lib/kunit/kunit-example-test.c | 37 ++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/lib/kunit/kunit-example-test.c b/lib/kunit/kunit-example-test.c index 6bb5c2ef6696..d2f7a3c62c18 100644 --- a/lib/kunit/kunit-example-test.c +++ b/lib/kunit/kunit-example-test.c @@ -287,4 +287,41 @@ static struct kunit_suite example_test_suite = { */ kunit_test_suites(&example_test_suite); +static int __init init_add(int x, int y) +{ + return (x + y); +} + +/* + * This test should always pass. Can be used to test init suites. + */ +static void __init example_init_test(struct kunit *test) +{ + KUNIT_EXPECT_EQ(test, init_add(1, 1), 2); +} + +/* + * The kunit_case struct cannot be marked as __initdata as this will be + * used in debugfs to retrieve results after test has run + */ +static struct kunit_case __refdata example_init_test_cases[] = { + KUNIT_CASE(example_init_test), + {} +}; + +/* + * The kunit_suite struct cannot be marked as __initdata as this will be + * used in debugfs to retrieve results after test has run + */ +static struct kunit_suite example_init_test_suite = { + .name = "example_init", + .test_cases = example_init_test_cases, +}; + +/* + * This registers the test suite and marks the suite as using init data + * and/or functions. + */ +kunit_test_init_section_suites(&example_init_test_suite); + MODULE_LICENSE("GPL v2"); From patchwork Wed Dec 13 19:44:19 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rae Moar X-Patchwork-Id: 754114 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="uNVPlWMr" Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 386E9F5 for ; Wed, 13 Dec 2023 11:44:34 -0800 (PST) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-5ddd64f83a4so60446087b3.0 for ; Wed, 13 Dec 2023 11:44:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1702496673; x=1703101473; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=7slFoawBCWkwzVSxACwTipDmNbMlYPdhOIzkAqH/aFw=; b=uNVPlWMr+Ahy/amoC39Sf5szLLwYzyOXxFBpwDI1N93AQEE1r4tL7KJUbF/aOipRsg cGY0zoNyX2H1G1E6+Wb5ZVjaCU3zjZyt84/xNVvKoS76CEpNov2kWuPqh+m3PZnMXXfa VRvyi7YRfNa07k9rLGg4e1KVoK3ggj0fDs/dPIOlh2DonBjwa+WpcNqo7Lj8D1I5IQfu UCZzFXlG0aFDMPoXtAhSLJV065Bom+ziG/LHPGWoNLtVtPm1/91aFBE2kUnrLP2oMjG7 c/rn7Eqx0WyDa3JmddT6+KzX+AMax+z2eVRUEO4SJNzVfhTG4SLFZ1IgJkReeWdTXUeK PMBQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1702496673; x=1703101473; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=7slFoawBCWkwzVSxACwTipDmNbMlYPdhOIzkAqH/aFw=; b=viJTVT+yvzyWFRCnCzuTV7UioLMGiIaVoBGrmUhbHcnAAfS4LXpHGzSpOotOiKbBhj rwBY5dDrjh3MCMnHXcwJHNJj3MjD+RkFVyUdgm5jcQZuzMkmJ+jAxZjnmKMPEPJSgUOd oMJIbZDjGA/QHHTnI3bSyhtZlVjYK/VpsurP810+Pvf7+Dfjvl7KMsp4LY0AbEo607k+ ExhmrFcY5UeEE+DuHvykHuIw5YLxFe26FwUjWf7OuOogpbD5IdoRcfboaZMYuSyys8jz OEwk9ZHXC+cJu5vDpmhCgrU3Sy5H9mCCMRsV5R6FPWPwTn5JfpzZlHDJ2+fl1pXnfw+M pLTw== X-Gm-Message-State: AOJu0YxfGNKwGJiJUbX5QzD1ZxotM7r+XeDacCvNVaghS2Qv7jP8/TiS B9ibEdbi1JjfLiHjoW0JMYNgdaUOHA== X-Google-Smtp-Source: AGHT+IF9ad/J/uSSD1qUN7zly9T8SGdMfHHvTDpxfYMPa9v+aOBcNTJrZmczyJwsCd+j/YbaPbNKoTsJzw== X-Received: from rmoar-specialist.c.googlers.com ([fda3:e722:ac3:cc00:2b:7d90:c0a8:45d3]) (user=rmoar job=sendgmr) by 2002:a5b:787:0:b0:d9c:801c:4230 with SMTP id b7-20020a5b0787000000b00d9c801c4230mr84320ybq.5.1702496673391; Wed, 13 Dec 2023 11:44:33 -0800 (PST) Date: Wed, 13 Dec 2023 19:44:19 +0000 In-Reply-To: <20231213194421.2031671-1-rmoar@google.com> Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20231213194421.2031671-1-rmoar@google.com> X-Mailer: git-send-email 2.43.0.472.g3155946c3a-goog Message-ID: <20231213194421.2031671-4-rmoar@google.com> Subject: [PATCH v5 4/6] kunit: add is_init test attribute From: Rae Moar To: shuah@kernel.org, davidgow@google.com, dlatypov@google.com, brendan.higgins@linux.dev, sadiyakazi@google.com Cc: keescook@chromium.org, arnd@arndb.de, linux-kselftest@vger.kernel.org, linux-arch@vger.kernel.org, kunit-dev@googlegroups.com, linux-kernel@vger.kernel.org, Rae Moar Add is_init test attribute of type bool. Add to_string, get, and filter methods to lib/kunit/attributes.c. Mark each of the tests in the init section with the is_init=true attribute. Add is_init to the attributes documentation. Reviewed-by: David Gow Signed-off-by: Rae Moar --- .../dev-tools/kunit/running_tips.rst | 7 +++ include/kunit/test.h | 1 + lib/kunit/attributes.c | 60 +++++++++++++++++++ lib/kunit/executor.c | 6 +- 4 files changed, 73 insertions(+), 1 deletion(-) diff --git a/Documentation/dev-tools/kunit/running_tips.rst b/Documentation/dev-tools/kunit/running_tips.rst index 766f9cdea0fa..024e9ad1d1e9 100644 --- a/Documentation/dev-tools/kunit/running_tips.rst +++ b/Documentation/dev-tools/kunit/running_tips.rst @@ -428,3 +428,10 @@ This attribute indicates the name of the module associated with the test. This attribute is automatically saved as a string and is printed for each suite. Tests can also be filtered using this attribute. + +``is_init`` + +This attribute indicates whether the test uses init data or functions. + +This attribute is automatically saved as a boolean and tests can also be +filtered using this attribute. diff --git a/include/kunit/test.h b/include/kunit/test.h index fe79cd736e94..b163b9984b33 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -253,6 +253,7 @@ struct kunit_suite { struct dentry *debugfs; struct string_stream *log; int suite_init_err; + bool is_init; }; /* Stores an array of suites, end points one past the end */ diff --git a/lib/kunit/attributes.c b/lib/kunit/attributes.c index 1b512f7e1838..2cf04cc09372 100644 --- a/lib/kunit/attributes.c +++ b/lib/kunit/attributes.c @@ -58,6 +58,16 @@ static const char *attr_enum_to_string(void *attr, const char * const str_list[] return str_list[val]; } +static const char *attr_bool_to_string(void *attr, bool *to_free) +{ + bool val = (bool)attr; + + *to_free = false; + if (val) + return "true"; + return "false"; +} + static const char *attr_speed_to_string(void *attr, bool *to_free) { return attr_enum_to_string(attr, speed_str_list, to_free); @@ -166,6 +176,37 @@ static int attr_string_filter(void *attr, const char *input, int *err) return false; } +static int attr_bool_filter(void *attr, const char *input, int *err) +{ + int i, input_int = -1; + long val = (long)attr; + const char *input_str = NULL; + + for (i = 0; input[i]; i++) { + if (!strchr(op_list, input[i])) { + input_str = input + i; + break; + } + } + + if (!input_str) { + *err = -EINVAL; + pr_err("kunit executor: filter value not found: %s\n", input); + return false; + } + + if (!strcmp(input_str, "true")) + input_int = (int)true; + else if (!strcmp(input_str, "false")) + input_int = (int)false; + else { + *err = -EINVAL; + pr_err("kunit executor: invalid filter input: %s\n", input); + return false; + } + + return int_filter(val, input, input_int, err); +} /* Get Attribute Methods */ @@ -194,6 +235,17 @@ static void *attr_module_get(void *test_or_suite, bool is_test) return (void *) ""; } +static void *attr_is_init_get(void *test_or_suite, bool is_test) +{ + struct kunit_suite *suite = is_test ? NULL : test_or_suite; + struct kunit_case *test = is_test ? test_or_suite : NULL; + + if (test) + return ((void *) NULL); + else + return ((void *) suite->is_init); +} + /* List of all Test Attributes */ static struct kunit_attr kunit_attr_list[] = { @@ -212,6 +264,14 @@ static struct kunit_attr kunit_attr_list[] = { .filter = attr_string_filter, .attr_default = (void *)"", .print = PRINT_SUITE, + }, + { + .name = "is_init", + .get_attr = attr_is_init_get, + .to_string = attr_bool_to_string, + .filter = attr_bool_filter, + .attr_default = (void *)false, + .print = PRINT_SUITE, } }; diff --git a/lib/kunit/executor.c b/lib/kunit/executor.c index 847329c51e91..717b9599036b 100644 --- a/lib/kunit/executor.c +++ b/lib/kunit/executor.c @@ -300,6 +300,7 @@ struct kunit_suite_set kunit_merge_suite_sets(struct kunit_suite_set init_suite_ struct kunit_suite_set total_suite_set = {NULL, NULL}; struct kunit_suite **total_suite_start = NULL; size_t init_num_suites, num_suites, suite_size; + int i = 0; init_num_suites = init_suite_set.end - init_suite_set.start; num_suites = suite_set.end - suite_set.start; @@ -310,8 +311,11 @@ struct kunit_suite_set kunit_merge_suite_sets(struct kunit_suite_set init_suite_ if (!total_suite_start) return total_suite_set; - /* Append init suites and then all other kunit suites */ + /* Append and mark init suites and then append all other kunit suites */ memcpy(total_suite_start, init_suite_set.start, init_num_suites * suite_size); + for (i = 0; i < init_num_suites; i++) + total_suite_start[i]->is_init = true; + memcpy(total_suite_start + init_num_suites, suite_set.start, num_suites * suite_size); /* Set kunit suite set start and end */ From patchwork Wed Dec 13 19:44:20 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rae Moar X-Patchwork-Id: 753724 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="EExTdg2w" Received: from mail-yb1-xb4a.google.com (mail-yb1-xb4a.google.com [IPv6:2607:f8b0:4864:20::b4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 044B4109 for ; Wed, 13 Dec 2023 11:44:36 -0800 (PST) Received: by mail-yb1-xb4a.google.com with SMTP id 3f1490d57ef6-dbcd4696599so869510276.1 for ; Wed, 13 Dec 2023 11:44:35 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1702496675; x=1703101475; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=B8tncFbKtMEfDV232Jf8Udjxo5BkNQcKRErRNc1mfng=; b=EExTdg2wHWobqRKaLEUMOtQz6feP3N2A+c/9riOiNMnyLFl1Yx7YnbxmrvjoKGsJti A5cpxYa5v+rKqn7i6d79SHkkcKjVAMxx1RxgMlXQV3DOAGFZPDypgZizkq6e2v0JtdrD gwsHuVxymRpEdG2HQ57NRw0r3XUJhU3dbjSBC6RmObw7hqsRbNx/UY2yJXa+F970S6+Z 7ubQaRNyLF7Y3TgNAjxw46+Pvdp5Xp7UFTo5fqAy3286jz5wNkODa393tKN0pa+qR6zF PiqXulLx6foMpBB3pMiD6B0DX7wdblbT1UUOL77EGAPvpCgaTiiFreVxBqG1V3sp+dtR vUOQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1702496675; x=1703101475; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=B8tncFbKtMEfDV232Jf8Udjxo5BkNQcKRErRNc1mfng=; b=DmVhy0XUmkh7nG50PjCZ0ePtx9hPZIlyxHrjSw35F1xsUcg7xdwcIQT0AgxGeQKPg3 e2Ql/ou1OlMjrkMuq4vMGijNxWNUHlgTf9Y0bAE5IjEMblhVM80+p3Ahp5HhSj5nC6BT rwhdB093c+v1LdE0HsufPb6QFwiEY67feet0NUx5noBGnpoQeev4mlZca136Mg1n8GhB bEx0y5SB1n38JuoGCnWQaMIMYuGeyDBf32EGlNsrT+zcAyjL+8rihDjnQs/81lt4ZLcG v16/lcSd/J5I8+qsT5UDKQ32vCxB+4ZOfkDfDJLMH5Zf8EpAJ//yC4hfPmfdAk6aTdpE s1nA== X-Gm-Message-State: AOJu0YznZeBx2FliI8ewZpa0m/X6vRVS7ixwuqomF5rl8UonvTNDTqOw znQUob8Anc9e3jygqqSgCTl3SRECCw== X-Google-Smtp-Source: AGHT+IGIGpvW5Hth/xS09Z3Wm6iVTz9ZW3JUyPaVJIlkAwr02Gz0pNUos512zjOZrZQLcMeYXah2urnH8Q== X-Received: from rmoar-specialist.c.googlers.com ([fda3:e722:ac3:cc00:2b:7d90:c0a8:45d3]) (user=rmoar job=sendgmr) by 2002:a05:6902:4d0:b0:dbc:b226:bd23 with SMTP id v16-20020a05690204d000b00dbcb226bd23mr50429ybs.0.1702496675240; Wed, 13 Dec 2023 11:44:35 -0800 (PST) Date: Wed, 13 Dec 2023 19:44:20 +0000 In-Reply-To: <20231213194421.2031671-1-rmoar@google.com> Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20231213194421.2031671-1-rmoar@google.com> X-Mailer: git-send-email 2.43.0.472.g3155946c3a-goog Message-ID: <20231213194421.2031671-5-rmoar@google.com> Subject: [PATCH v5 5/6] kunit: add ability to run tests after boot using debugfs From: Rae Moar To: shuah@kernel.org, davidgow@google.com, dlatypov@google.com, brendan.higgins@linux.dev, sadiyakazi@google.com Cc: keescook@chromium.org, arnd@arndb.de, linux-kselftest@vger.kernel.org, linux-arch@vger.kernel.org, kunit-dev@googlegroups.com, linux-kernel@vger.kernel.org, Rae Moar Add functionality to run built-in tests after boot by writing to a debugfs file. Add a new debugfs file labeled "run" for each test suite to use for this purpose. As an example, write to the file using the following: echo "any string" > /sys/kernel/debugfs/kunit//run This will trigger the test suite to run and will print results to the kernel log. To guard against running tests concurrently with this feature, add a mutex lock around running kunit. This supports the current practice of not allowing tests to be run concurrently on the same kernel. This new functionality could be used to design a parameter injection feature in the future. Reviewed-by: David Gow Signed-off-by: Rae Moar --- lib/kunit/debugfs.c | 68 +++++++++++++++++++++++++++++++++++++++++++++ lib/kunit/test.c | 10 +++++++ 2 files changed, 78 insertions(+) diff --git a/lib/kunit/debugfs.c b/lib/kunit/debugfs.c index 382706dfb47d..d548750a325a 100644 --- a/lib/kunit/debugfs.c +++ b/lib/kunit/debugfs.c @@ -8,12 +8,14 @@ #include #include +#include #include "string-stream.h" #include "debugfs.h" #define KUNIT_DEBUGFS_ROOT "kunit" #define KUNIT_DEBUGFS_RESULTS "results" +#define KUNIT_DEBUGFS_RUN "run" /* * Create a debugfs representation of test suites: @@ -21,6 +23,8 @@ * Path Semantics * /sys/kernel/debug/kunit//results Show results of last run for * testsuite + * /sys/kernel/debug/kunit//run Write to this file to trigger + * testsuite to run * */ @@ -101,6 +105,51 @@ static int debugfs_results_open(struct inode *inode, struct file *file) return single_open(file, debugfs_print_results, suite); } +/* + * Print a usage message to the debugfs "run" file + * (/sys/kernel/debug/kunit//run) if opened. + */ +static int debugfs_print_run(struct seq_file *seq, void *v) +{ + struct kunit_suite *suite = (struct kunit_suite *)seq->private; + + seq_puts(seq, "Write to this file to trigger the test suite to run.\n"); + seq_printf(seq, "usage: echo \"any string\" > /sys/kernel/debugfs/kunit/%s/run\n", + suite->name); + return 0; +} + +/* + * The debugfs "run" file (/sys/kernel/debug/kunit//run) + * contains no information. Write to the file to trigger the test suite + * to run. + */ +static int debugfs_run_open(struct inode *inode, struct file *file) +{ + struct kunit_suite *suite; + + suite = (struct kunit_suite *)inode->i_private; + + return single_open(file, debugfs_print_run, suite); +} + +/* + * Trigger a test suite to run by writing to the suite's "run" debugfs + * file found at: /sys/kernel/debug/kunit//run + * + * Note: what is written to this file will not be saved. + */ +static ssize_t debugfs_run(struct file *file, + const char __user *buf, size_t count, loff_t *ppos) +{ + struct inode *f_inode = file->f_inode; + struct kunit_suite *suite = (struct kunit_suite *) f_inode->i_private; + + __kunit_test_suites_init(&suite, 1); + + return count; +} + static const struct file_operations debugfs_results_fops = { .open = debugfs_results_open, .read = seq_read, @@ -108,11 +157,23 @@ static const struct file_operations debugfs_results_fops = { .release = debugfs_release, }; +static const struct file_operations debugfs_run_fops = { + .open = debugfs_run_open, + .read = seq_read, + .write = debugfs_run, + .llseek = seq_lseek, + .release = debugfs_release, +}; + void kunit_debugfs_create_suite(struct kunit_suite *suite) { struct kunit_case *test_case; struct string_stream *stream; + /* If suite log already allocated, do not create new debugfs files. */ + if (suite->log) + return; + /* * Allocate logs before creating debugfs representation. * The suite->log and test_case->log pointer are expected to be NULL @@ -140,6 +201,13 @@ void kunit_debugfs_create_suite(struct kunit_suite *suite) debugfs_create_file(KUNIT_DEBUGFS_RESULTS, S_IFREG | 0444, suite->debugfs, suite, &debugfs_results_fops); + + /* Do not create file to re-run test if test runs on init */ + if (!suite->is_init) { + debugfs_create_file(KUNIT_DEBUGFS_RUN, S_IFREG | 0644, + suite->debugfs, + suite, &debugfs_run_fops); + } return; err: diff --git a/lib/kunit/test.c b/lib/kunit/test.c index 6c082911a85f..a52fcb9a4457 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -22,6 +23,8 @@ #include "string-stream.h" #include "try-catch-impl.h" +static DEFINE_MUTEX(kunit_run_lock); + /* * Hook to fail the current test and print an error message to the log. */ @@ -654,6 +657,7 @@ static void kunit_init_suite(struct kunit_suite *suite) kunit_debugfs_create_suite(suite); suite->status_comment[0] = '\0'; suite->suite_init_err = 0; + string_stream_clear(suite->log); } bool kunit_enabled(void) @@ -670,6 +674,11 @@ int __kunit_test_suites_init(struct kunit_suite * const * const suites, int num_ return 0; } + /* Use mutex lock to guard against running tests concurrently. */ + if (mutex_lock_interruptible(&kunit_run_lock)) { + pr_err("kunit: test interrupted\n"); + return -EINTR; + } static_branch_inc(&kunit_running); for (i = 0; i < num_suites; i++) { @@ -678,6 +687,7 @@ int __kunit_test_suites_init(struct kunit_suite * const * const suites, int num_ } static_branch_dec(&kunit_running); + mutex_unlock(&kunit_run_lock); return 0; } EXPORT_SYMBOL_GPL(__kunit_test_suites_init); From patchwork Wed Dec 13 19:44:21 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rae Moar X-Patchwork-Id: 754113 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="SX4do2Tt" Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6CD3ADB for ; Wed, 13 Dec 2023 11:44:38 -0800 (PST) Received: by mail-yb1-xb49.google.com with SMTP id 3f1490d57ef6-dbcdf587bd6so324162276.0 for ; Wed, 13 Dec 2023 11:44:38 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1702496677; x=1703101477; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=mQok1uBhfQkPoGi0cPucpJmmij0VDZxQ9yN4E4VUQ2c=; b=SX4do2TtIQuYGbaqiCa2LvlqYkCsEFfAuOtGfNCZAesSc6aSmfojhjDdWXiVpW1CYv w7VsGtLZzVY5llvLJSidZ/ANqj+GaqYBj8g4lDKqSUZxCviBIlIXQ7E1R7G2Wr3rHxp4 gKZFE9PCXdmmhZOpDQrHftcpopvKHFjovj/PgzABrzWPoUlaKeqGlIEiBY83vWFsfpDs uQaOuyOqS68JpTXYErL1/LFsNyeUGCtB0W74VWGMukPNjRaTL3Yu567+YgXRYLIfOLEE p0jyMof83CfvHLUpP+2Cp4qYiNSEf8l5huOXvOblkTOmUD/ognh+FHmWCg+6DuiyIar3 7Cpw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1702496677; x=1703101477; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=mQok1uBhfQkPoGi0cPucpJmmij0VDZxQ9yN4E4VUQ2c=; b=jKecnZ2t/0Oam1MQ3dwPW6PP+FCBPgn71WSUSGx+N6CVfEdgoJAVFl+ndfYKWqn5Nk c4n8qUUukjATBRayU9VT4CdY02cg/RvVVbCuWCNUfqGomu/RCcp/1OKe1Kyumy5lIkE9 HRfbSSoWJTe67AB1VAQaaf3d3AcJCcoPduwQoADZS3kNmgyhGIyK9PZuO1eNUkBuiNsD cZxkd/Pd0o8/1qxxhxfadDJHXg8671pcJogimpH/mXqNuSilv0yQWWcxHDqP5ep3Cj10 MEkAM18CurtpP5U076ZAYQuP6v+PL1CINjRP4OJFWvBBQWOn2VuyTQVmWF59PJx/+NO1 Uiqw== X-Gm-Message-State: AOJu0Yx3gE6vr7MR0xDwkLMuqVphH+mV5bm8lZudoSWeOG0tIVEx/xc/ O0F4ZKrYBIEebegd//tf5W4Q1PwJrQ== X-Google-Smtp-Source: AGHT+IFR2bPHl3zKQutXVKFaZX+dvvnolgHXSOHsNmNdg1HD/2lOzglWuRZblQjG/huqwxGrs2ZNL3UQzQ== X-Received: from rmoar-specialist.c.googlers.com ([fda3:e722:ac3:cc00:2b:7d90:c0a8:45d3]) (user=rmoar job=sendgmr) by 2002:a25:bf92:0:b0:dbc:d3fd:ac61 with SMTP id l18-20020a25bf92000000b00dbcd3fdac61mr25376ybk.12.1702496677685; Wed, 13 Dec 2023 11:44:37 -0800 (PST) Date: Wed, 13 Dec 2023 19:44:21 +0000 In-Reply-To: <20231213194421.2031671-1-rmoar@google.com> Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20231213194421.2031671-1-rmoar@google.com> X-Mailer: git-send-email 2.43.0.472.g3155946c3a-goog Message-ID: <20231213194421.2031671-6-rmoar@google.com> Subject: [PATCH v5 6/6] Documentation: Add debugfs docs with run after boot From: Rae Moar To: shuah@kernel.org, davidgow@google.com, dlatypov@google.com, brendan.higgins@linux.dev, sadiyakazi@google.com Cc: keescook@chromium.org, arnd@arndb.de, linux-kselftest@vger.kernel.org, linux-arch@vger.kernel.org, kunit-dev@googlegroups.com, linux-kernel@vger.kernel.org, Rae Moar Expand the documentation on the KUnit debugfs filesystem on the run_manual.rst page. Add section describing how to access results using debugfs. Add section describing how to run tests after boot using debugfs. Reviewed-by: David Gow Signed-off-by: Rae Moar --- Documentation/dev-tools/kunit/run_manual.rst | 51 ++++++++++++++++++-- 1 file changed, 47 insertions(+), 4 deletions(-) diff --git a/Documentation/dev-tools/kunit/run_manual.rst b/Documentation/dev-tools/kunit/run_manual.rst index e7b46421f247..699d92885075 100644 --- a/Documentation/dev-tools/kunit/run_manual.rst +++ b/Documentation/dev-tools/kunit/run_manual.rst @@ -49,9 +49,52 @@ loaded. The results will appear in TAP format in ``dmesg``. +debugfs +======= + +KUnit can be accessed from userspace via the debugfs filesystem (See more +information about debugfs at Documentation/filesystems/debugfs.rst). + +If ``CONFIG_KUNIT_DEBUGFS`` is enabled, the KUnit debugfs filesystem is +mounted at /sys/kernel/debug/kunit. You can use this filesystem to perform +the following actions. + +Retrieve Test Results +===================== + +You can use debugfs to retrieve KUnit test results. The test results are +accessible from the debugfs filesystem in the following read-only file: + +.. code-block :: bash + + /sys/kernel/debug/kunit//results + +The test results are printed in a KTAP document. Note this document is separate +to the kernel log and thus, may have different test suite numbering. + +Run Tests After Kernel Has Booted +================================= + +You can use the debugfs filesystem to trigger built-in tests to run after +boot. To run the test suite, you can use the following command to write to +the ``/sys/kernel/debug/kunit//run`` file: + +.. code-block :: bash + + echo "any string" > /sys/kernel/debugfs/kunit//run + +As a result, the test suite runs and the results are printed to the kernel +log. + +However, this feature is not available with KUnit suites that use init data, +because init data may have been discarded after the kernel boots. KUnit +suites that use init data should be defined using the +kunit_test_init_section_suites() macro. + +Also, you cannot use this feature to run tests concurrently. Instead a test +will wait to run until other tests have completed or failed. + .. note :: - If ``CONFIG_KUNIT_DEBUGFS`` is enabled, KUnit test results will - be accessible from the ``debugfs`` filesystem (if mounted). - They will be in ``/sys/kernel/debug/kunit//results``, in - TAP format. + For test authors, to use this feature, tests will need to correctly initialise + and/or clean up any data, so the test runs correctly a second time.