版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_16777851/article/details/81811116
终于到了最后的函数了
static int run_main_loop(void)
{
#ifdef CONFIG_SANDBOX /* 没定义 */
sandbox_main_loop_init();
#endif
/* main_loop() can return to retry autoboot, if so just run it again */
for (;;)
main_loop();
return 0;
}
1.1、main_loop
void main_loop(void)
{
const char *s;
/* bootstage_mark_name函数调用了show_boot_progress，利用它显示启动进程(progress)，
7 此处为空函数 */
bootstage_mark_name(BOOTSTAGE_ID_MAIN_LOOP, "main_loop");
#ifdef CONFIG_VERSION_VARIABLE /* 没定义 */
setenv("ver", version_string); /* set version variable */
#endif /* CONFIG_VERSION_VARIABLE */
/* cli_init用来初始化hush shell使用的一些变量。 */
cli_init();
/* 函数从环境变量中获取"preboot"的定义，*/
/* 该变量包含了一些预启动命令，一般环境变量中不包含该项配置。 */
run_preboot_environment_command();
#if defined(CONFIG_UPDATE_TFTP) /* 网络相关的没定义 */
update_tftp(0UL, NULL, NULL);
#endif /* CONFIG_UPDATE_TFTP */
/* bootdelay_process从环境变量中取出"bootdelay"和"bootcmd"的配置值 */
/* 将取出的"bootdelay"配置值转换成整数，赋值给全局变量stored_bootdelay */
/* 最后返回"bootcmd"的配置值 */
/* bootdelay为u-boot的启动延时计数值，计数期间内如无用户按键输入干预，那么将执行"bootcmd"配置中的命令 */
s = bootdelay_process();
if (cli_process_fdt(&s)) /* 环境变量里面有bootcmd,fdt如果有,fdt的会覆盖掉env里面的 */
cli_secure_boot_cmd(s);
/* autoboot_command，倒数计时实现,计时到-1前,没按键会指行bootcmd *
autoboot_command(s);
/* 进入 uboot 命令行中 */
cli_loop();
panic("No CLI available");
}
1.1.1、cli_init
void cli_init(void)
{
#ifdef CONFIG_HUSH_PARSER /* 定义了 */
u_boot_hush_start();
#endif
#if defined(CONFIG_HUSH_INIT_VAR) /* 没定义 */
hush_init_var();
#endif
}
/* 初始化哈希表用到的参数 */
int u_boot_hush_start(void)
{
if (top_vars == NULL) {
top_vars = malloc(sizeof(struct variables));
top_vars->name = "HUSH_VERSION";
top_vars->value = "0.01";
top_vars->next = NULL;
top_vars->flg_export = 0;
top_vars->flg_read_only = 1;
#ifdef CONFIG_NEEDS_MANUAL_RELOC /* 没定义 */
u_boot_hush_reloc();
#endif
}
return 0;
}1.1.2、run_preboot_environment_command
static void run_preboot_environment_command(void)
{
#ifdef CONFIG_PREBOOT
char *p;
p = getenv("preboot");
if (p != NULL) {
# ifdef CONFIG_AUTOBOOT_KEYED
int prev = disable_ctrlc(1); /* disable Control C checking */
# endif
run_command_list(p, -1, 0);
# ifdef CONFIG_AUTOBOOT_KEYED
disable_ctrlc(prev); /* restore Control C checking */
# endif
}
#endif /* CONFIG_PREBOOT */
}1.1.2、bootdelay_process
默认是没配置CONFIG_AUTOBOOT
meke menuconfig配置添加这个宏，设置倒数时间，会出现开机倒数计时功能。
const char *bootdelay_process(void)
{
char *s;
int bootdelay;
#ifdef CONFIG_BOOTCOUNT_LIMIT /* 没定义 */
unsigned long bootcount = 0;
unsigned long bootlimit = 0;
#endif /* CONFIG_BOOTCOUNT_LIMIT */
#ifdef CONFIG_BOOTCOUNT_LIMIT /* 没定义 */
bootcount = bootcount_load();
bootcount++;
bootcount_store(bootcount);
setenv_ulong("bootcount", bootcount);
bootlimit = getenv_ulong("bootlimit", 10, 0);
#endif /* CONFIG_BOOTCOUNT_LIMIT */
s = getenv("bootdelay"); /* 这个是取得环境变量里的 */
bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;
#ifdef CONFIG_OF_CONTROL /* 得到刚才配置的环境变量里的时间,并转化为整数,或覆盖前面的 */
bootdelay = fdtdec_get_config_int(gd->fdt_blob, "bootdelay",
bootdelay);
#endif
debug("### main_loop entered: bootdelay=%d\n\n", bootdelay);
#if defined(CONFIG_MENU_SHOW) /* 没定义 */
bootdelay = menu_show(bootdelay);
#endif
bootretry_init_cmd_timeout();
#ifdef CONFIG_POST /* 没定义 */
if (gd->flags & GD_FLG_POSTFAIL) {
s = getenv("failbootcmd");
} else
#endif /* CONFIG_POST */
#ifdef CONFIG_BOOTCOUNT_LIMIT /* 没定义 */
if (bootlimit && (bootcount > bootlimit)) {
printf("Warning: Bootlimit (%u) exceeded. Using altbootcmd.\n",
(unsigned)bootlimit);
s = getenv("altbootcmd");
} else
#endif /* CONFIG_BOOTCOUNT_LIMIT */
s = getenv("bootcmd"); /* 得到环境变量里的启动参数 */
process_fdt_options(gd->fdt_blob);
stored_bootdelay = bootdelay; /* 把bootdelay时间放到全局变量里面 */
return s;
}
1.1.3、
void autoboot_command(const char *s)
{
debug("### main_loop: bootcmd=\"%s\"\n", s ? s : "<UNDEFINED>");
/* 判断倒数计时 */
if (stored_bootdelay != -1 && s && !abortboot(stored_bootdelay)) {
#if defined(CONFIG_AUTOBOOT_KEYED) && !defined(CONFIG_AUTOBOOT_KEYED_CTRLC)
int prev = disable_ctrlc(1); /* disable Control C checking bootdelay期间ctrl + C无效*/
#endif
/* 运行bootcmd */
run_command_list(s, -1, 0);
#if defined(CONFIG_AUTOBOOT_KEYED) && !defined(CONFIG_AUTOBOOT_KEYED_CTRLC)
disable_ctrlc(prev); /* restore Control C checking */
#endif
}
#ifdef CONFIG_MENUKEY /* 没定义 */
if (menukey == CONFIG_MENUKEY) {
s = getenv("menucmd");
if (s)
run_command_list(s, -1, 0);
}
#endif /* CONFIG_MENUKEY */
}
static int abortboot(int bootdelay)
{
int abort = 0;
if (bootdelay >= 0) /* bootdelay大于0,就要实现倒数计时 */
abort = __abortboot(bootdelay);
#ifdef CONFIG_SILENT_CONSOLE /* 没定义 */
if (abort)
gd->flags &= ~GD_FLG_SILENT;
#endif
return abort;
}
static int __abortboot(int bootdelay)
{
int abort = 0;
unsigned long ts;
#ifdef CONFIG_MENUPROMPT /* 没定义 */
printf(CONFIG_MENUPROMPT);
#else
printf("Hit any key to stop autoboot: %2d ", bootdelay); /* 时间打印提示信息,2d是以两位数打印 */
#endif
/*
* Check if key already pressed
*/
if (tstc()) { /* we got a key press,判断串口是否有按键,有按键则终止 auto boot */
(void) getc(); /* consume input */
puts("\b\b\b 0");
abort = 1; /* don't auto boot */
}
while ((bootdelay > 0) && (!abort)) {
--bootdelay;
/* delay 1000 ms */
ts = get_timer(0);
do {
if (tstc()) { /* we got a key press */
abort = 1; /* don't auto boot */
bootdelay = 0; /* no more delay */
# ifdef CONFIG_MENUKEY
menukey = getc();
# else
(void) getc(); /* consume input */
# endif
break;
}
udelay(10000); //10000us = 10 ms延时
} while (!abort && get_timer(ts) < 1000); /* 有按键或超过1s则退出 */
printf("\b\b\b%2d ", bootdelay); /* 覆盖掉之前的显示,并显示新的时间 */
}
putc('\n');
return abort; /* 0表示没按键要执行bootcmd,1表示有按键 */
}/* 执行命令行参数,和传进来的cmd有关 */
int run_command_list(const char *cmd, int len, int flag)
{
int need_buff = 1;
char *buff = (char *)cmd; /* cast away const */
int rcode = 0;
if (len == -1) {
len = strlen(cmd);
#ifdef CONFIG_HUSH_PARSER /* 我们使用哈希表 */
/* hush will never change our string */
need_buff = 0;
#else
/* the built-in parser will change our string if it sees \n */
need_buff = strchr(cmd, '\n') != NULL;
#endif
}
if (need_buff) {
buff = malloc(len + 1);
if (!buff)
return 1;
memcpy(buff, cmd, len);
buff[len] = '\0';
}
#ifdef CONFIG_HUSH_PARSER /* 解析字符串,在哈希表中找到对应的函数 */
rcode = parse_string_outer(buff, FLAG_PARSE_SEMICOLON);
#else
/*
* This function will overwrite any \n it sees with a \0, which
* is why it can't work with a const char *. Here we are making
* using of internal knowledge of this function, to avoid always
* doing a malloc() which is actually required only in a case that
* is pretty rare.
*/
#ifdef CONFIG_CMDLINE
rcode = cli_simple_run_command_list(buff, flag); /* 这个函数我放在后面分析 */
#else
rcode = board_run_command(buff);
#endif
#endif
if (need_buff)
free(buff);
return rcode;
}最终的函数
void cli_loop(void)
{
#ifdef CONFIG_HUSH_PARSER /* 一种是哈希表的文件结构分析命令行 */
parse_file_outer();
/* This point is never reached */
for (;;);
#elif defined(CONFIG_CMDLINE) /* 一种是循环扫描方式 */
cli_simple_loop();
#else
printf("## U-Boot command line is disabled. Please enable CONFIG_CMDLINE\n");
#endif /*CONFIG_HUSH_PARSER*/
}哈希表的主要是一些算法上的，因为篇幅所限，这里就先跳过
static int parse_file_outer(FILE *f)
#else
int parse_file_outer(void)
#endif
{
int rcode;
struct in_str input;
#ifndef __U_BOOT__
setup_file_in_str(&input, f);
#else
setup_file_in_str(&input);
#endif
rcode = parse_stream_outer(&input, FLAG_PARSE_SEMICOLON);
return rcode;
}我们简单分析一下循环命令行方式的
#define CONFIG_SYS_CBSIZE 256 //smdkv210.h文件定义,命令行的最大长度
void cli_simple_loop(void)
{
static char lastcommand[CONFIG_SYS_CBSIZE + 1] = { 0, };
int len;
int flag;
int rc = 1;
for (;;) {
if (rc >= 0) {
/* Saw enough of a valid command to
* restart the timeout. 命令行的rimeout主要是比如输入了一半命令好久没继续输入,则会把timeout超时提示重新输入,对主流程无关
*/
bootretry_reset_cmd_timeout();
}
/* 读取命令,比较重要,这个下面分析,传入参数CONFIG_SYS_PROMPT是我们在smdkv210_defconfig里面定义的"SMDKV210 #",也就是命令行提示符 */
len = cli_readline(CONFIG_SYS_PROMPT);
flag = 0; /* assume no special flags for now */
if (len > 0)
strlcpy(lastcommand, console_buffer, //把读到的命令拷贝到局部变量数组
CONFIG_SYS_CBSIZE + 1);
else if (len == 0)
flag |= CMD_FLAG_REPEAT;
#ifdef CONFIG_BOOT_RETRY_TIME //没定义
else if (len == -2) {
/* -2 means timed out, retry autoboot
*/
puts("\nTimed out waiting for command\n");
# ifdef CONFIG_RESET_TO_RETRY
/* Reinit board to run initialization code again */
do_reset(NULL, 0, 0, NULL);
# else
return; /* retry autoboot */
# endif
}
#endif
if (len == -1) /* -1是一些特殊的ctrl + c之类的特殊按键 */
puts("<INTERRUPT>\n");
else
rc = run_command_repeatable(lastcommand, flag); /* 运行命令 */
if (rc <= 0) {
/* invalid command or not repeatable, forget it */
lastcommand[0] = 0;
}
}
}读字符串
//全局变量
char console_buffer[CONFIG_SYS_CBSIZE + 1]; /* console I/O buffer */
int cli_readline(const char *const prompt)
{
/*
* If console_buffer isn't 0-length the user will be prompted to modify
* it instead of entering it from scratch as desired.
*/
console_buffer[0] = '\0'; /* 先初始化为0 */
/* 三个参数分别是 "SMDKV210 #", 空字符串, 0 */
return cli_readline_into_buffer(prompt, console_buffer, 0);
}
int cli_readline_into_buffer(const char *const prompt, char *buffer,
int timeout)
{
char *p = buffer;
/* 这个宏的作用是在使用终端时可以使用上下键,读取历史命令 */
#ifdef CONFIG_CMDLINE_EDITING
unsigned int len = CONFIG_SYS_CBSIZE;
int rc;
static int initted;
/*
* History uses a global array which is not
* writable until after relocation to RAM.
* Revert to non-history version if still
* running from flash.
*/
if (gd->flags & GD_FLG_RELOC) {
if (!initted) {
hist_init(); /* 初始化一些全局变量 */
initted = 1;
}
if (prompt)
puts(prompt); /* 打印命令行提示符 "SMDKV210 # */
rc = cread_line(prompt, p, &len, timeout); /* 读取命令行到上面传来的全局变量数组里（历史命令） */
return rc < 0 ? rc : len;
} else {
#endif /* CONFIG_CMDLINE_EDITING */
char *p_buf = p;
int n = 0; /* buffer index */
int plen = 0; /* prompt length */
int col; /* output column cnt */
char c;
/* print prompt */
if (prompt) {
plen = strlen(prompt); /* 打印命令行提示符 "SMDKV210 # */
puts(prompt);
}
col = plen;
for (;;) {
if (bootretry_tstc_timeout())
return -2; /* timed out */
WATCHDOG_RESET(); /* Trigger watchdog, if needed */
#ifdef CONFIG_SHOW_ACTIVITY
while (!tstc()) {
show_activity(0);
WATCHDOG_RESET();
}
#endif
c = getc();
/*
* Special character handling
*/
switch (c) {
case '\r': /* Enter */
case '\n':
*p = '\0';
puts("\r\n");
return p - p_buf;
case '\0': /* nul */
continue;
case 0x03: /* ^C - break */
p_buf[0] = '\0'; /* discard input */
return -1;
case 0x15: /* ^U - erase line */
while (col > plen) {
puts(erase_seq);
--col;
}
p = p_buf;
n = 0;
continue;
case 0x17: /* ^W - erase word */
p = delete_char(p_buf, p, &col, &n, plen);
while ((n > 0) && (*p != ' '))
p = delete_char(p_buf, p, &col, &n, plen);
continue;
case 0x08: /* ^H - backspace */
case 0x7F: /* DEL - backspace */
p = delete_char(p_buf, p, &col, &n, plen);
continue;
default:
/*
* Must be a normal character then
*/
if (n < CONFIG_SYS_CBSIZE-2) {
if (c == '\t') { /* expand TABs */
#ifdef CONFIG_AUTO_COMPLETE
/*
* if auto completion triggered just
* continue
*/
*p = '\0';
if (cmd_auto_complete(prompt,
console_buffer,
&n, &col)) {
p = p_buf + n; /* reset */
continue;
}
#endif
puts(tab_seq + (col & 07));
col += 8 - (col & 07);
} else {
char __maybe_unused buf[2];
/*
* Echo input using puts() to force an
* LCD flush if we are using an LCD
*/
++col;
buf[0] = c;
buf[1] = '\0';
puts(buf);
}
*p++ = c;
++n;
} else { /* Buffer full */
putc('\a');
}
}
}
#ifdef CONFIG_CMDLINE_EDITING
}
#endif
}
static int cread_line(const char *const prompt, char *buf, unsigned int *len,
int timeout)
{
unsigned long num = 0;
unsigned long eol_num = 0;
unsigned long wlen;
char ichar;
int insert = 1;
int esc_len = 0;
char esc_save[8];
int init_len = strlen(buf);
int first = 1;
if (init_len) /* 历史命令相关的 */
cread_add_str(buf, init_len, 1, &num, &eol_num, buf, *len);
while (1) {
if (bootretry_tstc_timeout())
return -2; /* timed out */
if (first && timeout) {
uint64_t etime = endtick(timeout);
while (!tstc()) { /* while no incoming data,反复的读命令，退出表明读到了字符输入 */
if (get_ticks() >= etime)
return -2; /* timed out */
WATCHDOG_RESET();
}
first = 0;
}
ichar = getcmd_getch(); // getcmd_getch == getc
/* 如果输入的是回车换行则退出break */
if ((ichar == '\n') || (ichar == '\r')) {
putc('\n');
break;
}
/*
* handle standard linux xterm esc sequences for arrow key, etc.
* 兼容linux的 xterm的关系不大
*/
if (esc_len != 0) {
enum { ESC_REJECT, ESC_SAVE, ESC_CONVERTED } act = ESC_REJECT;
if (esc_len == 1) {
if (ichar == '[' || ichar == 'O')
act = ESC_SAVE;
} else if (esc_len == 2) {
switch (ichar) {
case 'D': /* <- key */
ichar = CTL_CH('b');
act = ESC_CONVERTED;
break; /* pass off to ^B handler */
case 'C': /* -> key */
ichar = CTL_CH('f');
act = ESC_CONVERTED;
break; /* pass off to ^F handler */
case 'H': /* Home key */
ichar = CTL_CH('a');
act = ESC_CONVERTED;
break; /* pass off to ^A handler */
case 'F': /* End key */
ichar = CTL_CH('e');
act = ESC_CONVERTED;
break; /* pass off to ^E handler */
case 'A': /* up arrow */
ichar = CTL_CH('p');
act = ESC_CONVERTED;
break; /* pass off to ^P handler */
case 'B': /* down arrow */
ichar = CTL_CH('n');
act = ESC_CONVERTED;
break; /* pass off to ^N handler */
case '1':
case '3':
case '4':
case '7':
case '8':
if (esc_save[1] == '[') {
/* see if next character is ~ */
act = ESC_SAVE;
}
break;
}
} else if (esc_len == 3) {
if (ichar == '~') {
switch (esc_save[2]) {
case '3': /* Delete key */
ichar = CTL_CH('d');
act = ESC_CONVERTED;
break; /* pass to ^D handler */
case '1': /* Home key */
case '7':
ichar = CTL_CH('a');
act = ESC_CONVERTED;
break; /* pass to ^A handler */
case '4': /* End key */
case '8':
ichar = CTL_CH('e');
act = ESC_CONVERTED;
break; /* pass to ^E handler */
}
}
}
switch (act) {
case ESC_SAVE:
esc_save[esc_len++] = ichar;
continue;
case ESC_REJECT:
esc_save[esc_len++] = ichar;
cread_add_str(esc_save, esc_len, insert,
&num, &eol_num, buf, *len);
esc_len = 0;
continue;
case ESC_CONVERTED:
esc_len = 0;
break;
}
}
/* 输入的是特殊测什么ctrl +c,退格,ctrl+v之类,特殊处理*/
switch (ichar) {
case 0x1b:
if (esc_len == 0) {
esc_save[esc_len] = ichar;
esc_len = 1;
} else {
puts("impossible condition #876\n");
esc_len = 0;
}
break;
case CTL_CH('a'):
BEGINNING_OF_LINE();
break;
case CTL_CH('c'): /* ^C - break */
*buf = '\0'; /* discard input */
return -1;
case CTL_CH('f'):
if (num < eol_num) {
getcmd_putch(buf[num]);
num++;
}
break;
case CTL_CH('b'):
if (num) {
getcmd_putch(CTL_BACKSPACE);
num--;
}
break;
case CTL_CH('d'):
if (num < eol_num) {
wlen = eol_num - num - 1;
if (wlen) {
memmove(&buf[num], &buf[num+1], wlen);
putnstr(buf + num, wlen);
}
getcmd_putch(' ');
do {
getcmd_putch(CTL_BACKSPACE);
} while (wlen--);
eol_num--;
}
break;
case CTL_CH('k'):
ERASE_TO_EOL();
break;
case CTL_CH('e'):
REFRESH_TO_EOL();
break;
case CTL_CH('o'):
insert = !insert;
break;
case CTL_CH('x'):
case CTL_CH('u'):
BEGINNING_OF_LINE();
ERASE_TO_EOL();
break;
case DEL:
case DEL7:
case 8:
if (num) {
wlen = eol_num - num;
num--;
memmove(&buf[num], &buf[num+1], wlen);
getcmd_putch(CTL_BACKSPACE);
putnstr(buf + num, wlen);
getcmd_putch(' ');
do {
getcmd_putch(CTL_BACKSPACE);
} while (wlen--);
eol_num--;
}
break;
case CTL_CH('p'):
case CTL_CH('n'):
{
char *hline;
esc_len = 0;
if (ichar == CTL_CH('p'))
hline = hist_prev();
else
hline = hist_next();
if (!hline) {
getcmd_cbeep();
continue;
}
/* nuke the current line */
/* first, go home */
BEGINNING_OF_LINE();
/* erase to end of line */
ERASE_TO_EOL();
/* copy new line into place and display */
strcpy(buf, hline);
eol_num = strlen(buf);
REFRESH_TO_EOL();
continue;
}
#ifdef CONFIG_AUTO_COMPLETE
case '\t': {
int num2, col;
/* do not autocomplete when in the middle */
if (num < eol_num) {
getcmd_cbeep();
break;
}
buf[num] = '\0';
col = strlen(prompt) + eol_num;
num2 = num;
if (cmd_auto_complete(prompt, buf, &num2, &col)) {
col = num2 - num;
num += col;
eol_num += col;
}
break;
}
#endif
default:
/* 把字符放到buf数组里面去 */
cread_add_char(ichar, insert, &num, &eol_num, buf,
*len);
break; //
}
}
*len = eol_num;
buf[eol_num] = '\0'; /* lose the newline */
/* 保存参数 */
if (buf[0] && buf[0] != CREAD_HIST_CHAR)
cread_add_to_hist(buf);
hist_cur = hist_add_idx;
return 0;
}
运行命令
int run_command_repeatable(const char *cmd, int flag) //flag = 0
{
#ifndef CONFIG_HUSH_PARSER
return cli_simple_run_command(cmd, flag); /* 分析写个,不分析哈希的 */
#else
/*
* parse_string_outer() returns 1 for failure, so clean up
* its result.
*/
if (parse_string_outer(cmd,
FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP))
return -1;
return 0;
#endif
}int cli_simple_run_command(const char *cmd, int flag)
{
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;
debug_parser("[RUN_COMMAND] cmd[%p]=\"", cmd);
if (DEBUG_PARSER) {
/* use puts - string may be loooong */
puts(cmd ? cmd : "NULL");
puts("\"\n");
}
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); /* 拷贝一份局部的cmd,这样可以随意修改 */
/* Process separators and check for invalid
* repeatable commands
*/
debug_parser("[PROCESS_SEPARATORS] %s\n", cmd);
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;
}
/*
* Limit the token to data between separators
*
*/
token = str;
if (*sep) {
str = sep + 1; /* start of command for next pass */
*sep = '\0';
} else {
str = sep; /* no more commands for next pass */
}
debug_parser("token: \"%s\"\n", token);
/* find macros in this token and replace them,里面各种解析,主要是解析一些宏,比如uboot,kernel之类要解析成对应的地址等,通过finaltoken返回 */
cli_simple_process_macros(token, finaltoken);
/* Extract arguments,分解finaltoken,里面的命令行带的参数,分解成argc和argv类型 */
argc = cli_simple_parse_line(finaltoken, argv);
if (argc == 0) {
rc = -1; /* no command at all */
continue;
}
/* 真正的执行命令和前面解析好的参数 */
if (cmd_process(flag, argc, argv, &repeatable, NULL))
rc = -1;
/* Did the user stop this? */
if (had_ctrlc())
return -1; /* if stopped then not repeatable */
}
return rc ? rc : repeatable;
}下面要用到的一些数据结构
enum command_ret_t {
CMD_RET_SUCCESS, /* 0 = Success */
CMD_RET_FAILURE, /* 1 = Failure */
CMD_RET_USAGE = -1, /* Failure, please report 'usage' error */
};
/* uboot中的所有命令都是采用这种形式,所以这个结构体很重要 */
struct cmd_tbl_s {
char *name; /* Command Name,比如bootcmd,help之类*/
int maxargs; /* maximum number of arguments,每个命令都有最大参数限制 */
int repeatable; /* autorepeat allowed? ,是否支持可重复,即按回车键会再次执行 */
/* Implementation function,正真的处理命令的函数 */
int (*cmd)(struct cmd_tbl_s *, int, int, char * const []);
char *usage; /* Usage message (short) ,短帮助信息*/
#ifdef CONFIG_SYS_LONGHELP
char *help; /* Help message (long) 长帮助信息 */
#endif
#ifdef CONFIG_AUTO_COMPLETE
/* do auto completion on the arguments ,命令自动补全,目前我们是没定义的,可以在smdkv210.h中定义 */
int (*complete)(int argc, char * const argv[], char last_char, int maxv, char *cmdv[]);
#endif
};
typedef struct cmd_tbl_s cmd_tbl_t;
enum command_ret_t cmd_process(int flag, int argc, char * const argv[],
int *repeatable, ulong *ticks)
{
enum command_ret_t rc = CMD_RET_SUCCESS;
cmd_tbl_t *cmdtp;
/* Look up command in command table */
cmdtp = find_cmd(argv[0]); /* argv[0],就是命令本身,这里通过这个字符串找到对应的cmd_tbl_t */
if (cmdtp == NULL) { /* NULL表示没找到 */
printf("Unknown command '%s' - try 'help'\n", argv[0]);
return 1;
}
/* found - check max args */
if (argc > cmdtp->maxargs) /* 检查参数个数 */
rc = CMD_RET_USAGE;
#if defined(CONFIG_CMD_BOOTD)
/* avoid "bootd" recursion */
else if (cmdtp->cmd == do_bootd) { /* 如果定义这个命令的话,则执行bootm命令 */
if (flag & CMD_FLAG_BOOTD) {
puts("'bootd' recursion detected\n");
rc = CMD_RET_FAILURE; /* 执行bootm是不会返回的,返回就说明错了 */
} else {
flag |= CMD_FLAG_BOOTD;
}
}
#endif
/* If OK so far, then do the command */
if (!rc) {
if (ticks)
*ticks = get_timer(0);
rc = cmd_call(cmdtp, flag, argc, argv); /* 执行找到的命令,并把上面解析好的参数传给它 */
if (ticks)
*ticks = get_timer(*ticks);
*repeatable &= cmdtp->repeatable; /* 执行完上一条命令,则把上一条命令的repet置位给大循环里面传过来的 */
}
if (rc == CMD_RET_USAGE)
rc = cmd_usage(cmdtp);
return rc;
}
查找到命令
cmd_tbl_t *find_cmd(const char *cmd)
{
cmd_tbl_t *start = ll_entry_start(cmd_tbl_t, cmd);
const int len = ll_entry_count(cmd_tbl_t, cmd);
return find_cmd_tbl(cmd, start, len);
}
在分析这命令之前，我们先看一下uboot的链接脚本布局
这里有个u_boot_list*段
我们分析一个简单的uboot的命令实现
const char __weak version_string[] = U_BOOT_VERSION_STRING;
/* 真正的函数,所有的函数格式都是cmd_tbl_t里面的函数指针一样 */
static int do_version(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
printf("\n%s\n", version_string);
#ifdef CC_VERSION_STRING
puts(CC_VERSION_STRING "\n");
#endif
#ifdef LD_VERSION_STRING
puts(LD_VERSION_STRING "\n");
#endif
#ifdef CONFIG_SYS_COREBOOT
printf("coreboot-%s (%s)\n", lib_sysinfo.version, lib_sysinfo.build);
#endif
return 0;
}
/* 这句是真正的定义uboot的一个命令,U_BOOT_CMD是一个宏下面我们一次把这个version命令展开 */
U_BOOT_CMD(
version, 1, 1, do_version,
"print monitor, compiler and linker version",
""
);
看起来很负责的样子，我们一步一步来展开
#define U_BOOT_CMD_MKENT_COMPLETE(_name, _maxargs, _rep, _cmd, \
_usage, _help, _comp) \
{ #_name, _maxargs, _rep, _cmd, _usage, \
_CMD_HELP(_help) _CMD_COMPLETE(_comp) }
#define ll_entry_declare(_type, _name, _list) \
_type _u_boot_list_2_##_list##_2_##_name __aligned(4) \
__attribute__((unused, \
section(".u_boot_list_2_"#_list"_2_"#_name)))
#define U_BOOT_CMD_COMPLETE(_name, _maxargs, _rep, _cmd, _usage, _help, _comp) \
ll_entry_declare(cmd_tbl_t, _name, cmd) = \
U_BOOT_CMD_MKENT_COMPLETE(_name, _maxargs, _rep, _cmd, \
_usage, _help, _comp);
#define U_BOOT_CMD(_name, _maxargs, _rep, _cmd, _usage, _help) \
U_BOOT_CMD_COMPLETE(_name, _maxargs, _rep, _cmd, _usage, _help, NULL)第一步
U_BOOT_CMD(
version, 1, 1, do_version,
"print monitor, compiler and linker version",
""
);
#define U_BOOT_CMD(_name, _maxargs, _rep, _cmd, _usage, _help) \
U_BOOT_CMD_COMPLETE(_name, _maxargs, _rep, _cmd, _usage, _help, NULL)
展开后
#define U_BOOT_CMD(version, 1, 1, do_version,"print monitor, compiler and linker version", "") \
U_BOOT_CMD_COMPLETE(version, 1, 1, do_version, "print monitor, compiler and linker version", "", NULL)
第二步
U_BOOT_CMD_COMPLETE(version, 1, 1, do_version, "print monitor, compiler and linker version", "", NULL)
#define U_BOOT_CMD_COMPLETE(_name, _maxargs, _rep, _cmd, _usage, _help, _comp) \
ll_entry_declare(cmd_tbl_t, _name, cmd) = \
U_BOOT_CMD_MKENT_COMPLETE(_name, _maxargs, _rep, _cmd, \
_usage, _help, _comp);
展开后
#define U_BOOT_CMD_COMPLETE(version, 1, 1, do_version, "print monitor, compiler and linker version", "", NULL) \
ll_entry_declare(cmd_tbl_t, version, cmd) = \
U_BOOT_CMD_MKENT_COMPLETE(version, 1, 1, do_version, \
"print monitor, compiler and linker version", "", NULL);
第三步
ll_entry_declare(cmd_tbl_t, version, cmd) = \
U_BOOT_CMD_MKENT_COMPLETE(version, 1, 1, do_version, \
"print monitor, compiler and linker version", "", NULL);
#define ll_entry_declare(_type, _name, _list) \
_type _u_boot_list_2_##_list##_2_##_name __aligned(4) \
__attribute__((unused, \
section(".u_boot_list_2_"#_list"_2_"#_name)))
#define U_BOOT_CMD_MKENT_COMPLETE(_name, _maxargs, _rep, _cmd, \
_usage, _help, _comp) \
{ #_name, _maxargs, _rep, _cmd, _usage, \
_CMD_HELP(_help) _CMD_COMPLETE(_comp) }
这里面有量个宏,我们分两次分别展开
第一个
ll_entry_declare(cmd_tbl_t, version, cmd)
#define ll_entry_declare(_type, _name, _list) \
_type _u_boot_list_2_##_list##_2_##_name __aligned(4) \
__attribute__((unused, \
section(".u_boot_list_2_"#_list"_2_"#_name)))
#define ll_entry_declare(cmd_tbl_t, version, cmd) \
cmd_tbl_t _u_boot_list_2_cmd_2_version __aligned(4) \
__attribute__((unused, \
section(".u_boot_list_2_cmd_2_version")))
第二个
U_BOOT_CMD_MKENT_COMPLETE(version, 1, 1, do_version, \
"print monitor, compiler and linker version", "", NULL);
#define U_BOOT_CMD_MKENT_COMPLETE(_name, _maxargs, _rep, _cmd, \
_usage, _help, _comp) \
{ #_name, _maxargs, _rep, _cmd, _usage, \
_CMD_HELP(_help) _CMD_COMPLETE(_comp) }
#define U_BOOT_CMD_MKENT_COMPLETE(version, 1, 1, do_version, \
"print monitor, compiler and linker version", "", NULL) \
{ "version", 1, 1, do_version, "print monitor, compiler and linker version", \
_CMD_HELP("") _CMD_COMPLETE(NULL) }
第四步、合并上一步的两个
#define ll_entry_declare(cmd_tbl_t, version, cmd) \
cmd_tbl_t _u_boot_list_2_cmd_2_version __aligned(4) \
__attribute__((unused, \
section(".u_boot_list_2_cmd_2_version")))
#define U_BOOT_CMD_MKENT_COMPLETE(version, 1, 1, do_version, \
"print monitor, compiler and linker version", "", NULL) \
{ "version", 1, 1, do_version, "print monitor, compiler and linker version", \
_CMD_HELP("") _CMD_COMPLETE(NULL) }
合并后
cmd_tbl_t _u_boot_list_2_cmd_2_version __aligned(4) __attribute__ ((unused,section(".u_boot_list_2_cmd_2_version")))
{
"version",
1,
1,
do_version,
"print monitor, compiler and linker version",
_CMD_HELP("") _CMD_COMPLETE(NULL)
}第五步
#ifdef CONFIG_AUTO_COMPLETE /* 假设都定义了 */
# define _CMD_COMPLETE(x) x,
#else
# define _CMD_COMPLETE(x)
#endif
#ifdef CONFIG_SYS_LONGHELP
# define _CMD_HELP(x) x,
#else
# define _CMD_HELP(x)
#endif
cmd_tbl_t _u_boot_list_2_cmd_2_version __aligned(4) __attribute__ ((unused,section(".u_boot_list_2_cmd_2_version")))
{
"version",
1,
1,
do_version,
"print monitor, compiler and linker version",
_CMD_HELP("") _CMD_COMPLETE(NULL)
}
展开后
cmd_tbl_t _u_boot_list_2_cmd_2_version __aligned(4) __attribute__ ((unused,section(".u_boot_list_2_cmd_2_version")))
{
"version",
1,
1,
do_version,
"print monitor, compiler and linker version",
"",
NULL, /* 自动命令补全 */
}
通过上面的五步分析可以看到，每个命令结构体都会被__sttribute__定义在一个新的段里面，这里可以看到每个命令的段都是不同的，那怎么统一管理呢？
看一下连接脚本就懂了
用*，只要前面的u_boot_list段相同，后面的不同用*则忽略，这样吧所有的命令都定义在了这个段里面了。
下面要用到一个宏在这里就一块分析了
#define ll_entry_count(_type, _list) \
({ \
_type *start = ll_entry_start(_type, _list); \
_type *end = ll_entry_end(_type, _list); \
unsigned int _ll_result = end - start; \
_ll_result; \
})
假设传给它的还是cmd_tbl_t 和version
#define ll_entry_count(cmd_tbl_t , version) \
({ \
cmd_tbl_t *start = ll_entry_start(cmd_tbl_t , version); \
cmd_tbl_t *end = ll_entry_end(cmd_tbl_t , version); \
unsigned int _ll_result = end - version; \
_ll_result; \
})
#define ll_entry_start(_type, _list) \
({ \
static char start[0] __aligned(4) __attribute__((unused, \
section(".u_boot_list_2_"#_list"_1"))); \
(_type *)&start; \
})
替换后
#define ll_entry_start(cmd_tbl_t , version) \
({ \
static char start[0] __aligned(4) __attribute__((unused, \
section(".u_boot_list_2_version_1"))); \
(cmd_tbl_t *)&start; \
})
继续
static char start[0] __aligned(4) __attribute__ ((unused,section(".u_boot_list_2_version_1")));
(cmd_tbl_t *)&start;
#define ll_entry_end(_type, _list) \
({ \
static char end[0] __aligned(4) __attribute__((unused, \
section(".u_boot_list_2_"#_list"_3"))); \
(_type *)&end; \
})
替换
#define ll_entry_end(cmd_tbl_t , version) \
({ \
static char end[0] __aligned(4) __attribute__((unused, \
section(".u_boot_list_2_version_3"))); \
(cmd_tbl_t *)&end; \
})
继续 定义一个指针,用来存放 该段的地址
static char end[0] __aligned(4) __attribute__ ((unused, section(".u_boot_list_2_version_3")));
(cmd_tbl_t *)&end;
#define ll_entry_count(cmd_tbl_t , version) \
({ \
cmd_tbl_t *start = ll_entry_start(cmd_tbl_t , version); \
cmd_tbl_t *end = ll_entry_end(cmd_tbl_t , version); \
unsigned int _ll_result = end - version; \
_ll_result; \
})
整体替换
#define ll_entry_count(cmd_tbl_t , version) \
({ \
cmd_tbl_t *start = &u_boot_list_2_version_1; \
cmd_tbl_t *end = &u_boot_list_2_version_3; \
unsigned int _ll_result = end - version; \
_ll_result; \
})
为什么一个boot_list要定义这么多的1、2、3这么多的段，看一下官方的举例解释
/**
* A linker list is constructed by grouping together linker input
* sections, each containing one entry of the list. Each input section
* contains a constant initialized variable which holds the entry's
* content. Linker list input sections are constructed from the list
* and entry names, plus a prefix which allows grouping all lists
* together. Assuming _list and _entry are the list and entry names,
* then the corresponding input section name is
*
* .u_boot_list_ + 2_ + @_list + _2_ + @_entry
*
* and the C variable name is
*
* _u_boot_list + _2_ + @_list + _2_ + @_entry
*
* This ensures uniqueness for both input section and C variable name.
*
* Note that the names differ only in the first character, "." for the
* section and "_" for the variable, so that the linker cannot confuse
* section and symbol names. From now on, both names will be referred
* to as
*
* %u_boot_list_ + 2_ + @_list + _2_ + @_entry
*
* Entry variables need never be referred to directly.
*
* The naming scheme for input sections allows grouping all linker lists
* into a single linker output section and grouping all entries for a
* single list.
*
* Note the two '_2_' constant components in the names: their presence
* allows putting a start and end symbols around a list, by mapping
* these symbols to sections names with components "1" (before) and
* "3" (after) instead of "2" (within).
* Start and end symbols for a list can generally be defined as
*
* %u_boot_list_2_ + @_list + _1_...
* %u_boot_list_2_ + @_list + _3_...
*
* Start and end symbols for the whole of the linker lists area can be
* defined as
*
* %u_boot_list_1_...
* %u_boot_list_3_...
*
* Here is an example of the sorted sections which result from a list
* "array" made up of three entries : "first", "second" and "third",
* iterated at least once.
*
* .u_boot_list_2_array_1
* .u_boot_list_2_array_2_first
* .u_boot_list_2_array_2_second
* .u_boot_list_2_array_2_third
* .u_boot_list_2_array_3
*
* If lists must be divided into sublists (e.g. for iterating only on
* part of a list), one can simply give the list a name of the form
* 'outer_2_inner', where 'outer' is the global list name and 'inner'
* is the sub-list name. Iterators for the whole list should use the
* global list name ("outer"); iterators for only a sub-list should use
* the full sub-list name ("outer_2_inner").
*
* Here is an example of the sections generated from a global list
* named "drivers", two sub-lists named "i2c" and "pci", and iterators
* defined for the whole list and each sub-list:
*
* %u_boot_list_2_drivers_1
* %u_boot_list_2_drivers_2_i2c_1
* %u_boot_list_2_drivers_2_i2c_2_first
* %u_boot_list_2_drivers_2_i2c_2_first
* %u_boot_list_2_drivers_2_i2c_2_second
* %u_boot_list_2_drivers_2_i2c_2_third
* %u_boot_list_2_drivers_2_i2c_3
* %u_boot_list_2_drivers_2_pci_1
* %u_boot_list_2_drivers_2_pci_2_first
* %u_boot_list_2_drivers_2_pci_2_second
* %u_boot_list_2_drivers_2_pci_2_third
* %u_boot_list_2_drivers_2_pci_3
* %u_boot_list_2_drivers_3
*/哇，还来2可以实现很多个。好吧，我们还是分析点简单的。
下面再分析find_cmd就会简单有一些
cmd_tbl_t *find_cmd(const char *cmd)
{
/* 可以看到上面ll_entry_start/ll_entry_start这个宏解析后就是一个和命令名称相关的唯一的段 */
cmd_tbl_t *start = ll_entry_start(cmd_tbl_t, cmd);
const int len = ll_entry_count(cmd_tbl_t, cmd); /* 假设我们的长度就1个命令 */
return find_cmd_tbl(cmd, start, len); /* 命令的地址和长度都有了,接下来就直接搜索就可以 */
}
find_cmd_tbl
/* find command table entry for a command */
cmd_tbl_t *find_cmd_tbl(const char *cmd, cmd_tbl_t *table, int table_len)
{
#ifdef CONFIG_CMDLINE
cmd_tbl_t *cmdtp;
cmd_tbl_t *cmdtp_temp = table; /* Init value */
const char *p;
int len;
int n_found = 0;
if (!cmd) /* 检查参数有效 */
return NULL;
/*
* Some commands allow length modifiers (like "cp.b");
* compare command name only until first dot.
* 上面注释说的比较明白了,一些命令会有多个命令既,比如cp.b cp.w cp.l,命令集每个的后缀和命令名用.间隔
*/
/* 如果是命令集,只要.前面命令的长度 */
len = ((p = strchr(cmd, '.')) == NULL) ? strlen (cmd) : (p - cmd);
/* 循环搜索,看命令集（1个命令也可以这样称呼）中的名字能否匹配上 */
for (cmdtp = table; cmdtp != table + table_len; cmdtp++) {
if (strncmp(cmd, cmdtp->name, len) == 0) {
if (len == strlen(cmdtp->name)) /* 命令集中的名字长度和这个一致 */
return cmdtp; /* full match,正确返回这个命令结构体的地址 */
cmdtp_temp = cmdtp; /* abbreviated command ? */
n_found++;
}
}
if (n_found == 1) { /* exactly one match */
return cmdtp_temp;
}
#endif /* CONFIG_CMDLINE */
return NULL; /* not found or ambiguous command,没找到则返回NULL */
}通过查找，如果找到命令了，则就要执行命令了
static int cmd_call(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int result;
/* 执行函数命令很简单,直接一个指针函数调用,具体函数在命令实现中 */
result = (cmdtp->cmd)(cmdtp, flag, argc, argv); /* 正常命令执行返回0 */
if (result)
debug("Command failed, result=%d\n", result);
return result;