Blame view
cmd/nvedit.c
30.3 KB
a68d3ed0a
|
1 |
/* |
ea009d474
|
2 |
* (C) Copyright 2000-2013 |
a68d3ed0a
|
3 4 5 6 |
* Wolfgang Denk, DENX Software Engineering, wd@denx.de. * * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com> * Andreas Heppel <aheppel@sysgo.de> |
a000b7950
|
7 8 9 |
* * Copyright 2011 Freescale Semiconductor, Inc. * |
3765b3e7b
|
10 |
* SPDX-License-Identifier: GPL-2.0+ |
a68d3ed0a
|
11 |
*/ |
ea882baf9
|
12 |
/* |
a68d3ed0a
|
13 14 |
* Support for persistent environment data * |
ea882baf9
|
15 16 |
* The "environment" is stored on external storage as a list of '\0' * terminated "name=value" strings. The end of the list is marked by |
fc0b5948e
|
17 |
* a double '\0'. The environment is preceded by a 32 bit CRC over |
ea882baf9
|
18 19 |
* the data part and, in case of redundant environment, a byte of * flags. |
a68d3ed0a
|
20 |
* |
ea882baf9
|
21 22 23 |
* This linearized representation will also be used before * relocation, i. e. as long as we don't have a full C runtime * environment. After that, we use a hash table. |
a68d3ed0a
|
24 25 26 |
*/ #include <common.h> |
18d66533a
|
27 |
#include <cli.h> |
a68d3ed0a
|
28 |
#include <command.h> |
24b852a7a
|
29 |
#include <console.h> |
a68d3ed0a
|
30 |
#include <environment.h> |
ea882baf9
|
31 32 |
#include <search.h> #include <errno.h> |
246c69225
|
33 |
#include <malloc.h> |
0eb25b619
|
34 |
#include <mapmem.h> |
2a3cb0207
|
35 |
#include <watchdog.h> |
a68d3ed0a
|
36 37 |
#include <linux/stddef.h> #include <asm/byteorder.h> |
fd37dac9e
|
38 |
#include <asm/io.h> |
a68d3ed0a
|
39 |
|
d87080b72
|
40 |
DECLARE_GLOBAL_DATA_PTR; |
f3c615b8a
|
41 42 |
#if !defined(CONFIG_ENV_IS_IN_EEPROM) && \ !defined(CONFIG_ENV_IS_IN_FLASH) && \ |
f3c615b8a
|
43 |
!defined(CONFIG_ENV_IS_IN_MMC) && \ |
57210c7cc
|
44 |
!defined(CONFIG_ENV_IS_IN_FAT) && \ |
fd1000b9c
|
45 |
!defined(CONFIG_ENV_IS_IN_EXT4) && \ |
f3c615b8a
|
46 47 48 |
!defined(CONFIG_ENV_IS_IN_NAND) && \ !defined(CONFIG_ENV_IS_IN_NVRAM) && \ !defined(CONFIG_ENV_IS_IN_ONENAND) && \ |
125d193c4
|
49 |
!defined(CONFIG_ENV_IS_IN_SATA) && \ |
f3c615b8a
|
50 |
!defined(CONFIG_ENV_IS_IN_SPI_FLASH) && \ |
0a85a9e70
|
51 |
!defined(CONFIG_ENV_IS_IN_REMOTE) && \ |
2b74433f3
|
52 |
!defined(CONFIG_ENV_IS_IN_UBI) && \ |
f3c615b8a
|
53 |
!defined(CONFIG_ENV_IS_NOWHERE) |
7b7341d7f
|
54 |
# error Define one of CONFIG_ENV_IS_IN_{EEPROM|FLASH|MMC|FAT|EXT4|\ |
d1b88cd32
|
55 |
NAND|NVRAM|ONENAND|SATA|SPI_FLASH|REMOTE|UBI} or CONFIG_ENV_IS_NOWHERE |
a68d3ed0a
|
56 |
#endif |
ea882baf9
|
57 58 59 60 |
/* * Maximum expected input data size for import command */ #define MAX_ENV_SIZE (1 << 20) /* 1 MiB */ |
a68d3ed0a
|
61 |
|
a68d3ed0a
|
62 |
/* |
ea882baf9
|
63 |
* This variable is incremented on each do_env_set(), so it can |
da95427ce
|
64 65 66 67 68 |
* be used via get_env_id() as an indication, if the environment * has changed or not. So it is possible to reread an environment * variable only if the environment was changed ... done so for * example in NetInitLoop() */ |
2f70c49e5
|
69 |
static int env_id = 1; |
a68d3ed0a
|
70 |
|
f3c615b8a
|
71 |
int get_env_id(void) |
2f70c49e5
|
72 73 74 |
{ return env_id; } |
a68d3ed0a
|
75 |
|
7ac2fe2da
|
76 |
#ifndef CONFIG_SPL_BUILD |
4c94f6c54
|
77 |
/* |
ea882baf9
|
78 79 80 |
* Command interface: print one or all environment variables * * Returns 0 in case of error, or length of printed string |
4c94f6c54
|
81 |
*/ |
be11235ab
|
82 |
static int env_print(char *name, int flag) |
a68d3ed0a
|
83 |
{ |
ea882baf9
|
84 |
char *res = NULL; |
22a4a6c5c
|
85 |
ssize_t len; |
ea882baf9
|
86 87 88 89 90 91 |
if (name) { /* print a single name */ ENTRY e, *ep; e.key = name; e.data = NULL; |
be11235ab
|
92 |
hsearch_r(e, FIND, &ep, &env_htab, flag); |
ea882baf9
|
93 94 |
if (ep == NULL) return 0; |
f3c615b8a
|
95 96 |
len = printf("%s=%s ", ep->key, ep->data); |
ea882baf9
|
97 98 |
return len; } |
a68d3ed0a
|
99 |
|
ea882baf9
|
100 |
/* print whole list */ |
be11235ab
|
101 102 |
len = hexport_r(&env_htab, ' ', flag, &res, 0, 0, NULL); |
a68d3ed0a
|
103 |
|
ea882baf9
|
104 105 106 107 |
if (len > 0) { puts(res); free(res); return len; |
a68d3ed0a
|
108 |
} |
ea882baf9
|
109 |
/* should never happen */ |
22a4a6c5c
|
110 111 |
printf("## Error: cannot export environment "); |
ea882baf9
|
112 |
return 0; |
4c94f6c54
|
113 |
} |
a68d3ed0a
|
114 |
|
088f1b199
|
115 116 |
static int do_env_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
4c94f6c54
|
117 118 119 |
{ int i; int rcode = 0; |
be11235ab
|
120 121 122 123 124 125 126 |
int env_flag = H_HIDE_DOT; if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'a') { argc--; argv++; env_flag &= ~H_HIDE_DOT; } |
a68d3ed0a
|
127 |
|
4c94f6c54
|
128 129 |
if (argc == 1) { /* print all env vars */ |
be11235ab
|
130 |
rcode = env_print(NULL, env_flag); |
ea882baf9
|
131 |
if (!rcode) |
4c94f6c54
|
132 133 134 135 136 137 138 |
return 1; printf(" Environment size: %d/%ld bytes ", rcode, (ulong)ENV_SIZE); return 0; } |
a68d3ed0a
|
139 |
|
4c94f6c54
|
140 |
/* print selected env vars */ |
be11235ab
|
141 |
env_flag &= ~H_HIDE_DOT; |
4c94f6c54
|
142 |
for (i = 1; i < argc; ++i) { |
be11235ab
|
143 |
int rc = env_print(argv[i], env_flag); |
ea882baf9
|
144 145 146 |
if (!rc) { printf("## Error: \"%s\" not defined ", argv[i]); |
4c94f6c54
|
147 |
++rcode; |
a68d3ed0a
|
148 149 |
} } |
4c94f6c54
|
150 |
|
a68d3ed0a
|
151 152 |
return rcode; } |
a000b7950
|
153 |
#ifdef CONFIG_CMD_GREPENV |
d09b1787a
|
154 155 |
static int do_env_grep(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
a000b7950
|
156 |
{ |
5a31ea04c
|
157 |
char *res = NULL; |
be29df6a1
|
158 |
int len, grep_how, grep_what; |
a000b7950
|
159 160 |
if (argc < 2) |
4c12eeb8b
|
161 |
return CMD_RET_USAGE; |
a000b7950
|
162 |
|
be29df6a1
|
163 164 |
grep_how = H_MATCH_SUBSTR; /* default: substring search */ grep_what = H_MATCH_BOTH; /* default: grep names and values */ |
d87244d5a
|
165 |
|
9a8323311
|
166 167 |
while (--argc > 0 && **++argv == '-') { char *arg = *argv; |
d87244d5a
|
168 169 |
while (*++arg) { switch (*arg) { |
be29df6a1
|
170 171 172 173 174 |
#ifdef CONFIG_REGEX case 'e': /* use regex matching */ grep_how = H_MATCH_REGEX; break; #endif |
d87244d5a
|
175 |
case 'n': /* grep for name */ |
be29df6a1
|
176 |
grep_what = H_MATCH_KEY; |
d87244d5a
|
177 178 |
break; case 'v': /* grep for value */ |
be29df6a1
|
179 |
grep_what = H_MATCH_DATA; |
d87244d5a
|
180 181 |
break; case 'b': /* grep for both */ |
be29df6a1
|
182 |
grep_what = H_MATCH_BOTH; |
d87244d5a
|
183 184 185 186 187 188 189 190 191 192 |
break; case '-': goto DONE; default: return CMD_RET_USAGE; } } } DONE: |
5a31ea04c
|
193 194 |
len = hexport_r(&env_htab, ' ', |
be29df6a1
|
195 |
flag | grep_what | grep_how, |
5a31ea04c
|
196 |
&res, 0, argc, argv); |
a000b7950
|
197 |
|
5a31ea04c
|
198 199 200 |
if (len > 0) { puts(res); free(res); |
a000b7950
|
201 |
} |
5a31ea04c
|
202 203 204 205 |
if (len < 2) return 1; return 0; |
a000b7950
|
206 207 |
} #endif |
7ac2fe2da
|
208 |
#endif /* CONFIG_SPL_BUILD */ |
a000b7950
|
209 |
|
ea882baf9
|
210 |
/* |
c3f652585
|
211 212 |
* Set a new environment variable, * or replace or delete an existing one. |
2598090b7
|
213 |
*/ |
94b467b14
|
214 |
static int _do_env_set(int flag, int argc, char * const argv[], int env_flag) |
c3f652585
|
215 216 217 218 |
{ int i, len; char *name, *value, *s; ENTRY e, *ep; |
24ab5a191
|
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 |
debug("Initial value for argc=%d ", argc); while (argc > 1 && **(argv + 1) == '-') { char *arg = *++argv; --argc; while (*++arg) { switch (*arg) { case 'f': /* force */ env_flag |= H_FORCE; break; default: return CMD_RET_USAGE; } } } debug("Final value for argc=%d ", argc); |
c3f652585
|
237 |
name = argv[1]; |
c3f652585
|
238 239 240 241 242 243 244 245 246 |
if (strchr(name, '=')) { printf("## Error: illegal character '='" "in variable name \"%s\" ", name); return 1; } env_id++; |
c3f652585
|
247 |
|
a68d3ed0a
|
248 |
/* Delete only ? */ |
d09b1787a
|
249 |
if (argc < 3 || argv[2] == NULL) { |
24ab5a191
|
250 |
int rc = hdelete_r(name, &env_htab, env_flag); |
ea882baf9
|
251 |
return !rc; |
a68d3ed0a
|
252 253 254 |
} /* |
ea882baf9
|
255 |
* Insert / replace new value |
a68d3ed0a
|
256 |
*/ |
f3c615b8a
|
257 |
for (i = 2, len = 0; i < argc; ++i) |
a68d3ed0a
|
258 |
len += strlen(argv[i]) + 1; |
f3c615b8a
|
259 260 261 |
value = malloc(len); if (value == NULL) { |
ea882baf9
|
262 263 |
printf("## Can't malloc %d bytes ", len); |
a68d3ed0a
|
264 265 |
return 1; } |
f3c615b8a
|
266 |
for (i = 2, s = value; i < argc; ++i) { |
ea882baf9
|
267 |
char *v = argv[i]; |
a68d3ed0a
|
268 |
|
ea882baf9
|
269 |
while ((*s++ = *v++) != '\0') |
a68d3ed0a
|
270 |
; |
d09b1787a
|
271 |
*(s - 1) = ' '; |
ea882baf9
|
272 273 274 |
} if (s != value) *--s = '\0'; |
d09b1787a
|
275 276 |
e.key = name; e.data = value; |
24ab5a191
|
277 |
hsearch_r(e, ENTER, &ep, &env_htab, env_flag); |
ea882baf9
|
278 279 280 281 282 283 |
free(value); if (!ep) { printf("## Error inserting \"%s\" variable, errno=%d ", name, errno); return 1; |
a68d3ed0a
|
284 |
} |
a68d3ed0a
|
285 |
|
a68d3ed0a
|
286 287 |
return 0; } |
382bee57f
|
288 |
int env_set(const char *varname, const char *varvalue) |
a68d3ed0a
|
289 |
{ |
84b5e8022
|
290 |
const char * const argv[4] = { "setenv", varname, varvalue, NULL }; |
a7eb1d66c
|
291 292 293 |
/* before import into hashtable */ if (!(gd->flags & GD_FLG_ENV_READY)) return 1; |
d09b1787a
|
294 |
if (varvalue == NULL || varvalue[0] == '\0') |
94b467b14
|
295 |
return _do_env_set(0, 2, (char * const *)argv, H_PROGRAMMATIC); |
9ffd451af
|
296 |
else |
94b467b14
|
297 |
return _do_env_set(0, 3, (char * const *)argv, H_PROGRAMMATIC); |
a68d3ed0a
|
298 |
} |
d67f10ce0
|
299 300 301 |
/** * Set an environment variable to an integer value * |
9602286d3
|
302 |
* @param varname Environment variable to set |
d67f10ce0
|
303 304 305 |
* @param value Value to set it to * @return 0 if ok, 1 on error */ |
018f53032
|
306 |
int env_set_ulong(const char *varname, ulong value) |
d67f10ce0
|
307 308 309 |
{ /* TODO: this should be unsigned */ char *str = simple_itoa(value); |
382bee57f
|
310 |
return env_set(varname, str); |
d67f10ce0
|
311 312 313 |
} /** |
bfc599664
|
314 |
* Set an environment variable to an value in hex |
d67f10ce0
|
315 |
* |
9602286d3
|
316 |
* @param varname Environment variable to set |
bfc599664
|
317 |
* @param value Value to set it to |
d67f10ce0
|
318 319 |
* @return 0 if ok, 1 on error */ |
018f53032
|
320 |
int env_set_hex(const char *varname, ulong value) |
d67f10ce0
|
321 322 |
{ char str[17]; |
bfc599664
|
323 |
sprintf(str, "%lx", value); |
382bee57f
|
324 |
return env_set(varname, str); |
d67f10ce0
|
325 |
} |
bfebc8c96
|
326 |
ulong env_get_hex(const char *varname, ulong default_val) |
76b8f79c2
|
327 328 329 330 |
{ const char *s; ulong value; char *endp; |
00caae6d4
|
331 |
s = env_get(varname); |
76b8f79c2
|
332 333 334 335 336 337 338 |
if (s) value = simple_strtoul(s, &endp, 16); if (!s || endp == s) return default_val; return value; } |
7ac2fe2da
|
339 |
#ifndef CONFIG_SPL_BUILD |
088f1b199
|
340 |
static int do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
a68d3ed0a
|
341 |
{ |
47e26b1bf
|
342 |
if (argc < 2) |
4c12eeb8b
|
343 |
return CMD_RET_USAGE; |
a68d3ed0a
|
344 |
|
94b467b14
|
345 |
return _do_env_set(flag, argc, argv, H_INTERACTIVE); |
a68d3ed0a
|
346 |
} |
ea882baf9
|
347 |
/* |
a68d3ed0a
|
348 349 |
* Prompt for environment variable */ |
c76fe4742
|
350 |
#if defined(CONFIG_CMD_ASKENV) |
f3c615b8a
|
351 |
int do_env_ask(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
a68d3ed0a
|
352 |
{ |
6d0f6bcf3
|
353 |
char message[CONFIG_SYS_CBSIZE]; |
7d85591dd
|
354 |
int i, len, pos, size; |
a68d3ed0a
|
355 |
char *local_args[4]; |
7d85591dd
|
356 |
char *endptr; |
a68d3ed0a
|
357 358 359 360 361 |
local_args[0] = argv[0]; local_args[1] = argv[1]; local_args[2] = NULL; local_args[3] = NULL; |
7d85591dd
|
362 363 364 365 366 367 |
/* * Check the syntax: * * env_ask envname [message1 ...] [size] */ if (argc == 1) |
4c12eeb8b
|
368 |
return CMD_RET_USAGE; |
a68d3ed0a
|
369 |
|
7d85591dd
|
370 371 372 373 374 375 376 377 378 379 380 381 382 |
/* * We test the last argument if it can be converted * into a decimal number. If yes, we assume it's * the size. Otherwise we echo it as part of the * message. */ i = simple_strtoul(argv[argc - 1], &endptr, 10); if (*endptr != '\0') { /* no size */ size = CONFIG_SYS_CBSIZE - 1; } else { /* size given */ size = i; --argc; } |
a68d3ed0a
|
383 |
|
7d85591dd
|
384 385 386 387 |
if (argc <= 2) { sprintf(message, "Please enter '%s': ", argv[1]); } else { /* env_ask envname message1 ... messagen [size] */ |
bf52fcdef
|
388 |
for (i = 2, pos = 0; i < argc && pos+1 < sizeof(message); i++) { |
f3c615b8a
|
389 |
if (pos) |
a68d3ed0a
|
390 |
message[pos++] = ' '; |
f3c615b8a
|
391 |
|
c667723ff
|
392 |
strncpy(message + pos, argv[i], sizeof(message) - pos); |
a68d3ed0a
|
393 394 |
pos += strlen(argv[i]); } |
c667723ff
|
395 396 397 398 399 |
if (pos < sizeof(message) - 1) { message[pos++] = ' '; message[pos] = '\0'; } else message[CONFIG_SYS_CBSIZE - 1] = '\0'; |
a68d3ed0a
|
400 |
} |
6d0f6bcf3
|
401 402 |
if (size >= CONFIG_SYS_CBSIZE) size = CONFIG_SYS_CBSIZE - 1; |
a68d3ed0a
|
403 404 405 406 407 |
if (size <= 0) return 1; /* prompt for input */ |
e1bf824df
|
408 |
len = cli_readline(message); |
a68d3ed0a
|
409 410 411 412 413 414 415 416 417 418 419 |
if (size < len) console_buffer[size] = '\0'; len = 2; if (console_buffer[0] != '\0') { local_args[2] = console_buffer; len = 3; } /* Continue calling setenv code */ |
94b467b14
|
420 |
return _do_env_set(flag, len, local_args, H_INTERACTIVE); |
a68d3ed0a
|
421 |
} |
902531788
|
422 |
#endif |
a68d3ed0a
|
423 |
|
5e2b3e0c5
|
424 |
#if defined(CONFIG_CMD_ENV_CALLBACK) |
cca98fd6a
|
425 426 |
static int print_static_binding(const char *var_name, const char *callback_name, void *priv) |
5e2b3e0c5
|
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 |
{ printf("\t%-20s %-20s ", var_name, callback_name); return 0; } static int print_active_callback(ENTRY *entry) { struct env_clbk_tbl *clbkp; int i; int num_callbacks; if (entry->callback == NULL) return 0; /* look up the callback in the linker-list */ num_callbacks = ll_entry_count(struct env_clbk_tbl, env_clbk); for (i = 0, clbkp = ll_entry_start(struct env_clbk_tbl, env_clbk); i < num_callbacks; i++, clbkp++) { #if defined(CONFIG_NEEDS_MANUAL_RELOC) if (entry->callback == clbkp->callback + gd->reloc_off) #else if (entry->callback == clbkp->callback) #endif break; } if (i == num_callbacks) /* this should probably never happen, but just in case... */ printf("\t%-20s %p ", entry->key, entry->callback); else printf("\t%-20s %-20s ", entry->key, clbkp->name); return 0; } /* * Print the callbacks available and what they are bound to */ int do_env_callback(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { struct env_clbk_tbl *clbkp; int i; int num_callbacks; /* Print the available callbacks */ puts("Available callbacks: "); puts("\tCallback Name "); puts("\t------------- "); num_callbacks = ll_entry_count(struct env_clbk_tbl, env_clbk); for (i = 0, clbkp = ll_entry_start(struct env_clbk_tbl, env_clbk); i < num_callbacks; i++, clbkp++) printf("\t%s ", clbkp->name); puts(" "); /* Print the static bindings that may exist */ puts("Static callback bindings: "); printf("\t%-20s %-20s ", "Variable Name", "Callback Name"); printf("\t%-20s %-20s ", "-------------", "-------------"); |
cca98fd6a
|
499 |
env_attr_walk(ENV_CALLBACK_LIST_STATIC, print_static_binding, NULL); |
5e2b3e0c5
|
500 501 502 503 504 505 506 507 508 509 510 511 512 513 |
puts(" "); /* walk through each variable and print the callback if it has one */ puts("Active callback bindings: "); printf("\t%-20s %-20s ", "Variable Name", "Callback Name"); printf("\t%-20s %-20s ", "-------------", "-------------"); hwalk_r(&env_htab, print_active_callback); return 0; } #endif |
fffad71bc
|
514 |
#if defined(CONFIG_CMD_ENV_FLAGS) |
cca98fd6a
|
515 516 |
static int print_static_flags(const char *var_name, const char *flags, void *priv) |
fffad71bc
|
517 518 |
{ enum env_flags_vartype type = env_flags_parse_vartype(flags); |
267541f77
|
519 |
enum env_flags_varaccess access = env_flags_parse_varaccess(flags); |
fffad71bc
|
520 |
|
267541f77
|
521 522 523 524 |
printf("\t%-20s %-20s %-20s ", var_name, env_flags_get_vartype_name(type), env_flags_get_varaccess_name(access)); |
fffad71bc
|
525 526 527 528 529 530 531 |
return 0; } static int print_active_flags(ENTRY *entry) { enum env_flags_vartype type; |
267541f77
|
532 |
enum env_flags_varaccess access; |
fffad71bc
|
533 534 535 536 537 538 |
if (entry->flags == 0) return 0; type = (enum env_flags_vartype) (entry->flags & ENV_FLAGS_VARTYPE_BIN_MASK); |
267541f77
|
539 540 541 542 543 |
access = env_flags_parse_varaccess_from_binflags(entry->flags); printf("\t%-20s %-20s %-20s ", entry->key, env_flags_get_vartype_name(type), env_flags_get_varaccess_name(access)); |
fffad71bc
|
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 |
return 0; } /* * Print the flags available and what variables have flags */ int do_env_flags(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { /* Print the available variable types */ printf("Available variable type flags (position %d): ", ENV_FLAGS_VARTYPE_LOC); puts("\tFlag\tVariable Type Name "); puts("\t----\t------------------ "); env_flags_print_vartypes(); puts(" "); |
267541f77
|
564 565 566 567 568 569 570 571 572 573 574 |
/* Print the available variable access types */ printf("Available variable access flags (position %d): ", ENV_FLAGS_VARACCESS_LOC); puts("\tFlag\tVariable Access Name "); puts("\t----\t-------------------- "); env_flags_print_varaccess(); puts(" "); |
fffad71bc
|
575 576 577 |
/* Print the static flags that may exist */ puts("Static flags: "); |
267541f77
|
578 579 580 581 582 583 |
printf("\t%-20s %-20s %-20s ", "Variable Name", "Variable Type", "Variable Access"); printf("\t%-20s %-20s %-20s ", "-------------", "-------------", "---------------"); |
cca98fd6a
|
584 |
env_attr_walk(ENV_FLAGS_LIST_STATIC, print_static_flags, NULL); |
fffad71bc
|
585 586 587 588 589 590 |
puts(" "); /* walk through each variable and print the flags if non-default */ puts("Active flags: "); |
267541f77
|
591 592 593 594 595 596 |
printf("\t%-20s %-20s %-20s ", "Variable Name", "Variable Type", "Variable Access"); printf("\t%-20s %-20s %-20s ", "-------------", "-------------", "---------------"); |
fffad71bc
|
597 598 599 600 |
hwalk_r(&env_htab, print_active_flags); return 0; } #endif |
ea882baf9
|
601 |
/* |
246c69225
|
602 603 604 |
* Interactively edit an environment variable */ #if defined(CONFIG_CMD_EDITENV) |
088f1b199
|
605 606 |
static int do_env_edit(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
246c69225
|
607 608 609 |
{ char buffer[CONFIG_SYS_CBSIZE]; char *init_val; |
246c69225
|
610 |
|
47e26b1bf
|
611 |
if (argc < 2) |
4c12eeb8b
|
612 |
return CMD_RET_USAGE; |
246c69225
|
613 |
|
94b467b14
|
614 615 616 |
/* before import into hashtable */ if (!(gd->flags & GD_FLG_ENV_READY)) return 1; |
246c69225
|
617 |
/* Set read buffer to initial value or empty sting */ |
00caae6d4
|
618 |
init_val = env_get(argv[1]); |
246c69225
|
619 |
if (init_val) |
5d49b4cdf
|
620 |
snprintf(buffer, CONFIG_SYS_CBSIZE, "%s", init_val); |
246c69225
|
621 622 |
else buffer[0] = '\0'; |
e1bf824df
|
623 |
if (cli_readline_into_buffer("edit: ", buffer, 0) < 0) |
18a3cce9f
|
624 |
return 1; |
246c69225
|
625 |
|
94b467b14
|
626 627 628 629 630 631 632 633 634 635 |
if (buffer[0] == '\0') { const char * const _argv[3] = { "setenv", argv[1], NULL }; return _do_env_set(0, 2, (char * const *)_argv, H_INTERACTIVE); } else { const char * const _argv[4] = { "setenv", argv[1], buffer, NULL }; return _do_env_set(0, 3, (char * const *)_argv, H_INTERACTIVE); } |
246c69225
|
636 637 |
} #endif /* CONFIG_CMD_EDITENV */ |
7ac2fe2da
|
638 |
#endif /* CONFIG_SPL_BUILD */ |
246c69225
|
639 |
|
ea882baf9
|
640 |
/* |
a68d3ed0a
|
641 642 643 644 |
* Look up variable from environment, * return address of storage for that variable, * or NULL if not found */ |
00caae6d4
|
645 |
char *env_get(const char *name) |
a68d3ed0a
|
646 |
{ |
d09b1787a
|
647 |
if (gd->flags & GD_FLG_ENV_READY) { /* after import into hashtable */ |
ea882baf9
|
648 |
ENTRY e, *ep; |
a68d3ed0a
|
649 |
|
91a76751a
|
650 |
WATCHDOG_RESET(); |
2a3cb0207
|
651 |
|
d09b1787a
|
652 653 |
e.key = name; e.data = NULL; |
c4e0057fa
|
654 |
hsearch_r(e, FIND, &ep, &env_htab, 0); |
91a76751a
|
655 |
|
f3c615b8a
|
656 |
return ep ? ep->data : NULL; |
a68d3ed0a
|
657 |
} |
ea882baf9
|
658 |
/* restricted capabilities before import */ |
00caae6d4
|
659 |
if (env_get_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) > 0) |
ea882baf9
|
660 |
return (char *)(gd->env_buf); |
91a76751a
|
661 |
|
ea882baf9
|
662 |
return NULL; |
a68d3ed0a
|
663 |
} |
ea882baf9
|
664 665 666 |
/* * Look up variable from environment for restricted C runtime env. */ |
00caae6d4
|
667 |
int env_get_f(const char *name, char *buf, unsigned len) |
a68d3ed0a
|
668 |
{ |
87c7fb396
|
669 |
int i, nxt, c; |
a68d3ed0a
|
670 |
|
d09b1787a
|
671 |
for (i = 0; env_get_char(i) != '\0'; i = nxt + 1) { |
a68d3ed0a
|
672 |
int val, n; |
87c7fb396
|
673 674 675 |
for (nxt = i; (c = env_get_char(nxt)) != '\0'; ++nxt) { if (c < 0) return c; |
f3c615b8a
|
676 677 |
if (nxt >= CONFIG_ENV_SIZE) return -1; |
a68d3ed0a
|
678 |
} |
f3c615b8a
|
679 680 681 |
val = envmatch((uchar *)name, i); if (val < 0) |
a68d3ed0a
|
682 |
continue; |
9ed4a9582
|
683 |
|
a68d3ed0a
|
684 |
/* found; copy out */ |
f3c615b8a
|
685 |
for (n = 0; n < len; ++n, ++buf) { |
87c7fb396
|
686 687 688 689 |
c = env_get_char(val++); if (c < 0) return c; *buf = c; |
d09b1787a
|
690 |
if (*buf == '\0') |
9ed4a9582
|
691 692 693 694 695 |
return n; } if (n) *--buf = '\0'; |
a02a884b9
|
696 697 698 |
printf("env_buf [%d bytes] too small for value of \"%s\" ", len, name); |
9ed4a9582
|
699 700 |
return n; |
a68d3ed0a
|
701 |
} |
d09b1787a
|
702 |
|
f3c615b8a
|
703 |
return -1; |
a68d3ed0a
|
704 |
} |
4a9b41310
|
705 706 707 708 709 710 711 712 713 |
/** * Decode the integer value of an environment variable and return it. * * @param name Name of environemnt variable * @param base Number base to use (normally 10, or 16 for hex) * @param default_val Default value to return if the variable is not * found * @return the decoded value, or default_val if not found */ |
bfebc8c96
|
714 |
ulong env_get_ulong(const char *name, int base, ulong default_val) |
4a9b41310
|
715 716 |
{ /* |
00caae6d4
|
717 |
* We can use env_get() here, even before relocation, since the |
4a9b41310
|
718 719 |
* environment variable value is an integer and thus short. */ |
00caae6d4
|
720 |
const char *str = env_get(name); |
4a9b41310
|
721 722 723 |
return str ? simple_strtoul(str, NULL, base) : default_val; } |
7ac2fe2da
|
724 |
#ifndef CONFIG_SPL_BUILD |
bdab39d35
|
725 |
#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE) |
088f1b199
|
726 727 |
static int do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
a68d3ed0a
|
728 |
{ |
01510091d
|
729 |
return env_save() ? 1 : 0; |
a68d3ed0a
|
730 |
} |
8bde7f776
|
731 |
|
ba69dc26a
|
732 |
U_BOOT_CMD( |
ea882baf9
|
733 |
saveenv, 1, 0, do_env_save, |
2fb2604d5
|
734 |
"save environment variables to persistent storage", |
a89c33db9
|
735 |
"" |
ba69dc26a
|
736 |
); |
a68d3ed0a
|
737 |
#endif |
7ac2fe2da
|
738 |
#endif /* CONFIG_SPL_BUILD */ |
a68d3ed0a
|
739 |
|
ea882baf9
|
740 |
/* |
a68d3ed0a
|
741 742 743 744 |
* Match a name / name=value pair * * s1 is either a simple 'name', or a 'name=value' pair. * i2 is the environment index for a 'name2=value2' pair. |
d09b1787a
|
745 |
* If the names match, return the index for the value2, else -1. |
a68d3ed0a
|
746 |
*/ |
f3c615b8a
|
747 |
int envmatch(uchar *s1, int i2) |
a68d3ed0a
|
748 |
{ |
586197dfe
|
749 750 |
if (s1 == NULL) return -1; |
a68d3ed0a
|
751 752 |
while (*s1 == env_get_char(i2++)) if (*s1++ == '=') |
f3c615b8a
|
753 |
return i2; |
d09b1787a
|
754 |
|
a68d3ed0a
|
755 |
if (*s1 == '\0' && env_get_char(i2-1) == '=') |
f3c615b8a
|
756 |
return i2; |
d09b1787a
|
757 |
|
f3c615b8a
|
758 |
return -1; |
a68d3ed0a
|
759 |
} |
8bde7f776
|
760 |
|
7ac2fe2da
|
761 |
#ifndef CONFIG_SPL_BUILD |
b64b7c3df
|
762 |
static int do_env_default(cmd_tbl_t *cmdtp, int __flag, |
d09b1787a
|
763 |
int argc, char * const argv[]) |
ea882baf9
|
764 |
{ |
b64b7c3df
|
765 |
int all = 0, flag = 0; |
f3c615b8a
|
766 |
|
b64b7c3df
|
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 |
debug("Initial value for argc=%d ", argc); while (--argc > 0 && **++argv == '-') { char *arg = *argv; while (*++arg) { switch (*arg) { case 'a': /* default all */ all = 1; break; case 'f': /* force */ flag |= H_FORCE; break; default: return cmd_usage(cmdtp); } } } debug("Final value for argc=%d ", argc); if (all && (argc == 0)) { /* Reset the whole environment */ set_default_env("## Resetting to default environment "); return 0; } if (!all && (argc > 0)) { /* Reset individual variables */ set_default_vars(argc, argv); return 0; } return cmd_usage(cmdtp); |
ea882baf9
|
800 |
} |
d09b1787a
|
801 802 |
static int do_env_delete(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
ea882baf9
|
803 |
{ |
9d8d661d7
|
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 |
int env_flag = H_INTERACTIVE; int ret = 0; debug("Initial value for argc=%d ", argc); while (argc > 1 && **(argv + 1) == '-') { char *arg = *++argv; --argc; while (*++arg) { switch (*arg) { case 'f': /* force */ env_flag |= H_FORCE; break; default: return CMD_RET_USAGE; } } } debug("Final value for argc=%d ", argc); env_id++; while (--argc > 0) { char *name = *++argv; if (!hdelete_r(name, &env_htab, env_flag)) ret = 1; } return ret; |
ea882baf9
|
836 |
} |
0c79cda01
|
837 |
#ifdef CONFIG_CMD_EXPORTENV |
ea882baf9
|
838 |
/* |
37f2fe747
|
839 |
* env export [-t | -b | -c] [-s size] addr [var ...] |
ea882baf9
|
840 841 842 843 844 845 846 847 848 |
* -t: export as text format; if size is given, data will be * padded with '\0' bytes; if not, one terminating '\0' * will be added (which is included in the "filesize" * setting so you can for exmple copy this to flash and * keep the termination). * -b: export as binary format (name=value pairs separated by * '\0', list end marked by double "\0\0") * -c: export as checksum protected environment format as * used for example by "saveenv" command |
37f2fe747
|
849 850 |
* -s size: * size of output buffer |
ea882baf9
|
851 |
* addr: memory address where environment gets stored |
37f2fe747
|
852 853 854 |
* var... List of variable names that get included into the * export. Without arguments, the whole environment gets * exported. |
ea882baf9
|
855 856 857 858 |
* * With "-c" and size is NOT given, then the export command will * format the data as currently used for the persistent storage, * i. e. it will use CONFIG_ENV_SECT_SIZE as output block size and |
fc0b5948e
|
859 |
* prepend a valid CRC32 checksum and, in case of redundant |
ea882baf9
|
860 861 862 863 864 865 866 867 |
* environment, a "current" redundancy flag. If size is given, this * value will be used instead of CONFIG_ENV_SECT_SIZE; again, CRC32 * checksum and redundancy flag will be inserted. * * With "-b" and "-t", always only the real data (including a * terminating '\0' byte) will be written; here the optional size * argument will be used to make sure not to overflow the user * provided buffer; the command will abort if the size is not |
fc0b5948e
|
868 |
* sufficient. Any remaining space will be '\0' padded. |
ea882baf9
|
869 870 871 872 |
* * On successful return, the variable "filesize" will be set. * Note that filesize includes the trailing/terminating '\0' byte(s). * |
fc0b5948e
|
873 |
* Usage scenario: create a text snapshot/backup of the current settings: |
ea882baf9
|
874 875 876 877 878 879 880 881 882 |
* * => env export -t 100000 * => era ${backup_addr} +${filesize} * => cp.b 100000 ${backup_addr} ${filesize} * * Re-import this snapshot, deleting all other settings: * * => env import -d -t ${backup_addr} */ |
d09b1787a
|
883 884 |
static int do_env_export(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
ea882baf9
|
885 886 |
{ char buf[32]; |
fd37dac9e
|
887 888 |
ulong addr; char *ptr, *cmd, *res; |
37f2fe747
|
889 |
size_t size = 0; |
ea882baf9
|
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 |
ssize_t len; env_t *envp; char sep = ' '; int chk = 0; int fmt = 0; cmd = *argv; while (--argc > 0 && **++argv == '-') { char *arg = *argv; while (*++arg) { switch (*arg) { case 'b': /* raw binary format */ if (fmt++) goto sep_err; sep = '\0'; break; case 'c': /* external checksum format */ if (fmt++) goto sep_err; sep = '\0'; chk = 1; break; |
37f2fe747
|
914 915 916 917 918 |
case 's': /* size given */ if (--argc <= 0) return cmd_usage(cmdtp); size = simple_strtoul(*++argv, NULL, 16); goto NXTARG; |
ea882baf9
|
919 920 921 922 923 924 925 |
case 't': /* text format */ if (fmt++) goto sep_err; sep = ' '; break; default: |
4c12eeb8b
|
926 |
return CMD_RET_USAGE; |
ea882baf9
|
927 928 |
} } |
37f2fe747
|
929 |
NXTARG: ; |
ea882baf9
|
930 |
} |
f3c615b8a
|
931 |
if (argc < 1) |
4c12eeb8b
|
932 |
return CMD_RET_USAGE; |
8bde7f776
|
933 |
|
fd37dac9e
|
934 935 |
addr = simple_strtoul(argv[0], NULL, 16); ptr = map_sysmem(addr, size); |
ea882baf9
|
936 |
|
37f2fe747
|
937 |
if (size) |
fd37dac9e
|
938 |
memset(ptr, '\0', size); |
37f2fe747
|
939 940 941 |
argc--; argv++; |
ea882baf9
|
942 943 |
if (sep) { /* export as text file */ |
ea009d474
|
944 945 |
len = hexport_r(&env_htab, sep, H_MATCH_KEY | H_MATCH_IDENT, |
fd37dac9e
|
946 |
&ptr, size, argc, argv); |
ea882baf9
|
947 |
if (len < 0) { |
9b643e312
|
948 949 |
pr_err("Cannot export environment: errno = %d ", errno); |
ea882baf9
|
950 951 |
return 1; } |
8c3aff525
|
952 |
sprintf(buf, "%zX", (size_t)len); |
382bee57f
|
953 |
env_set("filesize", buf); |
ea882baf9
|
954 955 956 |
return 0; } |
fd37dac9e
|
957 |
envp = (env_t *)ptr; |
ea882baf9
|
958 959 960 961 |
if (chk) /* export as checksum protected block */ res = (char *)envp->data; else /* export as raw binary data */ |
fd37dac9e
|
962 |
res = ptr; |
ea882baf9
|
963 |
|
ea009d474
|
964 965 966 |
len = hexport_r(&env_htab, '\0', H_MATCH_KEY | H_MATCH_IDENT, &res, ENV_SIZE, argc, argv); |
ea882baf9
|
967 |
if (len < 0) { |
9b643e312
|
968 969 |
pr_err("Cannot export environment: errno = %d ", errno); |
ea882baf9
|
970 971 972 973 |
return 1; } if (chk) { |
d09b1787a
|
974 |
envp->crc = crc32(0, envp->data, ENV_SIZE); |
ea882baf9
|
975 976 977 978 |
#ifdef CONFIG_ENV_ADDR_REDUND envp->flags = ACTIVE_FLAG; #endif } |
018f53032
|
979 |
env_set_hex("filesize", len + offsetof(env_t, data)); |
ea882baf9
|
980 981 982 983 |
return 0; sep_err: |
d09b1787a
|
984 985 |
printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed ", cmd); |
ea882baf9
|
986 987 |
return 1; } |
0c79cda01
|
988 |
#endif |
ea882baf9
|
989 |
|
0c79cda01
|
990 |
#ifdef CONFIG_CMD_IMPORTENV |
ea882baf9
|
991 |
/* |
ecd1446fe
|
992 |
* env import [-d] [-t [-r] | -b | -c] addr [size] |
ea882baf9
|
993 |
* -d: delete existing environment before importing; |
fc0b5948e
|
994 |
* otherwise overwrite / append to existing definitions |
ea882baf9
|
995 996 |
* -t: assume text format; either "size" must be given or the * text data must be '\0' terminated |
ecd1446fe
|
997 998 999 1000 |
* -r: handle CRLF like LF, that means exported variables with * a content which ends with \r won't get imported. Used * to import text files created with editors which are using CRLF * for line endings. Only effective in addition to -t. |
ea882baf9
|
1001 1002 1003 1004 1005 1006 |
* -b: assume binary format ('\0' separated, "\0\0" terminated) * -c: assume checksum protected environment format * addr: memory address to read from * size: length of input data; if missing, proper '\0' * termination is mandatory */ |
d09b1787a
|
1007 1008 |
static int do_env_import(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
ea882baf9
|
1009 |
{ |
fd37dac9e
|
1010 1011 |
ulong addr; char *cmd, *ptr; |
ea882baf9
|
1012 1013 1014 1015 1016 |
char sep = ' '; int chk = 0; int fmt = 0; int del = 0; |
ecd1446fe
|
1017 |
int crlf_is_lf = 0; |
ea882baf9
|
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 |
size_t size; cmd = *argv; while (--argc > 0 && **++argv == '-') { char *arg = *argv; while (*++arg) { switch (*arg) { case 'b': /* raw binary format */ if (fmt++) goto sep_err; sep = '\0'; break; case 'c': /* external checksum format */ if (fmt++) goto sep_err; sep = '\0'; chk = 1; break; case 't': /* text format */ if (fmt++) goto sep_err; sep = ' '; break; |
ecd1446fe
|
1043 1044 1045 |
case 'r': /* handle CRLF like LF */ crlf_is_lf = 1; break; |
ea882baf9
|
1046 1047 1048 1049 |
case 'd': del = 1; break; default: |
4c12eeb8b
|
1050 |
return CMD_RET_USAGE; |
ea882baf9
|
1051 1052 1053 |
} } } |
f3c615b8a
|
1054 |
if (argc < 1) |
4c12eeb8b
|
1055 |
return CMD_RET_USAGE; |
ea882baf9
|
1056 1057 1058 1059 |
if (!fmt) printf("## Warning: defaulting to text format "); |
ecd1446fe
|
1060 1061 1062 |
if (sep != ' ' && crlf_is_lf ) crlf_is_lf = 0; |
fd37dac9e
|
1063 1064 |
addr = simple_strtoul(argv[0], NULL, 16); ptr = map_sysmem(addr, 0); |
ea882baf9
|
1065 1066 1067 |
if (argc == 2) { size = simple_strtoul(argv[1], NULL, 16); |
3775dcd9c
|
1068 1069 1070 1071 |
} else if (argc == 1 && chk) { puts("## Error: external checksum format must pass size "); return CMD_RET_FAILURE; |
ea882baf9
|
1072 |
} else { |
fd37dac9e
|
1073 |
char *s = ptr; |
ea882baf9
|
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 |
size = 0; while (size < MAX_ENV_SIZE) { if ((*s == sep) && (*(s+1) == '\0')) break; ++s; ++size; } if (size == MAX_ENV_SIZE) { printf("## Warning: Input data exceeds %d bytes" " - truncated ", MAX_ENV_SIZE); } |
d3f80c77c
|
1088 |
size += 2; |
79afc88d2
|
1089 1090 |
printf("## Info: input data size = %zu = 0x%zX ", size, size); |
ea882baf9
|
1091 1092 1093 1094 |
} if (chk) { uint32_t crc; |
fd37dac9e
|
1095 |
env_t *ep = (env_t *)ptr; |
ea882baf9
|
1096 1097 1098 1099 1100 1101 1102 1103 1104 |
size -= offsetof(env_t, data); memcpy(&crc, &ep->crc, sizeof(crc)); if (crc32(0, ep->data, size) != crc) { puts("## Error: bad CRC, import failed "); return 1; } |
fd37dac9e
|
1105 |
ptr = (char *)ep->data; |
ea882baf9
|
1106 |
} |
ecd1446fe
|
1107 1108 |
if (himport_r(&env_htab, ptr, size, sep, del ? 0 : H_NOCLEAR, crlf_is_lf, 0, NULL) == 0) { |
9b643e312
|
1109 1110 |
pr_err("Environment import failed: errno = %d ", errno); |
ea882baf9
|
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 |
return 1; } gd->flags |= GD_FLG_ENV_READY; return 0; sep_err: printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed ", cmd); return 1; } |
0c79cda01
|
1123 |
#endif |
ea882baf9
|
1124 |
|
88733e2c6
|
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 |
#if defined(CONFIG_CMD_ENV_EXISTS) static int do_env_exists(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { ENTRY e, *ep; if (argc < 2) return CMD_RET_USAGE; e.key = argv[1]; e.data = NULL; hsearch_r(e, FIND, &ep, &env_htab, 0); return (ep == NULL) ? 1 : 0; } #endif |
ea882baf9
|
1141 1142 1143 1144 1145 1146 1147 1148 |
/* * New command line interface: "env" command with subcommands */ static cmd_tbl_t cmd_env_sub[] = { #if defined(CONFIG_CMD_ASKENV) U_BOOT_CMD_MKENT(ask, CONFIG_SYS_MAXARGS, 1, do_env_ask, "", ""), #endif U_BOOT_CMD_MKENT(default, 1, 0, do_env_default, "", ""), |
9d8d661d7
|
1149 |
U_BOOT_CMD_MKENT(delete, CONFIG_SYS_MAXARGS, 0, do_env_delete, "", ""), |
ea882baf9
|
1150 1151 1152 |
#if defined(CONFIG_CMD_EDITENV) U_BOOT_CMD_MKENT(edit, 2, 0, do_env_edit, "", ""), #endif |
5e2b3e0c5
|
1153 1154 1155 |
#if defined(CONFIG_CMD_ENV_CALLBACK) U_BOOT_CMD_MKENT(callbacks, 1, 0, do_env_callback, "", ""), #endif |
fffad71bc
|
1156 1157 1158 |
#if defined(CONFIG_CMD_ENV_FLAGS) U_BOOT_CMD_MKENT(flags, 1, 0, do_env_flags, "", ""), #endif |
0c79cda01
|
1159 |
#if defined(CONFIG_CMD_EXPORTENV) |
ea882baf9
|
1160 |
U_BOOT_CMD_MKENT(export, 4, 0, do_env_export, "", ""), |
0c79cda01
|
1161 |
#endif |
a000b7950
|
1162 1163 1164 |
#if defined(CONFIG_CMD_GREPENV) U_BOOT_CMD_MKENT(grep, CONFIG_SYS_MAXARGS, 1, do_env_grep, "", ""), #endif |
0c79cda01
|
1165 |
#if defined(CONFIG_CMD_IMPORTENV) |
ea882baf9
|
1166 |
U_BOOT_CMD_MKENT(import, 5, 0, do_env_import, "", ""), |
0c79cda01
|
1167 |
#endif |
ea882baf9
|
1168 1169 1170 1171 1172 1173 1174 1175 |
U_BOOT_CMD_MKENT(print, CONFIG_SYS_MAXARGS, 1, do_env_print, "", ""), #if defined(CONFIG_CMD_RUN) U_BOOT_CMD_MKENT(run, CONFIG_SYS_MAXARGS, 1, do_run, "", ""), #endif #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE) U_BOOT_CMD_MKENT(save, 1, 0, do_env_save, "", ""), #endif U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 0, do_env_set, "", ""), |
88733e2c6
|
1176 1177 1178 |
#if defined(CONFIG_CMD_ENV_EXISTS) U_BOOT_CMD_MKENT(exists, 2, 0, do_env_exists, "", ""), #endif |
ea882baf9
|
1179 |
}; |
2e5167cca
|
1180 |
#if defined(CONFIG_NEEDS_MANUAL_RELOC) |
60f7da1f4
|
1181 1182 1183 1184 1185 |
void env_reloc(void) { fixup_cmdtable(cmd_env_sub, ARRAY_SIZE(cmd_env_sub)); } #endif |
f3c615b8a
|
1186 |
static int do_env(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
ea882baf9
|
1187 1188 |
{ cmd_tbl_t *cp; |
5904da021
|
1189 |
if (argc < 2) |
4c12eeb8b
|
1190 |
return CMD_RET_USAGE; |
5904da021
|
1191 |
|
ea882baf9
|
1192 1193 1194 1195 1196 1197 1198 1199 |
/* drop initial "env" arg */ argc--; argv++; cp = find_cmd_tbl(argv[0], cmd_env_sub, ARRAY_SIZE(cmd_env_sub)); if (cp) return cp->cmd(cmdtp, flag, argc, argv); |
4c12eeb8b
|
1200 |
return CMD_RET_USAGE; |
ea882baf9
|
1201 |
} |
088f1b199
|
1202 1203 |
#ifdef CONFIG_SYS_LONGHELP static char env_help_text[] = |
ea882baf9
|
1204 1205 1206 1207 |
#if defined(CONFIG_CMD_ASKENV) "ask name [message] [size] - ask for environment variable env " #endif |
5e2b3e0c5
|
1208 1209 1210 1211 |
#if defined(CONFIG_CMD_ENV_CALLBACK) "callbacks - print callbacks and their associated variables env " #endif |
b64b7c3df
|
1212 1213 1214 1215 |
"default [-f] -a - [forcibly] reset default environment " "env default [-f] var [...] - [forcibly] reset variable(s) to their default values " |
9d8d661d7
|
1216 1217 |
"env delete [-f] var [...] - [forcibly] delete variable(s) " |
ea882baf9
|
1218 1219 1220 1221 |
#if defined(CONFIG_CMD_EDITENV) "env edit name - edit environment variable " #endif |
88733e2c6
|
1222 1223 1224 1225 |
#if defined(CONFIG_CMD_ENV_EXISTS) "env exists name - tests for existence of variable " #endif |
4796bc4bb
|
1226 |
#if defined(CONFIG_CMD_EXPORTENV) |
37f2fe747
|
1227 1228 |
"env export [-t | -b | -c] [-s size] addr [var ...] - export environment " |
4796bc4bb
|
1229 |
#endif |
fffad71bc
|
1230 1231 1232 1233 |
#if defined(CONFIG_CMD_ENV_FLAGS) "env flags - print variables that have non-default flags " #endif |
a000b7950
|
1234 |
#if defined(CONFIG_CMD_GREPENV) |
be29df6a1
|
1235 1236 1237 1238 |
#ifdef CONFIG_REGEX "env grep [-e] [-n | -v | -b] string [...] - search environment " #else |
d87244d5a
|
1239 1240 |
"env grep [-n | -v | -b] string [...] - search environment " |
a000b7950
|
1241 |
#endif |
be29df6a1
|
1242 |
#endif |
4796bc4bb
|
1243 |
#if defined(CONFIG_CMD_IMPORTENV) |
ecd1446fe
|
1244 1245 |
"env import [-d] [-t [-r] | -b | -c] addr [size] - import environment " |
4796bc4bb
|
1246 |
#endif |
be11235ab
|
1247 1248 |
"env print [-a | name ...] - print environment " |
ea882baf9
|
1249 1250 1251 1252 |
#if defined(CONFIG_CMD_RUN) "env run var [...] - run commands in an environment variable " #endif |
d798a9b5d
|
1253 |
#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE) |
ea882baf9
|
1254 1255 |
"env save - save environment " |
d798a9b5d
|
1256 |
#endif |
088f1b199
|
1257 1258 1259 1260 1261 1262 1263 |
"env set [-f] name [arg ...] "; #endif U_BOOT_CMD( env, CONFIG_SYS_MAXARGS, 1, do_env, "environment handling commands", env_help_text |
ea882baf9
|
1264 1265 1266 1267 1268 |
); /* * Old command line interface, kept for compatibility */ |
8bde7f776
|
1269 |
|
246c69225
|
1270 |
#if defined(CONFIG_CMD_EDITENV) |
722b061b6
|
1271 |
U_BOOT_CMD_COMPLETE( |
ea882baf9
|
1272 |
editenv, 2, 0, do_env_edit, |
246c69225
|
1273 1274 1275 |
"edit environment variable", "name " |
722b061b6
|
1276 1277 |
" - edit environment variable 'name'", var_complete |
246c69225
|
1278 1279 |
); #endif |
722b061b6
|
1280 |
U_BOOT_CMD_COMPLETE( |
ea882baf9
|
1281 |
printenv, CONFIG_SYS_MAXARGS, 1, do_env_print, |
2fb2604d5
|
1282 |
"print environment variables", |
be11235ab
|
1283 1284 1285 |
"[-a] - print [all] values of all environment variables " |
8bde7f776
|
1286 1287 |
"printenv name ... " |
722b061b6
|
1288 1289 |
" - print value of environment variable 'name'", var_complete |
8bde7f776
|
1290 |
); |
a000b7950
|
1291 1292 1293 1294 |
#ifdef CONFIG_CMD_GREPENV U_BOOT_CMD_COMPLETE( grepenv, CONFIG_SYS_MAXARGS, 0, do_env_grep, "search environment variables", |
be29df6a1
|
1295 1296 1297 1298 |
#ifdef CONFIG_REGEX "[-e] [-n | -v | -b] string ... " #else |
d87244d5a
|
1299 1300 |
"[-n | -v | -b] string ... " |
be29df6a1
|
1301 |
#endif |
d87244d5a
|
1302 1303 |
" - list environment name=value pairs matching 'string' " |
be29df6a1
|
1304 1305 1306 1307 |
#ifdef CONFIG_REGEX " \"-e\": enable regular expressions; " #endif |
d87244d5a
|
1308 1309 1310 |
" \"-n\": search variable names; \"-v\": search values; " " \"-b\": search both names and values (default)", |
a000b7950
|
1311 1312 1313 |
var_complete ); #endif |
722b061b6
|
1314 |
U_BOOT_CMD_COMPLETE( |
ea882baf9
|
1315 |
setenv, CONFIG_SYS_MAXARGS, 0, do_env_set, |
2fb2604d5
|
1316 |
"set environment variables", |
24ab5a191
|
1317 1318 1319 1320 1321 1322 1323 |
"[-f] name value ... " " - [forcibly] set environment variable 'name' to 'value ...' " "setenv [-f] name " " - [forcibly] delete environment variable 'name'", |
722b061b6
|
1324 |
var_complete |
8bde7f776
|
1325 |
); |
c76fe4742
|
1326 |
#if defined(CONFIG_CMD_ASKENV) |
8bde7f776
|
1327 |
|
0d4983930
|
1328 |
U_BOOT_CMD( |
ea882baf9
|
1329 |
askenv, CONFIG_SYS_MAXARGS, 1, do_env_ask, |
2fb2604d5
|
1330 |
"get environment variables from stdin", |
8bde7f776
|
1331 1332 |
"name [message] [size] " |
7d85591dd
|
1333 |
" - get environment variable 'name' from stdin (max 'size' chars)" |
8bde7f776
|
1334 |
); |
902531788
|
1335 |
#endif |
8bde7f776
|
1336 |
|
c76fe4742
|
1337 |
#if defined(CONFIG_CMD_RUN) |
722b061b6
|
1338 |
U_BOOT_CMD_COMPLETE( |
6d0f6bcf3
|
1339 |
run, CONFIG_SYS_MAXARGS, 1, do_run, |
2fb2604d5
|
1340 |
"run commands in an environment variable", |
8bde7f776
|
1341 1342 |
"var [...] " |
722b061b6
|
1343 1344 |
" - run the commands in the environment variable(s) 'var'", var_complete |
8bde7f776
|
1345 |
); |
902531788
|
1346 |
#endif |
7ac2fe2da
|
1347 |
#endif /* CONFIG_SPL_BUILD */ |