From d7de5ef629352fe12ad99b6539ba1480b923f31e Mon Sep 17 00:00:00 2001 From: Rasmus Villemoes Date: Fri, 28 Oct 2022 13:50:50 +0200 Subject: cyclic: use a flag in gd->flags for recursion protection As a preparation for future patches, use a flag in gd->flags rather than a separate member in (the singleton) struct cyclic_drv to keep track of whether we're already inside cyclic_run(). Signed-off-by: Rasmus Villemoes Reviewed-by: Stefan Roese Tested-by: Stefan Roese Tested-by: Tim Harvey # imx8mm-venice-* --- common/cyclic.c | 6 +++--- include/asm-generic/global_data.h | 4 ++++ include/cyclic.h | 2 -- 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/common/cyclic.c b/common/cyclic.c index 7abb82c..ff75c8c 100644 --- a/common/cyclic.c +++ b/common/cyclic.c @@ -66,10 +66,10 @@ void cyclic_run(void) uint64_t now, cpu_time; /* Prevent recursion */ - if (gd->cyclic->cyclic_running) + if (gd->flags & GD_FLG_CYCLIC_RUNNING) return; - gd->cyclic->cyclic_running = true; + gd->flags |= GD_FLG_CYCLIC_RUNNING; list_for_each_entry_safe(cyclic, tmp, &gd->cyclic->cyclic_list, list) { /* * Check if this cyclic function needs to get called, e.g. @@ -99,7 +99,7 @@ void cyclic_run(void) } } } - gd->cyclic->cyclic_running = false; + gd->flags &= ~GD_FLG_CYCLIC_RUNNING; } void schedule(void) diff --git a/include/asm-generic/global_data.h b/include/asm-generic/global_data.h index c4b2bb4..8d348b0 100644 --- a/include/asm-generic/global_data.h +++ b/include/asm-generic/global_data.h @@ -650,6 +650,10 @@ enum gd_flags { * @GD_FLG_FDT_CHANGED: Device tree change has been detected by tests */ GD_FLG_FDT_CHANGED = 0x100000, + /** + * GD_FLG_CYCLIC_RUNNING: cyclic_run is in progress + */ + GD_FLG_CYCLIC_RUNNING = 0x200000, }; #endif /* __ASSEMBLY__ */ diff --git a/include/cyclic.h b/include/cyclic.h index 9c5c4fc..50427ba 100644 --- a/include/cyclic.h +++ b/include/cyclic.h @@ -19,12 +19,10 @@ * * @cyclic_list: Cylic list node * @cyclic_ready: Flag if cyclic infrastructure is ready - * @cyclic_running: Flag if cyclic infrastructure is running */ struct cyclic_drv { struct list_head cyclic_list; bool cyclic_ready; - bool cyclic_running; }; /** -- cgit v1.1 From 6b84b1db2d69609a783ab2fd6990c9e72903d367 Mon Sep 17 00:00:00 2001 From: Rasmus Villemoes Date: Fri, 28 Oct 2022 13:50:51 +0200 Subject: cyclic: drop redundant cyclic_ready flag We're already relying on gd->cyclic being NULL before cyclic_init() is called - i.e., we're relying on all of gd being zeroed before entering any C code. And when we do populate gd->cyclic, its ->cyclic_ready member is automatically set to true. So we can actually just rely on testing gd->cyclic itself. The only wrinkle is that cyclic_uninit() actually did set ->cyclic_ready to false. However, since it doesn't free gd->cyclic, the cyclic infrastructure is actually still ready (i.e., the list_head is properly initialized as an empty list). Signed-off-by: Rasmus Villemoes Reviewed-by: Stefan Roese Tested-by: Stefan Roese Tested-by: Tim Harvey # imx8mm-venice-* --- common/cyclic.c | 6 ++---- include/cyclic.h | 2 -- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/common/cyclic.c b/common/cyclic.c index ff75c8c..d6f11b0 100644 --- a/common/cyclic.c +++ b/common/cyclic.c @@ -30,7 +30,7 @@ struct cyclic_info *cyclic_register(cyclic_func_t func, uint64_t delay_us, { struct cyclic_info *cyclic; - if (!gd->cyclic->cyclic_ready) { + if (!gd->cyclic) { pr_debug("Cyclic IF not ready yet\n"); return NULL; } @@ -112,7 +112,7 @@ void schedule(void) * schedule() might get called very early before the cyclic IF is * ready. Make sure to only call cyclic_run() when it's initalized. */ - if (gd && gd->cyclic && gd->cyclic->cyclic_ready) + if (gd && gd->cyclic) cyclic_run(); } @@ -122,7 +122,6 @@ int cyclic_uninit(void) list_for_each_entry_safe(cyclic, tmp, &gd->cyclic->cyclic_list, list) cyclic_unregister(cyclic); - gd->cyclic->cyclic_ready = false; return 0; } @@ -137,7 +136,6 @@ int cyclic_init(void) memset(gd->cyclic, '\0', size); INIT_LIST_HEAD(&gd->cyclic->cyclic_list); - gd->cyclic->cyclic_ready = true; return 0; } diff --git a/include/cyclic.h b/include/cyclic.h index 50427ba..263b74d 100644 --- a/include/cyclic.h +++ b/include/cyclic.h @@ -18,11 +18,9 @@ * struct cyclic_drv - Cyclic driver internal data * * @cyclic_list: Cylic list node - * @cyclic_ready: Flag if cyclic infrastructure is ready */ struct cyclic_drv { struct list_head cyclic_list; - bool cyclic_ready; }; /** -- cgit v1.1 From 2399b628f4c1c92bbe9033273b450b1e514f802e Mon Sep 17 00:00:00 2001 From: Rasmus Villemoes Date: Fri, 28 Oct 2022 13:50:52 +0200 Subject: list.h: synchronize hlist_for_each_entry* iterators with linux All the way back in 2013, the linux kernel updated the four hlist_for_each_entry* iterators to require one less auxiliary variable: commit b67bfe0d42cac56c512dd5da4b1b347a23f4b70a Author: Sasha Levin Date: Wed Feb 27 17:06:00 2013 -0800 hlist: drop the node parameter from iterators Currently, there is only one "user" of any of these, namely in fs/ubifs/super.c, but that actually uses the "new-style" form, and is (obviously, or it wouldn't have built) inside #ifndef __UBOOT__. Before adding actual users of these, import the version as of linux v6.1-rc1, including the hlist_entry_safe() helper used by the new versions. Signed-off-by: Rasmus Villemoes Reviewed-by: Stefan Roese Tested-by: Stefan Roese Tested-by: Tim Harvey # imx8mm-venice-* --- include/linux/list.h | 53 +++++++++++++++++++++++++--------------------------- 1 file changed, 25 insertions(+), 28 deletions(-) diff --git a/include/linux/list.h b/include/linux/list.h index 3eacf68..6910721 100644 --- a/include/linux/list.h +++ b/include/linux/list.h @@ -646,54 +646,51 @@ static inline void hlist_add_after(struct hlist_node *n, for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \ pos = n) +#define hlist_entry_safe(ptr, type, member) \ + ({ typeof(ptr) ____ptr = (ptr); \ + ____ptr ? hlist_entry(____ptr, type, member) : NULL; \ + }) + /** * hlist_for_each_entry - iterate over list of given type - * @tpos: the type * to use as a loop cursor. - * @pos: the &struct hlist_node to use as a loop cursor. + * @pos: the type * to use as a loop cursor. * @head: the head for your list. * @member: the name of the hlist_node within the struct. */ -#define hlist_for_each_entry(tpos, pos, head, member) \ - for (pos = (head)->first; \ - pos && ({ prefetch(pos->next); 1;}) && \ - ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ - pos = pos->next) +#define hlist_for_each_entry(pos, head, member) \ + for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member);\ + pos; \ + pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) /** * hlist_for_each_entry_continue - iterate over a hlist continuing after current point - * @tpos: the type * to use as a loop cursor. - * @pos: the &struct hlist_node to use as a loop cursor. + * @pos: the type * to use as a loop cursor. * @member: the name of the hlist_node within the struct. */ -#define hlist_for_each_entry_continue(tpos, pos, member) \ - for (pos = (pos)->next; \ - pos && ({ prefetch(pos->next); 1;}) && \ - ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ - pos = pos->next) +#define hlist_for_each_entry_continue(pos, member) \ + for (pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member);\ + pos; \ + pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) /** * hlist_for_each_entry_from - iterate over a hlist continuing from current point - * @tpos: the type * to use as a loop cursor. - * @pos: the &struct hlist_node to use as a loop cursor. + * @pos: the type * to use as a loop cursor. * @member: the name of the hlist_node within the struct. */ -#define hlist_for_each_entry_from(tpos, pos, member) \ - for (; pos && ({ prefetch(pos->next); 1;}) && \ - ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ - pos = pos->next) +#define hlist_for_each_entry_from(pos, member) \ + for (; pos; \ + pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) /** * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry - * @tpos: the type * to use as a loop cursor. - * @pos: the &struct hlist_node to use as a loop cursor. - * @n: another &struct hlist_node to use as temporary storage + * @pos: the type * to use as a loop cursor. + * @n: a &struct hlist_node to use as temporary storage * @head: the head for your list. * @member: the name of the hlist_node within the struct. */ -#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \ - for (pos = (head)->first; \ - pos && ({ n = pos->next; 1; }) && \ - ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ - pos = n) +#define hlist_for_each_entry_safe(pos, n, head, member) \ + for (pos = hlist_entry_safe((head)->first, typeof(*pos), member);\ + pos && ({ n = pos->member.next; 1; }); \ + pos = hlist_entry_safe(n, typeof(*pos), member)) #endif -- cgit v1.1 From 28968394839bec37dacf6ffc2ae880e38756e917 Mon Sep 17 00:00:00 2001 From: Rasmus Villemoes Date: Fri, 28 Oct 2022 13:50:53 +0200 Subject: cyclic: switch to using hlist instead of list A hlist is headed by just a single pointer, so can only be traversed forwards, and insertions can only happen at the head (or before/after an existing list member). But each list node still consists of two pointers, so arbitrary elements can still be removed in O(1). This is precisely what we need for the cyclic_list - we never need to traverse it backwards, and the order the callbacks appear in the list should really not matter. One advantage, and the main reason for doing this switch, is that an empty list is represented by a NULL head pointer, so unlike a list_head, it does not need separate C code to initialize - a memset(,0,) of the containing structure is sufficient. This is mostly mechanical: - The iterators are updated with an h prefix, and the type of the temporary variable changed to struct hlist_node*. - Adding/removing is now just hlist_add_head (and not tail) and hlist_del(). - struct members and function return values updated. Signed-off-by: Rasmus Villemoes Reviewed-by: Stefan Roese Tested-by: Stefan Roese Tested-by: Tim Harvey # imx8mm-venice-* --- cmd/cyclic.c | 5 +++-- common/cyclic.c | 18 ++++++++++-------- include/cyclic.h | 6 +++--- 3 files changed, 16 insertions(+), 13 deletions(-) diff --git a/cmd/cyclic.c b/cmd/cyclic.c index c1bc556..97324d8 100644 --- a/cmd/cyclic.c +++ b/cmd/cyclic.c @@ -61,10 +61,11 @@ static int do_cyclic_demo(struct cmd_tbl *cmdtp, int flag, int argc, static int do_cyclic_list(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { - struct cyclic_info *cyclic, *tmp; + struct cyclic_info *cyclic; + struct hlist_node *tmp; u64 cnt, freq; - list_for_each_entry_safe(cyclic, tmp, cyclic_get_list(), list) { + hlist_for_each_entry_safe(cyclic, tmp, cyclic_get_list(), list) { cnt = cyclic->run_cnt * 1000000ULL * 100ULL; freq = lldiv(cnt, timer_get_us() - cyclic->start_time_us); printf("function: %s, cpu-time: %lld us, frequency: %lld.%02d times/s\n", diff --git a/common/cyclic.c b/common/cyclic.c index d6f11b0..32d9bf0 100644 --- a/common/cyclic.c +++ b/common/cyclic.c @@ -20,7 +20,7 @@ DECLARE_GLOBAL_DATA_PTR; void hw_watchdog_reset(void); -struct list_head *cyclic_get_list(void) +struct hlist_head *cyclic_get_list(void) { return &gd->cyclic->cyclic_list; } @@ -47,14 +47,14 @@ struct cyclic_info *cyclic_register(cyclic_func_t func, uint64_t delay_us, cyclic->name = strdup(name); cyclic->delay_us = delay_us; cyclic->start_time_us = timer_get_us(); - list_add_tail(&cyclic->list, &gd->cyclic->cyclic_list); + hlist_add_head(&cyclic->list, &gd->cyclic->cyclic_list); return cyclic; } int cyclic_unregister(struct cyclic_info *cyclic) { - list_del(&cyclic->list); + hlist_del(&cyclic->list); free(cyclic); return 0; @@ -62,7 +62,8 @@ int cyclic_unregister(struct cyclic_info *cyclic) void cyclic_run(void) { - struct cyclic_info *cyclic, *tmp; + struct cyclic_info *cyclic; + struct hlist_node *tmp; uint64_t now, cpu_time; /* Prevent recursion */ @@ -70,7 +71,7 @@ void cyclic_run(void) return; gd->flags |= GD_FLG_CYCLIC_RUNNING; - list_for_each_entry_safe(cyclic, tmp, &gd->cyclic->cyclic_list, list) { + hlist_for_each_entry_safe(cyclic, tmp, &gd->cyclic->cyclic_list, list) { /* * Check if this cyclic function needs to get called, e.g. * do not call the cyclic func too often @@ -118,9 +119,10 @@ void schedule(void) int cyclic_uninit(void) { - struct cyclic_info *cyclic, *tmp; + struct cyclic_info *cyclic; + struct hlist_node *tmp; - list_for_each_entry_safe(cyclic, tmp, &gd->cyclic->cyclic_list, list) + hlist_for_each_entry_safe(cyclic, tmp, &gd->cyclic->cyclic_list, list) cyclic_unregister(cyclic); return 0; @@ -135,7 +137,7 @@ int cyclic_init(void) return -ENOMEM; memset(gd->cyclic, '\0', size); - INIT_LIST_HEAD(&gd->cyclic->cyclic_list); + INIT_HLIST_HEAD(&gd->cyclic->cyclic_list); return 0; } diff --git a/include/cyclic.h b/include/cyclic.h index 263b74d..4a11f9b 100644 --- a/include/cyclic.h +++ b/include/cyclic.h @@ -20,7 +20,7 @@ * @cyclic_list: Cylic list node */ struct cyclic_drv { - struct list_head cyclic_list; + struct hlist_head cyclic_list; }; /** @@ -46,7 +46,7 @@ struct cyclic_info { uint64_t cpu_time_us; uint64_t run_cnt; uint64_t next_call; - struct list_head list; + struct hlist_node list; bool already_warned; }; @@ -95,7 +95,7 @@ int cyclic_uninit(void); * * @return: pointer to cyclic_list */ -struct list_head *cyclic_get_list(void); +struct hlist_head *cyclic_get_list(void); /** * cyclic_run() - Interate over all registered cyclic functions -- cgit v1.1 From 50128aeb0f8bb5a2d820e4c7a6ac0bb745809fc1 Mon Sep 17 00:00:00 2001 From: Rasmus Villemoes Date: Fri, 28 Oct 2022 13:50:54 +0200 Subject: cyclic: get rid of cyclic_init() Currently, we must call cyclic_init() at some point before cyclic_register() becomes possible. That turns out to be somewhat awkward, especially with SPL, and has resulted in a watchdog callback not being registered, thus causing the board to prematurely reset. We already rely on gd->cyclic reliably being set to NULL by the asm code that clears all of gd. Now that the cyclic list is a hlist, and thus an empty list is represented by a NULL head pointer, and struct cyclic_drv has no other members, we can just as well drop a level of indirection and put the hlist_head directly in struct global_data. This doesn't increase the size of struct global_data, gets rid of an early malloc(), and generates slightly smaller code. But primarily, this avoids having to call cyclic_init() early; the cyclic infrastructure is simply ready to register callbacks as soon as we enter C code. We can still end up with schedule() being called from asm very early, so we still need to check that gd itself has been properly initialized [*], but once it has, gd->cyclic_list is perfectly fine to access, and will just be an empty list. As for cyclic_uninit(), it was never really the opposite of cyclic_init() since it didn't free the struct cyclic_drv nor set gd->cyclic to NULL. Rename it to cyclic_unregister_all() and use that in test/, and also insert a call at the end of the board_init_f sequence so that gd->cyclic_list is a fresh empty list before we enter board_init_r(). A small piece of ugliness is that I had to add a cast in cyclic_get_list() to silence a "discards 'volatile' qualifier" warning, but that is completely equivalent to the existing handling of the uclass_root_s list_head member. [*] I'm not really sure where we guarantee that the register used for gd contains 0 until it gets explicitly initialized, but that must be the case, otherwise testing gd for being NULL would not make much sense. Signed-off-by: Rasmus Villemoes Reviewed-by: Stefan Roese Tested-by: Stefan Roese Tested-by: Tim Harvey # imx8mm-venice-* --- common/board_f.c | 11 ++++++++++- common/board_r.c | 1 - common/cyclic.c | 32 +++++++------------------------- include/asm-generic/global_data.h | 4 ++-- include/cyclic.h | 27 +++------------------------ test/test-main.c | 3 +-- 6 files changed, 23 insertions(+), 55 deletions(-) diff --git a/common/board_f.c b/common/board_f.c index faa0964..7c26e23 100644 --- a/common/board_f.c +++ b/common/board_f.c @@ -839,7 +839,6 @@ static const init_fnc_t init_sequence_f[] = { initf_malloc, log_init, initf_bootstage, /* uses its own timer, so does not need DM */ - cyclic_init, event_init, #ifdef CONFIG_BLOBLIST bloblist_init, @@ -957,6 +956,16 @@ static const init_fnc_t init_sequence_f[] = { do_elf_reloc_fixups, #endif clear_bss, + /* + * Deregister all cyclic functions before relocation, so that + * gd->cyclic_list does not contain any references to pre-relocation + * devices. Drivers will register their cyclic functions anew when the + * devices are probed again. + * + * This should happen as late as possible so that the window where a + * watchdog device is not serviced is as small as possible. + */ + cyclic_unregister_all, #if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX) && \ !CONFIG_IS_ENABLED(X86_64) jump_to_copy, diff --git a/common/board_r.c b/common/board_r.c index 828ad44..db9cfb3 100644 --- a/common/board_r.c +++ b/common/board_r.c @@ -617,7 +617,6 @@ static init_fnc_t init_sequence_r[] = { #endif initr_barrier, initr_malloc, - cyclic_init, log_init, initr_bootstage, /* Needs malloc() but has its own timer */ #if defined(CONFIG_CONSOLE_RECORD) diff --git a/common/cyclic.c b/common/cyclic.c index 32d9bf0..a49bfc8 100644 --- a/common/cyclic.c +++ b/common/cyclic.c @@ -22,7 +22,8 @@ void hw_watchdog_reset(void); struct hlist_head *cyclic_get_list(void) { - return &gd->cyclic->cyclic_list; + /* Silence "discards 'volatile' qualifier" warning. */ + return (struct hlist_head *)&gd->cyclic_list; } struct cyclic_info *cyclic_register(cyclic_func_t func, uint64_t delay_us, @@ -30,11 +31,6 @@ struct cyclic_info *cyclic_register(cyclic_func_t func, uint64_t delay_us, { struct cyclic_info *cyclic; - if (!gd->cyclic) { - pr_debug("Cyclic IF not ready yet\n"); - return NULL; - } - cyclic = calloc(1, sizeof(struct cyclic_info)); if (!cyclic) { pr_debug("Memory allocation error\n"); @@ -47,7 +43,7 @@ struct cyclic_info *cyclic_register(cyclic_func_t func, uint64_t delay_us, cyclic->name = strdup(name); cyclic->delay_us = delay_us; cyclic->start_time_us = timer_get_us(); - hlist_add_head(&cyclic->list, &gd->cyclic->cyclic_list); + hlist_add_head(&cyclic->list, cyclic_get_list()); return cyclic; } @@ -71,7 +67,7 @@ void cyclic_run(void) return; gd->flags |= GD_FLG_CYCLIC_RUNNING; - hlist_for_each_entry_safe(cyclic, tmp, &gd->cyclic->cyclic_list, list) { + hlist_for_each_entry_safe(cyclic, tmp, cyclic_get_list(), list) { /* * Check if this cyclic function needs to get called, e.g. * do not call the cyclic func too often @@ -113,31 +109,17 @@ void schedule(void) * schedule() might get called very early before the cyclic IF is * ready. Make sure to only call cyclic_run() when it's initalized. */ - if (gd && gd->cyclic) + if (gd) cyclic_run(); } -int cyclic_uninit(void) +int cyclic_unregister_all(void) { struct cyclic_info *cyclic; struct hlist_node *tmp; - hlist_for_each_entry_safe(cyclic, tmp, &gd->cyclic->cyclic_list, list) + hlist_for_each_entry_safe(cyclic, tmp, cyclic_get_list(), list) cyclic_unregister(cyclic); return 0; } - -int cyclic_init(void) -{ - int size = sizeof(struct cyclic_drv); - - gd->cyclic = (struct cyclic_drv *)malloc(size); - if (!gd->cyclic) - return -ENOMEM; - - memset(gd->cyclic, '\0', size); - INIT_HLIST_HEAD(&gd->cyclic->cyclic_list); - - return 0; -} diff --git a/include/asm-generic/global_data.h b/include/asm-generic/global_data.h index 8d348b0..02ad8ca 100644 --- a/include/asm-generic/global_data.h +++ b/include/asm-generic/global_data.h @@ -481,9 +481,9 @@ struct global_data { #endif #ifdef CONFIG_CYCLIC /** - * @cyclic: cyclic driver data + * @cyclic_list: list of registered cyclic functions */ - struct cyclic_drv *cyclic; + struct hlist_head cyclic_list; #endif /** * @dmtag_list: List of DM tags diff --git a/include/cyclic.h b/include/cyclic.h index 4a11f9b..44ad3cb 100644 --- a/include/cyclic.h +++ b/include/cyclic.h @@ -15,15 +15,6 @@ #include /** - * struct cyclic_drv - Cyclic driver internal data - * - * @cyclic_list: Cylic list node - */ -struct cyclic_drv { - struct hlist_head cyclic_list; -}; - -/** * struct cyclic_info - Information about cyclic execution function * * @func: Function to call periodically @@ -75,18 +66,11 @@ struct cyclic_info *cyclic_register(cyclic_func_t func, uint64_t delay_us, int cyclic_unregister(struct cyclic_info *cyclic); /** - * cyclic_init() - Set up cyclic functions - * - * Init a list of cyclic functions, so that these can be added as needed - */ -int cyclic_init(void); - -/** - * cyclic_uninit() - Clean up cyclic functions + * cyclic_unregister_all() - Clean up cyclic functions * * This removes all cyclic functions */ -int cyclic_uninit(void); +int cyclic_unregister_all(void); /** * cyclic_get_list() - Get cyclic list pointer @@ -134,12 +118,7 @@ static inline void schedule(void) { } -static inline int cyclic_init(void) -{ - return 0; -} - -static inline int cyclic_uninit(void) +static inline int cyclic_unregister_all(void) { return 0; } diff --git a/test/test-main.c b/test/test-main.c index ddfd89c..fe3ef6d 100644 --- a/test/test-main.c +++ b/test/test-main.c @@ -287,7 +287,6 @@ static int dm_test_restore(struct device_node *of_root) static int test_pre_run(struct unit_test_state *uts, struct unit_test *test) { ut_assertok(event_init()); - ut_assertok(cyclic_init()); if (test->flags & UT_TESTF_DM) ut_assertok(dm_test_pre_run(uts)); @@ -347,7 +346,7 @@ static int test_post_run(struct unit_test_state *uts, struct unit_test *test) ut_unsilence_console(uts); if (test->flags & UT_TESTF_DM) ut_assertok(dm_test_post_run(uts)); - ut_assertok(cyclic_uninit()); + ut_assertok(cyclic_unregister_all()); ut_assertok(event_uninit()); free(uts->of_other); -- cgit v1.1