一：Busyobx层的分析
这段时间,在忙到一个项目时,需要在busybox中用到reboot命令,开始在busybox中的shell中输入reboot命令,始终如下的信息,然后就停止在那里了,无法重启...为了彻底的弄明白这个问题,我在网络上找了很久,终于有个人写的一个reboot流程分析,我就借花献佛.在这里重新分析下busybox是如何运行这个命令,同时又是如何调用到Linux内核中的mach_reset中的arch_reset，当针对不同的ARM芯片时，作为Linux内核开发和驱动开发的朋友，对于这个流程还是一定要了解的。要不，出现问题，又如何找出问题呢。忘记了reboot的打印信息了，如下：
[plain] view plain copy
print?
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.
.
通过分析busybox1.20.0的代码可以看出在init.c中有这样一行的代码，如下：
[cpp] view plain copy
print?
int init_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int init_main(int argc UNUSED_PARAM, char **argv)
{
staTIc const int magic[] = {
RB_HALT_SYSTEM,
RB_POWER_OFF,
RB_AUTOBOOT
};
staTIc const smallint signals[] = { SIGUSR1, SIGUSR2, SIGTERM };
......
/* struct sysinfo is linux-specific */
#ifdef __linux__
/* Make sure there is enough memory to do something useful. */
if (ENABLE_SWAPONOFF) { //是否配置了swapoff命令
struct sysinfo info;
if (sysinfo(&info) == 0
&& (info.mem_unit ? info.mem_unit : 1) * (long long)info.totalram
) {
message(L_CONSOLE, "Low memory, forcing swapon");
/* swapon -a requires /proc typically */
new_init_acTIon(SYSINIT, "mount -t proc proc /proc", "");
/* Try to turn on swap */
new_init_action(SYSINIT, "swapon -a", "");
run_actions(SYSINIT); /* wait and removing */
}
}
#endif
......
/* Make the command line just say "init" - thats all, nothing else */
strncpy(argv[0], "init", strlen(argv[0]));
/* Wipe argv[1]-argv[N] so they don't clutter the ps listing */
while (*++argv)
memset(*argv, 0, strlen(*argv));
/* Set up signal handlers */
/* Set up signal handlers */
if (!DEBUG_INIT) {
struct sigaction sa;
bb_signals(0
+ (1 <
+ (1 <
+ (1 <
, halt_reboot_pwoff);//看到这个halt_reboot_pwoff
signal(SIGQUIT, restart_handler); /* re-exec another init */ //看到这个restart_handler函数，这是我们需要分析的
/* Stop handler must allow only SIGCONT inside itself */
memset(&sa, 0, sizeof(sa));
sigfillset(&sa.sa_mask);
sigdelset(&sa.sa_mask, SIGCONT);
sa.sa_handler = stop_handler;
/* NB: sa_flags doesn't have SA_RESTART.
* It must be able to interrupt wait().
*/
sigaction_set(SIGTSTP, &sa); /* pause */
/* Does not work as intended, at least in 2.6.20.
* SIGSTOP is simply ignored by init:
*/
sigaction_set(SIGSTOP, &sa); /* pause */
/* SIGINT (Ctrl-Alt-Del) must interrupt wait(),
* setting handler without SA_RESTART flag.
*/
bb_signals_recursive_norestart((1 <
}
......
}
单独拿出halt_reboot_pwoff和restart_handler这个函数来看看
[cpp] view plain copy
print?
/* The SIGUSR[12]/SIGTERM handler */
static void halt_reboot_pwoff(int sig) NORETURN;
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 */
}
restart_handler函数如下：
[cpp] view plain copy
print?
/* 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.
*/
//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();，我们重点关注如下这个函数：
[cpp] view plain copy
print?
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中都会调用这样一个函数，如下：
[cpp] view plain copy
print?
static void pause_and_low_level_reboot(unsigned magic) NORETURN;
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(magic)函数，对于vfork函数，请参考fork函数。这里不多说了.... 我们现在来看看reboot.h文件，如下：
[cpp] view plain copy
print?
/*
* Definitions related to the reboot() system call,
* shared between init.c and halt.c.
*/
#include
#ifndef RB_HALT_SYSTEM
# if defined(__linux__)
# define RB_HALT_SYSTEM 0xcdef0123
# define RB_ENABLE_CAD 0x89abcdef
# define RB_DISABLE_CAD 0
# define RB_POWER_OFF 0x4321fedc
# define RB_AUTOBOOT 0x01234567
# elif defined(RB_HALT)
# define RB_HALT_SYSTEM RB_HALT
# endif
#endif
/* Stop system and switch power off if possible. */
#ifndef RB_POWER_OFF
# if defined(RB_POWERDOWN)
# define RB_POWER_OFF RB_POWERDOWN
# elif defined(__linux__)
# define RB_POWER_OFF 0x4321fedc
# else
# warning "poweroff unsupported, using halt as fallback"
# define RB_POWER_OFF RB_HALT_SYSTEM
# endif
#endif
而在linux的内核中的定义如下：
busybox和linux内核中的REBOOT的定义值是一样的。看到了没有了。这个很重要的哦，否则busybox是无法调用linux内核的reboot函数。
二：Linux内核层的分析
Linux内核是如何衔接busybox的reboot函数的呢，如下代码：
[cpp] view plain copy
print?
/*
* Reboot system call: for obvious reasons only root may call it,
* and even root needs to set up some magic numbers in the registers
* so that some mistake won't make this reboot the whole machine.
* You can also set the meaning of the ctrl-alt-del-key here.
*
* reboot doesn't sync: do that yourself before calling this.
*/
SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
void __user *, arg)
{
char buffer[256];
int ret = 0;
/* We only trust the superuser with rebooting the system. */
if (!capable(CAP_SYS_BOOT))
return -EPERM;
/* For safety, we require "magic" arguments. */
if (magic1 != LINUX_REBOOT_MAGIC1 ||
(magic2 != LINUX_REBOOT_MAGIC2 &&
magic2 != LINUX_REBOOT_MAGIC2A &&
magic2 != LINUX_REBOOT_MAGIC2B &&
magic2 != LINUX_REBOOT_MAGIC2C))
return -EINVAL;
/* Instead of trying to make the power_off code look like
* halt when pm_power_off is not set do it the easy way.
*/
if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
cmd = LINUX_REBOOT_CMD_HALT;
lock_kernel();
switch (cmd) {
case LINUX_REBOOT_CMD_RESTART:
kernel_restart(NULL); //这个就是重新启动Linx的命令
break;
case LINUX_REBOOT_CMD_CAD_ON:
C_A_D = 1;
break;
case LINUX_REBOOT_CMD_CAD_OFF:
C_A_D = 0;
break;
case LINUX_REBOOT_CMD_HALT:
kernel_halt();
unlock_kernel();
do_exit(0);
panic("cannot halt");
case LINUX_REBOOT_CMD_POWER_OFF:
kernel_power_off();
unlock_kernel();
do_exit(0);
break;
case LINUX_REBOOT_CMD_RESTART2:
if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1)
unlock_kernel();
return -EFAULT;
}
buffer[sizeof(buffer) - 1] = '\0';
kernel_restart(buffer);
break;
#ifdef CONFIG_KEXEC
case LINUX_REBOOT_CMD_KEXEC:
ret = kernel_kexec();
break;
#endif
#ifdef CONFIG_HIBERNATION
case LINUX_REBOOT_CMD_SW_SUSPEND:
ret = hibernate();
break;
#endif
default:
ret = -EINVAL;
break;
}
unlock_kernel();
return ret;
}
继续跟踪kernel_restart()函数，如下：
最终会调用一个machine_restart(cmd)函数，这个是跟具体的芯片有很大的关系的，我们进一步的分析如下：
看到了吗，最终是调用arch_reset来复位整个系统的。同时我们也看到了S3C2440的reset的函数如下：
在arm_pm_restart = s3c24xx_pm_restart()函数，最终也是调用arm_machine_restart(mod, cmd)来实现的。而在arm_machine_restart()函数中，最终也是调用arch_reset()函数来实现，而这个函数是在哪里呢。在S3C2440没有看到arch_reset函数的实现，因此从S3C2410中找到了如下的代码，请继续看下面的代码：
终于看到了arch_reset函数，最终是采用S3C2410或者S3C2440的WatchDog来实现reboot的命令的。大家可以想想，busybox的poweroff命令，是如何实现通过Linux系统关闭整个系统的电源呢，其实很简单，只需要实现下面的函数中的pm_power_off的回调函数即可。
我们可以通过一个GPIO来控制整个系统的电源，而通过上面的pm_power_off的回调函数来实现，只需要在pm_power_off函数对GPIO进行操作就可以了。你看不是很简单吗?
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
