Mini2440之uboot移植之源码分析命令解析（五）

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

/* We come here after U-Boot is initialised and ready to process commands */
void main_loop(void)
{
    const char *s;

    bootstage_mark_name(BOOTSTAGE_ID_MAIN_LOOP, "main_loop");

#ifndef CONFIG_SYS_GENERIC_BOARD
    puts("Warning: Your board does not use generic board. Please readn");
    puts("doc/README.generic-board and take action. Boards notn");
    puts("upgraded by the late 2014 may break or be removed.n");
#endif

#ifdef CONFIG_VERSION_VARIABLE
    setenv("ver", version_string);  /* set version variable */
#endif /* CONFIG_VERSION_VARIABLE */

    cli_init();

    run_preboot_environment_command();   /*啥也没做 */

#if defined(CONFIG_UPDATE_TFTP)
    update_tftp(0UL, NULL, NULL);
#endif /* CONFIG_UPDATE_TFTP */

    s = bootdelay_process();
    if (cli_process_fdt(&s))
        cli_secure_boot_cmd(s);

    autoboot_command(s);

    cli_loop();
    panic("No CLI available");
}

void cli_init(void)
{
#ifdef CONFIG_SYS_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;
}

struct variables shell_ver = { "HUSH_VERSION", "0.01", 1, 1, 0 };
struct variables *top_vars = &shell_ver;

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

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=%dnn", 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;

    return s;
}

initcall: 0000f4e4 (relocated to 33f304e4)
### main_loop entered: bootdelay=5

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 */
#endif

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

void cli_loop(void)
{
#ifdef CONFIG_SYS_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_CMDLINEn");
#endif /*CONFIG_SYS_HUSH_PARSER*/
}

len = cli_readline(CONFIG_SYS_PROMPT);

rc = run_command_repeatable(lastcommand, flag);->cli_simple_run_command

int parse_file_outer(void)
{
    int rcode;
    struct in_str input;
    setup_file_in_str(&input);
    rcode = parse_stream_outer(&input, FLAG_PARSE_SEMICOLON);
    return rcode;
}

static void setup_file_in_str(struct in_str *i)
{
    i->peek = file_peek;
    i->get = file_get;
    i->__promptme=1;
    i->promptmode=1;
    i->p = NULL;
}

/* most recursion does not come through here, the exeception is
 * from builtin_source() */
static int parse_stream_outer(struct in_str *inp, int flag)
{

    struct p_context ctx;
    o_string temp=NULL_O_STRING;
    int rcode;
    int code = 1;
    do {
        ctx.type = flag;
        initialize_context(&ctx);
        update_ifs_map();
        if (!(flag & FLAG_PARSE_SEMICOLON) || (flag & FLAG_REPARSING)) mapset((uchar *)";$&|", 0);
        inp->promptmode=1;
        rcode = parse_stream(&temp, &ctx, inp,
                     flag & FLAG_CONT_ON_NEWLINE ? -1 : 'n');
        if (rcode == 1) flag_repeat = 0;
        if (rcode != 1 && ctx.old_flag != 0) {
            syntax();
            flag_repeat = 0;
        }
        if (rcode != 1 && ctx.old_flag == 0) {
            done_word(&temp, &ctx);
            done_pipe(&ctx,PIPE_SEQ);
            code = run_list(ctx.list_head);
            if (code == -2) {    /* exit */
                b_free(&temp);
                code = 0;
                /* XXX hackish way to not allow exit from main loop */
                if (inp->peek == file_peek) {
                    printf("exit not allowed from main input shell.n");
                    continue;
                }
                break;
            }
            if (code == -1)
                flag_repeat = 0;
        } else {
            if (ctx.old_flag != 0) {
                free(ctx.stack);
                b_reset(&temp);
            }
            if (inp->__promptme == 0) printf("<INTERRUPT>n");
            inp->__promptme = 1;
            temp.nonnull = 0;
            temp.quote = 0;
            inp->p = NULL;
            free_pipe_list(ctx.list_head,0);
        }
        b_free(&temp);
    /* loop on syntax errors, return on EOF */
    } while (rcode != -1 && !(flag & FLAG_EXIT_FROM_LOOP) &&
        (inp->peek != static_peek || b_peek(inp)));
    return (code != 0) ? 1 : 0;
}

#define FLAG_EXIT_FROM_LOOP 1
#define FLAG_PARSE_SEMICOLON (1 << 1)      /* symbol ';' is special for parser */
#define FLAG_REPARSING       (1 << 2)      /* >=2nd pass */
#define FLAG_CONT_ON_NEWLINE (1 << 3)      /* continue when we see n */

/* This holds pointers to the various results of parsing */
struct p_context {
    struct child_prog *child;
    struct pipe *list_head;
    struct pipe *pipe;
    reserved_style w;
    int old_flag;                /* for figuring out valid reserved words */
    struct p_context *stack;
    int type;            /* define type of parser : ";$" common or special symbol */
    /* How about quoting status? */
};

struct pipe {
    int num_progs;                /* total number of programs in job */
    struct child_prog *progs;    /* array of commands in pipe */
    struct pipe *next;            /* to track background commands */
    pipe_style followup;        /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
    reserved_style r_mode;        /* supports if, for, while, until */
};

struct child_prog {
    char **argv;                /* program name and arguments */
    /* was quoted when parsed; copy of struct o_string.nonnull field */
    int *argv_nonnull;
    int    argc;                            /* number of program arguments */
    struct pipe *group;            /* if non-NULL, first in group or subshell */
    int sp;                /* number of SPECIAL_VAR_SYMBOL */
    int type;
};

/* return code is 0 for normal exit, 1 for syntax error */
static int parse_stream(o_string *dest, struct p_context *ctx,
            struct in_str *input, int end_trigger)
{
    unsigned int ch, m;
    int next;

    /* Only double-quote state is handled in the state variable dest->quote.
     * A single-quote triggers a bypass of the main loop until its mate is
     * found.  When recursing, quote state is passed in via dest->quote. */

    debug_printf("parse_stream, end_trigger=%dn",end_trigger);
    while ((ch=b_getch(input))!=EOF) {  //EOF => ctrl + C
        m = map[ch];
        if (input->__promptme == 0) return 1;
        next = (ch == 'n') ? 0 : b_peek(input);

        debug_printf("parse_stream: ch=%c (%d) m=%d quote=%d - %cn",
            ch >= ' ' ? ch : '.', ch, m,
            dest->quote, ctx->stack == NULL ? '*' : '.');

        if (m==0 || ((m==1 || m==2) && dest->quote)) {
            b_addqchr(dest, ch, dest->quote);
        } else {
            if (m==2) {  /* unquoted IFS */
                if (done_word(dest, ctx)) {
                    return 1;
                }
                /* If we aren't performing a substitution, treat a newline as a
                 * command separator.  */
                if (end_trigger != '' && ch=='n')    // 最后执行到这里
                    done_pipe(ctx,PIPE_SEQ);
            }
            if (ch == end_trigger && !dest->quote && ctx->w==RES_NONE) {  //执行完毕，返回
                debug_printf("leaving parse_stream (triggered)n");
                return 0;
            }
            if (m!=2) switch (ch) {
        case '#':
            if (dest->length == 0 && !dest->quote) {
                while(ch=b_peek(input),ch!=EOF && ch!='n') { b_getch(input); }
            } else {
                b_addqchr(dest, ch, dest->quote);
            }
            break;
        case '\':
            if (next == EOF) {
                syntax();
                return 1;
            }
            b_addqchr(dest, '\', dest->quote);
            b_addqchr(dest, b_getch(input), dest->quote);
            break;
        case '$':
            if (handle_dollar(dest, ctx, input)!=0) return 1;
            break;
        case ''':
            dest->nonnull = 1;
            while(ch=b_getch(input),ch!=EOF && ch!=''') {
                if(input->__promptme == 0) return 1;
                b_addchr(dest,ch);
            }
            if (ch==EOF) {
                syntax();
                return 1;
            }
            break;
        case '"':
            dest->nonnull = 1;
            dest->quote = !dest->quote;
            break;
        case ';':
            done_word(dest, ctx);
            done_pipe(ctx,PIPE_SEQ);
            break;
        case '&':
            done_word(dest, ctx);
            if (next=='&') {
                b_getch(input);
                done_pipe(ctx,PIPE_AND);
            } else {
                syntax_err();
                return 1;
            }
            break;
        case '|':
            done_word(dest, ctx);
            if (next=='|') {
                b_getch(input);
                done_pipe(ctx,PIPE_OR);
            } else {
                /* we could pick up a file descriptor choice here
                 * with redirect_opt_num(), but bash doesn't do it.
                 * "echo foo 2| cat" yields "foo 2". */
                syntax_err();
                return 1;
            }
            break;
        case SUBSTED_VAR_SYMBOL:
            dest->nonnull = 1;
            while (ch = b_getch(input), ch != EOF &&
                ch != SUBSTED_VAR_SYMBOL) {
                debug_printf("subst, pass=%dn", ch);
                if (input->__promptme == 0)
                    return 1;
                b_addchr(dest, ch);
            }
            debug_printf("subst, term=%dn", ch);
            if (ch == EOF) {
                syntax();
                return 1;
            }
            break;
        default:
            syntax();   /* this is really an internal logic error */
            return 1;
            }
        }
    }
    /* complain if quote?  No, maybe we just finished a command substitution
     * that was quoted.  Example:
     * $ echo "`cat foo` plus more"
     * and we just got the EOF generated by the subshell that ran "cat foo"
     * The only real complaint is if we got an EOF when end_trigger != '',
     * that is, we were really supposed to get end_trigger, and never got
     * one before the EOF.  Can't use the standard "syntax error" return code,
     * so that parse_stream_outer can distinguish the EOF and exit smoothly. */
    debug_printf("leaving parse_stream (EOF)n");
    if (end_trigger != '') return -1;
    return 0;
}

#define b_getch(input) ((input)->get(input))

/* This is the magic location that prints prompts
 * and gets data back from the user */
static int file_get(struct in_str *i)
{
    int ch;

    ch = 0;
    /* If there is data waiting, eat it up */
    if (i->p && *i->p) {     
        ch = *i->p++;
    } else {
        /* need to double check i->file because we might be doing something
         * more complicated by now, like sourcing or substituting. */
        while(! i->p  || strlen(i->p)==0 ) {
            get_user_input(i);
        }
        i->promptmode=2;
        if (i->p && *i->p) {
            ch = *i->p++;
        }
        debug_printf("b_getch: got a %dn", ch);
    }
    return ch;
}

/* Select which version we will use */
static int run_list(struct pipe *pi)
{
    int rcode=0;
     rcode = run_list_real(pi);
    /* free_pipe_list has the side effect of clearing memory
     * In the long run that function can be merged with run_list_real,
     * but doing that now would hobble the debugging effort. */
    free_pipe_list(pi,0);
    return rcode;
}

static int run_list_real(struct pipe *pi)
{
     ...
     for (; pi; pi = (flag_restore != 0) ? rpipe : pi->next) {  //遍历每一个命令
         ...
         rcode = run_pipe_real(pi);
         ...
     }
　 ...

}

/* run_pipe_real() starts all the jobs, but doesn't wait for anything
 * to finish.  See checkjobs().
 *
 * return code is normally -1, when the caller has to wait for children
 * to finish to determine the exit status of the pipe.  If the pipe
 * is a simple builtin command, however, the action is done by the
 * time run_pipe_real returns, and the exit code is provided as the
 * return value.
 *
 * The input of the pipe is always stdin, the output is always
 * stdout.  The outpipe[] mechanism in BusyBox-0.48 lash is bogus,
 * because it tries to avoid running the command substitution in
 * subshell, when that is in fact necessary.  The subshell process
 * now has its stdout directed to the input of the appropriate pipe,
 * so this routine is noticeably simpler.
 */
static int run_pipe_real(struct pipe *pi)
{
    int i;
    int nextin;
    int flag = do_repeat ? CMD_FLAG_REPEAT : 0;
    struct child_prog *child;
    char *p;

    nextin = 0;

    /* Check if this is a simple builtin (not part of a pipe).
     * Builtins within pipes have to fork anyway, and are handled in
     * pseudo_exec.  "echo foo | read bar" doesn't work on bash, either.
     */
    if (pi->num_progs == 1) child = & (pi->progs[0]);   //pi->progs存放实际命令
    if (pi->num_progs == 1 && child->group) {
        int rcode;
        debug_printf("non-subshell groupingn");
        rcode = run_list_real(child->group);
        return rcode;
    } else if (pi->num_progs == 1 && pi->progs[0].argv != NULL) {
        for (i=0; is_assignment(child->argv[i]); i++) { /* nothing */ }
        if (i!=0 && child->argv[i]==NULL) {
            /* assignments, but no command: set the local environment */
            for (i=0; child->argv[i]!=NULL; i++) {

                /* Ok, this case is tricky.  We have to decide if this is a
                 * local variable, or an already exported variable.  If it is
                 * already exported, we have to export the new value.  If it is
                 * not exported, we need only set this as a local variable.
                 * This junk is all to decide whether or not to export this
                 * variable. */
                int export_me=0;
                char *name, *value;
                name = xstrdup(child->argv[i]);
                debug_printf("Local environment set: %sn", name);
                value = strchr(name, '=');
                if (value)
                    *value=0;

                free(name);
                p = insert_var_value(child->argv[i]);
                set_local_var(p, export_me);
                if (p != child->argv[i]) free(p);
            }
            return EXIT_SUCCESS;   /* don't worry about errors in set_local_var() yet */
        }
        for (i = 0; is_assignment(child->argv[i]); i++) {
            p = insert_var_value(child->argv[i]);
            set_local_var(p, 0);
            if (p != child->argv[i]) {
                child->sp--;
                free(p);
            }
        }
        if (child->sp) {
            char * str = NULL;

            str = make_string(child->argv + i,
                      child->argv_nonnull + i);
            parse_string_outer(str, FLAG_EXIT_FROM_LOOP | FLAG_REPARSING);
            free(str);
            return last_return_code;
        }
        /* check ";", because ,example , argv consist from
         * "help;flinfo" must not execute
         */
        if (strchr(child->argv[i], ';')) {
            printf("Unknown command '%s' - try 'help' or use "
                    "'run' commandn", child->argv[i]);
            return -1;
        }
        /* Process the command */
        return cmd_process(flag, child->argc, child->argv,
                   &flag_repeat, NULL);
    }
    return -1;
}

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]);
    if (cmdtp == NULL) {
        printf("Unknown command '%s' - try 'help'n", argv[0]);
        return 1;
    }

    /* found - check max args */
    if (argc > cmdtp->maxargs)
        rc = CMD_RET_USAGE;
    /* avoid "bootd" recursion */
    else if (cmdtp->cmd == do_bootd) {
        if (flag & CMD_FLAG_BOOTD) {
            puts("'bootd' recursion detectedn");
            rc = CMD_RET_FAILURE;
        } else {
            flag |= CMD_FLAG_BOOTD;
        }
    }

    /* 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;
    }
    if (rc == CMD_RET_USAGE)
        rc = cmd_usage(cmdtp);
    return rc;
}

(cmdtp->cmd)(cmdtp, flag, argc, argv)；

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);
}

__attribute__((section("section_name")))

static char start[0] __aligned(4) __attribute__((unused, section(".u_boot_list_2_"#_list"_1"))); 

#include <stdio.h>
#define ll_entry_start(_list) "u_boot_list_2_"#_list"_1"  //#_list会将_list替换成实际值，并加上""

int main(void) { 
    printf(ll_entry_start(cmd));
    return 0;
}

 .u_boot_list : {
  KEEP(*(SORT(.u_boot_list*)));
 }

.u_boot_list_2_cmd_1  长度为0
.u_boot_list_2_cmd_2_xx  由U_BOOT_CMD和U_BOOT_CMD_COMPLETE定义的命令所在的符号段 
.u_boot_list_2_cmd_3  长度为0

typedef struct cmd_tbl_s    cmd_tbl_t;

/*
 * Monitor Command Table
 */
struct cmd_tbl_s {
    char        *name;        /* 命令名            */
    int        maxargs;    /* 命令最大参数个数    */
    int        repeatable;    /* 自动重复？        */
    /* cmd为函数指针    */
    int        (*cmd)(struct cmd_tbl_s *, int, int, char *[]);
   /* 用法字符串 */
    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 */
    int        (*complete)(int argc, char *argv[], char last_char, int maxv, char *cmdv[]);
#endif
};

#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_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_MKENT_COMPLETE(_name, _maxargs, _rep, _cmd,        
                _usage, _help, _comp)            
        { #_name, _maxargs, _rep, _cmd, _usage,            
            _CMD_HELP(_help) _CMD_COMPLETE(_comp) }

/**
 * ll_entry_declare() - Declare linker-generated array entry
 * @_type:    Data type of the entry
 * @_name:    Name of the entry
 * @_list:    name of the list. Should contain only characters allowed
 *        in a C variable name!
 *
 * This macro declares a variable that is placed into a linker-generated
 * array. This is a basic building block for more advanced use of linker-
 * generated arrays. The user is expected to build their own macro wrapper
 * around this one.
 *
 * A variable declared using this macro must be compile-time initialized.
 *
 * Special precaution must be made when using this macro:
 *
 * 1) The _type must not contain the "static" keyword, otherwise the
 *    entry is generated and can be iterated but is listed in the map
 *    file and cannot be retrieved by name.
 *
 * 2) In case a section is declared that contains some array elements AND
 *    a subsection of this section is declared and contains some elements,
 *    it is imperative that the elements are of the same type.
 *
 * 4) In case an outer section is declared that contains some array elements
 *    AND an inner subsection of this section is declared and contains some
 *    elements, then when traversing the outer section, even the elements of
 *    the inner sections are present in the array.
 *
 * Example:
 * ll_entry_declare(struct my_sub_cmd, my_sub_cmd, cmd_sub) = {
 *         .x = 3,
 *         .y = 4,
 * };
 */
#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)))   //#_list会将_list替换成实际值，并加上""

U_BOOT_CMD(
    bootm,    CONFIG_SYS_MAXARGS,    1,    do_bootm,
    "boot application image from memory", bootm_help_text
);

U_BOOT_CMD(
    env, CONFIG_SYS_MAXARGS, 1, do_env,
    "environment handling commands", env_help_text
);  

U_BOOT_CMD_COMPLETE (
    env, CONFIG_SYS_MAXARGS, 1, do_env,
    "environment handling commands", env_help_text,NULL
);

U_BOOT_CMD_COMPLETE(env, CONFIG_SYS_MAXARGS , 1, do_env , "environment handling commands" , env_help_text , NULL ) 
    ll_entry_declare(cmd_tbl_t, env , cmd) =           
        U_BOOT_CMD_MKENT_COMPLETE(env , CONFIG_SYS_MAXARGS , 1, do_env , "environment handling commands" , env_help_text , NULL);

ll_entry_declare(cmd_tbl_t , env , cmd )            
    cmd_tbl_t _u_boot_list_2_cmd_2_env __aligned(4)       
            __attribute__((unused,              
            section(".u_boot_list_2_cmd_2_env" )))

U_BOOT_CMD_MKENT_COMPLETE(env , CONFIG_SYS_MAXARGS , 1, do_env , _usage, _help, _comp)     
        { "env", CONFIG_SYS_MAXARGS , 1, do_env , "environment handling commands" , env_help_text ,NULL}

cmd_tbl_t _u_boot_list_2_cmd_2_env __aligned(4)       
            __attribute__((unused, section(".u_boot_list_2_cmd_2_env" ))) =
{ "env", CONFIG_SYS_MAXARGS , 1, do_env , "environment handling commands" , env_help_text ,NULL}