u-boot、kernel和filesystem 执行过程分析

 

标题：

　　Uboot -kerne-root 启动流程

内容：

　　※uboot启动流程

　　※Kernel启动流程

　　※Root启动流程

　　※构建根文件系统

 

/*********************************

*u-boot: 　　u-boot2012.04.01

*kernel: 　　 linux-2.6.22

*busybox:    busybox-1.1.6

*********************************/ 

 

 

 

 

一、uboot启动流程

1.初始化硬件

2.把内核从NAND读到SDRAM

3.设置内核启动参数

4.跳转执行内核

 

执行第一个代码：/cpu/arm920t/start.S

 

 

第一阶段（start.S）

reset:

 　　set the cpu to SVC32 mode          //管理模式

 　　turn off the watchdog               //关看门狗

 　　mask all IRQs                         //屏蔽中断

　　 cpu_init_crit

　　flush v4 I/D caches              //关闭caches

　　disable MMU stuff and caches     //关闭MMU

　　lowlevel_init  //配置SDRAM

　　 Relocate                          //重定位

　　 stack_setup:                       //设置堆栈

 　　clear_bss:                         //清楚bss段

 　　start_armboot                      //跳转执行第二阶段

 

第二阶段（board.c）

start_armboot (void)

　　init_sequence

　　cpu_init,                      /* basic cpu dependent setup */

　　board_init,                   /* basic board dependent setup */

　　interrupt_init,              /* set up exceptions */

　　env_init,                      /* initialize environment */

　　init_baudrate,               /* initialze baudrate settings */

　　serial_init,                   /* serial communications setup */

　　console_init_f,             /* stage 1 init of console */

　　display_banner,                        /* say that we are here */

　　flash_init            初始化NOR

　　nand_init()           初始化NAND

　　env_relocate ()        将环境变量读入指定位置

　　cs8900_get_enetaddr     初始化网络设备

　　main_loop ()            死循环

　　　　s = getenv ("bootdelay")

　　　　　　bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;

　　　　s = getenv ("bootcmd");

　　　　Bootcmd=nand read.jffs2 0x30007fc0 kernel;bootm 0x30007fc0  //环境变量

　　　　run_command (s, 0);

　　　　continue;

 

 

Uboot命令的实现

①串口输入命令（字符串）

②动作（函数），命令对应于名字

因而根据命令找到对应函数，来执行。Uboot里面有一个结构体

包含1.名

2.函数

struct cmd_tbl_s {

          char                  *name;              /* Command Name                                 */

          int                    maxargs;           /* maximum number of arguments           */

          int                    repeatable;         /* autorepeat allowed?                */

                                                          /* Implementation function         */

          int                    (*cmd)(struct cmd_tbl_s *, int, int, char *[]);

          char                  *usage;              /* Usage message           (short)   */

#ifdef  CFG_LONGHELP

          char                  *help;               /* Help  message            (long)   */

#endif

#ifdef CONFIG_AUTO_COMPLETE

          /* do auto completion on the arguments */

          int                    (*complete)(int argc, char *argv[], char last_char, int maxv, char *cmdv[]);

#endif

};

 

此时run_command函数根据名字匹配该结构体

 

Run_command

命令的提取

while (*str) {

 

                      /*

                       * Find separator, or string end

                       * Allow simple escape of ';' by writing "\;"

                       */

                      for (inquotes = 0, sep = str; *sep; sep++) {

                                  if ((*sep=='\'') &&

                                      (*(sep-1) != '\\'))

                                              inquotes=!inquotes;

 

                                  if (!inquotes &&

                                      (*sep == ';') &&         /* separator                    */

                                      ( sep != str) &&         /* past string start           */

                                      (*(sep-1) != '\\'))        /* and NOT escaped        */

                                              break;

                      }

parse_line（）   //解析命令

Cmdtp=find_cmd()      //匹配命令  cmdtp就是指向上面的结构体cmd_tbl_s

for (cmdtp = &__u_boot_cmd_start;

               cmdtp != &__u_boot_cmd_end;

               cmdtp++)

 

 

 

 

以上：

#define Struct_Section  __attribute__ ((unused,section (".u_boot_cmd")))

比如启动命令：

Bootcmd=nand read.jffs2 0x30007fc0 kernel;bootm 0x30007fc0以bootm 0x30007fc0为例

U_BOOT_CMD(

     bootm,  CFG_MAXARGS,         1,         do_bootm,

     "bootm   - boot application image from memory\n",

     "[addr [arg ...]]\n    - boot application image stored in memory\n"

     "\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"

     "\t'arg' can be the address of an initrd image\n"

#ifdef CONFIG_OF_FLAT_TREE

     "\tWhen booting a Linux kernel which requires a flat device-tree\n"

     "\ta third argument is required which is the address of the of the\n"

     "\tdevice-tree blob. To boot that kernel without an initrd image,\n"

     "\tuse a '-' for the second argument. If you do not pass a third\n"

     "\ta bd_info struct will be passed instead\n"

#endif

);

U_boot_cmd的定义：

#define U_BOOT_CMD(name,maxargs,rep,cmd,usage,help) \

cmd_tbl_t __u_boot_cmd_##name Struct_Section = {#name, maxargs, rep, cmd, usage, help}

以上可以展开为;

cmd_tbl_t __u_boot_cmd_bootm  __attribute__ ((unused,section (".u_boot_cmd")))

= {bootm, CFG_MAXARGS, 1, do_bootm, "bootm   - boot application image from memory\n", help}

以上解释为：bootm命令定义了__u_boot_cmd_bootm结构体，该结构体类型是cmd_tbl_t，并且强制为.u_boot_cmd段属性

 

Uboot启动内核

内核启动依赖nand read.jffs2 0x30007fc0 kernel;bootm 0x30007fc0

nand read.jffs2 0x30007fc0 kernel把内核读到0x30007fc0

从哪里读？ --kernel分区在配置文件里面写死了smdk2410.h

读到哪里？ --0x30007fc0

Nand命令分析：

"nand read[.jffs2]     - addr off|partition size\n"

 

bootm 0x30007fc0从bootm 0x30007fc0启动它

Bootm命令分析：

do_bootm

image_header_t *hdr = &header;

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;

memmove ((void *) ntohl(hdr->ih_load), (uchar *)data, len);

//如果当前地址不是入口地址，移到加载地址0x30008000,由于头部占用64字节，所以此时地址是0x30007fc0

do_bootm_linux  (cmdtp, flag, argc, argv,

                                       addr, len_ptr, verify); //启动内核

setup_start_tag (bd);

setup_memory_tags (bd);

setup_commandline_tag (bd, commandline);

setup_end_tag (bd);

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

theKernel (0, bd->bi_arch_number, bd->bi_boot_params);

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

 

 

 

二、Kernel启动流程

 

处理uboot传入的参数

①判断是否支持这个CPU

②判断是否支持这个单板

③建立页表

④使能MMU

⑤跳到start_kernel函数

 

内核执行的第一个代码文件：/arch/arm/kernel/head.S  和 /arch/arm/boot/bootp/init.S

 

Start_kernel分析

1.输出内核版本信息

2.Setup_arch($command_line)

3.Setup_command_line(command_line)

 

 

调用关系：

Start_kernel

            printk(linux_banner);   //输出版本信息

            setup_arch(&command_line); //匹配ID，arch-type

                        setup_processor();

                                    list = lookup_processor_type(processor_id);

                        mdesc = setup_machine(machine_arch_type);

parse_cmdline(cmdline_p, from); //解析命令

            setup_command_line(command_line);

                        strcpy (saved_command_line, boot_command_line);

Rest_init

　　Kernel_thread()    //线程

　　// kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);

　　　　kernel_init（）

　　　　Prepare_namespace()

　　　　Mount_root()

　　　　Init_post()

　　　　　　Run_init_process()  //执行文件系统第一个程序

　　　　　　...

 

三、Root启动流程

init过程

1.读取配置文件

2.解析配置文件

3.执行客户程序

 

 

配置文件：1.指定程序；2.何时执行

 

busybox调用过程

busybox -> init_main

               parse_inittab

                           file = fopen(INITTAB, "r");//打开配置文件/etc/inittab

                          （没有配置文件时使用默认配置文件）

                           new_init_action（）

                           #1.创建init_action结构，填充

                           #2.把这个结构放入init_action_list链表里面

               run_actions(SYSINIT);

                           waitfor(a, 0); //执行程序，等待执行完毕

                                       run（a）； //系统调用，创建precess子进程

                                       waitpid(runpid, &status, 0) //等待结束

                           delete_init_action(a);//在init_action_list里面删掉应用程序

               run_actions(WAIT);

                           waitfor(a, 0);

                           delete_init_action(a);

               run_actions(ONCE);

                           run(a);//不会等待子进程结束

                           delete_init_action(a);//在init_action_list里面删

               while (1) {

                     run_actions(RESPAWN);

                                       run(a)  

                           run_actions(ASKFIRST);

                                       run(a)

                                                   打印："\nPlease press Enter to activate this console. ";

                                                   等待回车

                                                   创建子进程

                           wpid = wait(NULL);//等待子进程退出

                           while (wpid > 0) {

                                       a->pid = 0;//退出后，设置pid=0

                           }

               }

              

             

 

 

init_action_list里面有id，action，process等等

 

 

 static void new_init_action(int action, const char *command, const char *cons)

struct init_action *new_action, *a, *last;

 

init_action里面有：

struct init_action *next;

   int action;

   pid_t pid;    //进程号

   char command[INIT_BUFFS_SIZE];  //应用程序

   char terminal[CONSOLE_NAME_SIZE];  //终端

 

 

new_init_action做了什么

1.创建init_action结构，填充

2.把这个结构放入init_action_list链表里面          

 

现在假设没有配置文件，根据

/* No inittab file -- set up some default behavior */

#endif

               /* Reboot on Ctrl-Alt-Del */

               new_init_action(CTRLALTDEL, "reboot", "");

               /* Umount all filesystems on halt/reboot */

               new_init_action(SHUTDOWN, "umount -a -r", "");

               /* Swapoff on halt/reboot */

               if (ENABLE_SWAPONOFF) new_init_action(SHUTDOWN, "swapoff -a", "");

               /* Prepare to restart init when a HUP is received */

               new_init_action(RESTART, "init", "");

               /* Askfirst shell on tty1-4 */

               new_init_action(ASKFIRST, bb_default_login_shell, "");

               new_init_action(ASKFIRST, bb_default_login_shell, VC_2);

               new_init_action(ASKFIRST, bb_default_login_shell, VC_3);

               new_init_action(ASKFIRST, bb_default_login_shell, VC_4);

               /* sysinit */

               new_init_action(SYSINIT, INIT_SCRIPT, "");

              

来反推出默认配置项

#inittab格式：（文件在example/inittab文件）

 #<id>:<runlevels>:<action>:<process>

 

 #<id>         ：/dev/id，最终用作终端：stdin,stdout,stderrer:printf,scanf,err

 #<runlevels>  :忽略

 #<action>     ：何时执行的

 <action>: Valid actions include: sysinit, respawn, askfirst, wait, once,

                                  restart, ctrlaltdel, and shutdown.

 

 #<process>    ：应用程序或者脚本

 

 

 

 new_init_action(ASKFIRST, -/bin/sh, /dev/tty2);    

 

 

 new_init_action(CTRLALTDEL, "reboot", "");

 id=null

 runlevels=null

 action=ctrlaltdel

 那么上面就是:

 ::ctrlaltdel:reboot

 同理可知其他的配置项是：

 ::shutdown:umount -a -r

 ::restart:init

 ::askfirst:-/bin/sh

 tty2:askfirst:-/bin/sh

 tty3:askfirst:-/bin/sh

 tty4:askfirst:-/bin/sh

 ::sysinit:/etc/init.d/rcS

 

 

 

 

 

 其实：

 main里面

 signal(SIGHUP, exec_signal);

   signal(SIGQUIT, exec_signal);

   signal(SIGUSR1, shutdown_signal);

   signal(SIGUSR2, shutdown_signal);

   signal(SIGINT, ctrlaltdel_signal);

   signal(SIGTERM, shutdown_signal);

   signal(SIGCONT, cont_handler);

   signal(SIGSTOP, stop_handler);

   signal(SIGTSTP, stop_handler);

      

当用户按下 ctrl + alt +del时会产生一个信号，然后执行ctrlaltdel_signal函数

static void ctrlaltdel_signal(int sig ATTRIBUTE_UNUSED)

{

   run_actions(CTRLALTDEL);

}

 

 

 

 

 

总结：应用程序所需要的文件

 

1./dev/console /dev/null

2.配置文件/etc/inittab

3.配置文件里面指定的应用程序

4.库文件

5.init本身，即busybox

以上就是最小根文件系统所需要的项

 

构建根文件系统

 

 

read  INSTALL  rirst.

 

 

 

 

总结：应用程序所需要的文件

 

1./dev/console /dev/null

2.配置文件/etc/inittab

3.配置文件里面指定的应用程序

4.库文件

5.init本身，即busybox

以上就是最小根文件系统所需要的项

 

 

编译busybox

先阅读install文件可知道如何编译它

 

make menuconfig

make

make install（这里安装要注意）

安装到我们指定的某个文件里面

使用make CONFIG_PREFIX=/path/from/root install

 

 

 

编译需要在makefile里面加上cross_compiler里面加上arm-linux-

 

 

一、创建console

 

 

现在上面编译后busybox目录是work/FL_fs/first_fs

在此目录下：ls /dev/console /dev/null -l

crw------- 1 root root 5, 1 2015-01-05 20:57 /dev/console

crw-rw-rw- 1 root root 1, 3 2015-01-05 20:30 /dev/null

那么根据它来创建console null等设备

 

#mkdir dev

#cd dev

#mknod console c 5 1

#mknod null c 1 3

#ls -l

显示：

 crw-r--r-- 1 root root 5, 1 2015-05-06 20:39 console

crw-r--r-- 1 root root 1, 3 2015-05-06 20:40 null

表示创建成功

 

 

 

二、配置项

#cd work/FL_fs/first_fs

#mkdir etc

#vim  etc/inittab

 

输入：

console::askfirst:-/bin/sh

 

 

三、安装c库

#cd lib

#cp /work/tools/gcc-3.4.5-glibc-2.3.6/arm-linux/lib *.so* /work/FL_fs/first_fs/lib -d

 

 

 

 end

 

 最小根文件系统已经完成。

 

 此时需要制作镜像文件以烧写到硬件。

 yaffs2和jffs文件系统

 

 1.制作yaffs2

 #cd work/system

 yaffs_source_util_large_smmall_page_nand.tar.bz2

 

 #tar xjf  yaffs_source_util_large_small_page_nand.tar.bz2

 #cd Developement_util_ok

 #cd yaffs2

 #cd utils

 #make

 #cp mkyaffs2image /usr/local/bin

 #chmod +x /usr/local/bin/mkyaffs2image

 

 

 

 #cd /work/FL_fs

 #mkyaffs2image first_fs first_fs.yaffs2

 

 此后烧写到开发板里面。

 可以启动，并能使用ls，cd等命令。

 

 

 

 如何改进？

 

 #cd ../first_fs

 #mkdir proc

 

 

 单板上有虚拟系统

 #mkdir proc

 #mount -t proc none /proc

 #ps

 可以看到哪些程序及其内容

   PID TTY          TIME CMD

  383 pts/2    00:00:00 ps

30564 pts/2    00:00:00 su

30573 pts/2    00:00:00 bash

383 进程号

#cd 383

如果不想 手动挂载 #mount -t proc none /proc

也可以写到配置文件里面

 

#vim inittab

++ ::sysinit:/etc/init.d/rcS  需要脚本

#mkdir etc/init.d

#vim rcS

##mount -t proc none /proc

#chmod +x /etc/init.d/rcS

就可以了

 

上面#mount -t proc none /proc

也可以使用#mount -a

 

#mount -a是什么意思？

读出/etc/fstab内容来挂载

 

怎么使用呢？

#mount -a会依赖fstab文件

fstab文件内容有哪些呢？

#device         mount-point    type     options     dump   fsck

proc        /proc        proc defaults    0       0

 

那么，在/etc/fstab里面输入：

proc   /proc    default 0 0

然后在脚本rcS里面使用#mount -a

 

 

然后再制作yaffs镜像文件就和第一种方法是一样的。

可以使用#cat /proc/mounts查看挂载了哪些文件系统

 

 

继续

 

 

上面的dev是手工创建

那么怎么自动创建dev下面的设备节点呢

方法：使用mdev

 

怎么使用mdev？  在/

可以查看mdev.txt

 

[1] mount -t sysfs sysfs /sys

[2] echo /bin/mdev > /proc/sys/kernel/hotplug

[3] mdev -s

[4] mount -t tmpfs mdev /dev

[5] mkdir /dev/pts

[6] mount -t devpts devpts /dev/pts

这6步就可以了。

 

 

所以：

1、#cd ../first_fs

#mkdir sys

[1] mount -t sysfs sysfs /sys

[4] mount -t tmpfs mdev /dev

应该怎么做？

#vim /etc/fstab

#device         mount-point    type     options     dump   fsck

proc        /proc        proc defaults    0        0

sysfs           /sys           sysfs    default     0      0

tmpfs           /dev           tmpfs    default     0      0

 

 

[2] echo /bin/mdev > /proc/sys/kernel/hotplug

[3] mdev -s

[5] mkdir /dev/pts

[6] mount -t devpts devpts /dev/pts

怎么做呢？

#cd /etc/init.d/rcS

mount -a

mkdir /dev/pts/

mount -t devpts devpts /dev/pts

echo /sbin/mdev > /proc/sys/kernel/hotplug

mdev -s