uboot的环境变量

一、前言

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分区），整个环境变量相关的就清楚了。