电源管理入门-1关机重启详解
原创 thatway OS与AUTOSAR研究 2023-09-19 07:25 发表于北京
1.1 用户层****利用reboot、poweroff等命令进行关机，在应用层会执行：
- 发送SIGTERM给所有进程，让进程正常退出
- 发送SIGKILL给所有进程，将其杀掉，并等待一段时间
- 调用reboot系统调用让系统关机/重启
1.2 Linux 内核层**reboot系统调用会进入内核，具体流程为：**
- reboot系统调用根据参数找到kernel_power_off/reset
- 向关心reboot事件的进程发送消息--blocking_notifier_call_chain
- 内核Kobject状态发生改变不通知用户空间--usermodehelper_disable
- 关闭所有的设备--device_shutdown
- 禁止CPU热插拔，设置当前CPU为第一个在线CPU，把新任务转移到当前CPU上--migrate_to_reboot_cpu
- 关闭syscore设备--syscore_shutdown
- 提示用户空间系统将要关闭--pr_emerg
- 禁止cpu硬件中断--local_irq_disable
- 其他cpu处于非工作状态--smp_send_stop
- 调用psci接口，执行smc指令，关闭arm cpu--pmm_power_off/rese->psci_sys_poweroff/reset->invoke_psci_fn->arm_smccc_smc->SMCCC SMCCC_SMC
1.3 ATF 层**执行SMC指令后会触发异常，进入ATF的BL31中继续执行：**
- 进入异常向量处理的入口sync_exception_aarch64
- 跳转执行rt_svc_desc_t结构体保存的服务std_svc_smc_handler
- 执行psci相关处理。通用psci的处理函数psci_system_off和psci_system_reset，通过调用平台提供的system_off、 system_reset接口将psci消息转化为scmi消息发给SCP模块，实现最终的关机、重启。如果如果没有SCP固件的系统，会在ATF里面操作硬件寄存器进行关机重启处理。
1.4 SCP 层
ATF通过scim消息发送给MHU硬件并产生中断，SCP接受到中断后内部依次进行处理的模块为：mhu-->transport-->scmi-->scmi_system_power-->power_domain-->ppu/system_power-->i2c/cru，最后SCP固件通过控制PMIC/CRU的硬件寄存器实现对系统的关机重启设置。\
2. Busybox中的关机重启命令
执行关机重启的系统命令，例如shutdown/poweroff/halt/reboot/init命令进程及服务如果提前会被正确的中止，我们就说其是安全的退出。通常关机重启命令需要管理员权限执行，所在系统目录为/sbin/*，如下为shutdown命令：
命令格式
\[root\@localhost \~]# shutdown \[选项] 时间 \[警告信息] 选项:
-c：取消已经执行的 shutdown 命令；
-h：关机；
-r：重启；
init命令相关执行：
| \[root\@localhost\~]# init 0
#关机，也就是调用系统的 0 级别
\[root\@localhost \~】# init 6
#重启，也就是调用系统的 6 级别
现在Linux里面这些命令基本都使用busybox实现的，代码参考：\ https://busybox.net/downloads/busybox启动的时候，会注册reboot的处理信号init\init.c中**init_main**函数在初始化的时候调用
sigaddset(&G.delayed_sigset, SIGUSR1); /* halt */
sigaddset(&G.delayed_sigset, SIGTERM); /* reboot */
sigaddset(&G.delayed_sigset, SIGUSR2); /* poweroff */
/* Now run the looping stuff for the rest of forever */
while (1) {
/* (Re)run the respawn/askfirst stuff */
run_actions(RESPAWN | ASKFIRST);
/* Wait for any signal (typically it's SIGCHLD) */
check_delayed_sigs(NULL); /* NULL timespec makes it wait */
.....
}
check_delayed_sigs（）函数会收到reboot的信号运行busybox reboot的时候，reboot —> halt_main，可知会执行 halt_main()函数，在init\halt.c中
static const smallint signals[] = { SIGUSR1, SIGUSR2, SIGTERM };
# define RB_HALT_SYSTEM 0xcdef0123
# define RB_ENABLE_CAD 0x89abcdef
# define RB_DISABLE_CAD 0
# define RB_POWER_OFF 0x4321fedc
# define RB_AUTOBOOT 0x01234567
flags = getopt32(argv, "d:+nfwi", &delay);
if (!(flags & 4)) { /* no -f */
rc = kill(pidlist[0], signals[which]);
}
else{
rc = reboot(magic[which]);
}
这里可以看出来，分为两个流程：
- 当reboot命令没有加**-f**的时候，直接使用kill发送信号到busybox执行halt_reboot_pwoff函数
- 直接使用-f的话，直接使用reboot系统调用接口，通知内核，让内核执行重启操作，简单粗暴
如果1中发送kill命令的SIGTERM 信号后，在busybox的轮询处理函数中会接收信号进行处理，如下：
static void check_delayed_sigs(struct timespec *ts)
{
int sig = sigtimedwait(&G.delayed_sigset, /* siginfo_t */ NULL, ts);
if (sig <= 0)
return;
/* The signal "sig" was caught */
#if ENABLE_FEATURE_USE_INITTAB
if (sig == SIGHUP)
reload_inittab();
#endif
if (sig == SIGINT)
run_actions(CTRLALTDEL);
if (sig == SIGQUIT) {
exec_restart_action();
/* returns only if no restart action defined */
}
if ((1 << sig) & (0
#ifdef SIGPWR
| (1 << SIGPWR)
#endif
| (1 << SIGUSR1)
| (1 << SIGUSR2)
| (1 << SIGTERM)
)) {
halt_reboot_pwoff(sig);
}
/* if (sig == SIGCHLD) do nothing */
}
在busybox内部解析后会执行halt_reboot_pwoff（）函数
#define RB_AUTOBOOT 0x01234567
#define RB_POWER_OFF 0x4321fedc
static void halt_reboot_pwoff(int sig)
{
const char *m;
unsigned rb;
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);
}
halt_reboot_pwoff（）分为三步：
- 发送SIGTERM给所有进程，让进程正常退出
- 发送SIGKILL给所有进程，将其杀掉
- 让系统重启
发送SIGTERM和SIGKILL信号给其他进程
static void run_shutdown_and_kill_processes(void)
{
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, "Sent SIG%s to all processes", "TERM");
sync();
sleep1();
kill(-1, SIGKILL);
message(L_CONSOLE, "Sent SIG%s to all processes", "KILL");
sync();
/*sleep1(); - callers take care about making a pause */
}
调用子进程进行reboot系统调用：
static void pause_and_low_level_reboot(unsigned magic)
{
pid_t pid;
sleep1();
pid = vfork();
if (pid == 0) { /* child */
reboot(magic);
_exit(EXIT_SUCCESS);
}
waitpid(pid, NULL, 0);
sleep1(); /* paranoia */
_exit(EXIT_SUCCESS);
}
reboot(magic);进行了系统调用。\
3. Linux内核中的处理\
内核中代码执行流程图：\
关机主要过程总结：
- reboot系统调用根据参数找到kernel_power_off/reset
- 向关心reboot事件的进程发送消息--blocking_notifier_call_chain
- 内核Kobject状态发生改变不通知用户空间--usermodehelper_disable
- 关闭所有的设备--device_shutdown
- 禁止CPU热插拔，设置当前CPU为第一个在线CPU，把新任务转移到当前CPU上--migrate_to_reboot_cpu
- 关闭syscore设备--syscore_shutdown
- 提示用户空间系统将要关闭--pr_emerg
- 禁止cpu硬件中断--local_irq_disable
- 其他cpu处于非工作状态--smp_send_stop
- 调用psci接口，执行smc指令，关闭arm cpu--pmm_power_off/rese->psci_sys_poweroff/reset->invoke_psci_fn->arm_smccc_smc->SMCCC SMCCC_SMC
3.1 系统调用实现****在kernel/reboot.c中声明了rboot系统调用的实现：
SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,void __user *, arg)
{
......
switch (cmd) {
case LINUX_REBOOT_CMD_POWER_OFF:
kernel_power_off();
do_exit(0);
break;
其中cmd就是系统调用传进来的magic值，其他的值定义为：
#define LINUX_REBOOT_CMD_RESTART 0x01234567
#define LINUX_REBOOT_CMD_HALT 0xCDEF0123
#define LINUX_REBOOT_CMD_CAD_ON 0x89ABCDEF
#define LINUX_REBOOT_CMD_CAD_OFF 0x00000000
#define LINUX_REBOOT_CMD_POWER_OFF 0x4321FEDC
#define LINUX_REBOOT_CMD_RESTART2 0xA1B2C3D4
#define LINUX_REBOOT_CMD_SW_SUSPEND 0xD000FCE2
#define LINUX_REBOOT_CMD_KEXEC 0x45584543
reboot系统调用实现过程：
- 判断调用者的用户权限，如果不是超级用户（superuser），则直接返回错误（这也是我们再用户空间执行reboot、halt、poweroff等命令时，必须是root用户的原因）；
- 判断传入的magic number是否匹配，如果不匹配，直接返回错误。这样就可以尽可能的防止误动作发生；
- 调用reboot_pid_ns接口，检查是否需要由该接口处理reboot请求。这是一个有关pid namespaces的新特性，也是Linux内核重要的知识点；
- 如果是POWER_OFF命令，且没有注册power off的machine处理函数（pmm_power_off），把该命令转换为HALT命令；
- 根据具体的cmd命令，执行具体的处理，包括， 如果是RESTART或者RESTART2命令，调用kernel_restart。 如果是CAD_ON或CAD_OFF命令，更新C_A_D的值，表示是否允许通过Ctrl+Alt+Del组合键重启系统。 如果是HALT命令，调用kernel_halt。 如果是POWER_OFF命令，调用kernel_power_off。 如果是KEXEC命令，调用kernel_kexec接口。 如果是SW_SUSPEND，调用hibernate接口；
- 返回上述的处理结果，系统调用结束。
3.2 内核关机函数分析
****这里我们以关机poweroff命令为例，进行代码分析，重启流程相似。
void kernel_power_off(void)
{
kernel_shutdown_prepare(SYSTEM_POWER_OFF);
if (pmm_power_off_prepare)
pmm_power_off_prepare();//PM相关的power off prepare函数
migrate_to_reboot_cpu();//将当前的进程（task）移到一个CPU上
syscore_shutdown(); //syscore的关闭流程,将系统核心器件关闭（例如中断等）
pr_emerg("Power down\n");
kmsg_dump(KMSG_DUMP_POWEROFF);//向这个世界发出最后的声音（打印日志）
machine_power_off();//soc基本的关闭
}
1）调用kernel_xxx_prepare函数，进行restart/halt/power_off前的准备工作，包括， 调用blocking_notifier_call_chain接口，向关心reboot事件的进程，发送SYS_RESTART、 SYS_HALT或者SYS_POWER_OFF事件。对RESTART来说，还好将cmd参数一并发送出去。 将系统状态设置为相应的状态（SYS_RESTART、SYS_HALT或SYS_POWER_OFF）。 调用usermodehelper_disable接口，禁止User mode helper。 调用device_shutdown，关闭所有的设备（具体内容会在下一节讲述）；
2）如果是power_off，且存在PM相关的power off prepare函数（pm_power_off_prepare），则调用该回调函数；
3）调用migrate_to_reboot_cpu接口，将当前的进程（task）移到一个CPU上； 注2：对于多CPU的机器，无论哪个CPU触发了当前的系统调用，代码都可以运行在任意的CPU上。这个接口将代码分派到一个特定的CPU上，并禁止调度器分派代码到其它CPU上。也就是说，这个接口被执行后，只有一个CPU在运行，用于完成后续的reboot动作。
4）调用syscore_shutdown接口，将系统核心器件关闭（例如中断等）；
5）调用printk以及kmsg_dump，向这个世界发出最后的声音（打印日志）；
6）最后，由machine-core的代码，接管后续的处理。
3.3 关闭所有设备处理
****kernel_shutdown_prepare-->device_shutdown会关闭所有设备。设备关闭的过程是遍历全局变量devices_kset里面的所有设备，并从链表中删除，执行相关的shuntdown回调函数。函数处理过程如下：
void device_shutdown(void)
{
struct device *dev, *parent;
wait_for_device_probe();
device_block_probing();
spin_lock(&devices_kset->list_lock);
while (!list_empty(&devices_kset->list)) {
dev = list_entry(devices_kset->list.prev, struct device,
kobj.entry);
parent = get_device(dev->parent);
get_device(dev);
list_del_init(&dev->kobj.entry);
spin_unlock(&devices_kset->list_lock);
/* hold lock to avoid race with probe/release */
if (parent)
device_lock(parent);
device_lock(dev);
/* Don't allow any more runtime suspends */
pm_runtime_get_noresume(dev);
pm_runtime_barrier(dev);
if (dev->class && dev->class->shutdown_pre) {
if (initcall_debug)
dev_info(dev, "shutdown_pre\n");
dev->class->shutdown_pre(dev);
}
if (dev->bus && dev->bus->shutdown) {
if (initcall_debug)
dev_info(dev, "shutdown\n");
dev->bus->shutdown(dev);
} else if (dev->driver && dev->driver->shutdown) {
if (initcall_debug)
dev_info(dev, "shutdown\n");
dev->driver->shutdown(dev);
}
device_unlock(dev);
if (parent)
device_unlock(parent);
put_device(dev);
put_device(parent);
spin_lock(&devices_kset->list_lock);
}
spin_unlock(&devices_kset->list_lock);
}
| 1）遍历devices_kset的链表，取出所有的设备（struct device）；2）将该设备从链表中删除；3）调用pmm_runtime_get_noresume和pmm_runtime_barrier接口，停止所有的Runtime相关的电源管理动作；4）如果该设备的bus提供了shutdown函数，优先调用bus的shutdown，关闭设备；5）如果bus没有提供shutdown函数，检测设备driver是否提供，如果提供，调用设备driver的shutdown，关闭设备；6）直至处理完毕所有的设备。
系统中所有的设备都在“ /sys/devices/ ”目录下，这些设备是一个链表结构串起来的，devices_kset是链表头，里面都是struct device，然后找到对应的struct bus_type和struct device_driver等，然后按照优先级例如：class>bus>driver执行对应的shutdown回调函数。3.4 多 CPU 调度相关处理对于多CPU的机器，无论哪个CPU触发了当前的系统调用，代码都可以运行在任意的CPU上。这个接口将代码分派到一个特定的CPU上，并禁止调度器分派代码到其它CPU上。也就是说，这个接口被执行后，只有一个CPU在运行，用于完成后续的reboot动作。
void migrate_to_reboot_cpu(void)
{
/* The boot cpu is always logical cpu 0 */
int cpu = reboot_cpu;
cpu_hotplug_disable();
/* Make certain the cpu I'm about to reboot on is online */
if (!cpu_online(cpu))
cpu = cpumask_first(cpu_online_mask);
/* Prevent races with other tasks migrating this task */
current->flags |= PF_NO_SETAFFINITY;
/* Make certain I only run on the appropriate processor */
set_cpus_allowed_ptr(current, cpumask_of(cpu));
}
| 1）CPU 0是默认重启使用的CPU2）禁止CPU热插拔3）如果CPU 0不在线，则设置当前CPU为第一个在线的CPU4）允许current进程在重启使用的CPU上运行 |
3.5 内核核心关闭
**system core的shutdown和设备的shutdown类似，也是从一个链表中，遍历所有的system core，并调用它的shutdown接口。\
3.6 硬件平台的关闭*
void machine_power_off(void)
{
local_irq_disable();
smp_send_stop();
if (pmm_power_off)
pmm_power_off();
}
| 1）屏蔽当前CPU上的所有中断，通过操作arm核心中的寄存器来屏蔽到达CPU上的中断，此时中断控制器中所有送往该CPU上的中断信号都将被忽略。2）对于多CPU的机器来说，Restart之前必须保证其它的CPU处于非活动状态，由其中的一个主CPU负责Restart动作。调用smp_send_stop接口，确保其它CPU处于非活动状态；这里会等待1秒时间来停止其他CPU。3）调用PSCI相关接口实现相关关机操作 |
3.7 内核
PSCI 相关操作****PSCI（Power State Coordination Interface）电源状态协调接口，是ARM定义的电源管理接口规范。PSCI 初始化流程： 在kernel的setup_arch启动时，扫描设备树节点信息关于psci部分，根据compatible来匹配到psci_0_2_init()函数，然后进入psci_probe()函数，并在psci_0_2_set_functions()函数中设置相关的函数指针：start_kernel() -> setup_arch() -> psci_dt_init() -> psci_0_2_init() -> psci_probe() -> psci_0_2_set_functions()设备树里面的信息如下里标记的版本是psci-0.2，method是使用smc。
| psci { compatible = "arm,psci-0.2"; method = "smc"; }; |
psci_0_2_set_functions会给处理函数赋值
static void __init psci_0_2_set_functions(void)
{
pr_info("Using standard PSCI v0.2 function IDs\n");
psci_ops.get_version = psci_get_version;
psci_function_id[PSCI_FN_CPU_SUSPEND] =
PSCI_FN_NATIVE(0_2, CPU_SUSPEND);
psci_ops.cpu_suspend = psci_cpu_suspend;
psci_function_id[PSCI_FN_CPU_OFF] = PSCI_0_2_FN_CPU_OFF;
psci_ops.cpu_off = psci_cpu_off;
psci_function_id[PSCI_FN_CPU_ON] = PSCI_FN_NATIVE(0_2, CPU_ON);
psci_ops.cpu_on = psci_cpu_on;
.....
arm_pm_restart = psci_sys_reset;
pm_power_off = psci_sys_poweroff;
PSCI 关机流程：
#define PSCI_0_2_FN_BASE 0x84000000
#define PSCI_0_2_FN(n) (PSCI_0_2_FN_BASE + (n))
#define PSCI_0_2_FN_SYSTEM_OFF PSCI_0_2_FN(8)
static void psci_sys_poweroff(void)
{
invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0);
}
PSCI_0_2_FN_SYSTEM_OFF的值计算为：0x84000000+8，查看ARM PSCI手册：
invoke_psci_fn（）在smc模式下对应 __invoke_psci_fn_smc（）函数：
static unsigned long __invoke_psci_fn_smc(unsigned long function_id,
unsigned long arg0, unsigned long arg1,
unsigned long arg2)
{
struct arm_smccc_res res;
arm_smccc_smc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res);
return res.a0;
}
arm_smccc_smc（）函数的实现为汇编代码，在arch/arm/kernel/smccc-call.S中
.macro SMCCC_SMC
__SMC(0)
.endm
/* 定义SMCCC宏，其参数为instr */
.macro SMCCC instr
/* 将normal world中的寄存器入栈，保存现场 */
UNWIND( .fnstart)
mov r12, sp /* r12指向老的sp地址 */
push {r4-r7} /* 推r4-r7入栈，则sp = sp - 4 * 4 */
UNWIND( .save {r4-r7})
ldm r12, {r4-r7} /* 把r12指向的内容的刷入r4-r7，其实就是把参数a4-a7存入r4-r7
\instr /* 执行instr参数的内容，即执行smc切换 */
pop {r4-r7} /* 出栈操作，恢复现场 */
ldr r12, [sp, #(4 * 4)]
stm r12, {r0-r3}
bx lr
UNWIND( .fnend)
.endm
ENTRY(__arm_smccc_smc)
SMCCC SMCCC_SMC
ENDPROC(__arm_smccc_smc)
SMCCC宏如下，smc指令触发一个安全监视器异常后，将栈上的数据存到x0~x3上，回头看 __invoke_psci_fn_smc函数实际是返回x0的结果。由于smccc_smc函数的入参有9个参数，按照约定，前4个参数存在r0 - r3，其他参数从右向左入栈。r0=a0, r1=a1, r2=a2, r3=a3, r4=a4, r5=a5, r6=a6, r7=a7进入 ATF 中 EL3 模式执行： smc指令是arm-v8手册中定义的一个指令，这个安全监视器触发一个异常，然后进入到EL3。EL3:安全监控异常级别。异常级别，用于执行安全监视器代码，用于处理非安全状态和安全状态之间的转换。EL3始终处于Secure状态.\
**4. ATF Bl31中的处理\
**4.1 ATF 软件流程框图**
BL31中smc异常触发流程图执行****SMC 指令****后会触发异常，进入 ATF 的**BL31**中继续执行：
- 在Linux侧调用smc异常之后，会根据中断向量表触发cpu的同步异常sync_exception_aarch64/32
- 然后跳转执行到handle_sync_exception->smc_handler64/32中
- 根据_RT_SVC_DESCS_START_+RT_SVC_DESC_HANDLE的位置，跳转执行rt_svc_desc_t结构体保存的服务std_svc_smc_handler
- 执行psci相关处理，找到psci_system_off和psci_system_rese处理函数。ATF直接处理如果是关机就执行halt指令，重启则通过设置gpio，或者转送给SCP处理。
- 最后跳转到el3_exit返回Linux侧。
SMC 异常触发执行流程：
进入ATF的方式触发异常：同步异常SMC、异步异常(irq,fiq)
如果是同步异常，那么一定是在linux或tee中发生了smc调用，此时进入跳转ATF中异常向量表中的同步异常程序smc_handler64或smc_handler32\ 在该程序中，解析smc id，来选择跳转到具体哪一个rt-svc(runtime service)
如果是异步异常，那么一定是触发了irq或fiq或serror中断等，此时进入跳转ATF中异常向量表中的异步异常程序，进而跳转到响应的中断处理函数.
4.2 内存布局 bl31_entrypoint****编译使用的lds文件是arm-trusted-firmware/bl31/bl31.ld.S，开头就可以看到入口是bl31_entrypoint：
| ENTRY(bl31_entrypoint) |
|---|
bl31_entrypoint在bl31/aarch64/bl31_entrypoint.S中定义可以看到设置 _exception_vectors为runtime_exceptions函数的：
/* ---------------------------------------------------------------------
* For !RESET_TO_BL31 systems, only the primary CPU ever reaches
* bl31_entrypoint() during the cold boot flow, so the cold/warm boot
* and primary/secondary CPU logic should not be executed in this case.
*
* Also, assume that the previous bootloader has already initialised the
* SCTLR_EL3, including the endianness, and has initialised the memory.
* ---------------------------------------------------------------------
*/
el3_entrypoint_common \
_init_sctlr=0 \
_warm_boot_mailbox=0 \
_secondary_cold_boot=0 \
_init_memory=0 \
_init_c_runtime=1 \
_exception_vectors=runtime_exceptions \
_pie_fixup_size=BL31_LIMIT - BL31_BASE
在bl31/aarch64/runtime_exceptions.S中
.globl runtime_exceptions
vector_base runtime_exceptions //定义 .vectors
vector_entry sync_exception_aarch64
handle_sync_exception
check_vector_size sync_exception_aarch64
vector_entry sync_exception_aarch32
handle_sync_exception
check_vector_size sync_exception_aarch32
vector_base 是一个宏，在include/arch/aarch64/asm_macros.S中定义：
.macro vector_base label, section_name=.vectors//label为标号以冒号结尾
.section \section_name, "ax"//指定代码段必须存放在.vectors段里， “ax”表示该段可执行并且可‘a’读和可‘x’执行
.align 11, 0//地址方式对齐11 其余字节用0填充
\label:
.endm
同样其他宏经过转化如下：
.section .vectors, "ax" //指定代码段必须存放在.vectors段里， “ax”表示该段可执行并且可‘a’读和可‘x’执行
.align 11, 0 //地址方式对齐11 其余字节用0填充
runtime_exceptions:
.section .vectors, "ax"//指定代码段必须存放在.vectors段里， “ax”表示该段可执行并且可‘a’读和可‘x’执行
.align 7, 0 //地址方式对齐7
sync_exception_aarch64:
handle_sync_exception
.if (. - serror_aarch64) > (32 * 4) //这个.应该是当前位置 - 段的开头地址 如果大于 32条指令
.error "Vector exceeds 32 instructions" //向量超过32条指令
.endif
sync_exception_aarch32
handle_sync_exception
.if (. - serror_aarch64) > (32 * 4) //这个.应该是当前位置 - 段的开头地址 如果大于 32条指令
.error "Vector exceeds 32 instructions" //向量超过32条指令
.endif
4.3 runtime
服务程序初始化****bl31_entrypoint入口向下执行首先是bl31_setup，然后是bl31_main
void bl31_setup(u_register_t arg0, u_register_t arg1, u_register_t arg2,
u_register_t arg3)
{
/* Perform early platform-specific setup */
bl31_early_platform_setup2(arg0, arg1, arg2, arg3);
/* Perform late platform-specific setup */
bl31_plat_arch_setup();
bl31_main（）函数：
void bl31_main(void)
{
NOTICE("BL31: %s\n", version_string);
NOTICE("BL31: %s\n", build_message);
bl31_platform_setup(); //通用和安全时钟初始化，其他芯片相关功能初始化
bl31_lib_init(); //空函数
INFO("BL31: Initializing runtime services\n");
runtime_svc_init(); //重点 下面展开分析
if (bl32_init) {
INFO("BL31: Initializing BL32\n");
(*bl32_init)();
}
bl31_prepare_next_image_entry(); //加载下一阶段的入口地址
console_flush(); //控制台刷新
bl31_plat_runtime_setup(); //空函数
}
runtime_svc_init（）函数
//注册smc指令相关的服务
void runtime_svc_init(void)
{
int rc = 0;
unsigned int index, start_idx, end_idx;
/* Assert the number of descriptors detected are less than maximum indices */
//这句话表明 RT_SVC_DECS_NUM时当前加载的服务数量
assert((RT_SVC_DESCS_END >= RT_SVC_DESCS_START) &&
(RT_SVC_DECS_NUM < MAX_RT_SVCS));
if (RT_SVC_DECS_NUM == 0) //如果没有服务要注册
return;
memset(rt_svc_descs_indices, -1, sizeof(rt_svc_descs_indices));//初始化rt_svc_descs_indices
rt_svc_descs = (rt_svc_desc_t *)RT_SVC_DESCS_START;//建立一个注册表结构体
for (index = 0; index < RT_SVC_DECS_NUM; index++) {
rt_svc_desc_t *service = &rt_svc_descs[index];
rc = validate_rt_svc_desc(service);//判断每一个服务的各项参数是否正确
if (rc) {
ERROR("Invalid runtime service descriptor %p\n",
(void *) service);
panic(); //不正确
}
if (service->init) { //该服务是否需要初始化
rc = service->init(); //进行初始化
if (rc) { //初始化是否成功
ERROR("Error initializing runtime service %s\n",
service->name);
continue;
}
}
start_idx = get_unique_oen(rt_svc_descs[index].start_oen,
service->call_type); //八位的id号
assert(start_idx < MAX_RT_SVCS);
end_idx = get_unique_oen(rt_svc_descs[index].end_oen,
service->call_type); //八位的id号
assert(end_idx < MAX_RT_SVCS);
for (; start_idx <= end_idx; start_idx++)
rt_svc_descs_indices[start_idx] = index;//证明可以根据rt_svc_descs_indices[?]的值找到其对应的rt_svc_descs[index]中index值
}
}
RT_SVC_DECS_NUM表示svc数量
| #define RT_SVC_DECS_NUM ((RT_SVC_DESCS_END - RT_SVC_DESCS_START)\ / sizeof(rt_svc_desc_t)) |
RT_SVC_DESCS_START开始的位置已经存入了结构体数据数组，因为在ld文件中进行了内存布局说明在bl31/bl31.ld.S中：
RODATA_COMMON
/* Place pubsub sections for events */
. = ALIGN(8);
#include <lib/el3_runtime/pubsub_events.h>
. = ALIGN(PAGE_SIZE);
__RODATA_END__ = .;
} >RAM
#else
ro . : {
__RO_START__ = .;
*bl31_entrypoint.o(.text*)
*(SORT_BY_ALIGNMENT(.text*))
*(SORT_BY_ALIGNMENT(.rodata*))
RODATA_COMMON
在include/common/bl_common.ld.h中
#define RODATA_COMMON \
RT_SVC_DESCS \
FCONF_POPULATOR \
PMF_SVC_DESCS \
PARSER_LIB_DESCS \
CPU_OPS \
GOT \
BASE_XLAT_TABLE_RO \
EL3_LP_DESCS
#define RT_SVC_DESCS \
. = ALIGN(STRUCT_ALIGN); \
__RT_SVC_DESCS_START__ = .; \
KEEP(*(rt_svc_descs)) \
__RT_SVC_DESCS_END__ = .;
rt_svc_descs段存放的内容是通过DECLARE_RT_SVC宏来定义的：//其中
#define DECLARE_RT_SVC(_name, _start, _end, _type, _setup, _smch) \
static const rt_svc_desc_t __svc_desc_ ## _name \
__section("rt_svc_descs") __used = { \
.start_oen = (_start), \
.end_oen = (_end), \
.call_type = (_type), \
.name = #_name, \
.init = (_setup), \
.handle = (_smch) \
}
例如在services/std_svc/std_svc_setup.c中
/* Register Standard Service Calls as runtime service */
DECLARE_RT_SVC(
std_svc,
OEN_STD_START,
OEN_STD_END,
SMC_TYPE_FAST,
std_svc_setup,
std_svc_smc_handler
);
#define OEN_STD_START U(4) /* Standard Service Calls */
#define OEN_STD_END U(4)
#define SMC_TYPE_FAST UL(1)
#define SMC_TYPE_YIELD UL(0)
static const rt_svc_desc_t __svc_desc_std_svc服务。其服务id为SMC_TYPE_FAST << 6 + OEN_STD_START,结束服务的id为SMC_TYPE_FAST << 6 + OEN_STD_ENDservice->init()会执行std_svc_setup（）函数->psci_setup((const psci_lib_args_t *)svc_arg)(void) plat_setup_psci_ops((uintptr_t)lib_args->mailbox_ep,\&psci_plat_pm_ops);plat_setup_psci_ops（）的定义根据平台，我们使用的是qemu，对应plat/qemu/qemu_sbsa/sbsa_pm.c文件中：
*psci_ops = &plat_qemu_psci_pm_ops;
static const plat_psci_ops_t plat_qemu_psci_pm_ops = {
.cpu_standby = qemu_cpu_standby,
.pwr_domain_on = qemu_pwr_domain_on,
.pwr_domain_off = qemu_pwr_domain_off,
.pwr_domain_pwr_down_wfi = qemu_pwr_domain_pwr_down_wfi,
.pwr_domain_suspend = qemu_pwr_domain_suspend,
.pwr_domain_on_finish = qemu_pwr_domain_on_finish,
.pwr_domain_suspend_finish = qemu_pwr_domain_suspend_finish,
.system_off = qemu_system_off,
.system_reset = qemu_system_reset,
.validate_power_state = qemu_validate_power_state
};
4.4 SMC 异常处理入口分析
SMC命令执行后，CPU会根据异常向量表找到sync_exception_aarch64的入口会执行handle_sync_exception，在bl31/aarch64/runtime_exceptions.S中
* ---------------------------------------------------------------------
* This macro handles Synchronous exceptions.
* Only SMC exceptions are supported.
* ---------------------------------------------------------------------
*/
.macro handle_sync_exception
#if ENABLE_RUNTIME_INSTRUMENTATION
/*
* Read the timestamp value and store it in per-cpu data. The value
* will be extracted from per-cpu data by the C level SMC handler and
* saved to the PMF timestamp region.
*///存放时间戳
mrs x30, cntpct_el0
str x29, [sp, #CTX_GPREGS_OFFSET + CTX_GPREG_X29]
mrs x29, tpidr_el3
str x30, [x29, #CPU_DATA_PMF_TS0_OFFSET]
ldr x29, [sp, #CTX_GPREGS_OFFSET + CTX_GPREG_X29]
#endif
mrs x30, esr_el3 //将esr_el3存入x30
//#define ESR_EC_SHIFT U(26) #define ESR_EC_LENGTH U(6)
//相当于 保留 x30的bit[31-26]并将这几位提到bit[6-0]
ubfx x30, x30, #ESR_EC_SHIFT, #ESR_EC_LENGTH
/* Handle SMC exceptions separately from other synchronous exceptions */
cmp x30, #EC_AARCH32_SMC
b.eq smc_handler32
cmp x30, #EC_AARCH64_SMC
b.eq sync_handler64
cmp x30, #EC_AARCH64_SYS
b.eq sync_handler64
/* Synchronous exceptions other than the above are assumed to be EA */
ldr x30, [sp, #CTX_GPREGS_OFFSET + CTX_GPREG_LR]
b enter_lower_el_sync_ea
.endm
三种跳转选项其中smc_handler32/64能够正确触发异常，report_unhandled_exception则是错误的流程
#define EC_AARCH32_SMC U(0x13)
#define EC_AARCH64_SVC U(0x15)
#define EC_AARCH64_HVC U(0x16)
#define EC_AARCH64_SMC U(0x17)
x30里面存储的是esr_el3 的26-32位，里面是什么判断了smc64当前平台架构是aarch64的，看一下sync_handler64这个处理，在bl31/aarch64/runtime_exceptions.S中
/* Load descriptor index from array of indices */
//在runtime_svc_init()中会将所有的section rt_svc_descs段放入rt_svc_descs_indices数组，
//这里获取该数组地址
adrp x14, rt_svc_descs_indices
add x14, x14, :lo12:rt_svc_descs_indices
ldrb w15, [x14, x16]//找到rt_svc在rt_svc_descs_indices数组中的index
/*
* Get the descriptor using the index
* x11 = (base + off), w15 = index 这个index就是rt_svc_descs结构体数组下标
*
* handler = (base + off) + (index << log2(size))
*/
adr x11, (__RT_SVC_DESCS_START__ + RT_SVC_DESC_HANDLE) //base + off
lsl w10, w15, #RT_SVC_SIZE_LOG2 //(index << log2(size))
ldr x15, [x11, w10, uxtw] //handler = (base + off) + (index << log2(size))
blr x15//跳转到handler
b el3_exit
sync_handler64里找rt_svc_desc_t结构体类型里面的handle处理函数，而这些处理函数在rt_svc_descs节中一个问题： 怎么找到 index ？ ****例如发的一个smc消息id是0x84000000+8
•bit31决定是fast call，还是std call(yield对应的就是std call)•bit30表示是以32位传参，还是以64位传参，注意我们看了optee在linux的driver，都是以32位方式•bit29:24 决定服务的类型•bit23:16 reserved•bit15:0每种call类型下，表示range这个地方值为4，
/* Register Standard Service Calls as runtime service */
DECLARE_RT_SVC(
std_svc,
OEN_STD_START,
OEN_STD_END,
SMC_TYPE_FAST,
std_svc_setup,
std_svc_smc_handler
);
#define OEN_STD_START U(4) /* Standard Service Calls */
#define OEN_STD_END U(4)
系统启动的时候会把index信息存入到rt_svc_descs_indices里面，根据4取出来就可以了。
start_idx = (uint8_t)get_unique_oen(service->start_oen,service->call_type);
end_idx = (uint8_t)get_unique_oen(service->end_oen,service->call_type);
assert(start_idx <= end_idx);
assert(end_idx < MAX_RT_SVCS);
for (; start_idx <= end_idx; start_idx++)
rt_svc_descs_indices[start_idx] = index;
base+index << log2(size)找到结构体数组index对应的元素，然后off就是结构体内handle对应的函数。handler = (base + off) + (index << log2(size))翻译过来如下：w15 = （RT_SVC_DESCS_START + RT_SVC_DESC_HANDLE） + w15<< log2(size)\
4.5 smc 服务处理分析
****std_svc_smc_handler（）中，可以看到会调用psci_smc_handler函数。
/*
* Top-level Standard Service SMC handler. This handler will in turn dispatch
* calls to PSCI SMC handler
*/
static uintptr_t std_svc_smc_handler(uint32_t smc_fid,
u_register_t x1,
u_register_t x2,
u_register_t x3,
u_register_t x4,
void *cookie,
void *handle,
u_register_t flags)
{
ret = psci_smc_handler(smc_fid, x1, x2, x3, x4,
cookie, handle, flags);
而在psci_smc_handler函数中，就可以看到上面传入的psci传入的PSCI_SYSTEM_OFF指令
| case PSCI_SYSTEM_OFF: psci_system_off(); /* We should never return from psci_system_off() */ break; |
在psci_system_off进去就打印psci相关的打印，然后调用system_off回调。
void __dead2 psci_system_off(void)
{
psci_print_power_domain_map();//打印
assert(psci_plat_pm_ops->system_off != NULL);
/* Notify the Secure Payload Dispatcher */
if ((psci_spd_pm != NULL) && (psci_spd_pm->svc_system_off != NULL)) {
psci_spd_pm->svc_system_off();
}
console_flush();
/* Call the platform specific hook */
psci_plat_pm_ops->system_off();
/* This function does not return. We should never get here */
}
psci_print_power_domain_map()的打印再和设备重启时的日志进行对比，发现是一致的。
4.5 硬件平台相关处理
****在qemu平台上的实现如下：psci_plat_pm_ops系统初始化的时候会赋值.system_off = qemu_system_off,
static void __dead2 qemu_system_off(void)
{
#ifdef SECURE_GPIO_BASE
ERROR("QEMU System Power off: with GPIO.\n");
gpio_set_direction(SECURE_GPIO_POWEROFF, GPIO_DIR_OUT);
gpio_set_value(SECURE_GPIO_POWEROFF, GPIO_LEVEL_LOW);
gpio_set_value(SECURE_GPIO_POWEROFF, GPIO_LEVEL_HIGH);
#else
semihosting_exit(ADP_STOPPED_APPLICATION_EXIT, 0);
ERROR("QEMU System Off: semihosting call unexpectedly returned.\n");
#endif
panic();
}
semihosting_exit：
func semihosting_call
hlt #0xf000
ret
endfunc semihosting_call
semihosting_exit ：
对应重启，qemu_system_reset（）函数设置GPIO实现
gpio_set_direction(SECURE_GPIO_RESET, GPIO_DIR_OUT);
gpio_set_value(SECURE_GPIO_RESET, GPIO_LEVEL_LOW);
gpio_set_value(SECURE_GPIO_RESET, GPIO_LEVEL_HIGH);
如果不是ATF里面自己处理，有SCP，见下章节分析。
5. SCP中的处理
mhu模块： mhu_isr收到中断status = smt_channel->api->signal_message(smt_channel->id);
signal_message是smt模块里面提供的，对共享内存的数据进行处理
status = fwk_module_bind(smt_channel->id,
FWK_ID_API(FWK_MODULE_IDX_SMT, MOD_SMT_API_IDX_DRIVER_INPUT), &smt_channel->api);
文章篇幅有点多了，具体代码就不分析了，可以参考：[ARM SCP入门-AP与SCP通信](http://mp.weixin.qq.com/s?__biz=MzUzMDMwNTg2Nw==\&mid=2247484475\&idx=1\&sn=09183060a3506b1fdcd0af4d4877c89f\&chksm=fa52821fcd250b091731b09a971f655dbc6bc92f2fa7b4ea9df457f02401717c95510883e53c\&scene=21#wechat_redirect)，另外关于核间通信的细节里面没有说明，具体就是mhu或者PL320的驱动代码，以及共享内存的具体操作，后续专门写几篇核间通信的文章。
后记
本篇文章代码有点多，其实撸代码的过程也挺有趣味的，特别是加上自己的log打印，就有了自己可以控制的感觉，即时反馈带来游戏的快感。另外从职业技能上说，掌握一个方向的技术成为专家，也能让自己有个饭碗，加油，同志们。
“啥都懂一点，啥都不精通，
干啥都能干，干啥啥不是，
专业入门劝退，堪称程序员杂家”。
后续会继续更新，纯干货分析，欢迎分享给朋友，欢迎评论交流！