[UBOOT]main_loop函数分析！

1。main_loop

common/main.c

 

main_loop又臭又长，去掉宏注释掉的部分就只剩下一点点了。如下：

 

void main_loop (void)
{
#ifndef CONFIG_SYS_HUSH_PARSER
    static charlastcommand[CONFIG_SYS_CBSIZE] = { 0, };
    intlen;
    int rc =1;
    intflag;
#endif

#if defined(CONFIG_BOOTDELAY) &&(CONFIG_BOOTDELAY >= 0)
    char*s;
    intbootdelay;
#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   

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

       flag =0;   
       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) {//执行失败，则清空记录
         
         lastcommand[0] = 0;
       }
    }

}


2。自动补全
common/common.c
int var_complete(int argc, char *argv[], char last_char, int maxv,char *cmdv[])
{
    static chartmp_buf[512];
    intspace;

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

    if (space&& argc == 1)
       returnenv_complete("", maxv, cmdv, sizeof(tmp_buf), tmp_buf);

    if (!space&& argc == 2)
       returnenv_complete(argv[1], maxv, cmdv, sizeof(tmp_buf), tmp_buf);

    return0;
}

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
   
   int      (*complete)(int argc, char *argv[], char last_char, int maxv, char*cmdv[]);
#endif
};

typedef structcmd_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("Hitany key to stop autoboot: - ", bootdelay);

#if definedCONFIG_ZERO_BOOTDELAY_CHECK  //如果定义了这个宏，即使定义延时为0，也会检查一次是否有按键按下。只要在这里执行之前按键，还是能进入uboot的命令行。
    if(bootdelay >= 0) {
       if (tstc()){   测试是否有按键按下
          (void)getc();  修改标记，停止自动引导
       }
    }
#endif

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

      --bootdelay;
       每秒中测试按键100次，之后延时10ms。
       for (i=0;!abort && i<100;++i) {
          if (tstc()){   
            abort  =1;   */修改标记，停止自动引导
             bootdelay =0;   延时归零
             (void)getc();  获取按键
             break;
          }
         udelay(10000);//延时10000us，也就是10ms
       }

      printf("/b/b/b- ", bootdelay);//打印当前剩余时间
    }

   putc('/n');
    returnabort;//返回结果：1-停止引导，进入命令行；0-引导内核。
}

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

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

#define CONFIG_BOOTCOMMAND "runyboot "
#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 eraseclean 0x00200000 $(filesize);"/
          "nandwrite.jffs2 0x80008000 0x00200000 $(filesize);"/
          "setenvkernelsize $(filesize); saveenv/0"/
          /
          "upsafefs=""tftp 80008000 safefs.cramfs;"/
          "nand eraseclean 0x00600000 $(filesize);"/
          "nandwrite.jffs2 0x80008000 0x00600000 $(filesize)/0"/
          /
         "yboot=" "nand read.jffs2 0x810000000x00200000 $(filesize);"/
          "bootm81000000/0"/
          /
          "safemode=""setenv bootargs root=/dev/mtdblock3 console=ttyS0,115200, mem=64Mrootfstype=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;
    charcmdbuf[CONFIG_SYS_CBSIZE];   
    char*token;         
    char*sep;         
    charfinaltoken[CONFIG_SYS_CBSIZE];
    char *str =cmdbuf;
    char*argv[CONFIG_SYS_MAXARGS +1];   
    int argc,inquotes;
    intrepeatable = 1;
    int rc =0;

   clear_ctrlc();      

    if (!cmd ||!*cmd) {
       return-1;     空命令
    }

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

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

   
    while (*str){  //str指向cmdbuf

      
       for(inquotes = 0, sep = str; *sep; sep++) { //寻找分割符或者命令尾部。相邻的句子之间是用；隔开的。每次处理一句命令
          if((*sep=='/'') &&
             (*(sep-1) !='//'))
            inquotes=!inquotes;

          if(!inquotes &&
             (*sep ==';')&&   
             ( sep !=str)&&   
             (*(sep-1) !='//'))   
             break;
       }

      
       token =str;       //token指向命令的开头
       if (*sep){                     //如果是分隔符的话，将分隔符替换为空字符
          str = sep +1;   
      process_macros (token,finaltoken);      //将token指向的命令中的宏替换掉，如把$(kernelsize)替换成内核的大小

      
       if ((argc =parse_line (finaltoken, argv)) == 0) {//将每一个参数用‘/0’隔开，argv中的每一个指针指向一个参数的起始地址。返回值为参数的个数
          rc =-1;   
         continue;
       }

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

      
       if (argc> cmdtp->maxargs) { //检查参数个数是否过多
         cmd_usage(cmdtp);
          rc =-1;
         continue;
       }

      
       if((cmdtp->cmd) (cmdtp, flag, argc, argv) != 0){//调用命令执行函数。这是最重要的一步。
          rc =-1;
       }

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

      
       if(had_ctrlc())                //检查是否有ctrl+c按键按下，如果有，结束当前命令。本函数并没有从中断接收字符，接收ctrl+c的是一些执行命令的函数。
          return-1;   
    }

    return rc ?rc : repeatable;
}