devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

万字长文带你搞懂安全启动及ATF_atf是如何启动的

作者：繁依Fanyi0 | 2024-05-22 21:47:41

赞

踩

atf是如何启动的

SecureBoot（安全启动）启动吧

SecureBoot（安全启动）启动吧嗷呜嗷呜！！！

本文干货满满，将从以下三个方面带你玩转安全启动（Secure Boot）

  • • 一、 安全引导的作用

  • • 二、 安全引导的原理

  • • 三、 ATF的启动过程框架

  • • 四、ATF的启动过程Code解析

前言

既然是小白也能看懂，那么在开篇之前我先解释两个概念，相关从业者可以跳过这两点：

  • • 什么是ATF？

ARM Trusted Firmware中的Trusted Firmware-A（简称TF-A）。TF-A是Trusted Firmware Project中的一个项目。

TF(Trusted Firmware)是ARM在Armv8引入的安全解决方案，为安全提供了整体解决方案。它包括启动和运行过程中的特权级划分，对Armv7中的TrustZone（TZ）进行了提高，补充了启动过程信任链的传导，细化了运行过程的特权级区间。

TF实际有两种Profile，对ARM Profile A的CPU应用TF-A，对ARM Profile M的CPU应用TF-M。我们一般接触的都是TF-A，又因为这个概念是ARM提出的，有时候也缩写做ATF（ARM Trusted Firmware），所以本文对ATF和TF-A不再做特殊说明，ATF也是TF-A。

  • • 什么是安全引导？

或者叫安全启动

安全引导（Secure Boot）功能是指在系统的整个启动过程中，使用链式验证电子签名的方式来验证系统中重要镜像文件的可靠性，然后再加载镜像文件的引导过程。

安全引导功能可以保护二级厂商系统的独立性和完整性。在ARMv8架构中ARM提供了ARM可信固件（ATF）。

Bootloader、Linux内核、TEE OS的启动都由ATF来加载和引导。对于ARMv8, Bootloader、Linux内核和TEE OS镜像文件的验签工作都是在ATF中完成的。本文将介绍安全引导功能的原理以及ATF的启动过程。

不过在开始详细启动流程时，我们先对ATF有个概要的认识。

1. 冷启动(Cold boot)流程及阶段划分

restart--冷启动

reset--热启动

ATF冷启动实现分为5个步骤：

  • • BL1 - AP Trusted ROM，一般为BootRom。

  • • BL2 - Trusted Boot Firmware，一般为Trusted Bootloader。

  • • BL31 - EL3 Runtime Firmware，一般为SML，管理SMC执行处理和中断，运行在secure monitor中。

  • • BL32 - Secure-EL1 Payload，一般为TEE OS Image。

  • • BL33 - Non-Trusted Firmware，一般为uboot、linux kernel。

ATF输出BL1、BL2、BL31，提供BL32和BL33接口。

（我想提供的接口就是BL32和BL33的镜像可以是指定的，atf其实是一个启动框架，这其中包含的五个步骤，每个步骤你想要的内容，可以由厂商自己定义。）

启动流程如下：

图片

在这里插入图片描述

1.1 BL1

BL1位于ROM中，在EL3下从reset vector处开始运行。（bootrom就是芯片上电运行的（chip-rom的作用就是跳转到bootrom））

BL1做的工作主要有：

  • • 决定启动路径：冷启动还是热启动。

  • • 架构初始化：异常向量、CPU复位处理函数配置、控制寄存器设置(SCRLR_EL3/SCR_EL3/CPTR_EL3/DAIF)

  • • 平台初始化：使能Trusted Watchdog、初始化控制台、配置硬件一致性互联、配置MMU、初始化相关存储设备。

  • • 固件更新处理

  • • BL2镜像加载和执行：

  • • BL1输出“Booting Trusted Firmware"。

  • • BL1加载BL2到SRAM；如果SRAM不够或者BL2镜像错误，输出“Failed to load BL2 firmware.”。

  • • BL1切换到Secure EL1并将执行权交给BL2.

1.2 BL2

BL2位于SRAM中，运行在Secure EL1主要工作有：

  • • 架构初始化：EL1/EL0使能浮点单元和ASMID。

  • • 平台初始化：控制台初始化、相关存储设备初始化、MMU、相关设备安全配置、

  • • SCP_BL2：系统控制核镜像加载，单独核处理系统功耗、时钟、复位等控制。

  • • 加载BL31镜像：BL2将控制权交给BL1；BL1关闭MMU并关cache；BL1将控制权交给BL31。

  • • 加载BL32镜像：BL32运行在安全世界，BL2依赖BL31将控制权交给BL32。SPSR通过Secure-EL1 Payload Dispatcher进行初始化。

  • • 加载BL33镜像：BL2依赖BL31将控制权交给BL33。

1.3 BL31

BL31位于SRAM中，EL3模式。除了做架构初始化和平台初始化外，还做了如下工作：

  • • PSCI服务初始化，后续提供CPU功耗管理操作。

  • • BL32镜像运行初始化，处于Secure EL1模式。

  • • 初始化非安全EL2或EL1，跳转到BL33执行。

  • • 负责安全非安全世界切换。

  • • 进行安全服务请求的分发。

图片

在这里插入图片描述

这两幅图真的不错，棒。

一、 安全引导的作用

安全引导可用于保证系统的完整性，防止系统中重要镜像文件被破坏或替换。

一般情况下，安全引导需要保护

  • • 系统的BootLoader镜像文件、

  • • TEE镜像文件、

  • • Linux内核镜像文件、

  • • Recover镜像文件

  • • 以及在ARMv8中使用的ATF镜像文件。

将TEE镜像文件的加载操作加入安全引导功能中可阻止黑客通过替换TEE镜像文件的方式来窃取被TEE保护的重要资料。

当前使用ARM芯片的系统中大部分使能了安全引导功能，该功能对于用户的最直接感受就是，当用户非法刷入其他厂商的ROM后手机无法正常启动，这是因为非法刷机将导致系统中的重要镜像文件被替换，系统在启动过程中对镜像文件的电子验签失败，如果BootLoader验证失败，则系统在进入BootLoader阶段之前就会挂死。

（信任根这个词语此时有没有在你的脑子里包含）

二、 安全引导的原理

安全引导功能的原理就是采用链式验签的方式启动系统，也就是在系统启动过程中，在加载下一个阶段的镜像之前都会对需要被加载的镜像文件进行电子验签，只有验签操作通过后，该镜像才能被加载到内存中，然后系统才会跳转到下一个阶段继续执行，整个验签链中的任何一环验签失败都会导致系统挂死，系统启动过程中的第一级验签操作是由ChipRom来完成的。

只要芯片一出厂，用户就无法修改固化在芯片中的这部分代码，因此无法通过修改第一级验签结果来关闭安全引导功能。

而且验签操作使用的RSA公钥或者哈希值将会被保存在OTP/efuse中，该区域中的数据一般只有ChipRom和TEE能够读取且无法被修改。RSA公钥或者哈希值将会在产品出厂之前被写入到OTP/efuse中，而且不同厂商使用的密钥会不一样。

本质上也就是说Rom拿来校验后级第一部分的内容所用到的密钥是来自OTP里面，而这种是在出厂就确认好了的，无法修改的。ChipRom和OTP的配合让这个安全启动的最开始具备了灵活性和安全性兼顾。

在谷歌的安全引导功能白皮书中提出了安全引导功能实现方案的设计建议。

谷歌建议将镜像文件的电子签名信息和验签使用的RSA公钥保存在电子证书中，系统在启动的过程中首先会验证电子证书的合法性，如果验证通过则需从电子证书中获取签名信息和RSA公钥，然后再利用它们对镜像文件进行验证。整个验证过程就是先验证证书，验证证书通过后再去验证镜像文件的合法性。

但是在实际实现过程中，大多数芯片厂商是将签名信息与需要被验签的镜像文件打包在一起，而RSA公钥则会被打包到执行验证操作的镜像文件中。

（但是动态TA的事情）

不同厂商可能会对镜像文件进行加密操作，使保存在设备中的镜像文件都是以密文的形式存在。

在启动过程中，首先会验证密文镜像文件的合法性然后再进行解密镜像文件的操作，这些都完成后才会将明文的镜像文件加载到内存中然后再执行跳转操作。

先验证，再解密，签名的是加密的文件哦。

2.1 ARMv7安全引导的过程

对于安全引导功能的实现和验证过程各家芯片公司的方案都不一样，这是由该芯片的启动流程以及启动所需镜像文件来决定的，但都会遵循链式验签启动的原则。

ARMv7架构并没有使用ATF，系统的启动流程与以前一样使用BootLoader来引导Linux内核和TEE OS。安全引导的启动流程如图下所示。

图片

安全引导的启动流程

系统启动过程使用链式验签的方式进行引导，其中任何一环验签失败都会导致系统启动失败，为防止通过替换ramdisk来修改根文件系统中的内容，一般将ramdisk与Linux内核打包在同一个镜像文件中，而且该镜像文件需要待验签通过后才可被使用。

签名信息一般是对镜像文件的内容进行哈希计算获取摘要后再对该摘要使用RSA私钥进行电子签名来获得，验证时同样会计算需要被引导的镜像文件的摘要，然后使用该摘要、签名信息以及RSA公钥进行RSA算法的验证。这个就是对称的过程，加密签名，验签解密。

2.2 ARMv8安全引导的过程

ARMv8架构之后ARM提供了ATF, BootLoader、TEE镜像文件、Linux内核镜像文件、recovery镜像文件都是由ATF来进行引导和加载而不是由ChipRom来完成的。

ChipRom只会去验证ATF中bl1的合法性，后续引导过程同样也是按照链式验签的方式进行，符合TBBR规范。读者可使用git命令从gitHub上获取ATF的所有源代在ARMv8架构中整个安全引导的流程如图下所示。

图片

ARMv8的Secure Boot流程

ARMv8架构中引入了ATF，同时在ATF中提供了安全引导的功能，BootLoader镜像、Linux内核、recovery镜像和TEE OS镜像文件的签名方式都由ATF决定。当然开发者也可以对ATF进行定制化，修改ATF中的验签过程，但是修改后的验签方案需要符合TBBR规范。

此时ATF不要和BL31搞混了哦。ATF是一个整个启动链路。

三、 ATF的启动过程

ATF的启动过程根据ARMv8的运行模式（AArch32/AArch64）会有所不同，但基本一致。

在AArch32中是不会去加载bl31而是将EL3或者Monitor模式的运行代码保存在bl32中执行。在AArch64中，ATF的完整启动流程如图下所示。

图片

AArch64模式的ATF启动流程

在上述启动过程中，从一个镜像跳转到另外一个镜像文件执行的方式各不相同，以下为镜像跳转的过程和方式说明。

1-概要流程

1. bl1跳转到bl2执行

在bl1完成了将bl2镜像文件加载到RAM中的操作、中断向量表的设定以及其他CPU相关设定后，bl1_main函数会解析出bl2镜像文件的描述信息，获取入口地址，并设定下一个阶段的cpu上下文。这些操作完成之后，调用el3_exit函数来实现bl1到bl2的跳转，进入bl2中开始执行。

2. bl2跳转到bl31执行

在bl2中将会加载bl31、bl32、bl33的镜像文件到对应权限的内存中，并将该三个镜像文件的描述信息组成一个链表保存起来，以备bl31启动bl32和bl33使用。在AArch64中，bl31为EL3的执行软件，其运行时的主要功能是对安全监控模式调用（smc）指令和中断处理，运行在ARM的Monitor模式中。

bl32一般为TEE OS镜像文件，本章以OP-TEE为例进行说明。

bl33为正常世界状态的镜像文件，例如uboot、EKD2等。当前该部分为BootLoader部分的镜像文件，再由BootLoader来启动Linux内核镜像。

从bl2跳转到bl31是通过带入bl31的入口点信息作为参数，然后调用安全监控模式调用指令，触发在bl1中设定的安全监控模式调用请求，该请求处理完成后会将中央处理器的执行权限交给bl31，并跳转到bl31中去执行。

3. bl31跳转到bl32执行

在bl31中会执行runtime_service_inti函数，该函数会调用注册到EL3中所有服务的初始化函数，其中有一个服务项就是TEE服务，该服务项的初始化函数会将TEE OS的初始化函数赋值给bl32_init变量，当所有服务项执行完初始化后，在bl31中会调用bl32_init执行的函数来跳转到TEE OS中并开始执行TEE OS的启动。

4. bl31跳转到bl33执行

当TEE-OS镜像启动完成后会触发一个ID为TEESMC_OPTEED_RETURN_ENTRY_DONE的安全监控模式调用，该调用是用来告知EL3 TEE OS镜像已经完成了初始化，然后将CPU的状态恢复到bl31_init的位置继续执行。

bl31通过遍历在bl2中记录的所有镜像信息的链表来找到需要执行的bl33的镜像。然后通过获取到bl33镜像的信息，设定下一个阶段的CPU上下文，退出el3后进入到bl33镜像中开始执行。

2-code层面

1 ATF中bl1的启动

系统上电之后首先会运行ChipRom，之后会跳转到ATF的bl1中继续执行。bl1主要初始化CPU、设定异常向量、将bl2的镜像加载到安全RAM中，然后跳转到bl2中开始运行。

bl1的主要代码存放在bl1目录中，bl1的链接文件是bl1/bl1.ld.s文件，该文件指定bl1的入口函数是bl1_entrypoint。

AArch32的该函数定义在bl1/aarch32/bl1_entrypoint.S文件中，AArch64的该函数定义在bl1/aarch64/bl1_entrypoint. S文件中。bl1的执行流程如图所示。

图片

bl1执行流程

1. bl1_entrypoint函数说明

bl1_entrypoint函数主要完成ARMv8架构中EL3执行环境的基础初始化、设定异常向量表、加载bl2的镜像文件到内存中并进行跳转到bl2继续执行。该函数的内容如下：

  1.         func bl1_entrypoint
  2.  
  3.         /＊  EL3级别运行环境的初始化，该函数定义在include/common/aarch64/el3_common_macros.S文
  4.  
  5.         件中＊/
  6.  
  7.             el3_entrypoint_common           \
  8.  
  9.                 _set_endian=1               \
  10.  
  11.                 _warm_boot_mailbox=! PROGRAMMABLE_RESET_ADDRESS           \
  12.  
  13.                 _secondary_cold_boot=! COLD_BOOT_SINGLE_CPU                \
  14.  
  15.                 _init_memory=1              \
  16.  
  17.                 _init_c_runtime=1           \
  18.  
  19.                 _exception_vectors=bl1_exceptions
  20.  
  21.             bl  bl1_early_platform_setup  //调用bl1_early_platform_setup函数完成底层初始化
  22.  
  23.             bl  bl1_plat_arch_setup        //调用bl1_plat_arch_setup完成平台初始化
  24.  
  25.             bl  bl1_main                     //调用bl1_main函数，初始化验证模块，加载下一阶段的
  26.  
  27.             image到RAM中
  28.  
  29.             b   el3_exit                     //调用el3_exit函数，跳转到下一个image(bl2)
  30.  
  31.         endfunc bl1_entrypoint

el3_entrypoint_common函数执行时带入的参数包括大小端标识、属于冷启动还是重启操作、是否是从核的启动、是否需要进行内存初始化、是否需要建立C语言运行环境（栈初始化）、异常向量表地址注册等。

2. el3_entrypoint_common功能说明

该函数以宏的方式被定义，主要用来完成EL3运行环境的设置和异常向量表的注册，代码内容和注释如下：

  1.         .macro el3_entrypoint_common                                          \
  2.  
  3.                 _set_endian, _warm_boot_mailbox, _secondary_cold_boot,  \
  4.  
  5.                 _init_memory, _init_c_runtime, _exception_vectors
  6.  
  7.             /＊ 通过sctlr寄存器设定大小端 ＊/
  8.  
  9.             .if \_set_endian
  10.  
  11.                 mrs x0, sctlr_el3
  12.  
  13.                 bic x0, x0, #SCTLR_EE_BIT
  14.  
  15.                 msr sctlr_el3, x0
  16.  
  17.                 isb
  18.  
  19.             .endif /＊ _set_endian ＊/
  20.  
  21.             /＊ 判定是否需要调用do_cold_boot流程 ＊/
  22.  
  23.             .if \_warm_boot_mailbox
  24.  
  25.                 bl  plat_get_my_entrypoint
  26.  
  27.                 cbz x0, do_cold_boot
  28.  
  29.                 br  x0
  30.  
  31.             do_cold_boot:
  32.  
  33.             .endif /＊ _warm_boot_mailbox ＊/
  34.  
  35.             bl  reset_handler               //执行reset handle操作
  36.  
  37.             el3_arch_init_common \_exception_vectors //初始化异常向量
  38.  
  39.             /＊ 判定当前CPU是否是主CPU，如果是则执行主CPU的初始化 ＊/
  40.  
  41.             .if \_secondary_cold_boot
  42.  
  43.                 //获取当前core的编号，判定当前是主核还是从核
  44.  
  45.                 bl  plat_is_my_cpu_primary
  46.  
  47.                 //如果是主核则调用do_primary_cold_boot执行主核启动
  48.  
  49.                 cbnz     w0, do_primary_cold_boot
  50.  
  51.                 bl  plat_secondary_cold_boot_setup   //如果是从核则执行从核的启动
  52.  
  53.                 bl  el3_panic
  54.  
  55.             do_primary_cold_boot:
  56.  
  57.             .endif /＊ _secondary_cold_boot ＊/
  58.  
  59.             /＊ 初始化memory ＊/
  60.  
  61.             .if \_init_memory
  62.  
  63.                 bl  platform_mem_init                  //初始化memory
  64.  
  65.             .endif /＊ _init_memory ＊/
  66.  
  67.             /＊ 初始化C语言的运行环境 ＊/
  68.  
  69.             .if \_init_c_runtime
  70.  
  71.         #ifdef IMAGE_BL31
  72.  
  73.                 adr x0, __RW_START__                   //获取内存RW的起始地址
  74.  
  75.                 adr x1, __RW_END__                     //获取内存RW的末端地址
  76.  
  77.                 sub x1, x1, x0                          //RW的长度
  78.  
  79.                 bl  inv_dcache_range                   //无效数据cache
  80.  
  81.         #endif /＊ IMAGE_BL31 ＊/
  82.  
  83.                 ldr x0, =__BSS_START__                 //将BSS段内存的起始地址存放在x0中
  84.  
  85.                 ldr x1, =__BSS_SIZE__                  //将BSS段内如的某段地址存放在x1中
  86.  
  87.                 bl  zeromem                              //请扩BSS段内存
  88.  
  89.         #if USE_COHERENT_MEM
  90.  
  91.                 ldr x0, =__COHERENT_RAM_START__
  92.  
  93.                 ldr x1, =__COHERENT_RAM_UNALIGNED_SIZE__
  94.  
  95.                 bl  zeromem
  96.  
  97.         #endif
  98.  
  99.         #ifdef IMAGE_BL1
  100.  
  101.                 ldr x0, =__DATA_RAM_START__           //获取bl1的数据段存放到RAM中的起始地址
  102.  
  103.                 ldr x1, =__DATA_ROM_START__           //获取bl1中数据段在ROM中的起始地址
  104.  
  105.                 ldr x2, =__DATA_SIZE__                 //获取bl1数据端的大小
  106.  
  107.                 bl  memcpy16                            //将bl1的数据段复制到RAM中
  108.  
  109.         #endif
  110.  
  111.             .endif /＊ _init_c_runtime ＊/
  112.  
  113.             msr spsel, #0
  114.  
  115.             bl  plat_set_my_stack                       //设定堆栈
  116.  
  117.         #if STACK_PROTECTOR_ENABLED
  118.  
  119.             .if \_init_c_runtime
  120.  
  121.             bl  update_stack_protector_canary
  122.  
  123.             .endif /＊ _init_c_runtime ＊/
  124.  
  125.         #endif
  126.  
  127.             .endm
  128.  
  129.         #endif /＊ __EL3_COMMON_MACROS_S__ ＊/

el3_entrypoint_common函数主要完成C语言运行环境的搭建、异常向量表的注册、bl1镜像文件的复制、CPU安全运行环境的设定等。

3. bl1_early_platform_setup函数

bl1_early_platform_setup函数主要完成CPU中ARM核的早期初始化，包括内存、页表、外部设备以及ARM核状态的设定，其内容如下：

  1.         void bl1_early_platform_setup(void)
  2.  
  3.         {
  4.  
  5.             /＊ 使能看门狗，初始化console，初始化memory ＊/
  6.  
  7.             arm_bl1_early_platform_setup();
  8.  
  9.             plat_arm_interconnect_init(); //初始化外部设备
  10.  
  11.             plat_arm_interconnect_enter_coherency(); //使能外部设备
  12.  
  13.         }
4. bl_main函数

bl_main函数主要完成bl2镜像文件的加载和bl2运行环境的配置，如果使能了安全引导功能，则还需要对bl2镜像文件执行验签操作。该函数定义在/bl1/bl1_main.c文件中，主要内容和注释如下：

  1.         void bl1_main(void)
  2.  
  3.         {
  4.  
  5.             unsigned int image_id;
  6.  
  7.             print_errata_status();
  8.  
  9.         #if DEBUG
  10.  
  11.             u_register_t val;
  12.  
  13.         /＊ 确保MMU和cache使能 ＊/
  14.  
  15.         #ifdef AARCH32
  16.  
  17.             val = read_sctlr();
  18.  
  19.         #else
  20.  
  21.             val = read_sctlr_el3();
  22.  
  23.         #endif
  24.  
  25.             assert(val & SCTLR_M_BIT);
  26.  
  27.             assert(val & SCTLR_C_BIT);
  28.  
  29.             assert(val & SCTLR_I_BIT);
  30.  
  31.             val = (read_ctr_el0() >> CTR_CWG_SHIFT) & CTR_CWG_MASK;
  33.             if (val ! = 0)
  34.  
  35.                 assert(CACHE_WRITEBACK_GRANULE == SIZE_FROM_LOG2_WORDS(val));
  36.  
  37.             else
  38.  
  39.                 assert(CACHE_WRITEBACK_GRANULE ＜= MAX_CACHE_LINE_SIZE);
  40.  
  41.         #endif
  42.  
  43.             bl1_arch_setup();               //设置bl2镜像运行时的EL级别
  44.  
  45.         #if TRUSTED_BOARD_BOOT
  46.  
  47.             auth_mod_init();                //初始化image的验证模块
  48.  
  49.         #endif /＊ TRUSTED_BOARD_BOOT ＊/
  50.  
  51.             bl1_platform_setup();          //平台相关设置，主要是IO的设置
  52.  
  53.             //获取下一个阶段image的ID值。默认返回值为BL2_IMAGE_ID
  54.  
  55.             image_id = bl1_plat_get_next_image_id();
  56.  
  57.             if (image_id == BL2_IMAGE_ID)
  58.  
  59.                 bl1_load_bl2();             //将bl2 image加载到安全RAM中
  60.  
  61.               else
  62.  
  63.                   NOTICE("BL1-FWU: ＊＊＊＊＊＊＊FWU Process Started＊＊＊＊＊＊＊\n");
  64.  
  65.               //获取bl2镜像的描述信息、包括名字、ID、entry point info等，并将这些信息保存到
  66.  
  67.               //bl1_cpu_context的上下文中
  68.  
  69.               bl1_prepare_next_image(image_id);
  70.  
  71.               console_flush();                //刷新console
  72.  
  73.           }
  74.  
  75.
5. bl1_prepare_next_image函数

bl1_prepare_next_image函数用来获取bl2镜像的描述信息、bl2的入口地址信息、设定bl2的运行状态，以备跳转时使用，其内容和解释如下：

  1.         void bl1_prepare_next_image(unsigned int image_id)
  2.  
  3.         {
  4.  
  5.             unsigned int security_state;
  6.  
  7.             image_desc_t ＊image_desc;
  8.  
  9.             entry_point_info_t ＊next_bl_ep;
  10.  
  11.             /＊ 获取bl2 image的描述信息，主要包括入口地址、名字等信息 ＊/
  12.  
  13.             image_desc = bl1_plat_get_image_desc(image_id);
  14.  
  15.             assert(image_desc);
  16.  
  17.             /＊ 获取image的入口地址信息 ＊/
  18.  
  19.             next_bl_ep = &image_desc->ep_info;
  20.  
  21.             //获取bl2 image的安全状态（判定该image是属于安全态的image的还是非安全态的image）
  22.  
  23.             security_state = GET_SECURITY_STATE(next_bl_ep->h.attr);
  24.  
  25.             /＊ 设定用于存放CPU context的变量 ＊/
  26.  
  27.             if (! cm_get_context(security_state))
  28.  
  29.                 cm_set_context(&bl1_cpu_context[security_state], security_state);
  30.  
  31.             /＊ 为下个阶段的image准备好SPSR数据 ＊/
  32.  
  33.             if (security_state == SECURE) {
  34.  
  35.                 next_bl_ep->spsr = SPSR_64(MODE_EL1, MODE_SP_ELX,
  36.  
  37.                         DISABLE_ALL_EXCEPTIONS);
  38.  
  39.             } else {
  40.  
  41.                 /＊ Use EL2 if supported else use EL1. ＊/
  42.  
  43.                 if (read_id_aa64pfr0_el1() &
  44.  
  45.                     (ID_AA64PFR0_ELX_MASK ＜＜ ID_AA64PFR0_EL2_SHIFT)) {
  46.  
  47.                     next_bl_ep->spsr = SPSR_64(MODE_EL2, MODE_SP_ELX,
  48.  
  49.                         DISABLE_ALL_EXCEPTIONS);
  50.  
  51.                 } else {
  52.  
  53.                     next_bl_ep->spsr = SPSR_64(MODE_EL1, MODE_SP_ELX,
  54.  
  55.                         DISABLE_ALL_EXCEPTIONS);
  56.  
  57.                 }
  58.  
  59.             }
  60.  
  61.             bl1_plat_set_ep_info(image_id, next_bl_ep);
  62.  
  63.             /＊ 使用获取到的bl2 image的entrypoint info数据来初始化cpu context ＊/
  64.  
  65.             cm_init_my_context(next_bl_ep);
  66.  
  67.             /＊ 为进入到下个EL级别做准备 ＊/
  68.  
  69.             cm_prepare_el3_exit(security_state);
  70.  
  71.             /＊ 设定image的执行状态 ＊/
  72.  
  73.             image_desc->state = IMAGE_STATE_EXECUTED;
  74.  
  75.             /＊ 打印出bl2 image的入口信息 ＊/
  76.  
  77.             print_entry_point_info(next_bl_ep);
  78.  
  79.         }

2 ATF中bl2的启动

bl2镜像将为后续镜像的加载执行相关的初始化操作，主要是内存、MMU、串口以及EL3软件运行环境的设置，并且加载bl3x的镜像到内存中。

通过查看bl2.ld.S文件可发现，bl2镜像的入口函数是bl2_entrypoint。该函数定义在bl2/aarch64/bl2_entrypoint.S文件中。该阶段的执行流程如图所示。

图片

bl2执行流程

1. bl2_entrypoint函数

bl2_entrypoint函数最终会触发安全监控模式调用（smc），通知bl1将CPU的控制权限转交给bl31，然后执行bl31。

该函数会执行

  • • 平台相关的初始化、

  • • 获取存放bl3x镜像文件的结构体变量、

  • • 解析出bl31的入口地址等。

该函数的主要内容和注释如下：

  1.         func bl2_entrypoint
  2.  
  3.             mov x20, x1                      //获取可用安全内存的起始地址
  4.  
  5.             adr x0, early_exceptions       //设定异常向量
  6.  
  7.             msr vbar_el1, x0                //将异常向量表地址写入到VBAR寄存器中
  8.  
  9.             isb
  10.  
  11.             msr daifclr, #DAIF_ABT_BIT    //使能SErrot中断
  12.  
  13.             /＊ 使能指令cache、栈顶地址以及数据访问权限对齐检查 ＊/
  14.  
  15.             mov x1, #(SCTLR_I_BIT | SCTLR_A_BIT | SCTLR_SA_BIT)
  16.  
  17.             mrs x0, sctlr_el1
  18.  
  19.             orr x0, x0, x1
  20.  
  21.             msr sctlr_el1, x0
  22.  
  23.             isb
  24.  
  25.             /＊ 获取有效的RW内存以备bl2使用 ＊/
  26.  
  27.               adr x0, __RW_START__                   //获取RW内存的起始地址
  28.  
  29.               adr x1, __RW_END__                     //获取RW内存的末端地址
  30.  
  31.               sub x1, x1, x0                          //计算出RW内存的大小
  32.  
  33.               bl  inv_dcache_range                   //禁止数据cache
  34.  
  35.               ldr x0, =__BSS_START__                 //获取bl2中BSS段的起始地址
  36.  
  37.               ldr x1, =__BSS_SIZE__                  //获取bl2中BSS段的大小
  38.  
  39.               bl  zeromem                              //清空BSS段中的内容
  40.  
  41.           #if USE_COHERENT_MEM
  42.  
  43.               ldr x0, =__COHERENT_RAM_START__
  44.  
  45.               ldr x1, =__COHERENT_RAM_UNALIGNED_SIZE__
  46.  
  47.               bl  zeromem
  48.  
  49.           #endif
  50.  
  51.               bl  plat_set_my_stack                  //初始化bl2运行的栈
  52.  
  53.           #if STACK_PROTECTOR_ENABLED
  54.  
  55.               bl  update_stack_protector_canary    //更新栈保护区域数据
  56.  
  57.           #endif
  58.  
  59.               mov x0, x20
  60.  
  61.               bl  bl2_early_platform_setup          //设置平台相关
  62.  
  63.               bl  bl2_plat_arch_setup                //设置架构相关
  64.  
  65.               bl  bl2_main      //跳转到BL2的主要函数执行，从该函数中跳转到bl31以及bl32或者bl33
  66.  
  67.               no_ret plat_panic_handler
  68.  
  69.           endfunc bl2_entrypoint

在bl2_entrypoint函数中，完成bl2运行栈的初始化，配置完运行环境后，会调用bl2_main函数来完成bl2对bl3x镜像的加载，而CPU控制权限的转移则是通过触发安全监控模式调用（smc）来实现。

2. bl2_main函数

bl2_main函数完成了bl2阶段的主要操作，包括

  • • 对下一个阶段镜像文件的解析、

  • • 获取入口地址和镜像文件大小等信息，

  • • 然后对镜像文件进行验签和加载操作。

  • • 将bl31加载到内存中后会触发安全监控模式调用（smc）将CPU权限转交给bl31。

该函数的主要内容和相关注释如下：

  1. **        void bl2_main(void)
  2.  
  3.         {
  4.  
  5.             entry_point_info_t ＊next_bl_ep_info;
  6.  
  7.             bl2_arch_setup();               //执行平台相关初始化
  8.  
  9.         #if TRUSTED_BOARD_BOOT
  10.  
  11.             /＊ Initialize authentication module ＊/
  12.  
  13.             auth_mod_init();                //初始化image验证模块
  14.  
  15.         #endif /＊ TRUSTED_BOARD_BOOT ＊/
  16.  
  17.             //加载bl3x image到RAM中并返回bl31的入口地址
  18.  
  19.             next_bl_ep_info = bl2_load_images();
  20.  
  21.         #ifdef AARCH32
  22.  
  23.             disable_mmu_icache_secure();  //禁止MMU的指令cache
  24.  
  25.         #endif /＊ AArch32 ＊/
  26.  
  27.             console_flush();                //刷新console操作
  28.  
  29.             /＊ 调用smc指令，触发在bl1中设定的smc异常中断处理函数，跳转到bl31 ＊/
  30.  
  31.               smc(BL1_SMC_RUN_IMAGE, (unsigned long)next_bl_ep_info, 0, 0, 0, 0,0, 0);
  32.  
  33.           }**
3. bl2_load_images函数

bl2_load_images函数完成将bl32和bl33的镜像文件加载到内存中并返回bl31镜像的入口地址，最终在bl2_main函数中通过触发安全监控模式调用（smc）跳转到bl31，并将CPU控制权限交给bl31。

该函数的主要内容和注释如下：

  1.         entry_point_info_t ＊bl2_load_images(void)
  2.  
  3.         {
  4.  
  5.             bl_params_t ＊bl2_to_next_bl_params;
  6.  
  7.             bl_load_info_t ＊bl2_load_info;
  8.  
  9.             const bl_load_info_node_t ＊bl2_node_info;
  10.  
  11.             int plat_setup_done = 0;
  12.  
  13.             int err;
  14.  
  15.             /＊ 获取bl3x image的加载和入口函数信息 ＊/
  16.  
  17.             bl2_load_info = plat_get_bl_image_load_info();
  18.  
  19.             /＊ 检查返回的bl2_load_info中的信息是否正确 ＊/
  20.  
  21.             assert(bl2_load_info);
  22.  
  23.             assert(bl2_load_info->head);
  24.  
  25.             assert(bl2_load_info->h.type == PARAM_BL_LOAD_INFO);
  26.  
  27.             assert(bl2_load_info->h.version >= VERSION_2);
  28.  
  29.             /＊  将bl2_load_info中的head变量的值赋值为bl2_node_info，即将bl31  image的入口信息
  30.  
  31.             传递给bl2_node_info变量 ＊/
  32.  
  33.             bl2_node_info = bl2_load_info->head;
  34.  
  35.             /＊ 进入loop循环 ＊/
  36.  
  37.             while (bl2_node_info) {
  38.  
  39.                 /＊ 在加载特定的bl3x image到RAM之前先确定是否需要进行平台的初始化 ＊/
  40.  
  41.                 if (bl2_node_info->image_info->h.attr & IMAGE_ATTRIB_PLAT_SETUP) {
  42.  
  43.                     if (plat_setup_done) {
  44.  
  45.                         WARN("BL2: Platform setup already done! ! \n");
  46.  
  47.                     } else {
  48.  
  49.                         INFO("BL2: Doing platform setup\n");
  50.  
  51.                         bl2_platform_setup();
  52.  
  53.                         plat_setup_done = 1;
  54.  
  55.                     }
  56.  
  57.                 }
  58.  
  59.                 /＊ 对bl3x image进行电子验签，如果通过则执行加载操作 ＊/
  60.  
  61.                 if (! (bl2_node_info->image_info->h.attr & IMAGE_ATTRIB_SKIP_LOADING)) {
  62.  
  63.                     INFO("BL2: Loading image id %d\n", bl2_node_info->image_id);
  64.  
  65.                     err = load_auth_image(bl2_node_info->image_id,
  66.  
  67.                         bl2_node_info->image_info);
  68.  
  69.                     if (err) {
  70.  
  71.                         ERROR("BL2: Failed to load image (%i)\n", err);
  72.  
  73.                         plat_error_handler(err);
  74.  
  75.                     }
  76.  
  77.                 } else {
  78.  
  79.                     INFO("BL2: Skip loading image id %d\n", bl2_node_info->image_id);
  80.  
  81.                 }
  82.  
  83.                   /＊ 可以根据实际需要更改，通过给定image ID来更改image的加载信息 ＊/
  84.  
  85.                   err = bl2_plat_handle_post_image_load(bl2_node_info->image_id);
  86.  
  87.                   if (err) {
  88.  
  89.                       ERROR("BL2: Failure in post image load handling (%i)\n", err);
  90.  
  91.                       plat_error_handler(err);
  92.  
  93.                   }
  94.  
  95.                   bl2_node_info = bl2_node_info->next_load_info;
  96.  
  97.               }
  98.  
  99.               /＊  获取下一个执行的镜像的入口信息，并且将以后会被执行的镜像的入口信息组合成链表，通过判断
  100.  
  101.               image  des中的ep_info.h.attr的值是否为（EXECUTABLE|EP_FIRST_EX）来确定接下来第一个
  102.  
  103.               被执行的image＊/
  104.  
  105.               bl2_to_next_bl_params = plat_get_next_bl_params();
  106.  
  107.               assert(bl2_to_next_bl_params);
  108.  
  109.               assert(bl2_to_next_bl_params->head);
  110.  
  111.               assert(bl2_to_next_bl_params->h.type == PARAM_BL_PARAMS);
  112.  
  113.               assert(bl2_to_next_bl_params->h.version >= VERSION_2);
  114.  
  115.               plat_flush_next_bl_params();
  116.  
  117.               /＊ 返回下一个进入的镜像的入口信息，即bl31的入口信息 ＊/
  118.  
  119.               return bl2_to_next_bl_params->head->ep_info;
  120.  
  121.           }
4. bl3x镜像文件信息

ATF使用bl_mem_params_node_t结构体变量数组bl_mem_params_desc_ptr来保存bl3x镜像文件的信息。该结构体内容如下：

  1.         typedef struct bl_mem_params_node {
  2.  
  3.             unsigned int image_id;                   //镜像文件的id值
  4.  
  5.             image_info_t image_info;                 //镜像文件的信息
  6.  
  7.             entry_point_info_t ep_info;              //bl3x的入口地址信息
  8.  
  9.             unsigned int next_handoff_image_id;    //写一个阶段bl3x的id值
  10.  
  11.             bl_load_info_node_t load_node_mem;     //该镜像文件需要被保存在RAM中的信息
  12.  
  13.             bl_params_node_t params_node_mem;       //该镜像文件启动时所需参数在RAM中的信息
  14.  
  15.         } bl_mem_params_node_t;

在bl2_load_images函数中通过调用plat_get_bl_image_load_info函数来获取bl3x镜像文件的信息，ATF源代码中通过使用REGISTER_BL_IMAGE_DESCS宏将事先定义好的bl2_mem_params_descs变量中的数据保存到bl_mem_params_desc_ptr数组中，而bl2_mem_params_descs中保存的就是所有bl3x镜像文件的基本信息，开发者可根据不同平台的实际情况修改bl2_mem_params_descs变量中各镜像文件的信息。

5. bl2到bl31的跳转

在bl2_main函数中最终会调用smc（BL1_SMC_RUN_IMAGE,（unsigned long）next_bl_ep_info,0,0,0,0,0,0）来触发一个类型为BL1_SMC_RUN_IMAGE的安全监控模式调用。

安全监控模式调用的处理接口在bl1阶段时被指定，调用该函数时传入的command ID是BL1_SMC_RUN_IMAGE，故执行该函数之后，系统将跳转到中断处理函数（smc_handler64）继续执行。该函数定义在bl1/aarch64/bl1_exception.S文件中。

该函数最终通过判定安全监控模式调用的类型（在bl2中将会发送类型为BL1_SMC_RUN_IMAGE的smc）查看当前的安全监控模式调用是否是用于跳转，其内容如下：

  1.         func smc_handler64
  2.  
  3.             /＊ 判定触发smc操作时带入的参数是否为跳转执行image的操作 ＊/
  4.  
  5.             mov x30, #BL1_SMC_RUN_IMAGE   //将BL1_SMC_RUN_IMAGE的值保存到x30
  6.  
  7.             cmp x30, x0                      //比较x30与x0的值
  8.  
  9.             //如果x30与x0不同，则认为是普通类型的异常，进入smc_handler进行处理
  10.  
  11.             b.ne     smc_handler
  12.  
  13.             mrs x30, scr_el3                //获取scr寄存器的值
  14.  
  15.             tst x30, #SCR_NS_BIT           //比较scr寄存器中的NS bit与SCR_NS_BIT是否相等
  16.  
  17.             //如果当前NS bit为非安全位，则证明不合法，产生异常
  18.  
  19.             b.ne     unexpected_sync_exception
  20.  
  21.             //获取offset和sp的值
  22.  
  23.             ldr x30, [sp, #CTX_EL3STATE_OFFSET + CTX_RUNTIME_SP]
  24.  
  25.             msr spsel, #0                     //清空spsel中的值
  26.  
  27.             mov sp, x30                      //保存x30的值到sp寄存器，用于返回
  28.  
  29.             mov x20, x1                      //将x1中的数据保存到x20中
  30.  
  31.             mov x0, x20                      //将x20的数据保存到x0中
  32.  
  33.             bl  bl1_print_next_bl_ep_info //打印出bl3x镜像文件信息
  34.  
  35.             //传入参数和bl3x入口函数的PC指针
  36.  
  37.             ldp x0, x1, [x20, #ENTRY_POINT_INFO_PC_OFFSET]
  38.  
  39.             msr elr_el3, x0
  40.  
  41.             msr spsr_el3, x1
  42.  
  43.             ubfx     x0, x1, #MODE_EL_SHIFT, #2  //设定ARM核模式
  44.  
  45.             cmp x0, #MODE_EL3                      //比较x0寄存器中的值是否为MODE_EL3
  46.  
  47.             b.ne     unexpected_sync_exception   //如果x0中不是MODE_EL3，则产生异常
  48.  
  49.             bl  disable_mmu_icache_el3           //禁止MMU的指令cache
  50.  
  51.             tlbi     alle3
  52.  
  53.         #if SPIN_ON_BL1_EXIT
  54.  
  55.             bl  print_debug_loop_message
  56.  
  57.         debug_loop:
  58.  
  59.             b    debug_loop
  60.  
  61.         #endif
  62.  
  63.             mov x0, x20
  64.  
  65.             bl  bl1_plat_prepare_exit/
  66.  
  67.             /＊ 设定返回参数 ＊/
  68.  
  69.             ldp x6, x7, [x20, #(ENTRY_POINT_INFO_ARGS_OFFSET + 0x30)]
  70.  
  71.             ldp x4, x5, [x20, #(ENTRY_POINT_INFO_ARGS_OFFSET + 0x20)]
  72.  
  73.             ldp x2, x3, [x20, #(ENTRY_POINT_INFO_ARGS_OFFSET + 0x10)]
  74.  
  75.             ldp x0, x1, [x20, #(ENTRY_POINT_INFO_ARGS_OFFSET + 0x0)]
  76.  
  77.             eret                              //跳转到bl3x执行
  78.  
  79.         endfunc smc_handler64

在此安全监控模式调用处理过程中会将ARM核的状态切到EL3运行，即bl31是运行在EL3中的。

3 ATF中bl31的启动

在bl2中触发安全监控模式调用后会跳转到bl31中执行，bl31最主要的作用是建立EL3运行态的软件配置，在该阶段会完成各种类型的安全监控模式调用ID的注册和对应的ARM核状态的切换，bl31运行在EL3。bl31的执行流程如图所示。

图片

在这里插入图片描述

1. bl31_entrypoint函数

通过bl31.ld.S文件可知，bl31的入口函数是bl31_entrypoint。该函数的内容如下：

  1.         func bl31_entrypoint
  2.  
  3.         /＊
  4.  
  5.         el3初始化操作，该el3_entrypoint_common函数在上面已经介绍过，其中runtime_exceptions为
  6.  
  7.         el3 runtime software的异常向量表，内容定义在bl31/aarch64/runtime_exceptions.S文件中
  8.  
  9.         ＊/
  10.  
  11.         #if ! RESET_TO_BL31
  12.  
  13.             mov x20, x0
  14.  
  15.             mov x21, x1
  16.  
  17.             el3_entrypoint_common              \
  18.  
  19.                 _set_endian=0                   \
  20.  
  21.                 _warm_boot_mailbox=0          \
  22.  
  23.                 _secondary_cold_boot=0        \
  24.  
  25.                 _init_memory=0                  \
  26.  
  27.                 _init_c_runtime=1              \
  28.  
  29.                 _exception_vectors=runtime_exceptions
  30.  
  31.             mov x0, x20
  32.  
  33.             mov x1, x21
  34.  
  35.         #else
  36.  
  37.             el3_entrypoint_common              \
  38.  
  39.                 _set_endian=1                   \
  40.  
  41.                 _warm_boot_mailbox=! PROGRAMMABLE_RESET_ADDRESS    \
  42.  
  43.                   _secondary_cold_boot=! COLD_BOOT_SINGLE_CPU         \
  44.  
  45.                   _init_memory=1                  \
  46.  
  47.                   _init_c_runtime=1              \
  48.  
  49.                   _exception_vectors=runtime_exceptions
  50.  
  51.               mov x0, 0
  52.  
  53.               mov x1, 0
  54.  
  55.           #endif /＊ RESET_TO_BL31 ＊/
  56.  
  57.               bl  bl31_early_platform_setup    //平台架构相关的初始化设置
  58.  
  59.               bl  bl31_plat_arch_setup          //执行AArch初始化
  60.  
  61.               bl  bl31_main                       //跳转到bl31_main函数，执行该阶段需要的主要操作
  62.  
  63.               adr x0, __DATA_START__             //获取REE镜像的DATA段的起始地址
  64.  
  65.               adr x1, __DATA_END__               //获取REE镜像的DATA段的末端地址
  66.  
  67.               sub x1, x1, x0                      //计算镜像文件的大小
  68.  
  69.               bl  clean_dcache_range             //清空数据cache
  70.  
  71.               adr x0, __BSS_START__              //获取BSS段的起始地址
  72.  
  73.               adr x1, __BSS_END__                //获取BSS端的末端地址
  74.  
  75.               sub x1, x1, x0                      //计算BSS段的长度
  76.  
  77.               bl  clean_dcache_range             //清空数据cache
  78.  
  79.               //执行完成将跳转到bl33中执行，即执行BootLoader
  80.  
  81.               b    el3_exit
  82.  
  83.           endfunc bl31_entrypoint
2. bl31_main函数

该函数主要完成必要的初始化操作，注册EL3中各种安全监控模式调用的处理函数，以便在启动完成后响应在REE侧和TEE侧产生的安全监控模式调用。该函数的内容如下：

  1.         void bl31_main(void)
  2.  
  3.         {
  4.  
  5.             bl31_platform_setup();         //初始化相关驱动、时钟等
  6.  
  7.             bl31_lib_init();                //用于执行bl31软件中相关全局变量的初始化
  8.  
  9.             /＊初始化el3中的service，通过在编译时指定特定的section来确定哪些service会被作为el3
  10.  
  11.             service＊/
  12.  
  13.             runtime_svc_init();
  14.  
  15.             /＊  如果注册了TEE  OS支持，在调用完成run_service_init之后会使用TEE  OS的入口函数初
  16.  
  17.             始化bl32_init变量，然后执行对应的init函数，以OP-TEE为例，bl32_init将会被初始化成
  18.  
  19.             opteed_init，到此将会执行opteed_init函数来进入OP-TEE  OS的启动，当OP-TEE  OS启动完
  20.  
  21.             后，将会产生一个TEESMC_OPTEED_RETURN_ENTRY_DONE的smc异常，通知bl31已经完成了OP-
  22.  
  23.             TEE的启动＊/
  24.  
  25.             if (bl32_init) {
  26.  
  27.                 INFO("BL31: Initializing BL32\n");
  28.  
  29.                 (＊bl32_init)();
  30.  
  31.             }
  32.  
  33.             //准备跳转到bl33，在执行runtime_service时会运行一个spd service，该service的初始化
  34.  
  35.             函数将会去执行bl32的镜像来完成TEE OS初始化
  36.  
  37.             bl31_prepare_next_image_entry();
  38.  
  39.             console_flush();
  40.  
  41.             bl31_plat_runtime_setup();
  42.  
  43.         }

runtime_svc_init函数会将各种安全监控模式调用的处理函数的指针注册到EL3中，

并通过service-＞init函数来进行初始化，将TEE OS镜像的入口函数赋值给bl32_init，通过执行bl32_init指向的函数进入到TEE OS的启动过程。

待TEE OS启动完成之后就会去查找bl33的镜像文件，即REE侧的镜像文件，开始进入REE侧镜像的启动。

3. runtime_svc_init函数

该函数主要用来建立安全监控模式调用处理函数的索引表，并执行EL3中提供的服务项的初始化操作，获取TEE OS的入口地址并赋值给bl32_init变量，以备启动TEE OS。

而这些处理函数是通过DECLARE_RT_SVC宏定义被编译到镜像文件的rt_svc_descs段中的。

  1.         void runtime_svc_init(void)
  2.  
  3.         {
  4.  
  5.             int rc = 0, index, start_idx, end_idx;
  6.  
  7.             /＊判定rt_svc_descs段中service条数的是否超出MAX_RT_SVCS条＊/
  8.  
  9.             assert((RT_SVC_DESCS_END >= RT_SVC_DESCS_START) &&
  10.  
  11.                     (RT_SVC_DECS_NUM ＜ MAX_RT_SVCS));
  12.  
  13.             if (RT_SVC_DECS_NUM == 0)
  14.  
  15.                 return;
  16.  
  17.             /＊ 初始化t_svc_descs_indices数组中的数据成-1，表示当前所有的service无效＊/
  18.  
  19.             memset(rt_svc_descs_indices, -1, sizeof(rt_svc_descs_indices));
  20.  
  21.             /＊  获取第一条EL3  service在RAM中的起始地址，通过获取RT_SVC_DESCS_START的值来确定，
  22.  
  23.             该值在链接文件中有定义 ＊/
  24.  
  25.             rt_svc_descs = (rt_svc_desc_t ＊) RT_SVC_DESCS_START;
  26.  
  27.             /＊  遍历整个rt_svc_des段，将其call  type与rt_svc_descs_indices中的index建立对应
  28.  
  29.             关系 ＊/
  30.  
  31.             for (index = 0; index ＜ RT_SVC_DECS_NUM; index++) {
  32.  
  33.             rt_svc_desc_t ＊service = &rt_svc_descs[index];
  34.  
  35.                 /＊ 判定在编译时注册的service是否有效 ＊/
  36.  
  37.                 rc = validate_rt_svc_desc(service);
  38.  
  39.                 if (rc) {
  40.  
  41.                     ERROR("Invalid runtime service descriptor %p\n",
  42.  
  43.                         (void ＊) service);
  44.  
  45.                     panic();
  46.  
  47.                 }
  48.  
  49.                 /＊ 执行当前service的init的操作 ＊/
  50.  
  51.                 if (service->init) {
  52.  
  53.                     rc = service->init();
  54.  
  55.                     if (rc) {
  56.  
  57.                     ERROR("Error initializing runtime service %s\n",
  58.  
  59.                                   service->name);
  60.  
  61.                         continue;
  62.  
  63.                     }
  64.  
  65.                 }
  66.  
  67.                 /＊  根据该service的call  type以及start  oen来确定唯一的index，并且将该service
  68.  
  69.                 中支持的所有call type生成唯一的标识映射到同一个index中 ＊/
  70.  
  71.                 start_idx = get_unique_oen(rt_svc_descs[index].start_oen,
  72.  
  73.                         service->call_type);
  74.  
  75.                 assert(start_idx ＜ MAX_RT_SVCS);
  76.  
  77.                   end_idx = get_unique_oen(rt_svc_descs[index].end_oen,
  78.  
  79.                           service->call_type);
  80.  
  81.                   assert(end_idx ＜ MAX_RT_SVCS);
  82.  
  83.                   for (; start_idx ＜= end_idx; start_idx++)
  84.  
  85.                       rt_svc_descs_indices[start_idx] = index;
  86.  
  87.               }
  88.  
  89.           }
4. DECLARE_RT_SVC

该宏用来在编译时将EL3中的service编译进rt_svc_descs段中。该宏定义如下：

  1.         #define DECLARE_RT_SVC(_name, _start, _end, _type, _setup, _smch) \
  2.  
  3.             static const rt_svc_desc_t __svc_desc_ ## _name \
  4.  
  5.                 __section("rt_svc_descs") __used = { \
  6.  
  7.                     .start_oen = _start, \
  8.  
  9.                     .end_oen = _end, \
  10.  
  11.                     .call_type = _type, \
  12.  
  13.                     .name = #_name, \
  14.  
  15.                     .init = _setup, \
  16.  
  17.                     .handle = _smch }

该宏中的各种参数说明如下：

  • • □ start_oen：该service的起始内部编号；

  • • □ end.oen：该service的末尾编号；

  • • □ call_type：调用的smc的类型；

  • • □ name：该service的名字；

  • • □ init：该service在执行之前需要被执行的初始化操作；

  • • □ handle：当触发了call type的调用时调用的处理该请求的函数。

4 ATF中bl32的启动

bl31中的runtime_svc_init函数会初始化OP-TEE对应的服务，通过调用该服务项的初始化函数来完成OP-TEE的启动。对于OP-TEE的服务项会通过DECLARE_RT_SVC宏在编译时被存放到rt_svc_des段中。

该段中的init成员会被初始化成opteed_setup函数，由此开始进入到OP-TEE OS的启动。整个流程如图下所示。

图片

bl32执行流程

1. opteed_setup函数

该函数是ATF启动OP-TEE的入口函数，该函数会

  • • 查找到OP-TEE镜像的信息、

  • • 检查OP-TEE的入口函数指针是否有效、

  • • 设置OP-TEE运行的上下文，

  • • 然后调用OP-TEE的入口函数，

  • • 开始执行OP-TEE的启动。

该函数的内容如下：

  1.         int32_t opteed_setup(void)
  2.  
  3.         {
  4.  
  5.             entry_point_info_t ＊optee_ep_info;
  6.  
  7.             uint32_t linear_id;
  8.  
  9.             linear_id = plat_my_core_pos();  //获取当前core的ID
  10.  
  11.             /＊ 获取bl32(OP-TEE)镜像的描述信息 ＊/
  12.  
  13.             optee_ep_info = bl31_plat_get_next_image_ep_info(SECURE);
  14.  
  15.             if (! optee_ep_info) {
  16.  
  17.                 WARN("No OPTEE provided by BL2 boot loader, Booting device"
  18.  
  19.                     " without OPTEE initialization. SMC's destined for OPTEE"
  20.  
  21.                     " will return SMC_UNK\n");
  22.  
  23.                 return 1;
  24.  
  25.             }
  26.  
  27.             /＊ 检查OP-TEE镜像指定的PC地址是否有效 ＊/
  28.  
  29.             if (! optee_ep_info->pc)
  30.  
  31.                 return 1;
  32.  
  33.             opteed_rw = OPTEE_AARCH64;
  34.  
  35.             /＊ 初始化OP-TEE运行时CPU的smc上下文 ＊/
  36.  
  37.             opteed_init_optee_ep_state(optee_ep_info,
  38.  
  39.                         opteed_rw,
  40.  
  41.                         optee_ep_info->pc,
  42.  
  43.                         &opteed_sp_context[linear_id]);
  44.  
  45.             /＊ 使用opteed_init初始化bl32_init变量，以备在bl31中调用 ＊/
  46.  
  47.             bl31_register_bl32_init(&opteed_init);
  48.  
  49.             return 0;
  50.  
  51.         }
2. opteed_init函数

该函数的地址会被赋值给bl32_init变量，在bl31_main函数中会被调用，主要用来完成启动OP-TEE的设置。该函数内容如下：

  1.         static int32_t opteed_init(void)
  2.  
  3.         {
  4.  
  5.             uint32_t linear_id = plat_my_core_pos();
  6.  
  7.             //获取core的执行上下文变量
  8.  
  9.             optee_context_t ＊optee_ctx = &opteed_sp_context[linear_id];
  10.  
  11.             entry_point_info_t ＊optee_entry_point;
  12.  
  13.             uint64_t rc;
  14.  
  15.             /＊ 获取OPTEE image的信息 ＊/
  16.  
  17.             optee_entry_point = bl31_plat_get_next_image_ep_info(SECURE);
  18.  
  19.             assert(optee_entry_point);
  20.  
  21.             /＊ 使用optee image的entry point信息初始化CPU的上下文 ＊/
  22.  
  23.             cm_init_my_context(optee_entry_point);
  24.  
  25.             /＊ 开始设置CPU参数，最终会调用opteed_enter_sp函数执行跳转到OP-TEE的操作 ＊/
  26.  
  27.             rc = opteed_synchronous_sp_entry(optee_ctx);
  28.  
  29.             assert(rc ! = 0);
  30.  
  31.             return rc;
  32.  
  33.         }

5 REE侧镜像文件的启动

在bl31_main中启动完TEE OS之后通过调用bl31_prepare_next_image_entry函数来获取下一个阶段需要被加载的镜像文件，即REE侧的镜像文件，并配置好REE侧镜像的运行环境。

bl31_main执行完成之后会跳转到bl31_entrypoint中继续执行，计算出需要被加载的镜像文件的数据段大小和起始地址并清空BSS端中的数据，从EL3进入到EL1-NS开始执行REE侧的代码。

3 ATF启动过程小结

ATF作为最底层固件，OP-TEE OS、BootLoader、Linux内核的加载都是由ATF来完成的，而且ATF实现了安全引导的功能。

bl31运行于EL3，待系统启动完成后，在REE侧或TEE侧触发的安全监控模式调用（smc）都会进入bl31中被处理。

OP-TEE启动完成后会返回一个包含用于处理各种类型的安全监控模式调用的函数指针结构体变量，该变量会被添加到bl31的handle中，用于处理REE侧触发的安全监控模式调用。

bl2启动时通过触发安全监控模式调用通知bl1将CPU控制权限交给bl31, bl31通过解析特定段中是否存在OP-TEE的入口函数指针来确定是否需要加载OP-TEE。

OP-TEE启动后会触发安全监控模式调用重新进入到bl31中继续执行。

bl31通过查询链表的方式获取下一个需要被加载REE侧的镜像文件，并设定好REE侧运行时CPU的状态和运行环境，然后退出EL3进入REE侧镜像文件的启动，一般第一个REE侧镜像文件为BootLoader, BootLoader会加载Linux内核。

各芯片厂商的实际实现方法也不一样，但都会遵循链式验签的原则，由于ARMv8中引入ATF，其已完成了大部分的验签功能的开发，芯片厂商只需进行相应的调整就能实现完整的安全引导功能。

参考资料

  • • 1、http://www.5ityx.com/cate100/111266.html

  • • 2、https://blog.csdn.net/weixin_45264425/article/details/126643129

  • • 3、https://blog.csdn.net/weixin_45264425/article/details/126634498

  • • 4、https://blog.csdn.net/weixin_45264425/article/details/126634277

  • • 5、《可信应用开发指南》

  • • 6、https://www.cnblogs.com/arnoldlu/p/14332530.html

  • • 7、https://github.com/ARM-software/arm-trusted-firmware

  • • 8、https://github.com/Xilinx/arm-trusted-firmware

  • • 9、https://trustedfirmware-a.readthedocs.io/en/latest/

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/610038
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号