前言

一直以来都在学习和开发嵌入式linux，但对于一些常用的工具和机制却不甚了解，包括今天要说的uboot引导和启动linux内核，最近打算启动技术博客来学习和记录探索这些过程中所获得的知识。从事嵌入式linux开发的人应该都知道uboot，支持多种操作系统，多种硬件平台的uboot在嵌入式linux界可是大名鼎鼎，我们今天就来谈一谈uboot如何启动内核。这里我们不提供代码，仅给出相关的关键结构体，其余的请各位自行查看uboot代码

过程讲解

do_bootm

在uboot引导Linux启动时，使用的是bootm的命令。这个命令执行的函数就是do_bootm， 这个函数的地址在cmd/bootm.c中。
代码如下：

int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
#ifdef CONFIG_NEEDS_MANUAL_RELOC
    static int relocated = 0;

    if (!relocated) {
        int i;

        /* relocate names of sub-command table */
        for (i = 0; i < ARRAY_SIZE(cmd_bootm_sub); i++)
            cmd_bootm_sub[i].name += gd->reloc_off;

        relocated = 1;
    }
#endif

    /* determine if we have a sub command */
    argc--; argv++;
    if (argc > 0) {
        char *endp;

        simple_strtoul(argv[0], &endp, 16);
        /* endp pointing to NULL means that argv[0] was just a
         * valid number, pass it along to the normal bootm processing
         *
         * If endp is ':' or '#' assume a FIT identifier so pass
         * along for normal processing.
         *
         * Right now we assume the first arg should never be '-'
         */
        if ((*endp != 0) && (*endp != ':') && (*endp != '#'))
            return do_bootm_subcommand(cmdtp, flag, argc, argv);
    }

    return do_bootm_states(cmdtp, flag, argc, argv, BOOTM_STATE_START |
        BOOTM_STATE_FINDOS | BOOTM_STATE_FINDOTHER |
        BOOTM_STATE_LOADOS |
#ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
        BOOTM_STATE_RAMDISK |
#endif
#if defined(CONFIG_PPC) || defined(CONFIG_MIPS)
        BOOTM_STATE_OS_CMDLINE |
#endif
        BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
        BOOTM_STATE_OS_GO, &images, 1);
}

参数

我们来说说这个函数的参数

cmd_tbl_t *cmdtp:目前笔者也不清楚它的来历，从命名方式中可以看出大约是命令表之类结构体

int flag：该参数笔者跟踪了一下其传入位置，目前并没有发现需要它的地方

int argc：不用说了，相信大家都知道这个就是bootm传入参数的个数

char * const argv[]：同上，这个就是传入的参数了

函数讲解

这里先略过前面的CONFIG_NEEDS_MANUAL_RELOC宏定义的部分，这里笔者也不甚了解

然后如果在命令有传入参数，则使用simple_strtoul对参数进行字符串到长整型数据类型的转换，这里解析的是传入的第一个参数，并将其赋值给endp，其实该参数就是在存储介质中内核的地址，但这个变量似乎并没有传入到函数里面去，仅用作判断。

执行函数do_bootm_subcommand，这个函数中执行了do_bootm_states，uboot分阶段启动，每一个阶段称之为subcommand

而do_bootm_states执行的就是不同阶段的subcommand

在这里我们可以见到，如果没有传入do_bootm参数，也就是参数argc为0，那么do_bootm_states的state参数将会是一大堆的标志宏，这些标志宏就是uboot启动时需要的阶段，每个阶段都有一个宏来表示

do_bootm_states

我们现在假设没有给bootm命令传入参数，那么我们现在进入do_bootm_states函数了
代码如下，有点长，节选部分出来

int do_bootm_states(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
            int states, bootm_headers_t *images, int boot_progress)
{
    boot_os_fn *boot_fn;
    ulong iflag = 0;
    int ret = 0, need_boot_fn;

    images->state |= states;

    /*
     * Work through the states and see how far we get. We stop on
     * any error.
     */
    if (states & BOOTM_STATE_START)
        ret = bootm_start(cmdtp, flag, argc, argv);

    if (!ret && (states & BOOTM_STATE_FINDOS))
        ret = bootm_find_os(cmdtp, flag, argc, argv);

    if (!ret && (states & BOOTM_STATE_FINDOTHER))
        ret = bootm_find_other(cmdtp, flag, argc, argv);

    /* Load the OS */
    if (!ret && (states & BOOTM_STATE_LOADOS)) {
        ulong load_end;

        iflag = bootm_disable_interrupts();
        ret = bootm_load_os(images, &load_end, 0);
        if (ret == 0)
            lmb_reserve(&images->lmb, images->os.load,
                    (load_end - images->os.load));
        else if (ret && ret != BOOTM_ERR_OVERLAP)
            goto err;
        else if (ret == BOOTM_ERR_OVERLAP)
            ret = 0;
    }

       ........

    /* From now on, we need the OS boot function */
    if (ret)
        return ret;
    boot_fn = bootm_os_get_boot_func(images->os.os);
    need_boot_fn = states & (BOOTM_STATE_OS_CMDLINE |
            BOOTM_STATE_OS_BD_T | BOOTM_STATE_OS_PREP |
            BOOTM_STATE_OS_FAKE_GO | BOOTM_STATE_OS_GO);
    if (boot_fn == NULL && need_boot_fn) {
        if (iflag)
            enable_interrupts();
        printf("ERROR: booting os '%s' (%d) is not supported\n",
               genimg_get_os_name(images->os.os), images->os.os);
        bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS);
        return 1;
    }


    /* Call various other states that are not generally used */
    if (!ret && (states & BOOTM_STATE_OS_CMDLINE))
        ret = boot_fn(BOOTM_STATE_OS_CMDLINE, argc, argv, images);
    if (!ret && (states & BOOTM_STATE_OS_BD_T))
        ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, images);
    if (!ret && (states & BOOTM_STATE_OS_PREP)) {
#if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
        if (images->os.os == IH_OS_LINUX)
            fixup_silent_linux();
#endif
        ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, images);
    }

#ifdef CONFIG_TRACE
    /* Pretend to run the OS, then run a user command */
    if (!ret && (states & BOOTM_STATE_OS_FAKE_GO)) {
        char *cmd_list = getenv("fakegocmd");

        ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_FAKE_GO,
                images, boot_fn);
        if (!ret && cmd_list)
            ret = run_command_list(cmd_list, -1, flag);
    }
#endif

    /* Check for unsupported subcommand. */
    if (ret) {
        puts("subcommand not supported\n");
        return ret;
    }

    /* Now run the OS! We hope this doesn't return */
    if (!ret && (states & BOOTM_STATE_OS_GO))
        ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_GO,
                images, boot_fn);

    /* Deal with any fallout */

}

参数

cmd_tbl_t *cmdtp：同上

int flag：同上

int argc：同上

char * const argv[]：同上

int states：这个参数就是那一大堆的标志宏

bootm_headers_t *images：这个数据结果就重要了，他传入的是一个全局的结构体，这个结构体用于保存从存储介质中读到的linux内核头部信息，同时这个全局结构体的也被命名为images

int boot_progress：似乎无作用

函数讲解

那么我们最先看到的是images的成员被赋值为states

往下看是会将参数states跟宏BOOTM_STATE_START进行与操作，如果通过则执行

bootm_start，那么这里就可以知道上面所说的每个阶段都有一个宏来表示

接下来就会进入bootm_start这个函数了

1、这里我们先设置一个断点，直接跳到下面看bootm_start，看完我们再回来

好，我们看完bootm_start后，接下来往下面，接着执行bootm_find_os，同样，我们先跳到后面去查看它的函数讲解，等下再回来

2、执行完bootm_find_os，接着执行bootm_find_other，这里不细讲，主要是查询是否有ramdisk

3、然后关闭中断，执行bootm_load_os，我们继续跳到后面去看这个函数

4、跳过ramdisk的代码，我们直接查看bootm_os_get_boot_func，这个函数很简单，直接查看boot_os变量，直接获取我们使用的操作系统的启动函数，uboot为每个不同的操作系统都编写了不同的启动函数。将其返回并赋值给变量boot_fn。

终于要接近尾声了，继续跳过一些可选代码。我们直接看boot_selected_os，这函数里面就执行do_bootm_linux跳转到我们的内核去运行了，如无意外，到了这里一般情况下就不返回了。

这里我们使用的是linux，所以它的启动函数是do_bootm_linux

这里会根据不同的阶段去执行boot_fn，需要执行的阶段有以下这些

BOOTM_STATE_OS_CMDLINE

BOOTM_STATE_OS_BD_T

BOOTM_STATE_OS_PREP

BOOTM_STATE_OS_GO

5、在这里，我们讲解的是ARM架构，在这种结构中前2个阶段是不用的，我们跳到文章后面查看do_bootm_linux的BOOTM_STATE_OS_PREP 和 BOOTM_STATE_OS_GO实现吧

bootm_start

代码如下：

static int bootm_start(cmd_tbl_t *cmdtp, int flag, int argc,
               char * const argv[])
{
    memset((void *)&images, 0, sizeof(images));
    images.verify = getenv_yesno("verify");

    boot_start_lmb(&images);

    bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START, "bootm_start");
    images.state = BOOTM_STATE_START;

    return 0;
}

参数

cmdtp、flag、argc、argv[]这几个参数相信不用我讲大家也都知道他们是什么了

函数讲解

最先看到的是清空images结构体，然后获取uboot的环境变量verify，并复制给images的成员

然后执行boot_start_lmb，这个函数看起来想是初始化镜像结构体的lmb成员，
然后获取环境变量中的某些变量并复制到images->lmb中，具体其作用目前暂不明白

最后执行bootstage_mark_name，大致就是记录启动阶段的名字和记录此时的一些数据

好，我们回去刚刚的do_bootm_states

bootm_find_os

代码如下：

static int bootm_find_os(cmd_tbl_t *cmdtp, int flag, int argc,
             char * const argv[])
{
    const void *os_hdr;
    bool ep_found = false;
    int ret;

    /* get kernel image header, start address and length */
    os_hdr = boot_get_kernel(cmdtp, flag, argc, argv,
            &images, &images.os.image_start, &images.os.image_len);
    if (images.os.image_len == 0) {
        puts("ERROR: can't get kernel image!\n");
        return 1;
    }

    /* get image parameters */
    switch (genimg_get_format(os_hdr)) {
                images.os.type = image_get_type(os_hdr);
        images.os.comp = image_get_comp(os_hdr);
        images.os.os = image_get_os(os_hdr);

        images.os.end = image_get_image_end(os_hdr);
        images.os.load = image_get_load(os_hdr);
        images.os.arch = image_get_arch(os_hdr);
        }
        ......
    if (images.os.type == IH_TYPE_KERNEL_NOLOAD) {
        images.os.load = images.os.image_start;
        images.ep += images.os.load;
    }

    images.os.start = map_to_sysmem(os_hdr);
}

参数

同bootm_start

函数讲解

这里需要说一下函数，该函数主要参数有images，os_data，os_len

boot_get_kernel函数先执行genimg_get_kernel_addr_fit来获取内核镜像在存储介质中的位置，如果没有传入命令参数，则默认使用全局变量load_addr并返回,该变量由每个硬件平台自己定义宏并赋值，可能这里是移植需要做的工作之一。另外它似乎有扫描多个内核镜像并找到启动镜像的功能，但这里暂且不表。

获取到内核的存储地址后，使用genimg_get_image读取内核到内存中，这个函数将内核头部的64字节信息和内核全部读到指定地址CONFIG_SYS_LOAD_ADDR，然后返回内核所在的内存地址。

genimg_get_image获取头部信息指针后，然后根据头部指针来获取内核的大小和内核目前所在的内存地址os_len和os_data，这2个指针指向的其实就是在imges结构体中的成员。到了这里，boot_get_kernel执行完毕，我们返回内核头部信息指针

接着从内核头部信息指针中获取内核的格式，格式有传统格式，FIT格式和安卓格式等，这里我们使用传统格式来讲解。我们回到bootm_find_os。

根据返回的头部信息指针，我们去获取到内核想信息并复制给images.os的各个成员，包括内核类型type，内核压缩方式comp，内核是什么操作系统os，内核要装载到内存的哪个位置load，内核是什么体系架构arch，为以后的工作做准备，这里要说明一下，现在内核所在的内存地址是uboot所指定，而内核启动的内存地址不一定在这里，是在laod成员所执行的地址，后面需要把整个镜像拷贝到这里。

最后将images.os.load赋值给images.ep，其实就是内核的启动地址了

下面内核头部信息结构体，到了这里，我们就可以返回到do_bootm_states。

typedef struct image_header {
    __be32      ih_magic;   /* Image Header Magic Number    */ 
    __be32      ih_hcrc;    /* Image Header CRC Checksum    */
    __be32      ih_time;    /* Image Creation Timestamp */
    __be32      ih_size;    /* Image Data Size      */
    __be32      ih_load;    /* Data  Load  Address      */
    __be32      ih_ep;      /* Entry Point Address      */
    __be32      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;

bootm_load_os

主要参数

bootm_headers_t *images：就在这一行字的上边
代码如下：

static int bootm_load_os(bootm_headers_t *images, unsigned long *load_end,
             int boot_progress)
{
    image_info_t os = images->os;
    ulong load = os.load;
    ulong blob_start = os.start;
    ulong blob_end = os.end;
    ulong image_start = os.image_start;
    ulong image_len = os.image_len;
    bool no_overlap;
    void *load_buf, *image_buf;
    int err;

    load_buf = map_sysmem(load, 0);
    image_buf = map_sysmem(os.image_start, image_len);
    err = bootm_decomp_image(os.comp, load, os.image_start, os.type,
                 load_buf, image_buf, image_len,
                 CONFIG_SYS_BOOTM_LEN, load_end);
    if (err) {
        bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
        return err;
    }
    flush_cache(load, ALIGN(*load_end - load, ARCH_DMA_MINALIGN));

    debug("   kernel loaded at 0x%08lx, end = 0x%08lx\n", load, *load_end);
    bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED);

    no_overlap = (os.comp == IH_COMP_NONE && load == image_start);

    if (!no_overlap && (load < blob_end) && (*load_end > blob_start)) {
        debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n",
              blob_start, blob_end);
        debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load,
              *load_end);

        /* Check what type of image this is. */
        if (images->legacy_hdr_valid) {
            if (image_get_type(&images->legacy_hdr_os_copy)
                    == IH_TYPE_MULTI)
                puts("WARNING: legacy format multi component image overwritten\n");
            return BOOTM_ERR_OVERLAP;
        } else {
            puts("ERROR: new format image overwritten - must RESET the board to recover\n");
            bootstage_error(BOOTSTAGE_ID_OVERWRITTEN);
            return BOOTM_ERR_RESET;
        }
    }

    return 0;
}

函数讲解

首先调用bootm_decomp_image，来解压内核。查看其传入参数，我们知道都是从上一步中获取得到的各种数据，包括装载地址，解压类型等等。os.image_start是内核未解压时所在的地址，load_buf是内核的启动位置也就是解压后内核所在的地址了。

我们继续返回到do_bootm_states

do_bootm_linux

不同的硬件平台有不同的实现，我们这里查看的ARM架构的实现代码
代码如下

int do_bootm_linux(int flag, int argc, char * const argv[],
           bootm_headers_t *images)
{
    /* No need for those on ARM */
    if (flag & BOOTM_STATE_OS_BD_T || flag & BOOTM_STATE_OS_CMDLINE)
        return -1;

    if (flag & BOOTM_STATE_OS_PREP) {
        boot_prep_linux(images);
        return 0;
    }

    if (flag & (BOOTM_STATE_OS_GO | BOOTM_STATE_OS_FAKE_GO)) {
        boot_jump_linux(images, flag);
        return 0;
    }

    boot_prep_linux(images);
    boot_jump_linux(images, flag);
    return 0;
}

boot_prep_linux

首先先执行BOOTM_STATE_OS_PREP的代码，这里调用的是boot_prep_linux，这个函数跟内核传递参数有关系，uboot向内核传递参数就是在这里做的准备

这里先调用char *commandline = getenv("bootargs");从uboot的环境变量中获取到我们传入的启动参数，并
使用指针指向了这串字符串，该字符串在后面会用到

再调用setup_start_tag设置启动要用到的 tag，在这里有一个全局变量params，bd->bi_boot_params的值赋给它，params的结构如下

struct tag {
    struct tag_header hdr;
    union {
        struct tag_core     core;
        struct tag_mem32    mem;
        struct tag_videotext    videotext;
        struct tag_ramdisk  ramdisk;
        struct tag_initrd   initrd;
        struct tag_serialnr serialnr;
        struct tag_revision revision;
        struct tag_videolfb videolfb;
        struct tag_cmdline  cmdline;

        /*
         * Acorn specific
         */
        struct tag_acorn    acorn;
 
        /*
         * DC21285 specific
         */
        struct tag_memclk   memclk;
    } u;

他本质是一个tag结构。该结构包括hdr和各种类型的tag_*

hdr来标志当前的tag是哪种类型。
setup_start_tag是初始化了第一个tag，类型为tag_core。

最后调用tag_next跳到第一个tag末尾，为下一个tag赋值做准备。

接下来调用setup_serial_tag，代码如下，功能笔者觉得是设置控制台串口号。其中get_board_serial是各个硬件平台的实现，其功能大概是获取环境变量中的串口号，将该串口作为控制台输出。

static void setup_serial_tag(struct tag **tmp)
{
    struct tag *params = *tmp;
    struct tag_serialnr serialnr;

    get_board_serial(&serialnr);
    params->hdr.tag = ATAG_SERIAL;
    params->hdr.size = tag_size (tag_serialnr);
    params->u.serialnr.low = serialnr.low;
    params->u.serialnr.high= serialnr.high;
    params = tag_next (params);
    *tmp = params;
}

接着，再调用setup_commandline_tag，代码如下，可以看出，这里调用了strcpy来赋值字符串，赋值的字符串正是上面提到的，函数开头使用getenv获取的启动参数字符串

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

    if (!commandline)
        return;

    /* eat leading white space */
    for (p = commandline; *p == ' '; p++);

    /* skip non-existent command lines so the kernel will still
     * use its default command line.
     */
    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);
}

接着下面还调用了setup_revision_tag、setup_memory_tags，同理都是设置不同的tag而已。这里比较特殊的是setup_memory_tags，如果有多片内存ram，会循环为每一片的ram设置一个tag

继续调用setup_board_tags，这个是板级实现，如果没有实现则跳过

最后将最末尾的tag设置为ATAG_NONE,标志tag结束。

由此可知我们的启动参数params是一片连续的内存，这片内存有很多个tag，我们通过调用不同的程序来设置这些tag。

这样整个参数的准备就结束了，最后在调用boot_jump_linux时会将tags的首地址也就是bi_boot_params传给内核，让内核解析这些tag。当然我想也有朋友不懂内核传递的参数都是字符串，设置这些tag跟传递的参数有什么关系呢，笔者也不明白，等到后面我们再来讲解。

总结一下，uboot将参数以tag数组的形式布局在内存的某一个地址，每个tag代表一种类型的参数，首尾tag标志开始和结束，首地址传给kernel供其解析。

我们回到do_bootm_linux，其实这行到这里是跳出do_bootm_linux回到我们的do_bootm_states

boot_jump_linux

kernel_entry变量是个函数指针，我们会讲images->ep赋值给它作为跳转到内核执行的入口。寄存器r2会赋值为gd->bd->bi_boot_params，就是我们之前所有是tag启动参数

然后传入其余相关参数并执行kernel_entry启动内核

到了这里，uboot引导内核的启动过程讲解完毕

后记

总结来说,uboot启动内核就是读取内核，加载内核，解析内核头部，解压内核，装载内核到执行启动地址，准备启动参数，启动内核这几个阶段。
写完该片，笔者对uboot的理解深了一层，当然该文所讲的只是uboot引导的主要部分，还有很多细节我们跳过了(但大体上不影响)。以前笔者仅仅只是使用uboot，并没有对它进行一个系统的理解，今天算是对uboot的有了一些更深的理解。当然了，这些都是理论层面，还需要各位去根据uboot的代码进行实践。实践出真知，要了解uboot后的内核启动，我们还需要对操作系统和编译原理有一定的了解，关于我们后面有机会再继续聊吧

本文参考：
uboot向kernel的传参机制——bootm与tags https://blog.csdn.net/skyflying2012/article/details/35787971
什么是FIT uImage？ https://blog.csdn.net/rikeyone/article/details/86594196