uboot引导kernel分析

最新推荐文章于 2024-08-19 20:15:36 发布
最新推荐文章于 2024-08-19 20:15:36 发布
阅读量967 收藏 1
点赞数
分类专栏： uboot学习 文章标签： uboot

原创地址：http://blog.chinaunix.net/uid-361890-id-3248478.html


uboot 2011.12, powerpc开发板
---------------------------------
1. 从common/cmd_bootm.c ----> do_bootm开始分析，因为多数启动都是用命令bootm kernel_add ramdisk_addr fdt_addr.

2. 先贴函数的代码：

点击(此处)折叠或打开

  1. int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  2. {
  3.     ulong iflag;
  4.     ulong load_end = 0;
  5.     int ret;
  6.     boot_os_fn *boot_fn;
  7. #ifdef CONFIG_NEEDS_MANUAL_RELOC
  8.     static int relocated = 0;

  10.     /* relocate boot function table */
  11.     if (!relocated) {
  12.         int i;
  13.         for (i = 0; i < ARRAY_SIZE(boot_os); i++)
  14.             if (boot_os[i] != NULL)
  15.                 boot_os[i] += gd->reloc_off;
  16.         relocated = 1;
  17.     }
  18. #endif

  20.     /* determine if we have a sub command */
  21.     if (argc > 1) {
  22.         char *endp;

  24.         simple_strtoul(argv[1], &endp, 16);
  25.         /* endp pointing to NULL means that argv[1] was just a
  26.          * valid number, pass it along to the normal bootm processing
  27.          *
  28.          * If endp is ':' or '#' assume a FIT identifier so pass
  29.          * along for normal processing.
  30.          *
  31.          * Right now we assume the first arg should never be '-'
  32.          */
  33.         if ((*endp != 0) && (*endp != ':') && (*endp != '#'))
  34. //此函数为bootm的子命令，在多核系统时，通常通过这些子命令来先动其它核，再启动0核
  35.             return do_bootm_subcommand(cmdtp, flag, argc, argv);
  36.     }
  37. //bootm_start准备内核，并检查内核的完整性
  38.     if (bootm_start(cmdtp, flag, argc, argv))
  39.         return 1;

  40. 点击(此处)折叠或打开

    1. static int bootm_start(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
    2. {
    3.     void *os_hdr;
    4.     int ret;

    6.     memset((void *)&images, 0, sizeof(images));
    7.     images.verify = getenv_yesno("verify");

    9. //设置内存信息，此内存信息会被传到linux kernel
    1.     bootm_start_lmb();

    3.     /* get kernel image header, start address and length */
    4. //获取kernel的bin文件，os_hdr是tftp或其它方式下载kernel到内存的地址，images_start是压缩kernel（zImage)的头地址,即uImage头地址+0x40，image_len是长度。
    5. ## Current stack ends at 0x3fe2dbc0
      *  kernel: cmdline image address = 0x01000000
       --- p1_p2_rdb_pc.c show_boot_progress 165 i:1
      ## Booting kernel from Legacy Image at 01000000 ...
       --- p1_p2_rdb_pc.c show_boot_progress 165 i:2
       --- p1_p2_rdb_pc.c show_boot_progress 165 i:3
         Image Name:   Linux-3.0.32-rt52-02290-g11251b1
         Created:      2012-06-06   6:44:40 UTC
         Image Type:   PowerPC Linux Kernel Image (gzip compressed)
         Data Size:    3470673 Bytes = 3.3 MiB
         Load Address: 00000000
         Entry Point:  00000000
         Verifying Checksum ... OK
       --- p1_p2_rdb_pc.c show_boot_progress 165 i:4
       --- p1_p2_rdb_pc.c show_boot_progress 165 i:5
       --- p1_p2_rdb_pc.c show_boot_progress 165 i:6
         kernel data at 0x01000040, len = 0x0034f551 (3470673)

    7.     os_hdr = boot_get_kernel(cmdtp, flag, argc, argv,
    8.             &images, &images.os.image_start, &images.os.image_len);
    9.     if (images.os.image_len == 0) {
    10.         puts("ERROR: can't get kernel image!\n");
    11.         return 1;
    12.     }

    14.     /* get image parameters */
    15.     switch (genimg_get_format(os_hdr)) {
    16.     case IMAGE_FORMAT_LEGACY: 
    17. //设置image的一些参数，从uImage的64字节头获取
    18.         images.os.type = image_get_type(os_hdr);
    19.         images.os.comp = image_get_comp(os_hdr);
    20.         images.os.os = image_get_os(os_hdr);

    22.         images.os.end = image_get_image_end(os_hdr);
    23.         images.os.load = image_get_load(os_hdr);
    24.         break;
    25. #if defined(CONFIG_FIT)
    26.     case IMAGE_FORMAT_FIT:
    27.         if (fit_image_get_type(images.fit_hdr_os,
    28.                     images.fit_noffset_os, &images.os.type)) {
    29.             puts("Can't get image type!\n");
    30.             show_boot_progress(-109);
    31.             return 1;
    32.         }

    34.         if (fit_image_get_comp(images.fit_hdr_os,
    35.                     images.fit_noffset_os, &images.os.comp)) {
    36.             puts("Can't get image compression!\n");
    37.             show_boot_progress(-110);
    38.             return 1;
    39.         }
    40.         if (fit_image_get_os(images.fit_hdr_os,
    41.                     images.fit_noffset_os, &images.os.os)) {
    42.             puts("Can't get image OS!\n");
    43.             show_boot_progress(-111);
    44.             return 1;
    45.         }

    47.         images.os.end = fit_get_end(images.fit_hdr_os);

    49.         if (fit_image_get_load(images.fit_hdr_os, images.fit_noffset_os,
    50.                     &images.os.load)) {
    51.             puts("Can't get image load address!\n");
    52.             show_boot_progress(-112);
    53.             return 1;
    54.         }
    55.         break;
    56. #endif
    57.     default:
    58.         puts("ERROR: unknown image format type!\n");
    59.         return 1;
    60.     }

    62.     /* find kernel entry point */
    63.     if (images.legacy_hdr_valid) {
    64.  //执行此处，因为64Byte头已经做好了备份，即复制到了另一个头结构体中。获取入口地址，通常为0x0.
    65.         images.ep = image_get_ep(&images.legacy_hdr_os_copy);
    66. #if defined(CONFIG_FIT)
    67.     } else if (images.fit_uname_os) {
    68.         ret = fit_image_get_entry(images.fit_hdr_os,
    69.                 images.fit_noffset_os, &images.ep);
    70.         if (ret) {
    71.             puts("Can't get entry point property!\n");
    72.             return 1;
    73.         }
    74. #endif
    75.     } else {
    76.         puts("Could not find kernel entry point!\n");
    77.         return 1;
    78.     }

    80.     if (images.os.type == IH_TYPE_KERNEL_NOLOAD) {
    81.         images.os.load = images.os.image_start;
    82.         images.ep += images.os.load;
    83.     }


    86.     if (((images.os.type == IH_TYPE_KERNEL) ||
    87.          (images.os.type == IH_TYPE_KERNEL_NOLOAD) ||
    88.          (images.os.type == IH_TYPE_MULTI)) &&
    89.         (images.os.os == IH_OS_LINUX)) { //执行此处，因为type == IH_TYPE_KERNEL, os == IH_OS_LINUX
    90.         /* find ramdisk */

    *  ramdisk: cmdline image address = 0x02000000
    ## Loading init Ramdisk from Legacy Image at 02000000 ...
     --- p1_p2_rdb_pc.c show_boot_progress 165 i:9
     --- p1_p2_rdb_pc.c show_boot_progress 165 i:10
       Image Name:   fsl-image-core-p2020rdb-20120406
       Created:      2012-04-06  11:43:16 UTC
       Image Type:   PowerPC Linux RAMDisk Image (gzip compressed)
       Data Size:    23085665 Bytes = 22 MiB
       Load Address: 00000000
       Entry Point:  00000000
       Verifying Checksum ... OK
     --- p1_p2_rdb_pc.c show_boot_progress 165 i:11
       ramdisk start = 0x02000040, ramdisk end = 0x036042a1

    1.         ret = boot_get_ramdisk(argc, argv, &images, IH_INITRD_ARCH,
    2.                 &images.rd_start, &images.rd_end);
    3.         if (ret) {
    4.             puts("Ramdisk image is corrupt or invalid\n");
    5.             return 1;
    6.         }

    8. #if defined(CONFIG_OF_LIBFDT)
    9.         /* find flattened device tree */

    //*  fdt: cmdline image address = 0x00c00000
    ## Checking for 'FDT'/'FDT Image' at 00c00000
    Wrong FIT format: no description
    *  fdt: raw FDT blob
    ## Flattened Device Tree blob at 00c00000
       Booting using the fdt blob at 0x00c00000
       of_flat_tree at 0x00c00000 size 0x000032e8

    1.         ret = boot_get_fdt(flag, argc, argv, &images,
    2.                    &images.ft_addr, &images.ft_len);
    3.         if (ret) {
    4.             puts("Could not find a valid device tree\n");
    5.             return 1;
    6.         }

    8.         set_working_fdt_addr(images.ft_addr);
    9. #endif
    10.     }

    12.     images.os.start = (ulong)os_hdr;
    13.     images.state = BOOTM_STATE_START;

    15.     return 0;
    16. }


点击(此处)折叠或打开

  1. iflag = disable_interrupts();

  3. #if defined(CONFIG_CMD_USB)
  4.     /*
  5.      * turn off USB to prevent the host controller from writing to the
  6.      * SDRAM while Linux is booting. This could happen (at least for OHCI
  7.      * controller), because the HCCA (Host Controller Communication Area)
  8.      * lies within the SDRAM and the host controller writes continously to
  9.      * this area (as The HccaFrameNumber is for example
  10.      * updated every 1 ms within the HCCA structure in For more
  11.      * details see the OpenHCI specification.
  12.      */
  13.     usb_stop();
  14. #endif
  15.   
  16.  // 解压缩内核镜相文件，   
  17. Uncompressing Kernel Image ... OK
       kernel loaded at 0x00000000, end = 0x006c3b00
     --- p1_p2_rdb_pc.c show_boot_progress 165 i:7

  1.     ret = bootm_load_os(images.os, &load_end, 1);

  3.     if (ret < 0) { //加载kernel的错误处理
  4.         if (ret == BOOTM_ERR_RESET)
  5.             do_reset(cmdtp, flag, argc, argv);
  6.         if (ret == BOOTM_ERR_OVERLAP) {
  7.             if (images.legacy_hdr_valid) {
  8.                 image_header_t *hdr;
  9.                 hdr = &images.legacy_hdr_os_copy;
  10.                 if (image_get_type(hdr) == IH_TYPE_MULTI)
  11.                     puts("WARNING: legacy format multi "
  12.                         "component image "
  13.                         "overwritten\n");
  14.             } else {
  15.                 puts("ERROR: new format image overwritten - "
  16.                     "must RESET the board to recover\n");
  17.                 show_boot_progress(-113);
  18.                 do_reset(cmdtp, flag, argc, argv);
  19.             }
  20.         }
  21.         if (ret == BOOTM_ERR_UNIMPLEMENTED) {
  22.             if (iflag)
  23.                 enable_interrupts();
  24.             show_boot_progress(-7);
  25.             return 1;
  26.         }
  27.     }

//把kernel解压后所占的内在预留起来，以免其它程序再用，此参数会传到kernel里

  1.     lmb_reserve(&images.lmb, images.os.load, (load_end - images.os.load));

  3.     if (images.os.type == IH_TYPE_STANDALONE) { //不会执行此处
  4.         if (iflag)
  5.             enable_interrupts();
  6.         /* This may return when 'autostart' is 'no' */
  7.         bootm_start_standalone(iflag, argc, argv);
  8.         return 0;
  9.     }

  11.     show_boot_progress(8);

  13. #ifdef CONFIG_SILENT_CONSOLE
  14.     if (images.os.os == IH_OS_LINUX)
  15.         fixup_silent_linux();
  16. #endif
  17. //获取kernel启动函数，此处为：do_bootm_linux，因为images.os.os==5
  18.     boot_fn = boot_os[images.os.os];

  20.     if (boot_fn == NULL) {
  21.         if (iflag)
  22.             enable_interrupts();
  23.         printf("ERROR: booting os '%s' (%d) is not supported\n",
  24.             genimg_get_os_name(images.os.os), images.os.os);
  25.         show_boot_progress(-8);
  26.         return 1;
  27.     }

  29.     arch_preboot_os();

  31.     boot_fn(0, argc, argv, &images);
  32. ------------->不会执行到这里，因为boot_fn函数会启动kernel

  34.     show_boot_progress(-9);
  35. #ifdef DEBUG
  36.     puts("\n## Control returned to monitor - resetting...\n");
  37. #endif
  38.     do_reset(cmdtp, flag, argc, argv);

  40.     return 1;
  41. }
3. boot_fn实际上是do_bootm_linux，接下来分析此函数：


点击(此处)折叠或打开

  1. __attribute__((noinline))
  2. int do_bootm_linux(int flag, int argc, char * const argv[], bootm_headers_t *images)
  3. {
  4.     int ret;

  6.     if (flag & BOOTM_STATE_OS_CMDLINE) {
  7.         boot_cmdline_linux(images);
  8.         return 0;
  9.     }

  11.     if (flag & BOOTM_STATE_OS_BD_T) {
  12.         boot_bd_t_linux(images);
  13.         return 0;
  14.     }

  16.     if (flag & BOOTM_STATE_OS_PREP) {
  17.         boot_prep_linux(images);
  18.         return 0;
  19.     }

  21.     if (flag & BOOTM_STATE_OS_GO) {
  22.         boot_jump_linux(images);
  23.         return 0;
  24.     }
  25. //以上flag的处理多数是为多核准备的。

  27.     boot_prep_linux(images); //flush 相关的cache, 此时cache的数据对内核没用
  28. //分配内存给命令行参数，板子信息，DTB信息等
  29.     ret = boot_body_linux(images);
  30.     if (ret)
  31.         return ret;
  32.     boot_jump_linux(images);

  34.     return 0;
  35. }

点击(此处)折叠或打开

  1. static void boot_jump_linux(bootm_headers_t *images)
  2. {
  3.     void (*kernel)(bd_t *, ulong r4, ulong r5, ulong r6,
  4.               ulong r7, ulong r8, ulong r9);
  5. #ifdef CONFIG_OF_LIBFDT
  6.     char *of_flat_tree = images->ft_addr;
  7. #endif
  8. //获取kernel入口地址，通常为0x0.
  9.     kernel = (void (*)(bd_t *, ulong, ulong, ulong,
  10.                ulong, ulong, ulong))images->ep;
  11.     printf("## Transferring control to Linux (at address %08lx) ...\n",
  12.         (ulong)kernel);

  14.     show_boot_progress (15);

  16. #if defined(CONFIG_SYS_INIT_RAM_LOCK) && !defined(CONFIG_E500)
  17.     unlock_ram_in_cache();
  18. #endif

  20. #if defined(CONFIG_OF_LIBFDT) //执行此处
  21.     if (of_flat_tree) { /* device tree; boot new style */
  22.         /*
  23.          * Linux Kernel Parameters (passing device tree):
  24.          * r3: pointer to the fdt
  25.          * r4: 0
  26.          * r5: 0
  27.          * r6: epapr magic
  28.          * r7: size of IMA in bytes
  29.          * r8: 0
  30.          * r9: 0
  31.          */
  32. #if defined(CONFIG_MPC85xx) || defined(CONFIG_440)
  33.  #define EPAPR_MAGIC (0x45504150)
  34. #else
  35.  #define EPAPR_MAGIC (0x65504150)
  36. #endif

  38.         printf(" Booting using OF flat tree...\n");
  39.         WATCHDOG_RESET ();
  40. //开始执行内核代码
  41.         (*kernel) ((bd_t *)of_flat_tree, 0, 0, EPAPR_MAGIC,
  42.                getenv_bootm_mapsize(), 0, 0);
  43.         /* does not return */
  44.     } else


uboot验签kernel的实现
个人学习记录
12-26 1798
本文介绍uboot启动linux内核时，开启对kernel的签名认证功能，防止kernel和device tree被任意修改。fitimage本质上是dtb类型的结构，可用于打包不同的数据到一个文件中。这样做也是为了方便SecureBoot的实现，方便对kernel,system.dtb,rootfs进行RSA签名和认证。《u-boot FIT image介绍》提供了详细的结构解析，以及如何制作的命令。fitimage格式支持存储镜像的hash值，并且在加载镜像时会校验hash值。
如何显示Uboot版本和Kernel版本
joeyaung_1983的专栏
12-31 3152
显示Uboot版本（环境变量的定义特定平台可能会有差别） ： 1.uboot代码中增加版本的环境变量：setenv("ubootversion","XXXXXXXXXXXXX"); 2.system.prop 中最后添加：ubootenv.var.ubootversion= 3.应用层调用：String ubootVersion= SystemProperties.get("ubootenv
uboot验证内核镜像是否有效
500
05-23 3480
校验流程这块也不算复杂，后面整理好了之后，一并上传。 下面是u-boot的实验log: zImage的校验方式zImage的第37-40个字节存放这zImage的 “魔数” 依据 : 路径 : uboot/common/cmd_bootm.c 函数 : do_bootm( ) ;#ifdef CONFIG_ZIMAGE_BOOT
uboot到kernel的过程
wmdshhzsmile的博客
11-19 2159
这里有几篇我感觉写的很好的大牛博客 https://blog.youkuaiyun.com/itxiebo/article/details/50986253 https://blog.youkuaiyun.com/itxiebo/article/details/50990074 https://blog.youkuaiyun.com/czg13548930186/article/details/76383153 ...
UBOOT--启动内核
qq_52916060的博客
12-29 2811
uboot和内核到底是什么？ uboot是一个裸机程序 （1）复杂的裸机程序，和ARM裸机中学习的裸机程序没有本质区别 内核本省也是一个"裸机程序" （1）操作系统本身就是一个裸机程序，和uboot，和其他裸机程序并没有本质区别 （2）区别就是操作系统运行起来后再软件上分为内核层和应用层，分层后两层的权限不同，内存访问和设备操作的管理上更加精细（内核可以随便访问各种硬件，而应用程序只能被限制的访问的硬件和内存地址） uboot的镜像是uboot.bin，linux系统的镜像是zImage，这两个东西其实都是
uboot启动kernel使用命令过程分析
tang_vincent的博客
03-11 2729
为了让读者知道本文介绍的知识点在uboot所在位置，在介绍之前，先简单回顾下uboot的启动流程。.......SECTIONS#endif.text :*(.text*)........_start:/**/#elseb reset#endif分析该文件，做了一些列初始化，包括为C环境做的准备等，主要跳转了两个函数：board_init_f 和 board_init_r。
riscv_uboot程序运行架构分析
04-21
**RISC-V UBoot程序运行架构分析** 在深入探讨RISC-V UBoot程序运行架构之前，我们首先要理解几个关键概念。RISC-V是一种开放源代码的指令集架构（ISA），以其精简、高效的设计理念而受到业界的广泛关注。UBOOT，...
嵌入式 uboot引导kernel，kernel引导fs
skdkjxy的专栏
10-31 1609
1、引导的起始点 u-boot中有个bootm命令，它可以引导内存中的应用程序映像（Kernel），bootm命令对应 common/cmd_bootm.c中的do_bootm（）函数，此函数实现下面几个功能： 1）读flash中的内核映像文件 2) 解压内核 3）校验内核 4）跳到内核执行（调用do_bootm_linux（）函数）
飞腾uboot的分析
10-22
飞腾 U-BOOT 分析 U-BOOT 是一种开源的引导加载器，广泛应用于嵌入式系统中。飞腾 U-BOOT 是基于飞腾芯片的 U-BOOT 开发讲解，本文档将对飞腾 U-BOOT 的分析进行详细讲解。 一、飞腾 U-BOOT 概述 飞腾 U-BOOT 是...
uboot-1.1.6加载linux kernel内核过程
最新发布
哈米的博客
08-19 660
uboot-1.1.6加载linux kernel内核过程
uboot如何启动内核
qq_41719582的博客
09-04 737
uboot和内核是什么 uboot就是一个裸机程序 uboot本质就是一个复杂的裸机程序 内核本质也是一个“裸机程序” 操作系统内核本质上与uboot和其他裸机程序没什么不同。 区别就是操作系统运行起来后在软件上分为内核层和应用层，分层后两层的权限不同，内存 内存访问和设备操作的管理上更加精细（内核可以随便访问各种硬件，而应用程序只能被限制的访问硬件和内存地址） 直观来看：uboot的镜像是u-boot.bin，Linux系统的镜像是zImage，这两个东西都是其实都是裸机程序镜像。从系统的启动角
U-boot(五):启动内核
tyro_wzp的博客
11-26 1238
LINUX_ZIMAGE_MAGIC是魔数(0x016f2818)来表示zImage,即zImage格式镜像在头部存放该数作为标记辨别它是否是zImage(是否等于LINUX_ZIMAGE_MAGIC),若为在Image则对头部信息改造,用头信息初始化images,完成了校验。运行镜像过程:读取头信息MAGIC_NUM来确定镜像种类,镜像校验,读取头信息获取镜像信息(镜像长度,种类,入口地址),去entrypoint处运行镜像。
Linux-uboot-学习笔记（8）：uboot启动内核
qq_42826337的博客
03-27 4016
Linux-uboot-学习笔记（8）：uboot启动内核 uboot启动的第二阶段主要是执行第一阶段跳转到的start_armboot函数，该BL2阶段在DDR中初始化第一阶段未完成的任务和SoC各种外设。 start_armboot函数分析 start_armboot函数位于Board.c文件中，从文件名可以看出，该函数主要针对板级初始化的。 定义全局变量数据结构体（70） ...
[uboot] uboot启动kernel篇（三）——uboot解析uImage的kernel信息
ooonebook的博客
12-09 8949
bootm启动kernel的过程中解析Legacy-uImage的原理和流程。 bootm启动kernel的过程中解析FIT-uImage的原理和流程。
uboot之内核启动
qq_35480173的博客
10-12 596
uboot的最终目的就是用来启动内核，对于我们Inand版本的X210开发板来说，在uboot命令行执行bootm命令时，就去启动内核。那么uboot背后的机制是怎么样的呢？当我们输入bootm命令的时候，uboot会执行do_bootm函数。启动内核我们需要做的几件事情： step1:将内核从外部介质（SD卡、iNand等）中重定位到内存的相应位置 step2：进行内核镜像种类的识别（zIm...
linux uboot启动内核,uboot如何启动内核
weixin_42298424的博客
04-30 470
uboot和内核的本质uboot的本质是一个裸机程序，操作系统内核本质也是裸机程序。区别就是操作系统运行起来后，在软件上分为内核层和应用层，分层后两层的权限不同，内存访问和设备操作的管理更加精细(内核可以随便访问各种硬件，而应用程序只能被限制地访问硬件和内存地址)。直观来看，uboot的镜像是uboot.bin，Linux系统的镜像是zImage，这两个东西其实都是两个裸机程序镜像，从系统启动的角...
uboot启动内核笔记
chegxy的博客
02-09 866
uboot启动内核过程
uboot linux内核传递参数,linux驱动之uboot启动过程及参数传递
weixin_39636102的博客
04-29 635
前言一直以来都在学习和开发嵌入式linux，但对于一些常用的工具和机制却不甚了解，包括今天要说的uboot引导和启动linux内核，最近打算启动技术博客来学习和记录探索这些过程中所获得的知识。从事嵌入式linux开发的人应该都知道uboot，支持多种操作系统，多种硬件平台的uboot在嵌入式linux界可是大名鼎鼎，我们今天就来谈一谈uboot如何启动内核。这里我们不提供代码，仅给出相关的关键结构...
UBOOT启动到KERNEL流程解析
UBOOT引导过程 **初始化阶段：** - 硬件设备初始化：UBOOT首先会进行硬件设备的初始化，包括对内存、串口、时钟、I/O端口等进行设置。 - 自检：然后进行自检（Self Check），即上电自检（POST），以确保系统基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值