uboot中main_loop分析

终于分析完了main_loop，发文纪念一下。 1。main_loop common/main.c main_loop又臭又长，去掉宏注释掉的部分就只剩下一点点了。如下： void main_loop （void）
{
#ifndef CONFIG_SYS_HUSH_PARSER
    static char lastcommand[CONFIG_SYS_CBSIZE] = { 0, };
    int len;
    int rc = 1;
    int flag;
#endif

#if defined（CONFIG_BOOTDELAY） && （CONFIG_BOOTDELAY >= 0）
    char *s;
    int bootdelay;
#endif

#ifdef CONFIG_AUTO_COMPLETE
    install_auto_complete（）; //安装自动补全的函数，分析如下。
#endif

#if defined（CONFIG_BOOTDELAY） && （CONFIG_BOOTDELAY >= 0）
    s = getenv （"bootdelay"）;
    bootdelay = s ？（int）simple_strtol（s, NULL, 10） : CONFIG_BOOTDELAY;

    debug （"### main_loop entered: bootdelay=%d/n/n", bootdelay）;

        s = getenv （"bootcmd"）; //获取引导命令。分析见下面。

    debug （"### main_loop: bootcmd=/"%s/"/n", s ？ s : "<UNDEFINED>"）;

    if （bootdelay >= 0 && s && ！abortboot （bootdelay）） {//如果延时大于等于零，并且没有在延时过程中接收到按键，则引导内核。abortboot函数的分析见下面。
        run_command （s, 0）;            //运行引导内核的命令。这个命令是在配置头文件中定义的。run_command的分析在下面。
    }

#endif    /* CONFIG_BOOTDELAY */

    for （;;） {
        len = readline （CONFIG_SYS_PROMPT）; //CONFIG_SYS_PROMPT的意思是回显字符，一般是“>”。这是由配置头文件定义的

        flag = 0;    /* assume no special flags for now */
        if （len > 0）
            strcpy （lastcommand, console_buffer）; //保存输入的数据。
        else if （len == 0）
            flag |= CMD_FLAG_REPEAT;//如果输入数据为零，则重复执行上次的命令，如果上次输入的是一个命令的话

        if （len == -1）
            puts （"<INTERRUPT>/n"）;
        else
            rc = run_command （lastcommand, flag）; //执行命令

        if （rc <= 0） {//执行失败，则清空记录
            /* invalid command or not repeatable, forget it */
            lastcommand[0] = 0;
        }
    }

}

2。自动补全
common/common.c
int var_complete（int argc, char *argv[], char last_char, int maxv, char *cmdv[]）
{
    static char tmp_buf[512];
    int space;

    space = last_char == "/0" || last_char == " " || last_char == "/t";

    if （space && argc == 1）
        return env_complete（"", maxv, cmdv, sizeof（tmp_buf）, tmp_buf）;

    if （！space && argc == 2）
        return env_complete（argv[1], maxv, cmdv, sizeof（tmp_buf）, tmp_buf）;

    return 0;
}

static void install_auto_complete_handler（const char *cmd,
        int （*complete）（int argc, char *argv[], char last_char, int maxv, char *cmdv[]））
{
    cmd_tbl_t *cmdtp;

    cmdtp = find_cmd（cmd）;
    if （cmdtp == NULL）
        return;

    cmdtp->complete = complete; //命令结构体的complete指针指向传入的函数。
}

void install_auto_complete（void）
{
#if defined（CONFIG_CMD_EDITENV）
    install_auto_complete_handler（"editenv", var_complete）;
#endif
    install_auto_complete_handler（"printenv", var_complete）;
    install_auto_complete_handler（"setenv", var_complete）;
#if defined（CONFIG_CMD_RUN）
    install_auto_complete_handler（"run", var_complete）;
#endif
}

可以看到将editenv、printenv、setenv和run的自动补全函数安装为 var_complete。
var_complete的功能是根据给出的前缀字符串，找出所有前缀相同的命令。

每个命令在内存中用一个cmd_tbl_t 表示。
include/command.h
struct cmd_tbl_s {
    char        *name;        /* 命令名，输入的就是它            */
    int        maxargs;    /* 最大参数个数    */
    int        repeatable;    /* 允许自动重发，也就是在按下空格键之后执行最后一条命令。        */

    int        （*cmd）（struct cmd_tbl_s *, int, int, char *[]）; /* 实现命令的参数 */
    char        *usage;        /* 短的提示信息    */
#ifdef    CONFIG_SYS_LONGHELP
    char        *help;        /* 详细的帮助信息。    */
#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
};

typedef struct cmd_tbl_s    cmd_tbl_t;

extern cmd_tbl_t __u_boot_cmd_start;
extern cmd_tbl_t __u_boot_cmd_end;

#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}

#define U_BOOT_CMD_MKENT（name,maxargs,rep,cmd,usage,help） /
{#name, maxargs, rep, cmd, usage, help}

uboot中的命令使用U_BOOT_CMD这个宏声明来注册进系统，链接脚本会把所有的cmd_tbl_t结构体放在相邻的地方。
链接脚本中的一些内容如下：
. = .;
__u_boot_cmd_start = .;
.u_boot_cmd : { *（.u_boot_cmd） }
__u_boot_cmd_end = .;
可见，__u_boot_cmd_start 和__u_boot_cmd_end 分别对应命令结构体在内存中开始和结束的地址。

3。abortboot函数的分析
abortboot是uboot在引导期间的延时函数。期间可以按键进入uboot的命令行。
common/main.c
static __inline__ int abortboot（int bootdelay）
{
    int abort = 0;
    printf（"Hit any key to stop autoboot: %2d ", bootdelay）;

#if defined CONFIG_ZERO_BOOTDELAY_CHECK   //如果定义了这个宏，即使定义延时为0，也会检查一次是否有按键按下。只要在这里执行之前按键，还是能进入uboot的命令行。
    if （bootdelay >= 0） {
        if （tstc（）） {    /* we got a key press    */ 测试是否有按键按下
            （void） getc（）; /* consume input    */接收按键值
            puts （"/b/b/b 0"）;
            abort = 1;    /* don"t auto boot    */修改标记，停止自动引导
        }
    }
#endif

    while （（bootdelay > 0） && （！abort）） { //如果延时大于零并且停止标记没有赋值则进入延时循环，直到延时完或者接收到了按键
        int i;

        --bootdelay;
        /* delay 100 * 10ms */ 每秒中测试按键100次，之后延时10ms。
        for （i=0; ！abort && i<100; ++i） {
            if （tstc（）） {    /* we got a key press    */
                abort = 1;    /* don"t auto boot    */*/修改标记，停止自动引导
                bootdelay = 0;    /* no more delay    */延时归零
                （void） getc（）; /* consume input    */获取按键
                break;
            }
            udelay（10000）;//延时10000us，也就是10ms
        }

        printf（"/b/b/b%2d ", bootdelay）;//打印当前剩余时间
    }

    putc（"/n"）;
    return abort;//返回结果：1-停止引导，进入命令行； 0-引导内核。
}

可以看到uboot延时的单位是秒，如果想提高延时的精度，比如想进行10ms级的延时，将udelay（10000）改为udelay（100）就可以了。

4。引导命令
include/configs/smartarm.h

#define CONFIG_BOOTCOMMAND "run yboot "
#define CONFIG_EXTRA_ENV_SETTINGS /
            "serverip=192.168.1.110/0" /
            "gatewayip=192.168.1.254/0" /
            "ipaddr=192.168.1.164/0" /
            "bootfile=uImage/0"/
            /
            "upkernel=" "tftp 80008000 uImage;"/
            "nand erase clean 0x00200000 $（filesize）;"/
            "nand write.jffs2 0x80008000 0x00200000 $（filesize）;"/
            "setenv kernelsize $（filesize）; saveenv/0"/
            /
            "upsafefs=" "tftp 80008000 safefs.cramfs;"/
            "nand erase clean 0x00600000 $（filesize）;"/
            "nand write.jffs2 0x80008000 0x00600000 $（filesize）/0"/
            /
            "yboot=" "nand read.jffs2 0x81000000 0x00200000 $（filesize）;"/
            "bootm 81000000/0"/
            /
            "safemode=" "setenv bootargs root=/dev/mtdblock3 console=ttyS0,115200, mem=64M rootfstype=cramfs; run yboot/0"/
            /
            "zhiyuan=" "run upsafefs; run upkernel/0"

可见，引导内核其实就是将内核读取到内存中然后再跳到那个地方引导。

5。run_command
common/main.c
int run_command （const char *cmd, int flag）
{
    cmd_tbl_t *cmdtp;
    char cmdbuf[CONFIG_SYS_CBSIZE];    /* working copy of cmd        */
    char *token;            /* start of token in cmdbuf    */
    char *sep;            /* end of token （separator） in cmdbuf */
    char finaltoken[CONFIG_SYS_CBSIZE];
    char *str = cmdbuf;
    char *argv[CONFIG_SYS_MAXARGS + 1];    /* NULL terminated    */
    int argc, inquotes;
    int repeatable = 1;
    int rc = 0;

    clear_ctrlc（）;        /* forget any previous Control C */

    if （！cmd || ！*cmd） {
        return -1;    /* empty command */ 空命令
    }

    if （strlen（cmd） >= CONFIG_SYS_CBSIZE） { //命令太长
        puts （"## Command too long！/n"）;
        return -1;
    }

    strcpy （cmdbuf, cmd）;            //将命令拷贝到临时命令缓冲cmdbuf

    /* Process separators and check for invalid
    * repeatable commands
    */
    while （*str） { //str指向cmdbuf

        /*
        * 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;
        }

        /*
        * Limit the token to data between separators
        */
        token = str;        //token指向命令的开头
        if （*sep） {                      //如果是分隔符的话，将分隔符替换为空字符
            str = sep + 1;    /* start of command for next pass */str指向下一句的开头
            *sep = "/0";
        }
        else
            str = sep;    /* no more commands for next pass */如果没有其它命令了，str指向命令尾部

        /* find macros in this token and replace them */
        process_macros （token, finaltoken）;        //将token指向的命令中的宏替换掉，如把$（kernelsize）替换成内核的大小

        /* Extract arguments */
        if （（argc = parse_line （finaltoken, argv）） == 0） {//将每一个参数用‘/0’隔开，argv中的每一个指针指向一个参数的起始地址。返回值为参数的个数
            rc = -1;    /* no command at all */
            continue;
        }

        /* Look up command in command table */
        if （（cmdtp = find_cmd（argv[0]）） == NULL） { //第一个参数就是要运行的命令，首先在命令表中找到它的命令结构体的指针
            printf （"Unknown command "%s" - try "help"/n", argv[0]）;
            rc = -1;    /* give up after bad command */
            continue;
        }

        /* found - check max args */
        if （argc > cmdtp->maxargs） { //检查参数个数是否过多
            cmd_usage（cmdtp）;
            rc = -1;
            continue;
        }

        /* OK - call function to do the command */
        if （（cmdtp->cmd）（cmdtp, flag, argc, argv）！= 0） {//调用命令执行函数。这是最重要的一步。
            rc = -1;
        }

        repeatable &= cmdtp->repeatable;//设置命令自动重复执行的标志。也就是只按下enter键是否可以执行最近执行的命令 .

        /* Did the user stop this？ */
        if （had_ctrlc （））                 //检查是否有ctrl+c按键按下，如果有，结束当前命令。本函数并没有从中断接收字符，接收ctrl+c的是一些执行命令的函数。
            return -1;    /* if stopped then not repeatable */
    }

    return rc ？ rc : repeatable;
}