一、前言
uboot启动第二阶段与env相关的
uboot启动第二阶段与env有关的函数有两个：env_init（common/env_movi.c）、env_relocate（common/env_common.c）。
env_init函数定义（代码：37 ~82行）
#ifdef ENV_IS_EMBEDDED
extern uchar environment[];
env_t *env_ptr = (env_t *)(&environment[0]);
#else /* ! ENV_IS_EMBEDDED */
env_t *env_ptr = 0;
#endif /* ENV_IS_EMBEDDED */
int env_init(void)
{
#if defined(ENV_IS_EMBEDDED)
ulong total;
int crc1_ok = 0, crc2_ok = 0;
env_t *tmp_env1, *tmp_env2;
total = CFG_ENV_SIZE;
tmp_env1 = env_ptr;
tmp_env2 = (env_t *)((ulong)env_ptr + CFG_ENV_SIZE);
crc1_ok = (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
crc2_ok = (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
if (!crc1_ok && !crc2_ok)
gd->env_valid = 0;
else if(crc1_ok && !crc2_ok)
gd->env_valid = 1;
else if(!crc1_ok && crc2_ok)
gd->env_valid = 2;
else {
/* both ok - check serial */
if(tmp_env1->flags == 255 && tmp_env2->flags == 0)
gd->env_valid = 2;
else if(tmp_env2->flags == 255 && tmp_env1->flags == 0)
gd->env_valid = 1;
else if(tmp_env1->flags > tmp_env2->flags)
gd->env_valid = 1;
else if(tmp_env2->flags > tmp_env1->flags)
gd->env_valid = 2;
else /* flags are equal - almost impossible */
gd->env_valid = 1;
}
if (gd->env_valid == 1)
env_ptr = tmp_env1;
else if (gd->env_valid == 2)
env_ptr = tmp_env2;
#else /* ENV_IS_EMBEDDED */
gd->env_addr = (ulong)&default_environment[0];
gd->env_valid = 1;
#endif /* ENV_IS_EMBEDDED */
return (0);
}
（1）ENV_IS_EMBEDDED
当定义该宏时，环境变量存储在uboot的全局变量缓冲区内（environment，它的定义在environment.c中）；当未定义该宏时，环境变量存储在malloc申请的堆缓冲区中。
env_relocate函数定义（代码：234 ~ 275行）
void env_relocate (void)
{
DEBUGF ("%s[%d] offset = 0x%lx\n", __FUNCTION__,__LINE__,
gd->reloc_off);
#ifdef CONFIG_AMIGAONEG3SE
enable_nvram();
#endif
#ifdef ENV_IS_EMBEDDED
/*
* The environment buffer is embedded with the text segment,
* just relocate the environment pointer
*/
env_ptr = (env_t *)((ulong)env_ptr + gd->reloc_off);
DEBUGF ("%s[%d] embedded ENV at %p\n", __FUNCTION__,__LINE__,env_ptr);
#else
/*
* We must allocate a buffer for the environment
*/
env_ptr = (env_t *)malloc (CFG_ENV_SIZE);
DEBUGF ("%s[%d] malloced ENV at %p\n", __FUNCTION__,__LINE__,env_ptr);
#endif
if (gd->env_valid == 0) {
#if defined(CONFIG_GTH) || defined(CFG_ENV_IS_NOWHERE) /* Environment not changable */
puts ("Using default environment\n\n");
#else
puts ("*** Warning - bad CRC, using default environment\n\n");
show_boot_progress (-60);
#endif
set_default_env();
}
else {
env_relocate_spec ();
}
gd->env_addr = (ulong)&(env_ptr->data);
#ifdef CONFIG_AMIGAONEG3SE
disable_nvram();
#endif
}
二、uboot的环境变量基础
1.环境变量的作用
（1）可以不用修改uboot的源代码，而是通过环境变量来影响uboot运行时的一些数据和特性。例如，通过修改bootdelay环境变量，就可以更改系统开机自动启动时倒数的秒数。
2.环境变量的优先级
（1）uboot代码中有一个值，环境变量中也有一个值。uboot程序实际运行时的规则是：如果环境变量为空，则使用代码中的值；如果环境变量不为空，则优先使用环境变量中的值。
（2）例如machid（机器码）。uboot中在x210_sd.h中定义了一个机器码2456，写死在程序中不能更改。如果要修改uboot中配置的机器码，可以修改x210_sd.h中的机器码，但是在修改源代码后需要重新编译烧录，很麻烦；比较简单的方法就是使用环境变量machid。类似set machid 0x998这样，有了machid环境变量后，系统启动时会优先使用machid对应的环境变量，这就是优先级问题。
3.环境变量在uboot中的工作方式
（1）默认环境变量：common/env_common.c中的default_environment，它本质上是一个字符数组，大小为CFG_ENV_SIZE（16KB），里面的内容就是很多个环境变量连续分布组成的，每个环境变量最末端以'\0'结束。
（2）SD卡中的环境变量分区：在uboot的raw分区中。SD卡其实就是给了一个分区，专门用来存储而已。存储时其实是把DDR中环境变量整体的写入SD卡的分区中。因此当saveenv时，其实是把整个所有的环境变量都保存了一遍，而不是只保存更改的了。
（3）DDR中的环境变量：在default_environment中，实质是字符数组。在uboot中有一个全局变量，链接时在数据段，重定位时default_environment就被重定位到DDR中的一个内存地址处了，这个地址处的字符数组就是uboot运行时DDR中的环境变量了。
总结：刚烧录的系统中环境变量分区是空白的，uboot第一次运行时加载的是uboot代码中自带的那一份环境变量，叫做默认环境变量。在saveenv时，DDR中的环境变量会被更新到SD卡的环境变量分区中，这样就可以保存下来，在下次开机过程中，在环境变量relocate时会把SD卡环境变量分区中的内容加载到DDR中。
default_environment中的内容虽然在uboot源码中被初始化为一定的值（这个值就是默认环境变量），但是在uboot启动的第二阶段的env_relocate时，代码会去判断SD卡中的环境变量分区的CRC是否通过。如果CRC通过，说明SD卡中有正确的环境变量存储，relocate函数会从SD卡中读取环境变量来覆盖default_environment字符数组，从而每次开机可以保持上一次更改过的环境变量。
三、环境变量相关命令源码解析
1.printenv
（1）通过help printenv可以看到该命令有两种使用方法：第一种，直接使用printenv，不加参数，打印所有的环境变量；第二种，使用printenv name ...，只打印name这个环境变量的值。
（2）printenv命令对应的函数是do_printenv，命令和函数的定义都位于common/cmd_nvedit.c中（85 ~ 136行）
int do_printenv (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int i, j, k, nxt;
int rcode = 0;
if (argc == 1) { /* Print all env variables */
for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
for (nxt=i; env_get_char(nxt) != '\0'; ++nxt)
;
for (k=i; k<nxt; ++k)
putc(env_get_char(k));
putc ('\n');
if (ctrlc()) {
puts ("\n ** Abort\n");
return 1;
}
}
printf("\nEnvironment size: %d/%ld bytes\n",
i, (ulong)ENV_SIZE);
return 0;
}
for (i=1; i<argc; ++i) { /* print single env variables */
char *name = argv[i];
k = -1;
for (j=0; env_get_char(j) != '\0'; j=nxt+1) {
for (nxt=j; env_get_char(nxt) != '\0'; ++nxt)
;
k = envmatch((uchar *)name, j);
if (k < 0) {
continue;
}
puts (name);
putc ('=');
while (k < nxt)
putc(env_get_char(k++));
putc ('\n');
break;
}
if (k < 0) {
printf ("## Error: \"%s\" not defined\n", name);
rcode ++;
}
}
return rcode;
}
该函数首先区分argc等于1还是不等于1的情况：若argc等于1，就循环打印所有的环境变量；若argc不等于1，则根据后面的参数的值，是哪一个就打印哪一个。
2.setenv
（1）命令的定义和函数都位于commoon/cmd_nvedit.c（404 ~ 412行）文件中，setenv命令对应的函数是do_setenv。
/************************************************************************
* Set a new environment variable,
* or replace or delete an existing one.
*
* This function will ONLY work with a in-RAM copy of the environment
*/
int _do_setenv (int flag, int argc, char *argv[])
{
int i, len, oldval;
int console = -1;
uchar *env, *nxt = NULL;
char *name;
bd_t *bd = gd->bd;
uchar *env_data = env_get_addr(0);
if (!env_data) /* need copy in RAM */
return 1;
name = argv[1];
if (strchr(name, '=')) {
printf ("## Error: illegal character '=' in variable name \"%s\"\n", name);
return 1;
}
/*
* search if variable with this name already exists
*/
oldval = -1;
for (env=env_data; *env; env=nxt+1) {
for (nxt=env; *nxt; ++nxt)
;
if ((oldval = envmatch((uchar *)name, env-env_data)) >= 0)
break;
}
/*
* Delete any existing definition
*/
if (oldval >= 0) {
#ifndef CONFIG_ENV_OVERWRITE
/*
* Ethernet Address and serial# can be set only once,
* ver is readonly.
*/
if (
#ifdef CONFIG_HAS_UID
/* Allow serial# forced overwrite with 0xdeaf4add flag */
((strcmp (name, "serial#") == 0) && (flag != 0xdeaf4add)) ||
#else
(strcmp (name, "serial#") == 0) ||
#endif
((strcmp (name, "ethaddr") == 0)
#if defined(CONFIG_OVERWRITE_ETHADDR_ONCE) && defined(CONFIG_ETHADDR)
&& (strcmp ((char *)env_get_addr(oldval),MK_STR(CONFIG_ETHADDR)) != 0)
#endif /* CONFIG_OVERWRITE_ETHADDR_ONCE && CONFIG_ETHADDR */
) ) {
printf ("Can't overwrite \"%s\"\n", name);
return 1;
}
#endif
/* Check for console redirection */
if (strcmp(name,"stdin") == 0) {
console = stdin;
} else if (strcmp(name,"stdout") == 0) {
console = stdout;
} else if (strcmp(name,"stderr") == 0) {
console = stderr;
}
if (console != -1) {
if (argc < 3) { /* Cannot delete it! */
printf("Can't delete \"%s\"\n", name);
return 1;
}
/* Try assigning specified device */
if (console_assign (console, argv[2]) < 0)
return 1;
#ifdef CONFIG_SERIAL_MULTI
if (serial_assign (argv[2]) < 0)
return 1;
#endif
}
/*
* Switch to new baudrate if new baudrate is supported
*/
if (strcmp(argv[1],"baudrate") == 0) {
int baudrate = simple_strtoul(argv[2], NULL, 10);
int i;
for (i=0; i<N_BAUDRATES; ++i) {
if (baudrate == baudrate_table[i])
break;
}
if (i == N_BAUDRATES) {
printf ("## Baudrate %d bps not supported\n",
baudrate);
return 1;
}
printf ("## Switch baudrate to %d bps and press ENTER ...\n",
baudrate);
udelay(50000);
gd->baudrate = baudrate;
#if defined(CONFIG_PPC) || defined(CONFIG_MCF52x2)
gd->bd->bi_baudrate = baudrate;
#endif
serial_setbrg ();
udelay(50000);
for (;;) {
if (getc() == '\r')
break;
}
}
if (*++nxt == '\0') {
if (env > env_data) {
env--;
} else {
*env = '\0';
}
} else {
for (;;) {
*env = *nxt++;
if ((*env == '\0') && (*nxt == '\0'))
break;
++env;
}
}
*++env = '\0';
}
#ifdef CONFIG_NET_MULTI
if (strncmp(name, "eth", 3) == 0) {
char *end;
int num = simple_strtoul(name+3, &end, 10);
if (strcmp(end, "addr") == 0) {
eth_set_enetaddr(num, argv[2]);
}
}
#endif
/* Delete only ? */
if ((argc < 3) || argv[2] == NULL) {
env_crc_update ();
return 0;
}
/*
* Append new definition at the end
*/
for (env=env_data; *env || *(env+1); ++env)
;
if (env > env_data)
++env;
/*
* Overflow when:
* "name" + "=" + "val" +"\0\0" > ENV_SIZE - (env-env_data)
*/
len = strlen(name) + 2;
/* add '=' for first arg, ' ' for all others */
for (i=2; i<argc; ++i) {
len += strlen(argv[i]) + 1;
}
if (len > (&env_data[ENV_SIZE]-env)) {
printf ("## Error: environment overflow, \"%s\" deleted\n", name);
return 1;
}
while ((*env = *name++) != '\0')
env++;
for (i=2; i<argc; ++i) {
char *val = argv[i];
*env = (i==2) ? '=' : ' ';
while ((*++env = *val++) != '\0')
;
}
/* end is marked with double '\0' */
*++env = '\0';
/* Update CRC */
env_crc_update ();
/*
* Some variables should be updated when the corresponding
* entry in the enviornment is changed
*/
if (strcmp(argv[1],"ethaddr") == 0) {
char *s = argv[2]; /* always use only one arg */
char *e;
for (i=0; i<6; ++i) {
bd->bi_enetaddr[i] = s ? simple_strtoul(s, &e, 16) : 0;
if (s) s = (*e) ? e+1 : e;
}
#ifdef CONFIG_NET_MULTI
eth_set_enetaddr(0, argv[2]);
#endif
return 0;
}
if (strcmp(argv[1],"ipaddr") == 0) {
char *s = argv[2]; /* always use only one arg */
char *e;
unsigned long addr;
bd->bi_ip_addr = 0;
for (addr=0, i=0; i<4; ++i) {
ulong val = s ? simple_strtoul(s, &e, 10) : 0;
addr <<= 8;
addr |= (val & 0xFF);
if (s) s = (*e) ? e+1 : e;
}
bd->bi_ip_addr = htonl(addr);
return 0;
}
if (strcmp(argv[1],"loadaddr") == 0) {
load_addr = simple_strtoul(argv[2], NULL, 16);
return 0;
}
#if defined(CONFIG_CMD_NET)
if (strcmp(argv[1],"bootfile") == 0) {
copy_filename (BootFile, argv[2], sizeof(BootFile));
return 0;
}
#endif
#ifdef CONFIG_AMIGAONEG3SE
if (strcmp(argv[1], "vga_fg_color") == 0 ||
strcmp(argv[1], "vga_bg_color") == 0 ) {
extern void video_set_color(unsigned char attr);
extern unsigned char video_get_attr(void);
video_set_color(video_get_attr());
return 0;
}
#endif /* CONFIG_AMIGAONEG3SE */
return 0;
}
int do_setenv (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
if (argc < 2) {
printf ("Usage:\n%s\n", cmdtp->usage);
return 1;
}
return _do_setenv (flag, argc, argv);
}
（2）setenv的思路是：先去DDR中的环境变量处寻找原来有没有这个环境变量，如果有，则需要覆盖原来的环境变量，如果没有，则在最后增加增加一个即可。
第1步：遍历DDR中的环境变量数组，找到原来就有的那个环境变量对应的地址（168 ~ 174行）
第2步：擦除原来的环境变量（259 ~ 265行）
第3步：写入新的环境变量（266 ~ 273行）
（3）本来setenv做完上面的就完了，但是还要考虑一些附加的问题。
问题1：环境变量太多，超出DDR中的字符数组，溢出的解决方法。
问题2：有些环境变量如baudrate、ipaddr等，在gd中有对应的全局变量，这种环境变量在set更新时要同时更新对应的全局变量，否则就会出现在本次运行中环境变量和全局变量不一致的情况。
3.saveenv
（1）该命令对应的函数为do_saveenv，定义位于common/cmd_nvedit.c（545 ~ 560行）文件中。
#if ((defined(CFG_ENV_IS_IN_NVRAM) || defined(CFG_ENV_IS_IN_EEPROM) \
|| (defined(CONFIG_CMD_ENV) && defined(CONFIG_CMD_FLASH)) \
|| (defined(CONFIG_CMD_ENV) && defined(CONFIG_CMD_NAND)) \
|| (defined(CONFIG_CMD_ENV) && defined(CONFIG_CMD_ONENAND)) \
|| (defined(CONFIG_CMD_ENV) && defined(CONFIG_CMD_MOVINAND)) \
&& !defined(CFG_ENV_IS_NOWHERE)))
int do_saveenv (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
extern char * env_name_spec;
printf ("Saving Environment to %s...\n", env_name_spec);
return (saveenv() ? 1 : 0);
}
#endif
（2）从uboot实际执行saveenv命令的输出和x210_sd.h中的配置（#define CFG_ENV_IS_AUTO）可以分析出：saveenv命令实际使用的是env_auto.c中相关的内容，没有一种芯片叫auto的，env_auto.c中是使用宏定义的方式去条件编译各种常见的Flash芯片（如MoviNand、NorFlash、Nand等），然后在程序中读取INF_REG（OMPin内部对应的寄存器），从而知道启动介质，最后调用与这种启动介质对应的操作函数来操作。
（3）do_saveenv函数内部调用env_auto.c中的saveenv函数来执行实际的环境变量操作。
（4）寄存器地址：E010F000+0C=E010F0C0，含义是用户自定义数据。在start.S中判断启动介质后将#BOOT_MMCSD（就是3，定义在x210_sd.h中）写入了这个寄存器，所以这里读出的肯定是3，经过判断就是movinand，所以实际执行的函数是saveenv_movinand。
（5）真正执行保存环境变量操作的是：cpu/s5pc11x/movi.c中的movi_write_env函数，这个函数肯定是写SD卡，将DDR中的环境变量数组（其实就是default_environment这个数组，大小16KB，刚好32个扇区）写入iNand中的环境变量分区。
（6）raw_area_control是uboot中规划iNand/SD卡的原始分区表，这个里面记录了对iNand的分区，env分区也在这里，下标是2，追到这一层就够了，再里面就是调用驱动部分的写iNand/SD卡的底层函数了。
4.获取环境变量
代码：498 ~ 543行
char *getenv (char *name)
{
int i, nxt;
WATCHDOG_RESET();
for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
int val;
for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) {
if (nxt >= CFG_ENV_SIZE) {
return (NULL);
}
}
if ((val=envmatch((uchar *)name, i)) < 0)
continue;
return ((char *)env_get_addr(val));
}
return (NULL);
}
int getenv_r (char *name, char *buf, unsigned len)
{
int i, nxt;
for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
int val, n;
for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) {
if (nxt >= CFG_ENV_SIZE) {
return (-1);
}
}
if ((val=envmatch((uchar *)name, i)) < 0)
continue;
/* found; copy out */
n = 0;
while ((len > n++) && (*buf++ = env_get_char(val++)) != '\0')
;
if (len == n)
*buf = '\0';
return (n);
}
return (-1);
}
（1）getenv
应该不可重入的。
实现方式就是去遍历default_environment数组，挨个拿出环境变量比对name，找到相等的直接返回这个环境变量的首地址即可。
（2）getenv_r
可重入版本
getenv函数是直接返回找到的这个环境变量在DDR中环境变量处首地址，而getenv_r函数的做法是找到了DDR中环境变量地址后，将这个环境变量复制一份到提供的buf中，而不动原来DDR中的环境变量。
所以差别就是：getenv中返回的地址只能读不能随便乱写，而getenv_r中返回的环境变量是在自己提供的buf中，是可以随便改写加工的。
（3）总结
功能是一样的，但是可重入版本会比较安全一些，建议使用。
有关于环境变量的所有操作，主要理解了环境变量在DDR中的存储方法，理解了环境变量和gd全局变量的关联和优先级，理解了环境变量在存储介质中的存储方式（专用raw分区），整个环境变量相关的就清楚了。
扫一扫
802
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
