u-boot启动内核

最新推荐文章于 2023-06-16 12:51:53 发布
最新推荐文章于 2023-06-16 12:51:53 发布
阅读量295 收藏 1
点赞数
文章标签： linux 嵌入式 uboot java 内核
原文链接：https://blog.csdn.net/czg13548930186/article/details/76383153
版权

转载自：https://blog.csdn.net/czg13548930186/article/details/76383153

一、我们从上一节命令解析可以知道，u-boot启动启动Linux内核有两种方法：

第一种u-boot等待无空格按下自启内核：
 s = getenv ("bootcmd");
    if (bootdelay >= 0 && s && !abortboot (bootdelay)) {
        ......
        run_command (s, 0);
        ......
        }
  
  

  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
第二种在u-boot控制台输入boot命令启动:
int do_bootd (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
    int rcode = 0;
#ifndef CFG_HUSH_PARSER
    if (run_command (getenv ("bootcmd"), flag) < 0) rcode = 1;
#else
    if (parse_string_outer(getenv("bootcmd"),
        FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP) != 0 ) rcode = 1;
#endif
    return rcode;
}

U_BOOT_CMD(
boot, 1, 1, do_bootd,
“boot - boot default, i.e., run ‘bootcmd’\n”,
NULL
);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

这两种方式本质上都是一样的，通过最终调用run_command(bootcmd)来启动

比如我这里bootcmd=nand read.jffs2 0x30007FC0 kernel; bootm 0x30007FC0

二、nand read.jffs2解析

在run_command中会将命令分离并找对应的处理函数。

第一条命令是从调用(do_nand)把内核把读到到一个地址上去；第二条命令是从内核里面调用相应的函数(do_bootm)来启动内核；
① 在哪里来读
  • 从哪里读？从kernel分区读；
  • 读到哪里去？放到指定地址(0x30007fc0)去；
  • 在PC机上，每一个硬盘前面都有一个分区表。对于嵌入式Linux来说，flash上面没有分区表，显然这个分区就和PC机上不一样；既然没有分区表，这些分区怎么体现？只能在源码里面写死的；
定义分区的源码如下：(include\configs\100ask24x0.h)
#define MTDIDS_DEFAULT "nand0=nandflash0"
#define MTDPARTS_DEFAULT "mtdparts=nandflash0:256k@0(bootloader)," \
                            "128k(params)," \
                            "2m(kernel)," \
                            "-(root)"
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

这里写图片描述

上面定义了各个分区的起始地址；
② 通过什么读

在/common/cmd_nand.c中do_nand函数中

/* read write */
 if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0)
 
 

 
 
  • 1
  • 2

三、bootm 0x30007FC0解析

① 在/common/cmd_bootm.c中do_bootm函数中启动内核。启动内核的时候，首先对内核的头部要进行操作，原因是在Flash中保存的内核是由两部分构成的，第一部分是头部，第二部分是真正的内核。而头部的结构如下：
typedef struct image_header {
    uint32_t    ih_magic;    /* Image Header Magic Number    */
    uint32_t    ih_hcrc;    /* Image Header CRC Checksum    */
    uint32_t    ih_time;    /* Image Creation Timestamp    */
    uint32_t    ih_size;    /* Image Data Size        */
    uint32_t    ih_load;    /* Data     Load  Address        */
    uint32_t    ih_ep;        /* Entry Point Address        */
    uint32_t    ih_dcrc;    /* Image Data CRC Checksum    */
    uint8_t        ih_os;        /* Operating System        */
    uint8_t        ih_arch;    /* CPU architecture        */
    uint8_t        ih_type;    /* Image Type            */
    uint8_t        ih_comp;    /* Compression Type        */
    uint8_t        ih_name[IH_NMLEN];    /* Image Name        */
} image_header_t;
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
    ih_load是加载地址
    ih_ep是入口地址

下面要开始分析如何启动内核,主要是do_bootm函数:

int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])  
{  
    ......  
    image_header_t *hdr = &header;  //uimage 是内核加了一个4K的头部，这个头部的内容是按照结构体image_header_t来放在，是image传递给Uboot的信息。  
    ......  
    if (argc < 2) {  
        addr = load_addr;   //如果bootm的参数小于2 则使用默认的加载地址  
    } else {  
        addr = simple_strtoul(argv[1], NULL, 16);  
    }  
    ......  
    switch (hdr->ih_comp) {  
    case IH_COMP_NONE:  
        if(ntohl(hdr->ih_load) == addr) {      
/* 
    这里判断“uimage头部里指定的加载地址”与bootm指定的加载地址是否相等，不相等则需要移动 
    判断的方式有两种 
    1、判断 uimage头部里指定的加载地址 == bootm指定的加载地址 (hdr->ih_load == addr) 
    此时： 
        实际存放的地址  == uimage加载地址 == uimage连接地址-64字节 
        bootm == 实际存放的地址 
    例子： 
        实际存放在  0x30007fc0 
        bootm       0x30007fc0 
        加载地址    0x30007fc0 
        连接地址    0x30008000 
        1、uboot根据Bootm指定的0x30007fc0去找image，实际地址为0x30007fc0，找到头部 
        2、读出头部里的加载地址，判断是否和Bootm相等，相等则不移动，启动 
    2、判断 uimage头部里指定的加载地址 == bootm指定的加载地址 + 64字节 (hdr->ih_load == addr+64字节/data) 
    此时：  
        实际存放地址+64字节 == uimage加载地址 == uimage连接地址 
        bootm == 实际存放的地址 
    例子：  
        实际存放在  0x30007fc0 
        bootm       0x30007fc0 
        加载地址    0x30008000 
        连接地址    0x30008000 
        1、uboot根据Bootm指定的0x30007fc0去找image，实际地址为0x30007fc0，找到头部 
        2、读出头部里的加载地址，判断是否和Bootm + 字节相等，相等则不移动，启动 

首先bootm的地址要和我们 实际存放(不管它的加载地址是多少) 整个uimage的首地址吻合，这样就可以找到头部。 
这里存在两种情况，我们可以看到 Uboot源码里 
1、 hdr-&gt;ih_load == addr  
也就是说判断的是bootm_addr 与uimage里的ih_load加载地址是否相等，这样的话，我们在制作uimage的时候就应该让ih_load=bootmaddr 
那么uimage里的另一个参数，连接地址就应该等于bootm+64字节 
2、hdr-&gt;ih_load == addr+64字节  友善以及韦东山老师的uboot里判断条件都被改成了这样 
那么，uimage里的Load地址和连接地址应该相等，等于bootm+64字节

*/
printf (" XIP %s … ", name);
} else {
….do_bootm_linux (cmdtp, flag, argc, argv,addr, len_ptr, verify);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

总结：do_bootm有两个作用：
作用1：读取内核头部将内核移动到合适地方，还有一些校验
作用2：启动内核，用的是do_bootm_linux函数。在跳到ih_ep入口之前还要uboot设置内核启动参数，然后才是跳到ih_ep启动内核。
② do_bootm_linux函数有用的代码如下：
//uboot参数设置
#if defined (CONFIG_SETUP_MEMORY_TAGS) || \  
    defined (CONFIG_CMDLINE_TAG) || \
    defined (CONFIG_INITRD_TAG) || \
    defined (CONFIG_SERIAL_TAG) || \
    defined (CONFIG_REVISION_TAG) || \
    defined (CONFIG_LCD) || \
    defined (CONFIG_VFD)
 setup_start_tag (bd);
#ifdef CONFIG_SERIAL_TAG
 setup_serial_tag (&params);
#endif
#ifdef CONFIG_REVISION_TAG
 setup_revision_tag (&params);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
 setup_memory_tags (bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
 setup_commandline_tag (bd, commandline);
#endif
#ifdef CONFIG_INITRD_TAG
 if (initrd_start && initrd_end)
  setup_initrd_tag (bd, initrd_start, initrd_end);
#endif
#if defined (CONFIG_VFD) || defined (CONFIG_LCD)
 setup_videolfb_tag ((gd_t *) gd);
#endif
 setup_end_tag (bd);
#endif

printf ("\nStarting kernel …\n\n");

//启动内核
theKernel (0, bd->bi_arch_number, bd->bi_boot_params);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

theKernel定义：theKernel = (void (*)(int, int, uint))ntohl(hdr->ih_ep);

总结：do_bootm_linux有两个作用：
作用1：设置内核启动参数，参数的格式是tag（标记列表），对于韦东山的开发板标记列表开始地址是0x30000100，一般来说有四个标记传参函数。setup_start_tag (bd);setup_memory_tags (bd);setup_commandline_tag (bd, commandline);setup_end_tag (bd);
作用2：跳到入口地址去是
theKernel = (void (*)(int, int, uint))ntohl(hdr->ih_ep); 
theKernel (0, bd->bi_arch_number, bd->bi_boot_params); 
 
 

 
 
  • 1
  • 2
这样就启动内核了！！！

我们再来分析一下theKernel的三个参数 (0, bd->bi_arch_number, bd->bi_boot_params);

第一个参数是固定的

通过看来自于linux-2.6.30.4\Documentation\arm\Booting：
这里写图片描述

第二个参数是机器类型ID

看board\100ask24x0\100ask24x0.c

这里写图片描述

第三个参数是标记列表的开始地址

看board\100ask24x0\100ask24x0.c
这里写图片描述

1.启动标记：
setup_start_tag：

static void setup_start_tag (bd_t *bd)
{
 params = (struct tag *) bd->bi_boot_params;

params->hdr.tag = ATAG_CORE;
params->hdr.size = tag_size (tag_core);

params->u.core.flags = 0;
params->u.core.pagesize = 0;
params->u.core.rootdev = 0;

params = tag_next (params);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

由代码可以得到tag是一个结构体，bi_boot_params为0x300000100,ATAG_CORE为54410001

2.内存标记：
setup_memory_tag：

#ifdef CONFIG_SETUP_MEMORY_TAGS
static void setup_memory_tags (bd_t *bd)
{
 int i;

for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
params->hdr.tag = ATAG_MEM;
params->hdr.size = tag_size (tag_mem32);

params->u.mem.start = bd->bi_dram[i].start;
params->u.mem.size = bd->bi_dram[i].size;

params = tag_next (params);
}
}
#endif

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

bi_dram[i].start;内存的初始地址,bi_dram[i].start;内存的大小
这两个参数的初始值在start_armboot()函数中dram_init可以设置。

3.命令行标记：

static void setup_commandline_tag (bd_t *bd, char *commandline)
{
 char *p;

if (!commandline)
return;

把命令前面的空格给干掉
for (p = commandline; *p == ’ '; p++);

if (*p == ‘\0’)
return;

params->hdr.tag = ATAG_CMDLINE;
params->hdr.size =
(sizeof (struct tag_header) + strlen § + 1 + 4) >> 2;

strcpy (params->u.cmdline.cmdline, p);

params = tag_next (params);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

*commandlinechar的来源为*commandline = getenv ("bootargs");
　　那么在终端所获得的信息是bootargs=noinitrd root=/dev/mtdblock3 init=/linuxrc console=ttySAC0
　　root=/dev/mtdblock3 　　根文件系统在Flash中的第三分区
　　init=/linuxrc 　　　　　　 第一个进程为linuxrc
　　console=ttySAC0　　　　 内核打印信息从串口输出

4.结束标记：
setup_end_tag：

static void setup_end_tag (bd_t *bd)
{
 params->hdr.tag = ATAG_NONE;
 params->hdr.size = 0;
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

参数设置结束的时候将tag设置为空，size设置为0.

三、总结：

这里写图片描述

qq_45166299
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
uboot启动内核
heyunpign的博客
11-23 219
文章目录启动内核的第一阶段 启动内核的第一阶段
(六) u-boot 启动内核解析
Linux Openharmony Android Graphics Stack!
07-30 3783
一、我们从上一节命令解析可以知道，u-boot启动启动Linux内核有两种方法：第一种u-boot等待无空格按下自启内核： s = getenv ("bootcmd"); if (bootdelay >= 0 && s && !abortboot (bootdelay)) { ...... run_command (s, 0); ......
uboot学习之五-----uboot如何启动Linux内核
weixin_34129696的博客
05-15 469
uboot和内核到底是什么？uboot实质就是一个复杂的裸机程序；uboot可以被配置也可以做移植；操作系统内核本身就是一个裸机程序，和我们学的uboot和其他裸机程序没有本质的区别；区别就是我们操作系统运行起来后可以分为应用层和内核层，分层后，两层的权限不同，内存访问和设备操作的管理上更加精细(内核可以随便方位各种硬件，而应用程序只能被限制的访问硬件和内存地址)直观来看：uboot的镜像是u-b...
uboot命令行启动kernel
motianjie的博客
06-16 614
1：开机停留在uboot界面，即uboot处于board_r.c中的run_main_loop()的死循环中。2：确保rootfs,kernel和dts已烧写在emmc或者sd卡。
U-Boot启动参数解析
01-14
在 U-Boot 启动参数中，我们可以使用 `nboot` 命令加载 NAND FLASH 中的 uImage 内核文件，并使用 `setenv` 命令设置从 NAND FLASH 中加载 ubifs 格式文件系统。 SPI FLASH U-Boot 启动参数中，SPI FLASH 是指 U-...
RISC-V U-Boot启动流程图.pdf
06-01
总结来看，RISC-V U-Boot启动流程涵盖了从硬件的低级初始化，到建立运行时环境，再到进入主循环等待用户输入或自动引导进入操作系统。这个流程涉及了多个关键步骤，包括硬件初始化、阶段标记、环境设置、命令处理...
u-boot启动完全分析_u-boot启动完全分析_
09-29
《u-boot启动完全分析》 u-boot，全称Micro Bootstrap Loader，是嵌入式系统中常用的引导加载程序，它的主要任务是在系统上电或复位后执行，为操作系统（如Linux）提供初始化硬件、加载内核映像以及传递启动参数等...
U-Boot启动参数详解
11-15
4. **SPI FLASH**: 若无法从NAND FLASH启动内核镜像，U-Boot会继续检查是否有SPI FLASH存在。如果有SPI FLASH，U-Boot将尝试加载SPI FLASH中的内核镜像和NAND FLASH中的文件系统。 **部分关键环境变量解释：** - `...
U-Boot源码解析龙芯版
最新发布
11-10
U-Boot是一款广泛使用的开源嵌入式系统固件，其主要任务是加载并运行操作系统内核，是操作系统启动过程中的关键组成部分。 在【源码目录】部分，书中指出U-Boot的源码可以从官方GitHub仓库获取，但目前官方版本尚未...
Linux-uboot-学习笔记（8）：uboot启动内核
01-20
Linux-uboot-学习笔记（8）：uboot启动内核 uboot启动时，在执行到theKernel指针时即跳转到内核执行，也就标志着uboot的结束。在此之前uboot要进行内核启动的最后准备：从内核镜像的部署位置将内核搬移到DDR中，校验内核格式，准备内核传的参数，跳转到theKernel去执行内核。 一、uboot内核是什么 内核实质上是一个大的、复杂的“裸机程序”，和uboot、和其他裸机程序并没有本质区别。 区别就是操作系统运行起来后在软件上分为内核层和应用层，分层后两层的权限不同，内存访问和设备操作的管理上更加精细（内核可以随便访问各种硬件，而应用程序只能被限制的访问硬件和内存
Uboot 启动内核过程
weixin_40519342的博客
09-29 215
声明：参照韦东山老师的课程对Uboot的启动过程进行了大致得了解，现对UBoot的启动过程进行记录 有关Uboot的程序，我们可以将其看成一个较为复杂的单片机程序。 Uboot程序的主要目的：启动内核； 过程： （1）完成相关硬件的初始化，CPU的工作模式设为管理模式、关闭看门狗，关闭MMU、CACHE。 （2）初始化RAM空间，之后进行代码重定位。 （3）对即将用到的硬件设备进行初始化，包括系统...
uboot如何启动内核？
T9-MUSHAN的博客
04-22 1344
uboot如何启动内核？   1、操作系统运行起来后分为两内核层和应用层。两层的权限不同，内核可以直接访问硬件，而应用层对硬件的访问遭到了限制。 (uboot的镜像是u-boot.bin，Linux的镜像是zImage) 2、SD卡中的特定分区 在没有上电时，bootloader（引导区）、kernel（内核）、rootfs（文件系统）等必要
u-boot分析__uboot启动内核
cumtchw
02-28 2034
uboot启动内核时依赖于两个函数， s = getenv("bootcmd")获取环境变量，然后去运行命令，其中s就是这里的 这条命令的意思是，从nandflash上面的kernel分区把内核读到ox30007FC0地址，然后从这个地址启动。 分区的概念：在我们的PC上，每个硬盘前面会有一个分区表，但是在嵌入式Linux里面，Flash是没有分区表的，那我们的flash里面的boot env kernel 跟文件系统这些分区只能在源码中写死，所以我们不关心falsh里面这些分区的名字，而是这
UBOOT--启动内核
qq_52916060的博客
12-29 2623
uboot和内核到底是什么？ uboot是一个裸机程序 （1）复杂的裸机程序，和ARM裸机中学习的裸机程序没有本质区别 内核本省也是一个"裸机程序" （1）操作系统本身就是一个裸机程序，和uboot，和其他裸机程序并没有本质区别 （2）区别就是操作系统运行起来后再软件上分为内核层和应用层，分层后两层的权限不同，内存访问和设备操作的管理上更加精细（内核可以随便访问各种硬件，而应用程序只能被限制的访问的硬件和内存地址） uboot的镜像是uboot.bin，linux系统的镜像是zImage，这两个东西其实都是
uboot启动内核命令：bootz、bootm、boot
Calmer_的博客
06-06 2474
uboot启动内核命令：bootz、bootm、boot
06-uboot分析之uboot启动内核
zhhe14的博客
10-17 351
分析uboot启动内核命令 从uboot的终端执行print命令可以看到以下命令 bootcmd=nand read.jffs2 0x30007FC0 kernel; bootm 0x30007FC0 这就是读出内核,启动内核的命令 nand read.jffs2 0x30007FC0 kernel; bootm 0x30007FC0 从哪里读: 从nandflash 的kernel分区读出内核,...
uboot启动内核的相关命令详解——boot、bootm
weixin_42031299的博客
11-14 9466
1、boot和bootm命令的联系 当我们进入uboot的命令终端后，可以利用boot和bootm来启动内核，但是命令的使用方式有区别： 直接输入boot命令就可以启动内核，如果使用bootm命令，后面还需要传入内核在DDR中的地址。 (1)boot命令：完成内核的重定位，将内核从外存加载到内存，然后启动内核； (2)bootm命令：调用时一般要传入内核在内存中的地址，然后去该地址处启动内核；如果不传入内核在内存中的地址，bootm会用默认地址去启动内核，这样不保证能正确启动内核。 (3)bootm命令可
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值