u-boot 命令执行过程解析与添加自定义命令

雨点打透心脏的1/2处 2022-03-02 02:14 567阅读 0赞

当我们在控制台的时候，输入boot可以启动Linux内核，那么我们以boot为例子来解析一下uboot命令的执行过程，为下一步分析uboot怎样启动Linux来做准备。  
一、我们搜索boot命令  
grep -wnR "boot" common   
得到：common/cmd\_bootm.c:1162: boot, 1, 1, do\_bootd,

打开common/cmd\_bootm.c 文件  
int do\_bootd (cmd\_tbl\_t \*cmdtp, int flag, int argc, char \*argv\[\])  
\{  
    int rcode = 0;  
\#ifndef CFG\_HUSH\_PARSER  
    if (run\_command (getenv ("bootcmd"), flag) < 0) rcode = 1;  
\#else  
    if (parse\_string\_outer(getenv("bootcmd"),  
        FLAG\_PARSE\_SEMICOLON | FLAG\_EXIT\_FROM\_LOOP) != 0 ) rcode = 1;  
\#endif  
    return rcode;  
\}

U\_BOOT\_CMD(  
    boot,   1,  1,  do\_bootd,  
    "boot    - boot default, i.e., run 'bootcmd'\\n",  
    NULL  
);  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
其中U\_BOOT\_CMD命令格式如下：  
U\_BOOT\_CMD(name,maxargs,repeatable,command,"usage","help")

各个参数的意义如下：

name：命令名，非字符串，但在U\_BOOT\_CMD中用“\#”符号转化为字符串  
   maxargs：命令的最大参数个数  
   repeatable：是否自动重复（按Enter键是否会重复执行）  
   command：该命令对应的响应函数指针  
   usage：简短的使用说明（字符串）  
   help：较详细的使用说明（字符串）  
1  
2  
3  
4  
5  
6  
二、U\_BOOT\_CMD宏分析  
① U\_BOOT\_CMD宏在include/command.h中定义：  
\#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\}  
1  
2  
“\#\#”与“\#”都是预编译操作符，“\#\#”有字符串连接的功能，“\#”表示后面紧接着的是一个字符串。

② 其中的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 struct cmd\_tbl\_s  cmd\_tbl\_t;  
extern cmd\_tbl\_t  \_\_u\_boot\_cmd\_start;  
extern cmd\_tbl\_t  \_\_u\_boot\_cmd\_end;  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
一个cmd\_tbl\_t结构体变量包含了调用一条命令的所需要的信息。

③ 其中Struct\_Section在include/command.h中定义如下：  
 \#define Struct\_Section  \_\_attribute\_\_ ((unused,section (".u\_boot\_cmd")))  
1  
凡是带有attribute ((unused,section (“.u\_boot\_cmd”))属性声明的变量都将被存放在”.u\_boot\_cmd”段中，并且即使该变量没有在代码中显式的使用编译器也不产生警告信息。

在u-Boot连接脚本board\\smdk2410\\u-boot.lds中定义了”.u\_boot\_cmd”段：  
. = .;  
\_\_u\_boot\_cmd\_start = .;          /\*将 \_\_u\_boot\_cmd\_start指定为当前地址 \*/  
.u\_boot\_cmd : \{ \*(.u\_boot\_cmd) \}  
\_\_u\_boot\_cmd\_end = .;           /\*  将\_\_u\_boot\_cmd\_end指定为当前地址  \*/  
1  
2  
3  
4  
这表明带有“.u\_boot\_cmd”声明的函数或变量将存储在“u\_boot\_cmd”段。  
这样只要将u-boot所有命令对应的cmd\_tbl\_t变量加上“.u\_boot\_cmd”声明，编译器就会自动将其放在“u\_boot\_cmd”段，查找cmd\_tbl\_t变量时只要在\_\_u\_boot\_cmd\_start与\_\_u\_boot\_cmd\_end之间查找就可以了。  
三、boot命令宏展开  
因此“boot”命令的定义经过宏展开后如下：

cmd\_tbl\_t \_\_u\_boot\_cmd\_boot \_\_attribute\_\_ ((unused,section (".u\_boot\_cmd"))) = \{boot, 1, 1, do\_bootd, "boot    - boot default, i.e., run 'bootcmd'\\n", " NULL"\}  
1  
int do\_bootd (cmd\_tbl\_t \*cmdtp, int flag, int argc, char \*argv\[\])  
\{  
    int rcode = 0;  
\#ifndef CFG\_HUSH\_PARSER  
    if (run\_command (getenv ("bootcmd"), flag) < 0) rcode = 1;  
\#else  
    if (parse\_string\_outer(getenv("bootcmd"),  
        FLAG\_PARSE\_SEMICOLON | FLAG\_EXIT\_FROM\_LOOP) != 0 ) rcode = 1;  
\#endif  
    return rcode;  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
四、run\_command分析  
u-boot启动第二阶段最后跳到main\_loop函数中循环，  
        s = getenv ("bootcmd");  
    if (bootdelay >= 0 && s && !abortboot (bootdelay)) \{  
        ......  
        run\_command (s, 0);  
        ......  
        \}  
1  
2  
3  
4  
5  
6  
从main\_loop中我们知道，如果bootdelay时间内未按下按键则启动Linux内核，按下按键则进入uboot命令行等待用户输入命令。  
用户输入命令则调取run\_command函数，在该函数中有下面几个比较重要的点：  
1. 从注释我们很容易知道这段代码是在对命令进行分离，并且u-boot支持’;’分离命令。  
        /\*  
         \* 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;  
        \}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
2. 分离参数  
        /\* Extract arguments \*/  
        if ((argc = parse\_line (finaltoken, argv)) == 0) \{  
            rc = -1;    /\* no command at all \*/  
            continue;  
        \}  
1  
2  
3  
4  
5  
3. 用第一个参数argv\[0\]在命令列表中寻找对应的命令，并返回一个cmd\_tbl\_t类型的实例。我们可以猜到这个结构体应该保函了有关命令的一系列内容。  
        /\* 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;  
        \}  
1  
2  
3  
4  
5  
6  
在common/command.c 中查看find\_cmd函数  
/\*\_\_u\_boot\_cmd\_start与\_\_u\_boot\_cmd\_end间查找命令，并返回cmdtp->name命令的cmd\_tbl\_t结构。\*/  
cmd\_tbl\_t \*cmdtp;  
    cmd\_tbl\_t \*cmdtp\_temp = &\_\_u\_boot\_cmd\_start;    /\*Init value \*/  
    const char \*p;  
    int len;  
    int n\_found = 0;

/\*  
     \* Some commands allow length modifiers (like "cp.b");  
     \* compare command name only until first dot.  
     \*/  
    len = ((p = strchr(cmd, '.')) == NULL) ? strlen (cmd) : (p - cmd);

for (cmdtp = &\_\_u\_boot\_cmd\_start;  
         cmdtp != &\_\_u\_boot\_cmd\_end;  
         cmdtp++) \{  
        if (strncmp (cmd, cmdtp->name, len) == 0) \{  
            if (len == strlen (cmdtp->name))  
                return cmdtp;   /\* full match \*/

cmdtp\_temp = cmdtp; /\* abbreviated command ? \*/  
            n\_found++;  
        \}  
    \}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
五、总结命令执行过程  
① 在u-boot控制台中输入“boot”命令执行时，u-boot控制台接收输入的字符串“boot”，传递给run\_command函数。  
② run\_command函数调用common/command.c中实现的find\_cmd函数在\_\_u\_boot\_cmd\_start与\_\_u\_boot\_cmd\_end间查找命令，并返回boot命令的cmd\_tbl\_t结构。  
③ 然后run\_command函数使用返回的cmd\_tbl\_t结构中的函数指针调用boot命令的响应函数do\_bootd，从而完成了命令的执行。  
六、自制u-boot命令

① 首先我们在u-boot的common目录下增加一个cmd\_czg.c文件 。  
复制cmd\_bootm.c中的头文件到cmd\_czg.c

\#include <common.h>  
\#include <watchdog.h>  
\#include <command.h>  
\#include <image.h>  
\#include <malloc.h>  
\#include <zlib.h>  
\#include <bzlib.h>  
\#include <environment.h>  
\#include <asm/byteorder.h>  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
②、③定义命令和操作函数  
\#include <command.h>  
\#include <image.h>  
\#include <malloc.h>  
\#include <zlib.h>  
\#include <bzlib.h>  
\#include <environment.h>  
\#include <asm/byteorder.h>  
int do\_czg (cmd\_tbl\_t \*cmdtp, int flag, int argc, char \*argv\[\])  
\{  
        int i;  
        for(i=0;i<argc;i++)  
    \{  
    printf ("i love you ~ argc = %d\\n",argc);  
     printf ("argv\[%d\] = %s\\n",i,argv\[i\]);  
    \}  
        return 0;  
\}  
U\_BOOT\_CMD(  
        czg,    CFG\_MAXARGS,    1,      do\_czg,  
        "czg   - just for test\\n",/\*短帮助信息\*/  
        "czg, long help·····················\\n"//长帮帮助信息

);  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
④ 修改common下面的makefile文件，  
参考Makefile中其他文件的定义，加入一句

COBJS += cmd\_czg.o  
1  
⑤ 清除配置编译u-boot并烧录  
make distclean  
make 100ask24x0\_config  
make  
1  
2  
3

\---------------------   
作者：种瓜大爷   
来源：CSDN   
原文：https://blog.csdn.net/czg13548930186/article/details/76356019   
版权声明：本文为博主原创文章，转载请附上博文链接！