I.MX6U-MINI--U-boot启动Linux内核的过程

川长思鸟来 2022-12-07 15:12 294阅读 0赞

### 目录 ###

*  一、U-Boot启动模式介绍
 *   *  Boot
     *  bootm, bootz, booti
     *  bootefi, bootp, nboot
     *  bootm和bootz的不同地方
 *  二、bootz命令启动Linux内核过程
 *   *  2.1 images全局变量的数据结构
     *   *   *  BOOT的不同阶段
     *  2.2 do\_bootz函数
     *   *  do\_bootz函数的执行过程：
     *  2.2.1 bootz\_start函数
     *   *  bootz\_start函数执行过程：
     *  2.2.2 bootz\_setup函数
     *   *  bootz\_setup函数执行过程：
     *  2.2.3 bootm\_find\_images函数
     *   *  bootm\_find\_images执行过程：
     *  2.3.1 do\_bootm\_states 函数
     *  2.3.2 bootm\_os\_get\_boot\_func 函数
     *  2.4 U-Boot的倒数第二步：do\_bootm\_linux()
     *  2.5 U-Boot的最后一步：boot\_jump\_linux()

# 一、U-Boot启动模式介绍 #

大多数 Boot Loader 都包含两种不同的操作模式:"启动加载"模式和"下载"模式,这种区别仅对于开发人员才有意义。但从最终用户的角度看,Boot Loader 的作用就是用来加载操作系统,而并不存在所谓的启动加载模式与下载工作模式的区别。

*  **启动加载(Boot loading)模式**：这种模式也称为"自主"(Autonomous)模式。也即 Boot Loader 从目标机上的某个固态存储设备上将操作系统加载到 RAM 中运行,整个过程并没有用户的介入。这种模式是 BootLoader 的正常工作模式,因此在嵌入式产品发布的时侯,Boot Loader 显然必须工作在这种模式下。
 *  **下载(Downloading)模式**：在这种模式下,目标机上的 Boot Loader 将通过串口连接或网络连接等通信手段从主机(Host)下载文件,比如:下载内核映像和根文件系统映像等。从主机下载的文件通常首先被 BootLoader 保存到目标机的 RAM 中,然后再被 BootLoader 写到目标机上的 FLASH 类固态存储设备中。BootLoader 的这种模式通常在第一次安装内核与根文件系统时被使用;此外,以后的系统更新也会使用 BootLoader 的这种工作模式。工作于这种模式下的 Boot Loader 通常都会向它的终端用户提供一个简单的命令行接口。

说到uboot的启动方式，最后会使用autoboot(自主模式)尝试引导kernel，如果失败或者被手动取消，则进入uboot的命令行(下载模式)。

最新的uboot命令行已经发展得比较完善，很大程度上接近shell，包含了各种基本的驱动和完整的工具。这些工具的源码大多在u-boot/cmd下，查看Makefile可以看到，根据不同的配置编译出很多命令，你也可以通过搜索字符串U\_BOOT\_CMD(来查找这些命令的命名。这些命令的列表可以通过命令行输入help来查看，大致分成几个大类。

## Boot ##

以boot开头的命令，围绕引导kernel的启动过程，有boot, bootm, bootz, bootefi, bootp等等。这其中boot和bootd只是重复调用了autoboot的过程，适用于手动设置参数后启动的情况；其他的boot命令，则适用于不同kernel镜像数据来源。

## bootm, bootz, booti ##

这几个都是从内存中的某个地址获得kernel image。

*  **bootz**：是启动zImage
 *  **bootm**：是启动uImage
 *  **booti**：专门用来启动ARM 64位的uImage

它们的基本语法是：bootX ，这里的address都是指内存的物理地址，需要提前把image和file加载到内存中，其中根文件系统的地址可以省略（包含在kernel image中），用-来代替。  
 在常规的启动引导过程中，uboot的各种启动方式实际上最后都是调用bootz的，但之前会设置很多环境变量作为启动的参数。在调试过程中，我们也同样可以手动设置好参数，直接用bootX系列来启动系统。

## bootefi, bootp, nboot ##

这三个命令用于不同来源的kernel image，一个来自efi分区中的启动image，一个来自于网络，一个来自nand flash。它们只是比bootz多了一步加载行为，即将kernel image从某个设备拷贝到内存中，本质上是一样的。类似的命令还有tftpboot, usbboot, dhcp, nfs, rarpboot等。 其他boot系的命令也是大同小异，通过help能够看到对应的说明，需要自己根据情况选择使用。

## bootm和bootz的不同地方 ##

*  bootm用于加载uImage和ramdisk：`bootm ${kernel_load_address} ${ramdisk_load_address} ${devicetree_load_address};`
 *  bootz用于加载zImage和ext4文件系统：`bootz ${kernel_load_address} - ${devicetree_load_address}`

--------------------

# 二、bootz命令启动Linux内核过程 #

**bootm命令类似的目录和流程**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODc3MTI1_size_16_color_FFFFFF_t_70_pic_center]

## 2.1 images全局变量的数据结构 ##

不管是 bootz 还是 bootm 命令，在启动 Linux 内核的时候都会用到一个重要的全局变量：

**images全局变量的定义目录：common/bootm.c**

bootm_headers_t images;		/* pointers to os/initrd/fdt images */

*  os：操作系统
 *  initrd：英文含义是 boot loader initialized RAM disk，就是由 boot loader 初始化的内存盘。在 linux内核启动前， boot loader 会将存储介质中的 initrd 文件加载到内存，内核启动时会在访问真正的根文件系统前先访问该内存中的 initrd 文件系统。
 *  fdt：设备树

**images** 是 **bootm\_headers\_t** 类型的全局变量，**bootm\_headers\_t** 是个 boot 头结构体，在文件  
include/image.h 中的定义如下(删除了一些条件编译代码)：

/* * Legacy format image header, * all data in network byte order (aka natural aka bigendian). */
    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;
    
    typedef struct image_info { 
    	ulong		start, end;		        /* blob 开始和结束位置 */
    	ulong		image_start, image_len; /* 镜像起始地址(包括 blob)和长度 */
    	ulong		load;			        /* 系统镜像加载地址 */
    	uint8_t		comp, type, os;		    /* 镜像压缩、类型，OS 类型 */
    	uint8_t		arch;			        /* CPU 架构 */
    } image_info_t;
    
    /* * Legacy and FIT format headers used by do_bootm() and do_bootm_<os>() * routines. */
    typedef struct bootm_headers { 
    	/* * Legacy os image header, if it is a multi component image * then boot_get_ramdisk() and get_fdt() will attempt to get * data from second and third component accordingly. */
    	image_header_t	*legacy_hdr_os;		/* image header pointer */
    	image_header_t	legacy_hdr_os_copy;	/* header copy */
    	ulong		legacy_hdr_valid;
    
    ......
    
    #ifndef USE_HOSTCC
    	image_info_t os;       /* OS 镜像信息 */
    	ulong ep;              /* OS 入口点 */
    	
    	ulong rd_start, rd_end; /* ramdisk 开始和结束位置 */
    	
    	char *ft_addr;       /* 设备树地址 */
    	ulong ft_len;        /* 设备树长度 */
    	
    	ulong initrd_start;  /* initrd 开始位置 */
    	ulong initrd_end;    /* initrd 结束位置 */
    	ulong cmdline_start; /* cmdline 开始位置 */
    	ulong cmdline_end;   /* cmdline 结束位置 */
    	bd_t *kbd;
    #endif
    
    	int		verify;		/* env_get("verify")[0] != 'n' */
    
    #define BOOTM_STATE_START (0x00000001)
    #define BOOTM_STATE_FINDOS (0x00000002)
    #define BOOTM_STATE_FINDOTHER (0x00000004)
    #define BOOTM_STATE_LOADOS (0x00000008)
    #define BOOTM_STATE_RAMDISK (0x00000010)
    #define BOOTM_STATE_FDT (0x00000020)
    #define BOOTM_STATE_OS_CMDLINE (0x00000040)
    #define BOOTM_STATE_OS_BD_T (0x00000080)
    #define BOOTM_STATE_OS_PREP (0x00000100)
    #define BOOTM_STATE_OS_FAKE_GO (0x00000200) /* 'Almost' run the OS */
    #define BOOTM_STATE_OS_GO (0x00000400)
    	int		state;
    } bootm_headers_t;

#### BOOT的不同阶段 ####

*  BOOTM\_STATE\_START
 *  BOOTM\_STATE\_FINDOS
 *  BOOTM\_STATE\_FINDOTHER
 *  BOOTM\_STATE\_LOADOS
 *  BOOTM\_STATE\_RAMDISK
 *  BOOTM\_STATE\_FDT
 *  BOOTM\_STATE\_OS\_CMDLINE
 *  BOOTM\_STATE\_OS\_BD\_T
 *  BOOTM\_STATE\_OS\_PREP
 *  BOOTM\_STATE\_OS\_FAKE\_GO /\* ‘Almost’ run the OS \*/
 *  BOOTM\_STATE\_OS\_GO

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODc3MTI1_size_16_color_FFFFFF_t_70_pic_center]

## 2.2 do\_bootz函数 ##

文件目录：cmd/bootz.c

int do_bootz(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
    { 
    	int ret;
    
    	/* Consume 'bootz' */
    	argc--; argv++;
    
    	if (bootz_start(cmdtp, flag, argc, argv, &images))
    		return 1;
    
    	/* * We are doing the BOOTM_STATE_LOADOS state ourselves, so must * disable interrupts ourselves */
    	bootm_disable_interrupts();
    
    	images.os.os = IH_OS_LINUX;
    	ret = do_bootm_states(cmdtp, flag, argc, argv,
    #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
    			      BOOTM_STATE_RAMDISK |
    #endif
    			      BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
    			      BOOTM_STATE_OS_GO,
    			      &images, 1);
    
    	return ret;
    }

### do\_bootz函数的执行过程： ###

*  调用bootz\_start函数
 *  调用bootm\_disable\_interrupts函数关闭中断
 *  设置images.os.os为IH\_OS\_LINUX，也就是设置系统镜像为Linux，表示将要启动的是Linux系统，在后面将会根据images.os.os来选择具体的启动函数。
 *  调用函数do\_bootm\_states来执行不同的BOOT阶段，在这里要执行的BOOT阶段有：
    
     *  BOOTM\_STATE\_OS\_PREP
     *  BOOTM\_STATE\_OS\_FAKE\_GO
     *  BOOTM\_STATE\_OS\_GO

## 2.2.1 bootz\_start函数 ##

文件目录：cmd/bootz.c

/* * zImage booting support */
    static int bootz_start(cmd_tbl_t *cmdtp, int flag, int argc,
    			char * const argv[], bootm_headers_t *images)
    { 
    	int ret;
    	ulong zi_start, zi_end;
    	// 设置BOOT阶段为BOOTM_STATE_START
    	ret = do_bootm_states(cmdtp, flag, argc, argv, BOOTM_STATE_START,
    			      images, 1);
    	// 设置Linux镜像地址入口
    	/* Setup Linux kernel zImage entry point */
    	if (!argc) { 
    		images->ep = load_addr;
    		debug("* kernel: default image load address = 0x%08lx\n",
    				load_addr);
    	} else { 
    		images->ep = simple_strtoul(argv[0], NULL, 16);
    		debug("* kernel: cmdline image address = 0x%08lx\n",
    			images->ep);
    	}
    	// 判断是否为Linux镜像
    	ret = bootz_setup(images->ep, &zi_start, &zi_end);
    	if (ret != 0)
    		return 1;
    
    	lmb_reserve(&images->lmb, images->ep, zi_end - zi_start);
    
    	/* * Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not * have a header that provide this informaiton. */
    	if (bootm_find_images(flag, argc, argv))
    		return 1;
    
    #ifdef CONFIG_SECURE_BOOT
    	extern int authenticate_image(
    			uint32_t ddr_start, uint32_t raw_image_size);
    	if (authenticate_image(images->ep, zi_end - zi_start) != 0) { 
    		printf("Authenticate zImage Fail, Please check\n");
    		return 1;
    	}
    #endif
    	return 0;
    }

### bootz\_start函数执行过程： ###

*  调用函数do\_bootm\_states，执行 **BOOTM\_STATE\_START** 阶段
 *  设置images的ep成员变量，也就是系统镜像的入口点，使用bootz命令启动系统的时候就会设置系统在DRAM中的存储位置，这个存储位置就是系统镜像的入口点，因此：`images->ep = 0x80800000`
 *  调用bootz\_setup函数，此函数会判断当前的系统镜像文件是否为Linux的镜像文件，并且会打印出镜像相关信息。
 *  调用bootm\_find\_images查找ramdisk和设备树（dtb）文件，但是我们没有用到ramdisk，因此函数在这里仅仅用于查找设备树（dtb）文件。

## 2.2.2 bootz\_setup函数 ##

文件目录：arch/arm/lib/zimage.c

#define LINUX_ARM_ZIMAGE_MAGIC 0x016f2818
    
    struct arm_z_header { 
    	uint32_t	code[9];
    	uint32_t	zi_magic;
    	uint32_t	zi_start;
    	uint32_t	zi_end;
    } __attribute__ ((__packed__));
    
    int bootz_setup(ulong image, ulong *start, ulong *end)
    { 
    	struct arm_z_header *zi = (struct arm_z_header *)image;
    
    	if (zi->zi_magic != LINUX_ARM_ZIMAGE_MAGIC) { 
    #ifndef CONFIG_SPL_FRAMEWORK
    		puts("Bad Linux ARM zImage magic!\n");
    #endif
    		return 1;
    	}
    
    	*start = zi->zi_start;
    	*end = zi->zi_end;
    #ifndef CONFIG_SPL_FRAMEWORK
    	printf("Kernel image @ %#08lx [ %#08lx - %#08lx ]\n",
    	       image, *start, *end);
    #endif
    
    	return 0;
    }

### bootz\_setup函数执行过程： ###

*  宏 LINUX\_ARM\_ZIMAGE\_MAGIC 就是 ARM Linux 系统魔术数。
 *  从传递进来的参数 image(也就是系统镜像首地址)中获取 zimage 头。zImage 头结构体为 zimage\_header。
 *  判断 image 是否为 ARM 的 Linux 系统镜像，如果不是的话就直接返回，并且打印出“Bad Linux ARM zImage magic!”
 *  初始化函数bootz\_setup的参数start和end
 *  打印启动信息如果Linux系统镜像正常的话就会输出正常信息：`Kernel image @ 0x80800000 [ 0x000000 - 0x65ef68 ]`

## 2.2.3 bootm\_find\_images函数 ##

文件目录：common/bootm.c

/** * bootm_find_images - wrapper to find and locate various images * @flag: Ignored Argument * @argc: command argument count * @argv: command argument list * * boot_find_images() will attempt to load an available ramdisk, * flattened device tree, as well as specifically marked * "loadable" images (loadables are FIT only) * * Note: bootm_find_images will skip an image if it is not found * * @return: * 0, if all existing images were loaded correctly * 1, if an image is found but corrupted, or invalid */
    int bootm_find_images(int flag, int argc, char * const argv[])
    { 
    	int ret;
    
    	/* find ramdisk */
    	ret = boot_get_ramdisk(argc, argv, &images, IH_INITRD_ARCH,
    			       &images.rd_start, &images.rd_end);
    	if (ret) { 
    		puts("Ramdisk image is corrupt or invalid\n");
    		return 1;
    	}
    
    #if IMAGE_ENABLE_OF_LIBFDT
    	/* find flattened device tree */
    	ret = boot_get_fdt(flag, argc, argv, IH_ARCH_DEFAULT, &images,
    			   &images.ft_addr, &images.ft_len);
    	if (ret) { 
    		puts("Could not find a valid device tree\n");
    		return 1;
    	}
    	if (CONFIG_IS_ENABLED(CMD_FDT))
    		set_working_fdt_addr(map_to_sysmem(images.ft_addr));
    #endif
    ......
    	return 0;
    }

### bootm\_find\_images执行过程： ###

*  查找ramdisk，但是我们没有用到ramdisk，因此这部分代码不用管。
 *  查找设备树(dtb)文件，找到以后就将设备树的起始地址和长度分别写到images 的 ft\_addr 和 ft\_len 成员变量中。我们使用 bootz 启动 Linux 的时候已经指明了设备树在DRAM 中的存储地址，因此 images.ft\_addr=0X83000000，长度根据具体的设备树文件而定，比如我现在使用的设备树文件长度为 0X8C81，因此 images.ft\_len=0X8C81。

## 2.3.1 do\_bootm\_states 函数 ##

do\_bootz 最 后 调 用 的 就 是 函 数 do\_bootm\_states ， 而 且 在 bootz\_start 中 也 调 用 了do\_bootm\_states 函 数 ， 看 来 do\_bootm\_states 函 数 还 是 个 香 饽 饽 。 此 函 数 定 义 在 文 件common/bootm.c 中，函数代码如下

/** * Execute selected states of the bootm command. * * Note the arguments to this state must be the first argument, Any 'bootm' * or sub-command arguments must have already been taken. * * Note that if states contains more than one flag it MUST contain * BOOTM_STATE_START, since this handles and consumes the command line args. * * Also note that aside from boot_os_fn functions and bootm_load_os no other * functions we store the return value of in 'ret' may use a negative return * value, without special handling. * * @param cmdtp Pointer to bootm command table entry * @param flag Command flags (CMD_FLAG_...) * @param argc Number of subcommand arguments (0 = no arguments) * @param argv Arguments * @param states Mask containing states to run (BOOTM_STATE_...) * @param images Image header information * @param boot_progress 1 to show boot progress, 0 to not do this * @return 0 if ok, something else on error. Some errors will cause this * function to perform a reboot! If states contains BOOTM_STATE_OS_GO * then the intent is to boot an OS, so this function will not return * unless the image type is standalone. */
    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)) { 
    		iflag = bootm_disable_interrupts();
    		ret = bootm_load_os(images, 0);
    		if (ret && ret != BOOTM_ERR_OVERLAP)
    			goto err;
    		else if (ret == BOOTM_ERR_OVERLAP)
    			ret = 0;
    	}
    
    	/* Relocate the ramdisk */
    #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
    	if (!ret && (states & BOOTM_STATE_RAMDISK)) { 
    		ulong rd_len = images->rd_end - images->rd_start;
    
    		ret = boot_ramdisk_high(&images->lmb, images->rd_start,
    			rd_len, &images->initrd_start, &images->initrd_end);
    		if (!ret) { 
    			env_set_hex("initrd_start", images->initrd_start);
    			env_set_hex("initrd_end", images->initrd_end);
    		}
    	}
    #endif
    #if IMAGE_ENABLE_OF_LIBFDT && defined(CONFIG_LMB)
    	if (!ret && (states & BOOTM_STATE_FDT)) { 
    		boot_fdt_add_mem_rsv_regions(&images->lmb, images->ft_addr);
    		ret = boot_relocate_fdt(&images->lmb, &images->ft_addr,
    					&images->ft_len);
    	}
    #endif
    
    	/* 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 = env_get("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 */
    err:
    	if (iflag)
    		enable_interrupts();
    
    	if (ret == BOOTM_ERR_UNIMPLEMENTED)
    		bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL);
    	else if (ret == BOOTM_ERR_RESET)
    		do_reset(cmdtp, flag, argc, argv);
    
    	return ret;
    }

函数 do\_bootm\_states 根据不同的 BOOT 状态执行不同的代码段，通过如下代码来判断BOOT 状态：`states & BOOTM_STATE_XXX`在 do\_bootz 函数中会用到：

*  BOOTM\_STATE\_OS\_PREP
 *  BOOTM\_STATE\_OS\_FAKE\_GO
 *  BOOTM\_STATE\_OS\_GO  
    这三个 BOOT 状态，bootz\_start 函数中会用到：
 *  BOOTM\_STATE\_START  
    这个 BOOT 状态。  
    为了精简代码，方便分析，因此将函数do\_bootm\_states 进行精简，只留下下面这 4 个 BOOT 状态对应的处理代码：

处理 BOOTM\_STATE\_START 阶段，bootz\_start 会执行这一段代码，这里调用函数 bootm\_start，此函数定义在文件 common/bootm.c 中，函数内容如下：

static int bootm_start(cmd_tbl_t *cmdtp, int flag, int argc,
    		       char * const argv[])
    { 
    	memset((void *)&images, 0, sizeof(images));
    	images.verify = env_get_yesno("verify");
    
    	boot_start_lmb(&images);
    
    	bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START, "bootm_start");
    	images.state = BOOTM_STATE_START;
    
    	return 0;
    }

继续分析函数 do\_bootm\_states。  
**在do\_bootm\_states函数中，通过函数 bootm\_os\_get\_boot\_func 来查找系统启动函数（这里很重要！），参数 images->os.os 就是系统类型，根据这个系统类型来选择对应的启动函数，在 do\_bootz 中设置 images.os.os= IH\_OS\_LINUX。函数返回值就是找到的系统启动函数，这里找到的 Linux 系统启动函数为 do\_bootm\_linux。因此 boot\_fn=do\_bootm\_linux，后面执行 boot\_fn函数的地方实际上是执行的 do\_bootm\_linux 函数。**

在代码`if (!ret && (states & BOOTM_STATE_OS_PREP))`中处理 BOOTM\_STATE\_OS\_PREP 状态，调用函数boot\_fn实际上是调用 do\_bootm\_linux，do\_bootm\_linux也是调用 boot\_prep\_linux 来完成具体的处理过程。boot\_prep\_linux 主要用于处理环境变量  
bootargs，bootargs 保存着传递给 Linux kernel 的参数。

`if (!ret && (states & BOOTM_STATE_OS_FAKE_GO))`代码段是处理 BOOTM\_STATE\_OS\_FAKE\_GO 状态的，但是要我们没用使能 TRACE  
功能，因此宏 CONFIG\_TRACE 也就没有定义，所以这段程序不会编译。

`if (!ret && (states & BOOTM_STATE_OS_GO))`代码段调用函数 boot\_selected\_os 启动 Linux 内核，此函数第 4 个参数为 Linux 系统镜  
像头，第 5 个参数就是 Linux 系统启动函数 do\_bootm\_linux。boot\_selected\_os 函数定义在文件  
common/bootm\_os.c 中，函数内容如下

int boot_selected_os(int argc, char * const argv[], int state,
    		     bootm_headers_t *images, boot_os_fn *boot_fn)
    { 
    	arch_preboot_os();
    	board_preboot_os();
    	boot_fn(state, argc, argv, images);
    
    	/* Stand-alone may return when 'autostart' is 'no' */
    	if (images->os.type == IH_TYPE_STANDALONE ||
    	    IS_ENABLED(CONFIG_SANDBOX) ||
    	    state == BOOTM_STATE_OS_FAKE_GO) /* We expect to return */
    		return 0;
    	bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED);
    	debug("\n## Control returned to monitor - resetting...\n");
    
    	return BOOTM_ERR_RESET;
    }

在boot\_selected\_os函数中，通过调用boot\_fn函数，也就是do\_bootm\_linux函数来启动Linux内核。

## 2.3.2 bootm\_os\_get\_boot\_func 函数 ##

do\_bootm\_states 会调用 bootm\_os\_get\_boot\_func 来查找对应系统的启动函数，此函数定义在文件 common/bootm\_os.c 中，函数内容如下：

boot_os_fn *bootm_os_get_boot_func(int os)
    { 
    #ifdef CONFIG_NEEDS_MANUAL_RELOC
    	static bool relocated;
    
    	if (!relocated) { 
    		int i;
    
    		/* relocate boot function table */
    		for (i = 0; i < ARRAY_SIZE(boot_os); i++)
    			if (boot_os[i] != NULL)
    				boot_os[i] += gd->reloc_off;
    
    		relocated = true;
    	}
    #endif
    	return boot_os[os];
    }

函数中第一行到倒数第二行是条件编译，在本 uboot 中没有用到，因此这段代码无效，只有 509 行有效。在 509 行中 boot\_os 是个数组，这个数组里面存放着不同的系统对应的启动函数。boot\_os 也定义在文件 common/bootm\_os.c 中，如下所示：

static boot_os_fn *boot_os[] = { 
    	[IH_OS_U_BOOT] = do_bootm_standalone,
    #ifdef CONFIG_BOOTM_LINUX
    	[IH_OS_LINUX] = do_bootm_linux,
    #endif
    #ifdef CONFIG_BOOTM_NETBSD
    	[IH_OS_NETBSD] = do_bootm_netbsd,
    #endif
    #ifdef CONFIG_LYNXKDI
    	[IH_OS_LYNXOS] = do_bootm_lynxkdi,
    #endif
    #ifdef CONFIG_BOOTM_RTEMS
    	[IH_OS_RTEMS] = do_bootm_rtems,
    #endif
    #if defined(CONFIG_BOOTM_OSE)
    	[IH_OS_OSE] = do_bootm_ose,
    #endif
    #if defined(CONFIG_BOOTM_PLAN9)
    	[IH_OS_PLAN9] = do_bootm_plan9,
    #endif
    #if defined(CONFIG_BOOTM_VXWORKS) && \ (defined(CONFIG_PPC) || defined(CONFIG_ARM) || defined(CONFIG_RISCV))
    	[IH_OS_VXWORKS] = do_bootm_vxworks,
    #endif
    #if defined(CONFIG_CMD_ELF)
    	[IH_OS_QNX] = do_bootm_qnxelf,
    #endif
    #ifdef CONFIG_INTEGRITY
    	[IH_OS_INTEGRITY] = do_bootm_integrity,
    #endif
    #ifdef CONFIG_BOOTM_OPENRTOS
    	[IH_OS_OPENRTOS] = do_bootm_openrtos,
    #endif
    #ifdef CONFIG_BOOTM_OPTEE
    	[IH_OS_TEE] = do_bootm_tee,
    #endif
    };

由上可知就是Linux系统对应的启动函数：do\_bootm\_linux()

## 2.4 U-Boot的倒数第二步：do\_bootm\_linux() ##

目录：/arch/arm/lib/bootm.c

/* Main Entry point for arm bootm implementation * * Modeled after the powerpc implementation * DIFFERENCE: Instead of calling prep and go at the end * they are called if subcommand is equal 0. */
    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;
    	}
        // 如果参数flag等于BOOTM_STATE_OS_GO或者BOOTM_STATE_OS_FAKE_GO 的话就执行 boot_jump_linux 函数。
        // boot_selected_os 函数在调用 do_bootm_linux 的时候会将 flag 设置为 BOOTM_STATE_OS_GO。
    	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;
    }

## 2.5 U-Boot的最后一步：boot\_jump\_linux() ##

目录：/arch/arm/lib/bootm.c

/* Subcommand: GO */
    static void boot_jump_linux(bootm_headers_t *images, int flag)
    { 
    #ifdef CONFIG_ARM64 // 64位CPU
    ......
    #else // 32位CPU--IMX6U 就是32位的CPU
    	unsigned long machid = gd->bd->bi_arch_number;
    	char *s;
    	void (*kernel_entry)(int zero, int arch, uint params);
    	unsigned long r2;
    	int fake = (flag & BOOTM_STATE_OS_FAKE_GO);
    
    	kernel_entry = (void (*)(int, int, uint))images->ep;
    	......
    	s = env_get("machid");
    	if (s) { 
    		if (strict_strtoul(s, 16, &machid) < 0) { 
    			debug("strict_strtoul failed!\n");
    			return;
    		}
    		printf("Using machid 0x%lx from environment\n", machid);
    	}
    
    	debug("## Transferring control to Linux (at address %08lx)" \
    		"...\n", (ulong) kernel_entry);
    	bootstage_mark(BOOTSTAGE_ID_RUN_OS);
    	announce_and_cleanup(fake);
    
    	// 如果使用设备树，r2将是设备树的开始地址
    	if (IMAGE_ENABLE_OF_LIBFDT && images->ft_len)
    		r2 = (unsigned long)images->ft_addr;
    	else
    		r2 = gd->bd->bi_boot_params;
    
    	if (!fake) { 
    			......
    			kernel_entry(0, machid, r2);
    	}
    #endif
    }

条件编译宏`CONFIG_ARM64`是指定64 位 ARM 芯片对应的代码，Cortex-A7 是 32 位芯片，因此用不到。

变量 machid 保存机器 ID，如果不使用设备树的话这个机器 ID 会被传递给 Linux内核，Linux 内核会在自己的机器 ID 列表里面查找是否存在与 uboot 传递进来的 machid 匹配的项目，如果存在就说明 Linux 内核支持这个机器，那么 Linux 就会启动！

如果使用设备树的话，这个 machid 就无效了，设备树存有一个“兼容性”这个属性，Linux 内核会比较“兼容性”属性的值(字符串)来查看是否支持这个机器。

kernel\_entry 函数是进入 Linux 内核的，也就是最终的大 boos！！此函数有三个参数：zero，arch，params；

*  第一个参数 zero 同样为 0；
 *  第二个参数为机器 ID；
 *  第三个参数 ATAGS 或者设备树(DTB)首地址，ATAGS 是传统的方法，用于传递一些命令行信息啥的，如果使用设备树的话就要传递设备树(DTB)。

`kernel_entry = (void (*)(int, int, uint))images->ep;` 获取 kernel\_entry 函数，函数 kernel\_entry 并不是 uboot 定义的，而是 Linux 内核定义的，Linux 内核镜像文件的第一行代码就是函数 kernel\_entry，而 images->ep 保存着 Linux内核镜像的起始地址，起始地址保存的正是 Linux 内核第一行代码！

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODc3MTI1_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODc3MTI1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/3847e07b726c4fdab35dbc14df627470.png