u-boot启动内核的几种方式

叁歲伎倆 2022-03-26 16:08 397阅读 0赞

分析uboot是如何启动内核的

u-boot启动内核有以下几种方式：  
**1、使用do\_bootm\_linux()，在/lib\_arm/bootm.c定义，因为我们已经知道入口地址了，所以只需跳到入口地址就可以启动linux内核了**

**1.uboot启动内核的代码缩减如下：  
s = getenv ("bootcmd");  
debug ("\#\#\# main\_loop: bootcmd=\\"%s\\"\\n", s ? s : "<UNDEFINED>");  
if (bootdelay >= 0 && s && !abortboot (bootdelay))  
\{  
        run\_command (s, 0);  
\}  
  
2.假设bootcmd = nand read.jffs2 0x30007FC0 kernel; bootm 0x30007FC0  
<1> nand read.jffs2 0x30007FC0 kernel  
nand read.jffs2 0x30007FC0 kernel;  
从nand读出内核：从哪里读？   从kernel分区  
        放到哪里去？-0x30007FC0  
  
下面讲解什么是分区：  
就是将nand划分为几个区域，一般如下：  
bootloader-》params-》kernel-》root  
  
这些分区的划分是在/include/configs/mini2440.h中写死的：  
\#define MTDPARTS\_DEFAULT "mtdparts=nandflash0:250k@0(bootloader)," \\  
           "128k(params)," \\  
           "5m(kernel)," \\  
           "-(root)"  
注:@0表示从0地址开始，250k的bootloader分区可能对某些uboot不够用，这里只是举例而已。  
将上面的信息换算成十六进制：  
\#    name             大小        在nand上的起始地址      
0    bootloader     0x00040000        0x00000000  
1    params        0x00020000              0x00040000          
2    kernel        0x00200000        0x00060000  
3    root        0xfda00000        0x00260000  
  
那么上面的nand read.jffs2 0x30007FC0 kernel就等价于：  
nand read.jffs2 0x30007FC0 0x00060000 0x00200000  
注：这里的read.jffs2并不是指定要什么特定的格式，而是用read.jffs2不需要块/页对齐,所以这个kernel的分区大小可以  
随意定。  
  
<2> bootm 0x30007FC0  
关键函数do\_bootm()  
  
flash上存的内核：uImage  
uImage = 头部+真正的内核  
  
头部的定义如下：  
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;  
我们需要关心的是：  
    uint32\_t    ih\_load;    /\* Data     Load  Address        \*/  
    uint32\_t    ih\_ep;        /\* Entry Point Address        \*/  
ih\_load是加载地址，即内核运行是应该位于的地方    
ih\_ep是入口地址，即内核的入口地址  
  
这与uboot是类似的，uboot的加载地址是TEXT\_BASE = 0x33F80000；入口地址是start.S中的\_start。  
  
其实我们把内核中nand读出来的时候是可以放在内核的任何地方的，如0x31000000，0x32000000等等，只要它不破坏uboot所占用的内存空间就可以了，如下图：  
从0x33F4DF74-0x30000000都是可以用的。  
  
那么为什么既然设定好了加载地址和入口地址内核还能随意放呢？  
那是因为uImage有一个头部！头部里有加载地址和入口地址，当我们用bootm xxx的时候，  
do\_bootm这个函数会先去读uImage的头部以获取该uImage的加载地址和入口地址，当发现该uImage目前所处的内存地址不等于它的加载地址时，该函数会将该uImage移动到它的加载地址上，在代码中体现如下：  
case IH\_COMP\_NONE:：  
if (load != image\_start)  
\{  
        memmove\_wd ((void \*)load, (void \*)image\_start, image\_len, CHUNKSZ);  
\}  
另外，当我们的内核正好处于头部指定的加载地址的话，那么就不用uboot的do\_bootm函数来帮我们搬运内核了，这样可以节省启动时间。这就是为什么我们一般都下载uImage到  
0x30007FC0的原因了！  
  
我们所用的内核加载地址是0x30008000，而头部的大小为64个字节，所以将内核拷贝到0x30007FC0时，再加载头部的64个字节，内核正好位于0x30008000处！  
  
  
现在总结bootm做了什么：  
1.    读取头部  
2.    将内核移动到加载地址  
3.    启动内核  
  
具体如何启动内核？  
使用do\_bootm\_linux()，在/lib\_arm/bootm.c定义，因为我们已经知道入口地址了，所以只需跳到入口地址就可以启动linux内核了，但是在这之前需要做一件事————uboot传递参数给内核！！  
现在来分析do\_bootm\_linux()这个函数：  
    theKernel = (void (\*)(int, int, uint))images->ep;//先是将入口地址赋值给theKernel  
    theKernel (0, machid, bd->bi\_boot\_params);//然后是调用thekernel  
函数，以0，machid，bd->bi\_boot\_params作为参数  
下面分析这三个参数：  
1.machid就是uboot里设置好的板子的机器码，mini2440的是MACH\_TYPE\_MINI2440 (1999),内核所设置的机器码和uboot所设置的机器码必须一致才能启动内核  
2.bd->bi\_boot\_parmas就是uboot需传递给内核的启动参数所位于的地址  
3.0暂时还不知道什么作用/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
  
那么uboot传给内核的启动参数是在哪里设置的呢？  
其实就是在调用    theKernel (0, machid, bd->bi\_boot\_params);前面的一小段代码里设置的，下面我截取了部分片段：  
setup\_start\_tag (bd);  
setup\_revision\_tag (&params);  
setup\_memory\_tags (bd);  
setup\_commandline\_tag (bd, commandline);  
setup\_initrd\_tag (bd, images->rd\_start, images->rd\_end);  
setup\_videolfb\_tag ((gd\_t \*) gd);  
setup\_end\_tag (bd);  
每一个启动参数对应一个tag结构体，所谓的设置传递参数其实就是初始化这些tag的值，想了解这个结构体以及这些tag的值是如何设置的请看韦东山的书关于uboot移植章节！  
下面我们看一下setup\_start\_tag(bd)这个函数先：  
static void setup\_start\_tag (bd\_t \*bd)  
\{  
    params = (struct tag \*) bd->bi\_boot\_params;    
//在board.c中有一句gd->bd->bi\_boot\_params = 0x30000100，这里设置了参数存放的位置  
  
    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);  
\}  
我们再来看下setup\_commandline\_tag (bd, commandline);这个函数：  
static void setup\_commandline\_tag (bd\_t \*bd, char \*commandline)  
\{  
// commandline就是我们的bootargs  
    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 (p) + 1 + 4) >> 2;  
    strcpy (params->u.cmdline.cmdline, p);  
    params = tag\_next (params);  
\}  
Linux内核启动时就会去读取这些tag参数**