电子发烧友App
当我们接触电源管理的时候，最简单的流程就是 关机重启 ，但是仔细分析其涉及的所有源代码就会发现，关机重启虽然简单，但是“ 麻雀虽小，五脏俱全 ”，涉及到的软件模块非常的多，涉及的流程：Linux应用（busybox）-》Linux内核-》BL31-》SCP-》PMIC/CRU等硬件。所以是一个入门学习，特别是还没接触过Linux内核代码的好机会，下面进入代码的海洋遨游， 超级干货 ！
1. 关机重启软件流程框图
在Linux系统上的处理分为**用户态**空间、**内核**空间、 **ATF** 、**SCP**四个阶段（ATF是ARM独有的，SCP在复杂SoC上才有应用）来处理：
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指令，关闭armcpu--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的处理信号
initinit.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()函数，在inithalt.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系统调用：
|
Go 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系统调用实现过程：
|
1）判断调用者的用户权限，如果不是超级用户（superuser），则直接返回错误（这也是我们再用户空间执行reboot、halt、poweroff等命令时，必须是root用户的原因）； 2）判断传入的magic number是否匹配，如果不匹配，直接返回错误。这样就可以尽可能的防止误动作发生； 3）调用reboot_pid_ns接口，检查是否需要由该接口处理reboot请求。这是一个有关pid namespaces的新特性，也是Linux内核重要的知识点； 4）如果是POWER_OFF命令，且没有注册power off的machine处理函数（pmm_power_off），把该命令转换为HALT命令； 5）根据具体的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接口； 6）返回上述的处理结果，系统调用结束。 |
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 "); 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 "); dev->class->shutdown_pre(dev); } if (dev->bus && dev->bus->shutdown) { if (initcall_debug) dev_info(dev, "shutdown "); dev->bus->shutdown(dev); } else if (dev->driver && dev->driver->shutdown) { if (initcall_debug) dev_info(dev, "shutdown "); 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是默认重启使用的CPU 2）禁止CPU热插拔 3）如果CPU 0不在线，则设置当前CPU为第一个在线的CPU 4）允许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 "); 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) #define arm_smccc_smc(...) __arm_smccc_smc(__VA_ARGS__, NULL) |
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 ", version_string); NOTICE("BL31: %s ", build_message); bl31_platform_setup(); //通用和安全时钟初始化，其他芯片相关功能初始化 bl31_lib_init(); //空函数 INFO("BL31: Initializing runtime services "); runtime_svc_init(); //重点 下面展开分析 if (bl32_init) { INFO("BL31: Initializing BL32 "); (*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 ", (void *) service); panic(); //不正确 } if (service->init) { //该服务是否需要初始化 rc = service->init(); //进行初始化 if (rc) { //初始化是否成功 ERROR("Error initializing runtime service %s ", 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 . = 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宏来定义的：
//其中__setion("rt_svc_descs")的意思就是注册到rt_svc_descs段中
|
#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_END
service->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, 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:16reserved
•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 <
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. "); 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. "); #endif panic(); } |
semihosting_exit：
|
func semihosting_call hlt #0xf000 ret endfunc semihosting_call |
对应重启，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); |
审核编辑：刘清
工商网监
评论