From b63adb979583ef185718d774d8162387db5589c0 Mon Sep 17 00:00:00 2001 From: Guenter Roeck Date: Fri, 26 Sep 2014 00:03:16 +0000 Subject: [PATCH 1/8] kernel: add support for kernel restart handler call chain Various drivers implement architecture and/or device specific means to restart (reset) the system. Various mechanisms have been implemented to support those schemes. The best known mechanism is arm_pm_restart, which is a function pointer to be set either from platform specific code or from drivers. Another mechanism is to use hardware watchdogs to issue a reset; this mechanism is used if there is no other method available to reset a board or system. Two examples are alim7101_wdt, which currently uses the reboot notifier to trigger a reset, and moxart_wdt, which registers the arm_pm_restart function. The existing mechanisms have a number of drawbacks. Typically only one scheme to restart the system is supported (at least if arm_pm_restart is used). At least in theory there can be multiple means to restart the system, some of which may be less desirable (for example one mechanism may only reset the CPU, while another may reset the entire system). Using arm_pm_restart can also be racy if the function pointer is set from a driver, as the driver may be in the process of being unloaded when arm_pm_restart is called. Using the reboot notifier is always racy, as it is unknown if and when other functions using the reboot notifier have completed execution by the time the watchdog fires. Introduce a system restart handler call chain to solve the described problems. This call chain is expected to be executed from the architecture specific machine_restart() function. Drivers providing system restart functionality (such as the watchdog drivers mentioned above) are expected to register with this call chain. By using the priority field in the notifier block, callers can control restart handler execution sequence and thus ensure that the restart handler with the optimal restart capabilities for a given system is called first. Signed-off-by: Guenter Roeck Acked-by: Catalin Marinas Acked-by: Heiko Stuebner Cc: Russell King Cc: Wim Van Sebroeck Cc: Maxime Ripard Cc: Will Deacon Cc: Arnd Bergmann Cc: Jonas Jensen Cc: Randy Dunlap Cc: Steven Rostedt Cc: Ingo Molnar Cc: Dmitry Eremin-Solenikov Cc: David Woodhouse Cc: Tomasz Figa Signed-off-by: Andrew Morton --- include/linux/reboot.h | 3 ++ kernel/reboot.c | 81 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 84 insertions(+) diff --git a/include/linux/reboot.h b/include/linux/reboot.h index 48bf152761c7..67fc8fcdc4b0 100644 --- a/include/linux/reboot.h +++ b/include/linux/reboot.h @@ -38,6 +38,9 @@ extern int reboot_force; extern int register_reboot_notifier(struct notifier_block *); extern int unregister_reboot_notifier(struct notifier_block *); +extern int register_restart_handler(struct notifier_block *); +extern int unregister_restart_handler(struct notifier_block *); +extern void do_kernel_restart(char *cmd); /* * Architecture-specific implementations of sys_reboot commands. diff --git a/kernel/reboot.c b/kernel/reboot.c index a3a9e240fcdb..5925f5ae8dff 100644 --- a/kernel/reboot.c +++ b/kernel/reboot.c @@ -104,6 +104,87 @@ int unregister_reboot_notifier(struct notifier_block *nb) } EXPORT_SYMBOL(unregister_reboot_notifier); +/* + * Notifier list for kernel code which wants to be called + * to restart the system. + */ +static ATOMIC_NOTIFIER_HEAD(restart_handler_list); + +/** + * register_restart_handler - Register function to be called to reset + * the system + * @nb: Info about handler function to be called + * @nb->priority: Handler priority. Handlers should follow the + * following guidelines for setting priorities. + * 0: Restart handler of last resort, + * with limited restart capabilities + * 128: Default restart handler; use if no other + * restart handler is expected to be available, + * and/or if restart functionality is + * sufficient to restart the entire system + * 255: Highest priority restart handler, will + * preempt all other restart handlers + * + * Registers a function with code to be called to restart the + * system. + * + * Registered functions will be called from machine_restart as last + * step of the restart sequence (if the architecture specific + * machine_restart function calls do_kernel_restart - see below + * for details). + * Registered functions are expected to restart the system immediately. + * If more than one function is registered, the restart handler priority + * selects which function will be called first. + * + * Restart handlers are expected to be registered from non-architecture + * code, typically from drivers. A typical use case would be a system + * where restart functionality is provided through a watchdog. Multiple + * restart handlers may exist; for example, one restart handler might + * restart the entire system, while another only restarts the CPU. + * In such cases, the restart handler which only restarts part of the + * hardware is expected to register with low priority to ensure that + * it only runs if no other means to restart the system is available. + * + * Currently always returns zero, as atomic_notifier_chain_register() + * always returns zero. + */ +int register_restart_handler(struct notifier_block *nb) +{ + return atomic_notifier_chain_register(&restart_handler_list, nb); +} +EXPORT_SYMBOL(register_restart_handler); + +/** + * unregister_restart_handler - Unregister previously registered + * restart handler + * @nb: Hook to be unregistered + * + * Unregisters a previously registered restart handler function. + * + * Returns zero on success, or %-ENOENT on failure. + */ +int unregister_restart_handler(struct notifier_block *nb) +{ + return atomic_notifier_chain_unregister(&restart_handler_list, nb); +} +EXPORT_SYMBOL(unregister_restart_handler); + +/** + * do_kernel_restart - Execute kernel restart handler call chain + * + * Calls functions registered with register_restart_handler. + * + * Expected to be called from machine_restart as last step of the restart + * sequence. + * + * Restarts the system immediately if a restart handler function has been + * registered. Otherwise does nothing. + */ +void do_kernel_restart(char *cmd) +{ + atomic_notifier_call_chain(&restart_handler_list, reboot_mode, cmd); +} + void migrate_to_reboot_cpu(void) { /* The boot cpu is always logical cpu 0 */ From 0713e143c943c4f14aa5db1903bdbfd1356a2bb3 Mon Sep 17 00:00:00 2001 From: Guenter Roeck Date: Fri, 26 Sep 2014 00:03:16 +0000 Subject: [PATCH 2/8] power/restart: call machine_restart instead of arm_pm_restart machine_restart is supported on non-ARM platforms, and and ultimately calls arm_pm_restart, so dont call arm_pm_restart directly but use the more generic function. Signed-off-by: Guenter Roeck Acked-by: Catalin Marinas Acked-by: Heiko Stuebner Cc: Russell King Cc: Arnd Bergmann Cc: David Woodhouse Cc: Dmitry Eremin-Solenikov Cc: Ingo Molnar Cc: Jonas Jensen Cc: Maxime Ripard Cc: Randy Dunlap Cc: Steven Rostedt Cc: Tomasz Figa Cc: Will Deacon Cc: Wim Van Sebroeck Signed-off-by: Andrew Morton --- drivers/power/reset/restart-poweroff.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/drivers/power/reset/restart-poweroff.c b/drivers/power/reset/restart-poweroff.c index 3e51f8d29bfe..edd707ee7281 100644 --- a/drivers/power/reset/restart-poweroff.c +++ b/drivers/power/reset/restart-poweroff.c @@ -20,7 +20,8 @@ static void restart_poweroff_do_poweroff(void) { - arm_pm_restart(REBOOT_HARD, NULL); + reboot_mode = REBOOT_HARD; + machine_restart(NULL); } static int restart_poweroff_probe(struct platform_device *pdev) From 1c7ffc32eaadfae3e7ab106359af0cf21b7e94c1 Mon Sep 17 00:00:00 2001 From: Guenter Roeck Date: Fri, 26 Sep 2014 00:03:16 +0000 Subject: [PATCH 3/8] arm64: support restart through restart handler call chain The kernel core now supports a restart handler call chain to restart the system. Call it if arm_pm_restart is not set. Signed-off-by: Guenter Roeck Acked-by: Catalin Marinas Acked-by: Heiko Stuebner Cc: Arnd Bergmann Cc: David Woodhouse Cc: Dmitry Eremin-Solenikov Cc: Ingo Molnar Cc: Jonas Jensen Cc: Maxime Ripard Cc: Randy Dunlap Cc: Russell King Cc: Steven Rostedt Cc: Tomasz Figa Cc: Will Deacon Cc: Wim Van Sebroeck Signed-off-by: Andrew Morton --- arch/arm64/kernel/process.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/arch/arm64/kernel/process.c b/arch/arm64/kernel/process.c index 1309d64aa926..0d3fb9fd0dca 100644 --- a/arch/arm64/kernel/process.c +++ b/arch/arm64/kernel/process.c @@ -180,6 +180,8 @@ void machine_restart(char *cmd) /* Now call the architecture specific reboot code. */ if (arm_pm_restart) arm_pm_restart(reboot_mode, cmd); + else + do_kernel_restart(cmd); /* * Whoops - the architecture was unable to reboot. From 1a9607a3be14a43868c5e6a35962e7f6be9bcfe1 Mon Sep 17 00:00:00 2001 From: Guenter Roeck Date: Fri, 26 Sep 2014 00:03:17 +0000 Subject: [PATCH 4/8] arm: support restart through restart handler call chain The kernel core now supports a restart handler call chain for system restart functions. With this change, the arm_pm_restart callback is now optional, so drop its initialization and check if it is set before calling it. Only call the kernel restart handler if arm_pm_restart is not set. Signed-off-by: Guenter Roeck Acked-by: Catalin Marinas Acked-by: Heiko Stuebner Cc: Arnd Bergmann Cc: David Woodhouse Cc: Dmitry Eremin-Solenikov Cc: Ingo Molnar Cc: Jonas Jensen Cc: Maxime Ripard Cc: Randy Dunlap Cc: Russell King Cc: Steven Rostedt Cc: Tomasz Figa Cc: Will Deacon Cc: Wim Van Sebroeck Signed-off-by: Andrew Morton --- arch/arm/kernel/process.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/arch/arm/kernel/process.c b/arch/arm/kernel/process.c index 81ef686a91ca..ea279f7a8767 100644 --- a/arch/arm/kernel/process.c +++ b/arch/arm/kernel/process.c @@ -114,17 +114,13 @@ void soft_restart(unsigned long addr) BUG(); } -static void null_restart(enum reboot_mode reboot_mode, const char *cmd) -{ -} - /* * Function pointers to optional machine specific functions */ void (*pm_power_off)(void); EXPORT_SYMBOL(pm_power_off); -void (*arm_pm_restart)(enum reboot_mode reboot_mode, const char *cmd) = null_restart; +void (*arm_pm_restart)(enum reboot_mode reboot_mode, const char *cmd); EXPORT_SYMBOL_GPL(arm_pm_restart); /* @@ -230,7 +226,10 @@ void machine_restart(char *cmd) local_irq_disable(); smp_send_stop(); - arm_pm_restart(reboot_mode, cmd); + if (arm_pm_restart) + arm_pm_restart(reboot_mode, cmd); + else + do_kernel_restart(cmd); /* Give a grace period for failure to restart of 1s */ mdelay(1000); From ad0e0e6810b339ddeb97ab9ae24e996db5c11bac Mon Sep 17 00:00:00 2001 From: Guenter Roeck Date: Fri, 26 Sep 2014 00:03:17 +0000 Subject: [PATCH 5/8] watchdog: moxart: register restart handler with kernel restart handler The kernel now provides an API to trigger a system restart. Register with it instead of setting arm_pm_restart. Signed-off-by: Guenter Roeck Acked-by: Catalin Marinas Acked-by: Heiko Stuebner Cc: Arnd Bergmann Cc: David Woodhouse Cc: Dmitry Eremin-Solenikov Cc: Ingo Molnar Cc: Jonas Jensen Cc: Maxime Ripard Cc: Randy Dunlap Cc: Russell King Cc: Steven Rostedt Cc: Tomasz Figa Cc: Will Deacon Cc: Wim Van Sebroeck Signed-off-by: Andrew Morton --- drivers/watchdog/moxart_wdt.c | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/drivers/watchdog/moxart_wdt.c b/drivers/watchdog/moxart_wdt.c index 4aa3a8a876fe..a64405b82596 100644 --- a/drivers/watchdog/moxart_wdt.c +++ b/drivers/watchdog/moxart_wdt.c @@ -15,12 +15,12 @@ #include #include #include +#include #include +#include #include #include -#include - #define REG_COUNT 0x4 #define REG_MODE 0x8 #define REG_ENABLE 0xC @@ -29,17 +29,22 @@ struct moxart_wdt_dev { struct watchdog_device dev; void __iomem *base; unsigned int clock_frequency; + struct notifier_block restart_handler; }; -static struct moxart_wdt_dev *moxart_restart_ctx; - static int heartbeat; -static void moxart_wdt_restart(enum reboot_mode reboot_mode, const char *cmd) +static int moxart_restart_handle(struct notifier_block *this, + unsigned long mode, void *cmd) { - writel(1, moxart_restart_ctx->base + REG_COUNT); - writel(0x5ab9, moxart_restart_ctx->base + REG_MODE); - writel(0x03, moxart_restart_ctx->base + REG_ENABLE); + struct moxart_wdt_dev *moxart_wdt = container_of(this, + struct moxart_wdt_dev, + restart_handler); + writel(1, moxart_wdt->base + REG_COUNT); + writel(0x5ab9, moxart_wdt->base + REG_MODE); + writel(0x03, moxart_wdt->base + REG_ENABLE); + + return NOTIFY_DONE; } static int moxart_wdt_stop(struct watchdog_device *wdt_dev) @@ -136,8 +141,12 @@ static int moxart_wdt_probe(struct platform_device *pdev) if (err) return err; - moxart_restart_ctx = moxart_wdt; - arm_pm_restart = moxart_wdt_restart; + moxart_wdt->restart_handler.notifier_call = moxart_restart_handle; + moxart_wdt->restart_handler.priority = 128; + err = register_restart_handler(&moxart_wdt->restart_handler); + if (err) + dev_err(dev, "cannot register restart notifier (err=%d)\n", + err); dev_dbg(dev, "Watchdog enabled (heartbeat=%d sec, nowayout=%d)\n", moxart_wdt->dev.timeout, nowayout); @@ -149,9 +158,8 @@ static int moxart_wdt_remove(struct platform_device *pdev) { struct moxart_wdt_dev *moxart_wdt = platform_get_drvdata(pdev); - arm_pm_restart = NULL; + unregister_restart_handler(&moxart_wdt->restart_handler); moxart_wdt_stop(&moxart_wdt->dev); - watchdog_unregister_device(&moxart_wdt->dev); return 0; } From 87ffc69e4b05f6e98e2b7a42f23132ed3662450a Mon Sep 17 00:00:00 2001 From: Guenter Roeck Date: Fri, 26 Sep 2014 00:03:17 +0000 Subject: [PATCH 6/8] watchdog: alim7101: register restart handler with kernel restart handler The kernel core now provides an API to trigger a system restart. Register with it to restart the system instead of misusing the reboot notifier. Signed-off-by: Guenter Roeck Acked-by: Catalin Marinas Acked-by: Heiko Stuebner Cc: Arnd Bergmann Cc: David Woodhouse Cc: Dmitry Eremin-Solenikov Cc: Ingo Molnar Cc: Jonas Jensen Cc: Maxime Ripard Cc: Randy Dunlap Cc: Russell King Cc: Steven Rostedt Cc: Tomasz Figa Cc: Will Deacon Cc: Wim Van Sebroeck Signed-off-by: Andrew Morton --- drivers/watchdog/alim7101_wdt.c | 42 +++++++++++++++++++++++++-------- 1 file changed, 32 insertions(+), 10 deletions(-) diff --git a/drivers/watchdog/alim7101_wdt.c b/drivers/watchdog/alim7101_wdt.c index 996b2f7d330e..665e0e7dfe1e 100644 --- a/drivers/watchdog/alim7101_wdt.c +++ b/drivers/watchdog/alim7101_wdt.c @@ -301,6 +301,28 @@ static struct miscdevice wdt_miscdev = { .fops = &wdt_fops, }; +static int wdt_restart_handle(struct notifier_block *this, unsigned long mode, + void *cmd) +{ + /* + * Cobalt devices have no way of rebooting themselves other + * than getting the watchdog to pull reset, so we restart the + * watchdog on reboot with no heartbeat. + */ + wdt_change(WDT_ENABLE); + + /* loop until the watchdog fires */ + while (true) + ; + + return NOTIFY_DONE; +} + +static struct notifier_block wdt_restart_handler = { + .notifier_call = wdt_restart_handle, + .priority = 128, +}; + /* * Notifier for system down */ @@ -311,15 +333,6 @@ static int wdt_notify_sys(struct notifier_block *this, if (code == SYS_DOWN || code == SYS_HALT) wdt_turnoff(); - if (code == SYS_RESTART) { - /* - * Cobalt devices have no way of rebooting themselves other - * than getting the watchdog to pull reset, so we restart the - * watchdog on reboot with no heartbeat - */ - wdt_change(WDT_ENABLE); - pr_info("Watchdog timer is now enabled with no heartbeat - should reboot in ~1 second\n"); - } return NOTIFY_DONE; } @@ -338,6 +351,7 @@ static void __exit alim7101_wdt_unload(void) /* Deregister */ misc_deregister(&wdt_miscdev); unregister_reboot_notifier(&wdt_notifier); + unregister_restart_handler(&wdt_restart_handler); pci_dev_put(alim7101_pmu); } @@ -390,11 +404,17 @@ static int __init alim7101_wdt_init(void) goto err_out; } + rc = register_restart_handler(&wdt_restart_handler); + if (rc) { + pr_err("cannot register restart handler (err=%d)\n", rc); + goto err_out_reboot; + } + rc = misc_register(&wdt_miscdev); if (rc) { pr_err("cannot register miscdev on minor=%d (err=%d)\n", wdt_miscdev.minor, rc); - goto err_out_reboot; + goto err_out_restart; } if (nowayout) @@ -404,6 +424,8 @@ static int __init alim7101_wdt_init(void) timeout, nowayout); return 0; +err_out_restart: + unregister_restart_handler(&wdt_restart_handler); err_out_reboot: unregister_reboot_notifier(&wdt_notifier); err_out: From d20a1d90acf61f69a6474fce7e9656d36bd8ba80 Mon Sep 17 00:00:00 2001 From: Guenter Roeck Date: Fri, 26 Sep 2014 00:03:17 +0000 Subject: [PATCH 7/8] watchdog: sunxi: register restart handler with kernel restart handler The kernel core now provides an API to trigger a system restart. Register with it instead of setting arm_pm_restart. Signed-off-by: Guenter Roeck Acked-by: Heiko Stuebner Cc: Arnd Bergmann Cc: Catalin Marinas Cc: David Woodhouse Cc: Dmitry Eremin-Solenikov Cc: Ingo Molnar Cc: Jonas Jensen Cc: Maxime Ripard Cc: Randy Dunlap Cc: Russell King Cc: Steven Rostedt Cc: Tomasz Figa Cc: Will Deacon Cc: Wim Van Sebroeck Signed-off-by: Andrew Morton --- drivers/watchdog/sunxi_wdt.c | 31 ++++++++++++++++++++----------- 1 file changed, 20 insertions(+), 11 deletions(-) diff --git a/drivers/watchdog/sunxi_wdt.c b/drivers/watchdog/sunxi_wdt.c index 60deb9d304c0..480bb557f353 100644 --- a/drivers/watchdog/sunxi_wdt.c +++ b/drivers/watchdog/sunxi_wdt.c @@ -21,14 +21,13 @@ #include #include #include +#include #include #include #include #include #include -#include - #define WDT_MAX_TIMEOUT 16 #define WDT_MIN_TIMEOUT 1 #define WDT_MODE_TIMEOUT(n) ((n) << 3) @@ -50,6 +49,7 @@ static unsigned int timeout = WDT_MAX_TIMEOUT; struct sunxi_wdt_dev { struct watchdog_device wdt_dev; void __iomem *wdt_base; + struct notifier_block restart_handler; }; /* @@ -74,24 +74,29 @@ static const int wdt_timeout_map[] = { [16] = 0xB, /* 16s */ }; -static void __iomem *reboot_wdt_base; -static void sun4i_wdt_restart(enum reboot_mode mode, const char *cmd) +static int sunxi_restart_handle(struct notifier_block *this, unsigned long mode, + void *cmd) { + struct sunxi_wdt_dev *sunxi_wdt = container_of(this, + struct sunxi_wdt_dev, + restart_handler); + void __iomem *wdt_base = sunxi_wdt->wdt_base; + /* Enable timer and set reset bit in the watchdog */ - writel(WDT_MODE_EN | WDT_MODE_RST_EN, reboot_wdt_base + WDT_MODE); + writel(WDT_MODE_EN | WDT_MODE_RST_EN, wdt_base + WDT_MODE); /* * Restart the watchdog. The default (and lowest) interval * value for the watchdog is 0.5s. */ - writel(WDT_CTRL_RELOAD, reboot_wdt_base + WDT_CTRL); + writel(WDT_CTRL_RELOAD, wdt_base + WDT_CTRL); while (1) { mdelay(5); - writel(WDT_MODE_EN | WDT_MODE_RST_EN, - reboot_wdt_base + WDT_MODE); + writel(WDT_MODE_EN | WDT_MODE_RST_EN, wdt_base + WDT_MODE); } + return NOTIFY_DONE; } static int sunxi_wdt_ping(struct watchdog_device *wdt_dev) @@ -205,8 +210,12 @@ static int sunxi_wdt_probe(struct platform_device *pdev) if (unlikely(err)) return err; - reboot_wdt_base = sunxi_wdt->wdt_base; - arm_pm_restart = sun4i_wdt_restart; + sunxi_wdt->restart_handler.notifier_call = sunxi_restart_handle; + sunxi_wdt->restart_handler.priority = 128; + err = register_restart_handler(&sunxi_wdt->restart_handler); + if (err) + dev_err(&pdev->dev, + "cannot register restart handler (err=%d)\n", err); dev_info(&pdev->dev, "Watchdog enabled (timeout=%d sec, nowayout=%d)", sunxi_wdt->wdt_dev.timeout, nowayout); @@ -218,7 +227,7 @@ static int sunxi_wdt_remove(struct platform_device *pdev) { struct sunxi_wdt_dev *sunxi_wdt = platform_get_drvdata(pdev); - arm_pm_restart = NULL; + unregister_restart_handler(&sunxi_wdt->restart_handler); watchdog_unregister_device(&sunxi_wdt->wdt_dev); watchdog_set_drvdata(&sunxi_wdt->wdt_dev, NULL); From 6cd6d94d96d9b1cd8a62da91aac44cf56e301e75 Mon Sep 17 00:00:00 2001 From: Guenter Roeck Date: Fri, 26 Sep 2014 00:03:17 +0000 Subject: [PATCH 8/8] arm/arm64: unexport restart handlers Implementing a restart handler in a module don't make sense as there would be no guarantee that the module is loaded when a restart is needed. Unexport arm_pm_restart to ensure that no one gets the idea to do it anyway. Signed-off-by: Guenter Roeck Acked-by: Catalin Marinas Acked-by: Heiko Stuebner Cc: Arnd Bergmann Cc: David Woodhouse Cc: Dmitry Eremin-Solenikov Cc: Ingo Molnar Cc: Jonas Jensen Cc: Maxime Ripard Cc: Randy Dunlap Cc: Russell King Cc: Steven Rostedt Cc: Tomasz Figa Cc: Will Deacon Cc: Wim Van Sebroeck Signed-off-by: Andrew Morton --- arch/arm/kernel/process.c | 1 - arch/arm64/kernel/process.c | 1 - 2 files changed, 2 deletions(-) diff --git a/arch/arm/kernel/process.c b/arch/arm/kernel/process.c index ea279f7a8767..250b6f652afc 100644 --- a/arch/arm/kernel/process.c +++ b/arch/arm/kernel/process.c @@ -121,7 +121,6 @@ void (*pm_power_off)(void); EXPORT_SYMBOL(pm_power_off); void (*arm_pm_restart)(enum reboot_mode reboot_mode, const char *cmd); -EXPORT_SYMBOL_GPL(arm_pm_restart); /* * This is our default idle handler. diff --git a/arch/arm64/kernel/process.c b/arch/arm64/kernel/process.c index 0d3fb9fd0dca..398ab05081b4 100644 --- a/arch/arm64/kernel/process.c +++ b/arch/arm64/kernel/process.c @@ -98,7 +98,6 @@ void (*pm_power_off)(void); EXPORT_SYMBOL_GPL(pm_power_off); void (*arm_pm_restart)(enum reboot_mode reboot_mode, const char *cmd); -EXPORT_SYMBOL_GPL(arm_pm_restart); /* * This is our default idle handler.