linux kernel panic之后重启
panic_timeout
//linux-xxx/kernel/panic.c
core_param(panic, panic_timeout, int, 0644);

void panic(const char *fmt, ...)
{
...
        if (panic_timeout > 0) {
                /*
                 * Delay timeout seconds before rebooting the machine.
                 * We can't use the "normal" timers since we just panicked.
		 */
                printk(KERN_EMERG "Rebooting in %d seconds..", panic_timeout);
                for (i = 0; i < panic_timeout * 1000; i += PANIC_TIMER_STEP) {
                        touch_nmi_watchdog();
                        if (i >= i_next) {
                                i += panic_blink(state ^= 1);
                                i_next = i + 3600 / PANIC_BLINK_SPD;
                        }
                        mdelay(PANIC_TIMER_STEP);
                }
        }
        if (panic_timeout != 0) {
                /*
                 * This will not be a clean reboot, with everything
                 * shutting down.  But if there is a chance of
                 * rebooting the system it will be rebooted.
                 */
                emergency_restart();
        }
...
}

只要设置模块参数panic大于0就能调用emergency_restart重启了

core_param(panic, panic_timeout, int, 0644);

通过core_param定义的参数在/sys/module/kernel/parameters目录下

通过module_param定义的参数在/sys/module/xxx/parameters目录下
emergency_restart
emergency_restart
	machine_emergency_restart  //include/asm-generic/emergency_restart.h
		machine_restart  //arch/rlx/kernel/reset.c
			_machine_restart <==> bsp_machine_restart  //bsp/setup.c
				reboot_by_wdt  //drivers/watchdog/rtsx_wdt.c

最终调用了watchdog中的函数来复位整个系统。
reboot命令
reboot来自busybox，看看reboot的一步步调用流程是怎样的

reboot时打印消息:
The system is going down NOW !!  
Sending SIGTERM to all processes.  
Sending SIGKILL to all processes.  
Please stand by while rebooting the system.  
Restarting system.  

用户空间调用流程
在busybox代码init/init.c中有这么一段，
int init_main(int argc UNUSED_PARAM, char **argv)
{
...
                bb_signals(0
                        + (1 << SIGUSR1) /* halt */
                        + (1 << SIGTERM) /* reboot */
                        + (1 << SIGUSR2) /* poweroff */
                        , halt_reboot_pwoff);
                signal(SIGQUIT, restart_handler); /* re-exec another init */
...

单独拿出halt_reboot_pwoff和restart_handler
static void halt_reboot_pwoff(int sig)
{
        const char *m;
        unsigned rb;

        /* We may call run() and it unmasks signals,
         * including the one masked inside this signal handler.
         * Testcase which would start multiple reboot scripts:
         *  while true; do reboot; done
         * Preventing it:
         */
        reset_sighandlers_and_unblock_sigs();
        run_shutdown_and_kill_processes();

        m = "halt";
        rb = RB_HALT_SYSTEM;
        if (sig == SIGTERM) {
                m = "reboot";
                rb = RB_AUTOBOOT;
        } else if (sig == SIGUSR2) {
                m = "poweroff";
                rb = RB_POWER_OFF;
        }
        message(L_CONSOLE, "Requesting system %s", m);
        pause_and_low_level_reboot(rb);
        /* not reached */
}

/* Handler for QUIT - exec "restart" action,
 * else (no such action defined) do nothing */
static void restart_handler(int sig UNUSED_PARAM)
{
        struct init_action *a;

        for (a = init_action_list; a; a = a->next) {
                if (!(a->action_type & RESTART))
                        continue;

                /* Starting from here, we won't return.
                 * Thus don't need to worry about preserving errno
                 * and such.
                 */

                reset_sighandlers_and_unblock_sigs();
                run_shutdown_and_kill_processes();

#ifdef RB_ENABLE_CAD
                /* Allow Ctrl-Alt-Del to reboot the system.
                 * This is how kernel sets it up for init, we follow suit.
                 */
                reboot(RB_ENABLE_CAD); /* misnomer */
#endif

                if (open_stdio_to_tty(a->terminal)) {
                        dbg_message(L_CONSOLE, "Trying to re-exec %s", a->command);
                        /* Theoretically should be safe.
                         * But in practice, kernel bugs may leave
                         * unkillable processes, and wait() may block forever.
                         * Oh well. Hoping "new" init won't be too surprised
                         * by having children it didn't create.
                         */
                reset_sighandlers_and_unblock_sigs();
                run_shutdown_and_kill_processes();

#ifdef RB_ENABLE_CAD
                /* Allow Ctrl-Alt-Del to reboot the system.
                 * This is how kernel sets it up for init, we follow suit.
                 */
                reboot(RB_ENABLE_CAD); /* misnomer */
#endif

                if (open_stdio_to_tty(a->terminal)) {
                        dbg_message(L_CONSOLE, "Trying to re-exec %s", a->command);
                        /* Theoretically should be safe.
                         * But in practice, kernel bugs may leave
                         * unkillable processes, and wait() may block forever.
                         * Oh well. Hoping "new" init won't be too surprised
                         * by having children it didn't create.
                         */
                        //while (wait(NULL) > 0)
                        //      continue;
                        init_exec(a->command);
                }
                /* Open or exec failed */
                pause_and_low_level_reboot(RB_HALT_SYSTEM);
                /* not reached */
        }
}

我们看到他们都会有调用这两个函数：reset_sighandlers_and_unblock_sigs();以及 run_shutdown_and_kill_processes();，我们重点关注如下这个函数：
static void run_shutdown_and_kill_processes(void)
{
        /* Run everything to be run at "shutdown".  This is done _prior_
         * to killing everything, in case people wish to use scripts to
         * shut things down gracefully... */
        run_actions(SHUTDOWN);

        message(L_CONSOLE | L_LOG, "The system is going down NOW!");

        /* Send signals to every process _except_ pid 1 */
        kill(-1, SIGTERM);
        message(L_CONSOLE | L_LOG, "Sent SIG%s to all processes", "TERM");
        sync();
        sleep(1);

        kill(-1, SIGKILL);
        message(L_CONSOLE, "Sent SIG%s to all processes", "KILL");
        sync();
        /*sleep(1); - callers take care about making a pause */
}

终于看到了上面的打印信息：The system is going down NOW !! 以及Sending SIGTERM to all processes.

同时在上面的halt_reboot_pwoff和restart_handler中都会调用这样一个函数:
static void pause_and_low_level_reboot(unsigned magic)
{
        pid_t pid;

        /* Allow time for last message to reach serial console, etc */
        sleep(1);

        /* We have to fork here, since the kernel calls do_exit(EXIT_SUCCESS)
         * in linux/kernel/sys.c, which can cause the machine to panic when
         * the init process exits... */
        pid = vfork();
        if (pid == 0) { /* child */
                reboot(magic);
                _exit(EXIT_SUCCESS);
        }
        while (1)
                sleep(1);
}

这里最终调用了内核提供的reboot系统调用。
linux内核空间调用流程
//reboot系统调用
SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
                void __user *, arg)
{
        switch (cmd) {
        case LINUX_REBOOT_CMD_RESTART:
                kernel_restart(NULL);
...
}

kernel_restart
    kernel_restart_prepare
        blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
    syscore_shutdown
        ops->shutdown()
	machine_restart  //arch/rlx/kernel/reset.c
		_machine_restart <==> bsp_machine_restart  //bsp/setup.c
			reboot_by_wdt  //drivers/watchdog/rtsx_wdt.c

可以实现在驱动中通过register_reboot_notifier向reboot_notifier_list注册回调函数，这样在系统reboot的时候回调函数就会被调用到了

也可以在驱动中实现syscore_ops函数，这样在系统reboot的时候也会被调用到

当调用到machine_restart就和上面发生panic时调用的流程一样了，最终通过watchdog提供的函数接口复位整个系统。
参考文章
基于Linux与Busybox的Reboot命令流程分析 

说白了其实很简单，看代码:
 
[zcm@c #17]$cat r.c
#include <sys/reboot.h>

int main( void )
{
        puts("reboot now");
        reboot(RB_AUTOBOOT);

        return 0;
}
[zcm@c #18]$make
gcc -g -o r r.c 
[zcm@c #19]$


执行下"./r"，系统将会重启！

shutdown 命令
shutdown [选项] 时间

-c 取消前一个关机命令
-h 关机
-r 重启

shutdown -h now 马上关机

halt 关机

poweroff 关机

init 0 关机

reboot 重启

init 6 重启
系统运行级别

0   关机
1   单用户
2   不完全多用户，不含NFS服务
3   完全多用户
4   未分配
5   图形界面
6   重启

runlevel 查询系统运行级别：
N 3

进入当前级别前的级别    当前级别
/etc/inittab 修改系统默认运行级别
id:3:initdefault:    		3 为默认级别
logout  退出登录

关机重启命令
shutdown [选项] 时间
-c 取消前一个关机命令
-h 关机 
-r 重启
其他关机命令
halt
poweroff
init 0
其他 重启命令
reboot
init 6
系统运行级别
0 关机
1 单用户
2 不完全多用户，不含NFC服务
3 完全多用户
4 未分配
5 图形界面
6 重启

修改系统默认运行级别 
cat /etc/inittab
id:3:initdefault
查询系统运行级别
runlevel

退出登录 logout