Merge branch 'master' of https://source.denx.de/u-boot/custodians/u-boot-watchdog

- cyclic: get rid of (the need for) cyclic_init() (Rasmus)

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",

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,

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)

common/cyclic.c

@@ -20,9 +20,10 @@ 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;
+	/* 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->cyclic_ready) {
-		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,14 +43,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, cyclic_get_list());
 
 	return cyclic;
 }
 
 int cyclic_unregister(struct cyclic_info *cyclic)
 {
-	list_del(&cyclic->list);
+	hlist_del(&cyclic->list);
 	free(cyclic);
 
 	return 0;
@@ -62,15 +58,16 @@ 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 */
-	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) {
+	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
@@ -99,7 +96,7 @@ void cyclic_run(void)
 			}
 		}
 	}
-	gd->cyclic->cyclic_running = false;
+	gd->flags &= ~GD_FLG_CYCLIC_RUNNING;
 }
 
 void schedule(void)
@@ -112,32 +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 && gd->cyclic->cyclic_ready)
+	if (gd)
 		cyclic_run();
 }
 
-int cyclic_uninit(void)
+int cyclic_unregister_all(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, cyclic_get_list(), list)
 		cyclic_unregister(cyclic);
-	gd->cyclic->cyclic_ready = false;
-
-	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_LIST_HEAD(&gd->cyclic->cyclic_list);
-	gd->cyclic->cyclic_ready = true;
 
 	return 0;
 }

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
@@ -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__ */

include/cyclic.h

@@ -14,19 +14,6 @@
 #include <linux/list.h>
 #include <asm/types.h>
 
-/**
- * struct cyclic_drv - Cyclic driver internal data
- *
- * @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;
-};
-
 /**
  * struct cyclic_info - Information about cyclic execution function
  *
@@ -50,7 +37,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;
 };
 
@@ -79,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
+ * cyclic_unregister_all() - Clean 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
  *
  * This removes all cyclic functions
  */
-int cyclic_uninit(void);
+int cyclic_unregister_all(void);
 
 /**
  * cyclic_get_list() - Get cyclic list pointer
@@ -99,7 +79,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
@@ -138,12 +118,7 @@ static inline void schedule(void)
 {
 }
 
-static inline int cyclic_init(void)
+static inline int cyclic_unregister_all(void)
-{
-	return 0;
-}
-
-static inline int cyclic_uninit(void)
 {
 	return 0;
 }

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 type * to use as a loop cursor.
- * @pos:	the &struct hlist_node 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)			 \
+#define hlist_for_each_entry(pos, head, member)				\
-	for (pos = (head)->first;					 \
+	for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member);\
-	     pos && ({ prefetch(pos->next); 1;}) &&			 \
+	     pos;							\
-		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
-	     pos = pos->next)
 
 /**
  * hlist_for_each_entry_continue - iterate over a hlist continuing after current point
- * @tpos:	the type * to use as a loop cursor.
+ * @pos:	the type * to use as a loop cursor.
- * @pos:	the &struct hlist_node 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)		 \
+#define hlist_for_each_entry_continue(pos, member)			\
-	for (pos = (pos)->next;						 \
+	for (pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member);\
-	     pos && ({ prefetch(pos->next); 1;}) &&			 \
+	     pos;							\
-		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
-	     pos = pos->next)
 
 /**
  * hlist_for_each_entry_from - iterate over a hlist continuing from current point
- * @tpos:	the type * to use as a loop cursor.
+ * @pos:	the type * to use as a loop cursor.
- * @pos:	the &struct hlist_node 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)			 \
+#define hlist_for_each_entry_from(pos, member)				\
-	for (; pos && ({ prefetch(pos->next); 1;}) &&			 \
+	for (; pos;							\
-		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
-	     pos = pos->next)
 
 /**
  * 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 type * to use as a loop cursor.
- * @pos:	the &struct hlist_node to use as a loop cursor.
+ * @n:		a &struct hlist_node to use as temporary storage
- * @n:		another &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)		 \
+#define hlist_for_each_entry_safe(pos, n, head, member) 		\
-	for (pos = (head)->first;					 \
+	for (pos = hlist_entry_safe((head)->first, typeof(*pos), member);\
-	     pos && ({ n = pos->next; 1; }) &&				 \
+	     pos && ({ n = pos->member.next; 1; });			\
-		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = hlist_entry_safe(n, typeof(*pos), member))
-	     pos = n)
 
 #endif

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);