diff options
Diffstat (limited to 'roms/u-boot/tools/env')
| -rw-r--r-- | roms/u-boot/tools/env/.gitignore | 3 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/Makefile | 37 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/README | 63 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/crc32.c | 1 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/ctype.c | 1 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/env_attr.c | 1 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/env_flags.c | 1 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/fw_env.c | 1842 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/fw_env.config | 38 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/fw_env.h | 161 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/fw_env_main.c | 284 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/fw_env_private.h | 54 | ||||
| -rw-r--r-- | roms/u-boot/tools/env/linux_string.c | 1 |
13 files changed, 2487 insertions, 0 deletions
diff --git a/roms/u-boot/tools/env/.gitignore b/roms/u-boot/tools/env/.gitignore new file mode 100644 index 000000000..8d28b2b70 --- /dev/null +++ b/roms/u-boot/tools/env/.gitignore @@ -0,0 +1,3 @@ +embedded.c +fw_printenv +fw_printenv_unstripped diff --git a/roms/u-boot/tools/env/Makefile b/roms/u-boot/tools/env/Makefile new file mode 100644 index 000000000..b627796e9 --- /dev/null +++ b/roms/u-boot/tools/env/Makefile @@ -0,0 +1,37 @@ +# SPDX-License-Identifier: GPL-2.0+ +# +# (C) Copyright 2002-2006 +# Wolfgang Denk, DENX Software Engineering, wd@denx.de. + +# fw_printenv is supposed to run on the target system, which means it should be +# built with cross tools. Although it may look weird, we only replace "HOSTCC" +# with "CC" here for the maximum code reuse of scripts/Makefile.host. +override HOSTCC = $(CC) + +# Compile for a hosted environment on the target +HOST_EXTRACFLAGS = -I$(srctree)/tools \ + $(patsubst -I%,-idirafter%, $(filter -I%, $(UBOOTINCLUDE))) \ + -idirafter $(srctree)/tools/env \ + -DUSE_HOSTCC \ + -DTEXT_BASE=$(TEXT_BASE) + +ifeq ($(MTD_VERSION),old) +HOST_EXTRACFLAGS += -DMTD_OLD +endif + +always := fw_printenv +hostprogs-y := fw_printenv + +lib-y += fw_env.o \ + crc32.o ctype.o linux_string.o \ + env_attr.o env_flags.o + +fw_printenv-objs := fw_env_main.o $(lib-y) + +quiet_cmd_crosstools_strip = STRIP $^ + cmd_crosstools_strip = $(STRIP) $^; touch $@ + +$(obj)/.strip: $(obj)/fw_printenv + $(call cmd,crosstools_strip) + +always += .strip diff --git a/roms/u-boot/tools/env/README b/roms/u-boot/tools/env/README new file mode 100644 index 000000000..709251383 --- /dev/null +++ b/roms/u-boot/tools/env/README @@ -0,0 +1,63 @@ + +This is a demo implementation of a Linux command line tool to access +the U-Boot's environment variables. + +In order to cross-compile fw_printenv, run + make CROSS_COMPILE=<your cross-compiler prefix> envtools +in the root directory of the U-Boot distribution. For example, + make CROSS_COMPILE=arm-linux- envtools + +You should then create a symlink from fw_setenv to fw_printenv. They use +the same program and its function depends on its basename. + +For the run-time utility configuration uncomment the line +#define CONFIG_FILE "/etc/fw_env.config" +in fw_env.h. + +For building against older versions of the MTD headers (meaning before +v2.6.8-rc1) it is required to pass the argument "MTD_VERSION=old" to +make. + +See comments in the fw_env.config file for definitions for the +particular board. + +Configuration can also be done via #defines in the fw_env.h file. The +following lines are relevant: + +#define HAVE_REDUND /* For systems with 2 env sectors */ +#define DEVICE1_NAME "/dev/mtd1" +#define DEVICE2_NAME "/dev/mtd2" +#define DEVICE1_OFFSET 0x0000 +#define ENV1_SIZE 0x4000 +#define DEVICE1_ESIZE 0x4000 +#define DEVICE1_ENVSECTORS 2 +#define DEVICE2_OFFSET 0x0000 +#define ENV2_SIZE 0x4000 +#define DEVICE2_ESIZE 0x4000 +#define DEVICE2_ENVSECTORS 2 + +Un-define HAVE_REDUND, if you want to use the utilities on a system +that does not have support for redundant environment enabled. +If HAVE_REDUND is undefined, DEVICE2_NAME is ignored, +as is ENV2_SIZE and DEVICE2_ESIZE. + +The DEVICEx_NAME constants define which MTD character devices are to +be used to access the environment. + +The DEVICEx_OFFSET constants define the environment offset within the +MTD character device. + +ENVx_SIZE defines the size in bytes taken by the environment, which +may be less then flash sector size, if the environment takes less +then 1 sector. + +DEVICEx_ESIZE defines the size of the first sector in the flash +partition where the environment resides. + +DEVICEx_ENVSECTORS defines the number of sectors that may be used for +this environment instance. On NAND this is used to limit the range +within which bad blocks are skipped, on NOR it is not used. + +To prevent losing changes to the environment and to prevent confusing the MTD +drivers, a lock file at /var/lock/fw_printenv.lock is used to serialize access +to the environment. diff --git a/roms/u-boot/tools/env/crc32.c b/roms/u-boot/tools/env/crc32.c new file mode 100644 index 000000000..34f8178e3 --- /dev/null +++ b/roms/u-boot/tools/env/crc32.c @@ -0,0 +1 @@ +#include "../../lib/crc32.c" diff --git a/roms/u-boot/tools/env/ctype.c b/roms/u-boot/tools/env/ctype.c new file mode 100644 index 000000000..21050e937 --- /dev/null +++ b/roms/u-boot/tools/env/ctype.c @@ -0,0 +1 @@ +#include "../../lib/ctype.c" diff --git a/roms/u-boot/tools/env/env_attr.c b/roms/u-boot/tools/env/env_attr.c new file mode 100644 index 000000000..4d8536335 --- /dev/null +++ b/roms/u-boot/tools/env/env_attr.c @@ -0,0 +1 @@ +#include "../../env/attr.c" diff --git a/roms/u-boot/tools/env/env_flags.c b/roms/u-boot/tools/env/env_flags.c new file mode 100644 index 000000000..71e13e202 --- /dev/null +++ b/roms/u-boot/tools/env/env_flags.c @@ -0,0 +1 @@ +#include "../../env/flags.c" diff --git a/roms/u-boot/tools/env/fw_env.c b/roms/u-boot/tools/env/fw_env.c new file mode 100644 index 000000000..2a61a5d6f --- /dev/null +++ b/roms/u-boot/tools/env/fw_env.c @@ -0,0 +1,1842 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * (C) Copyright 2000-2010 + * Wolfgang Denk, DENX Software Engineering, wd@denx.de. + * + * (C) Copyright 2008 + * Guennadi Liakhovetski, DENX Software Engineering, lg@denx.de. + */ + +#define _GNU_SOURCE + +#include <compiler.h> +#include <env.h> +#include <errno.h> +#include <env_flags.h> +#include <fcntl.h> +#include <libgen.h> +#include <linux/fs.h> +#include <linux/stringify.h> +#include <ctype.h> +#include <stdio.h> +#include <stdlib.h> +#include <stddef.h> +#include <string.h> +#include <sys/types.h> +#include <sys/ioctl.h> +#include <sys/stat.h> +#include <u-boot/crc.h> +#include <unistd.h> +#include <dirent.h> + +#ifdef MTD_OLD +# include <stdint.h> +# include <linux/mtd/mtd.h> +#else +# define __user /* nothing */ +# include <mtd/mtd-user.h> +#endif + +#include <mtd/ubi-user.h> + +#include "fw_env_private.h" +#include "fw_env.h" + +struct env_opts default_opts = { +#ifdef CONFIG_FILE + .config_file = CONFIG_FILE +#endif +}; + +#define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d)) + +#define min(x, y) ({ \ + typeof(x) _min1 = (x); \ + typeof(y) _min2 = (y); \ + (void) (&_min1 == &_min2); \ + _min1 < _min2 ? _min1 : _min2; }) + +struct envdev_s { + const char *devname; /* Device name */ + long long devoff; /* Device offset */ + ulong env_size; /* environment size */ + ulong erase_size; /* device erase size */ + ulong env_sectors; /* number of environment sectors */ + uint8_t mtd_type; /* type of the MTD device */ + int is_ubi; /* set if we use UBI volume */ +}; + +static struct envdev_s envdevices[2] = { + { + .mtd_type = MTD_ABSENT, + }, { + .mtd_type = MTD_ABSENT, + }, +}; + +static int dev_current; + +#define DEVNAME(i) envdevices[(i)].devname +#define DEVOFFSET(i) envdevices[(i)].devoff +#define ENVSIZE(i) envdevices[(i)].env_size +#define DEVESIZE(i) envdevices[(i)].erase_size +#define ENVSECTORS(i) envdevices[(i)].env_sectors +#define DEVTYPE(i) envdevices[(i)].mtd_type +#define IS_UBI(i) envdevices[(i)].is_ubi + +#define CUR_ENVSIZE ENVSIZE(dev_current) + +static unsigned long usable_envsize; +#define ENV_SIZE usable_envsize + +struct env_image_single { + uint32_t crc; /* CRC32 over data bytes */ + char data[]; +}; + +struct env_image_redundant { + uint32_t crc; /* CRC32 over data bytes */ + unsigned char flags; /* active or obsolete */ + char data[]; +}; + +enum flag_scheme { + FLAG_NONE, + FLAG_BOOLEAN, + FLAG_INCREMENTAL, +}; + +struct environment { + void *image; + uint32_t *crc; + unsigned char *flags; + char *data; + enum flag_scheme flag_scheme; + int dirty; +}; + +static struct environment environment = { + .flag_scheme = FLAG_NONE, +}; + +static int have_redund_env; + +#define DEFAULT_ENV_INSTANCE_STATIC +#include <env_default.h> + +#define UBI_DEV_START "/dev/ubi" +#define UBI_SYSFS "/sys/class/ubi" +#define UBI_VOL_NAME_PATT "ubi%d_%d" + +static int is_ubi_devname(const char *devname) +{ + return !strncmp(devname, UBI_DEV_START, sizeof(UBI_DEV_START) - 1); +} + +static int ubi_check_volume_sysfs_name(const char *volume_sysfs_name, + const char *volname) +{ + char path[256]; + FILE *file; + char *name; + int ret; + + strcpy(path, UBI_SYSFS "/"); + strcat(path, volume_sysfs_name); + strcat(path, "/name"); + + file = fopen(path, "r"); + if (!file) + return -1; + + ret = fscanf(file, "%ms", &name); + fclose(file); + if (ret <= 0 || !name) { + fprintf(stderr, + "Failed to read from file %s, ret = %d, name = %s\n", + path, ret, name); + return -1; + } + + if (!strcmp(name, volname)) { + free(name); + return 0; + } + free(name); + + return -1; +} + +static int ubi_get_volnum_by_name(int devnum, const char *volname) +{ + DIR *sysfs_ubi; + struct dirent *dirent; + int ret; + int tmp_devnum; + int volnum; + + sysfs_ubi = opendir(UBI_SYSFS); + if (!sysfs_ubi) + return -1; + +#ifdef DEBUG + fprintf(stderr, "Looking for volume name \"%s\"\n", volname); +#endif + + while (1) { + dirent = readdir(sysfs_ubi); + if (!dirent) + return -1; + + ret = sscanf(dirent->d_name, UBI_VOL_NAME_PATT, + &tmp_devnum, &volnum); + if (ret == 2 && devnum == tmp_devnum) { + if (ubi_check_volume_sysfs_name(dirent->d_name, + volname) == 0) + return volnum; + } + } + + return -1; +} + +static int ubi_get_devnum_by_devname(const char *devname) +{ + int devnum; + int ret; + + ret = sscanf(devname + sizeof(UBI_DEV_START) - 1, "%d", &devnum); + if (ret != 1) + return -1; + + return devnum; +} + +static const char *ubi_get_volume_devname(const char *devname, + const char *volname) +{ + char *volume_devname; + int volnum; + int devnum; + int ret; + + devnum = ubi_get_devnum_by_devname(devname); + if (devnum < 0) + return NULL; + + volnum = ubi_get_volnum_by_name(devnum, volname); + if (volnum < 0) + return NULL; + + ret = asprintf(&volume_devname, "%s_%d", devname, volnum); + if (ret < 0) + return NULL; + +#ifdef DEBUG + fprintf(stderr, "Found ubi volume \"%s:%s\" -> %s\n", + devname, volname, volume_devname); +#endif + + return volume_devname; +} + +static void ubi_check_dev(unsigned int dev_id) +{ + char *devname = (char *)DEVNAME(dev_id); + char *pname; + const char *volname = NULL; + const char *volume_devname; + + if (!is_ubi_devname(DEVNAME(dev_id))) + return; + + IS_UBI(dev_id) = 1; + + for (pname = devname; *pname != '\0'; pname++) { + if (*pname == ':') { + *pname = '\0'; + volname = pname + 1; + break; + } + } + + if (volname) { + /* Let's find real volume device name */ + volume_devname = ubi_get_volume_devname(devname, volname); + if (!volume_devname) { + fprintf(stderr, "Didn't found ubi volume \"%s\"\n", + volname); + return; + } + + free(devname); + DEVNAME(dev_id) = volume_devname; + } +} + +static int ubi_update_start(int fd, int64_t bytes) +{ + if (ioctl(fd, UBI_IOCVOLUP, &bytes)) + return -1; + return 0; +} + +static int ubi_read(int fd, void *buf, size_t count) +{ + ssize_t ret; + + while (count > 0) { + ret = read(fd, buf, count); + if (ret > 0) { + count -= ret; + buf += ret; + + continue; + } + + if (ret == 0) { + /* + * Happens in case of too short volume data size. If we + * return error status we will fail it will be treated + * as UBI device error. + * + * Leave catching this error to CRC check. + */ + fprintf(stderr, "Warning: end of data on ubi volume\n"); + return 0; + } else if (errno == EBADF) { + /* + * Happens in case of corrupted volume. The same as + * above, we cannot return error now, as we will still + * be able to successfully write environment later. + */ + fprintf(stderr, "Warning: corrupted volume?\n"); + return 0; + } else if (errno == EINTR) { + continue; + } + + fprintf(stderr, "Cannot read %u bytes from ubi volume, %s\n", + (unsigned int)count, strerror(errno)); + return -1; + } + + return 0; +} + +static int ubi_write(int fd, const void *buf, size_t count) +{ + ssize_t ret; + + while (count > 0) { + ret = write(fd, buf, count); + if (ret <= 0) { + if (ret < 0 && errno == EINTR) + continue; + + fprintf(stderr, "Cannot write %u bytes to ubi volume\n", + (unsigned int)count); + return -1; + } + + count -= ret; + buf += ret; + } + + return 0; +} + +static int flash_io(int mode); +static int parse_config(struct env_opts *opts); + +#if defined(CONFIG_FILE) +static int get_config(char *); +#endif + +static char *skip_chars(char *s) +{ + for (; *s != '\0'; s++) { + if (isblank(*s) || *s == '=') + return s; + } + return NULL; +} + +static char *skip_blanks(char *s) +{ + for (; *s != '\0'; s++) { + if (!isblank(*s)) + return s; + } + return NULL; +} + +/* + * s1 is either a simple 'name', or a 'name=value' pair. + * s2 is a 'name=value' pair. + * If the names match, return the value of s2, else NULL. + */ +static char *envmatch(char *s1, char *s2) +{ + if (s1 == NULL || s2 == NULL) + return NULL; + + while (*s1 == *s2++) + if (*s1++ == '=') + return s2; + if (*s1 == '\0' && *(s2 - 1) == '=') + return s2; + return NULL; +} + +/** + * Search the environment for a variable. + * Return the value, if found, or NULL, if not found. + */ +char *fw_getenv(char *name) +{ + char *env, *nxt; + + for (env = environment.data; *env; env = nxt + 1) { + char *val; + + for (nxt = env; *nxt; ++nxt) { + if (nxt >= &environment.data[ENV_SIZE]) { + fprintf(stderr, "## Error: " + "environment not terminated\n"); + return NULL; + } + } + val = envmatch(name, env); + if (!val) + continue; + return val; + } + return NULL; +} + +/* + * Search the default environment for a variable. + * Return the value, if found, or NULL, if not found. + */ +char *fw_getdefenv(char *name) +{ + char *env, *nxt; + + for (env = default_environment; *env; env = nxt + 1) { + char *val; + + for (nxt = env; *nxt; ++nxt) { + if (nxt >= &default_environment[ENV_SIZE]) { + fprintf(stderr, "## Error: " + "default environment not terminated\n"); + return NULL; + } + } + val = envmatch(name, env); + if (!val) + continue; + return val; + } + return NULL; +} + +/* + * Print the current definition of one, or more, or all + * environment variables + */ +int fw_printenv(int argc, char *argv[], int value_only, struct env_opts *opts) +{ + int i, rc = 0; + + if (value_only && argc != 1) { + fprintf(stderr, + "## Error: `-n'/`--noheader' option requires exactly one argument\n"); + return -1; + } + + if (!opts) + opts = &default_opts; + + if (fw_env_open(opts)) + return -1; + + if (argc == 0) { /* Print all env variables */ + char *env, *nxt; + for (env = environment.data; *env; env = nxt + 1) { + for (nxt = env; *nxt; ++nxt) { + if (nxt >= &environment.data[ENV_SIZE]) { + fprintf(stderr, "## Error: " + "environment not terminated\n"); + return -1; + } + } + + printf("%s\n", env); + } + fw_env_close(opts); + return 0; + } + + for (i = 0; i < argc; ++i) { /* print a subset of env variables */ + char *name = argv[i]; + char *val = NULL; + + val = fw_getenv(name); + if (!val) { + fprintf(stderr, "## Error: \"%s\" not defined\n", name); + rc = -1; + continue; + } + + if (value_only) { + puts(val); + break; + } + + printf("%s=%s\n", name, val); + } + + fw_env_close(opts); + + return rc; +} + +int fw_env_flush(struct env_opts *opts) +{ + if (!opts) + opts = &default_opts; + + if (!environment.dirty) + return 0; + + /* + * Update CRC + */ + *environment.crc = crc32(0, (uint8_t *) environment.data, ENV_SIZE); + + /* write environment back to flash */ + if (flash_io(O_RDWR)) { + fprintf(stderr, "Error: can't write fw_env to flash\n"); + return -1; + } + + return 0; +} + +/* + * Set/Clear a single variable in the environment. + * This is called in sequence to update the environment + * in RAM without updating the copy in flash after each set + */ +int fw_env_write(char *name, char *value) +{ + int len; + char *env, *nxt; + char *oldval = NULL; + int deleting, creating, overwriting; + + /* + * search if variable with this name already exists + */ + for (nxt = env = environment.data; *env; env = nxt + 1) { + for (nxt = env; *nxt; ++nxt) { + if (nxt >= &environment.data[ENV_SIZE]) { + fprintf(stderr, "## Error: " + "environment not terminated\n"); + errno = EINVAL; + return -1; + } + } + oldval = envmatch(name, env); + if (oldval) + break; + } + + deleting = (oldval && !(value && strlen(value))); + creating = (!oldval && (value && strlen(value))); + overwriting = (oldval && (value && strlen(value) && + strcmp(oldval, value))); + + /* check for permission */ + if (deleting) { + if (env_flags_validate_varaccess(name, + ENV_FLAGS_VARACCESS_PREVENT_DELETE)) { + printf("Can't delete \"%s\"\n", name); + errno = EROFS; + return -1; + } + } else if (overwriting) { + if (env_flags_validate_varaccess(name, + ENV_FLAGS_VARACCESS_PREVENT_OVERWR)) { + printf("Can't overwrite \"%s\"\n", name); + errno = EROFS; + return -1; + } else if (env_flags_validate_varaccess(name, + ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR)) { + const char *defval = fw_getdefenv(name); + + if (defval == NULL) + defval = ""; + if (strcmp(oldval, defval) + != 0) { + printf("Can't overwrite \"%s\"\n", name); + errno = EROFS; + return -1; + } + } + } else if (creating) { + if (env_flags_validate_varaccess(name, + ENV_FLAGS_VARACCESS_PREVENT_CREATE)) { + printf("Can't create \"%s\"\n", name); + errno = EROFS; + return -1; + } + } else + /* Nothing to do */ + return 0; + + environment.dirty = 1; + if (deleting || overwriting) { + if (*++nxt == '\0') { + *env = '\0'; + } else { + for (;;) { + *env = *nxt++; + if ((*env == '\0') && (*nxt == '\0')) + break; + ++env; + } + } + *++env = '\0'; + } + + /* Delete only ? */ + if (!value || !strlen(value)) + return 0; + + /* + * Append new definition at the end + */ + for (env = environment.data; *env || *(env + 1); ++env) + ; + if (env > environment.data) + ++env; + /* + * Overflow when: + * "name" + "=" + "val" +"\0\0" > CUR_ENVSIZE - (env-environment) + */ + len = strlen(name) + 2; + /* add '=' for first arg, ' ' for all others */ + len += strlen(value) + 1; + + if (len > (&environment.data[ENV_SIZE] - env)) { + fprintf(stderr, + "Error: environment overflow, \"%s\" deleted\n", name); + return -1; + } + + while ((*env = *name++) != '\0') + env++; + *env = '='; + while ((*++env = *value++) != '\0') + ; + + /* end is marked with double '\0' */ + *++env = '\0'; + + return 0; +} + +/* + * Deletes or sets environment variables. Returns -1 and sets errno error codes: + * 0 - OK + * EINVAL - need at least 1 argument + * EROFS - certain variables ("ethaddr", "serial#") cannot be + * modified or deleted + * + */ +int fw_env_set(int argc, char *argv[], struct env_opts *opts) +{ + int i; + size_t len; + char *name, **valv; + char *oldval; + char *value = NULL; + int valc; + int ret; + + if (!opts) + opts = &default_opts; + + if (argc < 1) { + fprintf(stderr, "## Error: variable name missing\n"); + errno = EINVAL; + return -1; + } + + if (fw_env_open(opts)) { + fprintf(stderr, "Error: environment not initialized\n"); + return -1; + } + + name = argv[0]; + valv = argv + 1; + valc = argc - 1; + + if (env_flags_validate_env_set_params(name, valv, valc) < 0) { + fw_env_close(opts); + return -1; + } + + len = 0; + for (i = 0; i < valc; ++i) { + char *val = valv[i]; + size_t val_len = strlen(val); + + if (value) + value[len - 1] = ' '; + oldval = value; + value = realloc(value, len + val_len + 1); + if (!value) { + fprintf(stderr, + "Cannot malloc %zu bytes: %s\n", + len, strerror(errno)); + free(oldval); + return -1; + } + + memcpy(value + len, val, val_len); + len += val_len; + value[len++] = '\0'; + } + + fw_env_write(name, value); + + free(value); + + ret = fw_env_flush(opts); + fw_env_close(opts); + + return ret; +} + +/* + * Parse a file and configure the u-boot variables. + * The script file has a very simple format, as follows: + * + * Each line has a couple with name, value: + * <white spaces>variable_name<white spaces>variable_value + * + * Both variable_name and variable_value are interpreted as strings. + * Any character after <white spaces> and before ending \r\n is interpreted + * as variable's value (no comment allowed on these lines !) + * + * Comments are allowed if the first character in the line is # + * + * Returns -1 and sets errno error codes: + * 0 - OK + * -1 - Error + */ +int fw_parse_script(char *fname, struct env_opts *opts) +{ + FILE *fp; + char *line = NULL; + size_t linesize = 0; + char *name; + char *val; + int lineno = 0; + int len; + int ret = 0; + + if (!opts) + opts = &default_opts; + + if (fw_env_open(opts)) { + fprintf(stderr, "Error: environment not initialized\n"); + return -1; + } + + if (strcmp(fname, "-") == 0) + fp = stdin; + else { + fp = fopen(fname, "r"); + if (fp == NULL) { + fprintf(stderr, "I cannot open %s for reading\n", + fname); + return -1; + } + } + + while ((len = getline(&line, &linesize, fp)) != -1) { + lineno++; + + /* + * Read a whole line from the file. If the line is not + * terminated, reports an error and exit. + */ + if (line[len - 1] != '\n') { + fprintf(stderr, + "Line %d not correctly terminated\n", + lineno); + ret = -1; + break; + } + + /* Drop ending line feed / carriage return */ + line[--len] = '\0'; + if (len && line[len - 1] == '\r') + line[--len] = '\0'; + + /* Skip comment or empty lines */ + if (len == 0 || line[0] == '#') + continue; + + /* + * Search for variable's name remove leading whitespaces + */ + name = skip_blanks(line); + if (!name) + continue; + + /* The first white space is the end of variable name */ + val = skip_chars(name); + len = strlen(name); + if (val) { + *val++ = '\0'; + if ((val - name) < len) + val = skip_blanks(val); + else + val = NULL; + } +#ifdef DEBUG + fprintf(stderr, "Setting %s : %s\n", + name, val ? val : " removed"); +#endif + + if (env_flags_validate_type(name, val) < 0) { + ret = -1; + break; + } + + /* + * If there is an error setting a variable, + * try to save the environment and returns an error + */ + if (fw_env_write(name, val)) { + fprintf(stderr, + "fw_env_write returns with error : %s\n", + strerror(errno)); + ret = -1; + break; + } + + } + free(line); + + /* Close file if not stdin */ + if (strcmp(fname, "-") != 0) + fclose(fp); + + ret |= fw_env_flush(opts); + + fw_env_close(opts); + + return ret; +} + +/** + * environment_end() - compute offset of first byte right after environment + * @dev - index of enviroment buffer + * Return: + * device offset of first byte right after environment + */ +off_t environment_end(int dev) +{ + /* environment is block aligned */ + return DEVOFFSET(dev) + ENVSECTORS(dev) * DEVESIZE(dev); +} + +/* + * Test for bad block on NAND, just returns 0 on NOR, on NAND: + * 0 - block is good + * > 0 - block is bad + * < 0 - failed to test + */ +static int flash_bad_block(int fd, uint8_t mtd_type, loff_t blockstart) +{ + if (mtd_type == MTD_NANDFLASH) { + int badblock = ioctl(fd, MEMGETBADBLOCK, &blockstart); + + if (badblock < 0) { + perror("Cannot read bad block mark"); + return badblock; + } + + if (badblock) { +#ifdef DEBUG + fprintf(stderr, "Bad block at 0x%llx, skipping\n", + (unsigned long long)blockstart); +#endif + return badblock; + } + } + + return 0; +} + +/* + * Read data from flash at an offset into a provided buffer. On NAND it skips + * bad blocks but makes sure it stays within ENVSECTORS (dev) starting from + * the DEVOFFSET (dev) block. On NOR the loop is only run once. + */ +static int flash_read_buf(int dev, int fd, void *buf, size_t count, + off_t offset) +{ + size_t blocklen; /* erase / write length - one block on NAND, + 0 on NOR */ + size_t processed = 0; /* progress counter */ + size_t readlen = count; /* current read length */ + off_t block_seek; /* offset inside the current block to the start + of the data */ + loff_t blockstart; /* running start of the current block - + MEMGETBADBLOCK needs 64 bits */ + int rc; + + blockstart = (offset / DEVESIZE(dev)) * DEVESIZE(dev); + + /* Offset inside a block */ + block_seek = offset - blockstart; + + if (DEVTYPE(dev) == MTD_NANDFLASH) { + /* + * NAND: calculate which blocks we are reading. We have + * to read one block at a time to skip bad blocks. + */ + blocklen = DEVESIZE(dev); + + /* Limit to one block for the first read */ + if (readlen > blocklen - block_seek) + readlen = blocklen - block_seek; + } else { + blocklen = 0; + } + + /* This only runs once on NOR flash */ + while (processed < count) { + rc = flash_bad_block(fd, DEVTYPE(dev), blockstart); + if (rc < 0) /* block test failed */ + return -1; + + if (blockstart + block_seek + readlen > environment_end(dev)) { + /* End of range is reached */ + fprintf(stderr, "Too few good blocks within range\n"); + return -1; + } + + if (rc) { /* block is bad */ + blockstart += blocklen; + continue; + } + + /* + * If a block is bad, we retry in the next block at the same + * offset - see env/nand.c::writeenv() + */ + lseek(fd, blockstart + block_seek, SEEK_SET); + + rc = read(fd, buf + processed, readlen); + if (rc == -1) { + fprintf(stderr, "Read error on %s: %s\n", + DEVNAME(dev), strerror(errno)); + return -1; + } + if (rc != readlen) { + fprintf(stderr, + "Read error on %s: Attempted to read %zd bytes but got %d\n", + DEVNAME(dev), readlen, rc); + return -1; + } +#ifdef DEBUG + fprintf(stderr, "Read 0x%x bytes at 0x%llx on %s\n", + rc, (unsigned long long)blockstart + block_seek, + DEVNAME(dev)); +#endif + processed += readlen; + readlen = min(blocklen, count - processed); + block_seek = 0; + blockstart += blocklen; + } + + return processed; +} + +/* + * Write count bytes from begin of environment, but stay within + * ENVSECTORS(dev) sectors of + * DEVOFFSET (dev). Similar to the read case above, on NOR and dataflash we + * erase and write the whole data at once. + */ +static int flash_write_buf(int dev, int fd, void *buf, size_t count) +{ + void *data; + struct erase_info_user erase; + size_t blocklen; /* length of NAND block / NOR erase sector */ + size_t erase_len; /* whole area that can be erased - may include + bad blocks */ + size_t erasesize; /* erase / write length - one block on NAND, + whole area on NOR */ + size_t processed = 0; /* progress counter */ + size_t write_total; /* total size to actually write - excluding + bad blocks */ + off_t erase_offset; /* offset to the first erase block (aligned) + below offset */ + off_t block_seek; /* offset inside the erase block to the start + of the data */ + loff_t blockstart; /* running start of the current block - + MEMGETBADBLOCK needs 64 bits */ + int was_locked = 0; /* flash lock flag */ + int rc; + + /* + * For mtd devices only offset and size of the environment do matter + */ + if (DEVTYPE(dev) == MTD_ABSENT) { + blocklen = count; + erase_len = blocklen; + blockstart = DEVOFFSET(dev); + block_seek = 0; + write_total = blocklen; + } else { + blocklen = DEVESIZE(dev); + + erase_offset = DEVOFFSET(dev); + + /* Maximum area we may use */ + erase_len = environment_end(dev) - erase_offset; + + blockstart = erase_offset; + + /* Offset inside a block */ + block_seek = DEVOFFSET(dev) - erase_offset; + + /* + * Data size we actually write: from the start of the block + * to the start of the data, then count bytes of data, and + * to the end of the block + */ + write_total = ((block_seek + count + blocklen - 1) / + blocklen) * blocklen; + } + + /* + * Support data anywhere within erase sectors: read out the complete + * area to be erased, replace the environment image, write the whole + * block back again. + */ + if (write_total > count) { + data = malloc(erase_len); + if (!data) { + fprintf(stderr, + "Cannot malloc %zu bytes: %s\n", + erase_len, strerror(errno)); + return -1; + } + + rc = flash_read_buf(dev, fd, data, write_total, erase_offset); + if (write_total != rc) + return -1; + +#ifdef DEBUG + fprintf(stderr, "Preserving data "); + if (block_seek != 0) + fprintf(stderr, "0x%x - 0x%lx", 0, block_seek - 1); + if (block_seek + count != write_total) { + if (block_seek != 0) + fprintf(stderr, " and "); + fprintf(stderr, "0x%lx - 0x%lx", + (unsigned long)block_seek + count, + (unsigned long)write_total - 1); + } + fprintf(stderr, "\n"); +#endif + /* Overwrite the old environment */ + memcpy(data + block_seek, buf, count); + } else { + /* + * We get here, iff offset is block-aligned and count is a + * multiple of blocklen - see write_total calculation above + */ + data = buf; + } + + if (DEVTYPE(dev) == MTD_NANDFLASH) { + /* + * NAND: calculate which blocks we are writing. We have + * to write one block at a time to skip bad blocks. + */ + erasesize = blocklen; + } else { + erasesize = erase_len; + } + + erase.length = erasesize; + if (DEVTYPE(dev) != MTD_ABSENT) { + was_locked = ioctl(fd, MEMISLOCKED, &erase); + /* treat any errors as unlocked flash */ + if (was_locked < 0) + was_locked = 0; + } + + /* This only runs once on NOR flash and SPI-dataflash */ + while (processed < write_total) { + rc = flash_bad_block(fd, DEVTYPE(dev), blockstart); + if (rc < 0) /* block test failed */ + return rc; + + if (blockstart + erasesize > environment_end(dev)) { + fprintf(stderr, "End of range reached, aborting\n"); + return -1; + } + + if (rc) { /* block is bad */ + blockstart += blocklen; + continue; + } + + if (DEVTYPE(dev) != MTD_ABSENT) { + erase.start = blockstart; + if (was_locked) + ioctl(fd, MEMUNLOCK, &erase); + /* These do not need an explicit erase cycle */ + if (DEVTYPE(dev) != MTD_DATAFLASH) + if (ioctl(fd, MEMERASE, &erase) != 0) { + fprintf(stderr, + "MTD erase error on %s: %s\n", + DEVNAME(dev), strerror(errno)); + return -1; + } + } + + if (lseek(fd, blockstart, SEEK_SET) == -1) { + fprintf(stderr, + "Seek error on %s: %s\n", + DEVNAME(dev), strerror(errno)); + return -1; + } +#ifdef DEBUG + fprintf(stderr, "Write 0x%llx bytes at 0x%llx\n", + (unsigned long long)erasesize, + (unsigned long long)blockstart); +#endif + if (write(fd, data + processed, erasesize) != erasesize) { + fprintf(stderr, "Write error on %s: %s\n", + DEVNAME(dev), strerror(errno)); + return -1; + } + + if (DEVTYPE(dev) != MTD_ABSENT) { + if (was_locked) + ioctl(fd, MEMLOCK, &erase); + } + + processed += erasesize; + block_seek = 0; + blockstart += erasesize; + } + + if (write_total > count) + free(data); + + return processed; +} + +/* + * Set obsolete flag at offset - NOR flash only + */ +static int flash_flag_obsolete(int dev, int fd, off_t offset) +{ + int rc; + struct erase_info_user erase; + char tmp = ENV_REDUND_OBSOLETE; + int was_locked; /* flash lock flag */ + + was_locked = ioctl(fd, MEMISLOCKED, &erase); + erase.start = DEVOFFSET(dev); + erase.length = DEVESIZE(dev); + /* This relies on the fact, that ENV_REDUND_OBSOLETE == 0 */ + rc = lseek(fd, offset, SEEK_SET); + if (rc < 0) { + fprintf(stderr, "Cannot seek to set the flag on %s\n", + DEVNAME(dev)); + return rc; + } + if (was_locked) + ioctl(fd, MEMUNLOCK, &erase); + rc = write(fd, &tmp, sizeof(tmp)); + if (was_locked) + ioctl(fd, MEMLOCK, &erase); + if (rc < 0) + perror("Could not set obsolete flag"); + + return rc; +} + +static int flash_write(int fd_current, int fd_target, int dev_target) +{ + int rc; + + switch (environment.flag_scheme) { + case FLAG_NONE: + break; + case FLAG_INCREMENTAL: + (*environment.flags)++; + break; + case FLAG_BOOLEAN: + *environment.flags = ENV_REDUND_ACTIVE; + break; + default: + fprintf(stderr, "Unimplemented flash scheme %u\n", + environment.flag_scheme); + return -1; + } + +#ifdef DEBUG + fprintf(stderr, "Writing new environment at 0x%llx on %s\n", + DEVOFFSET(dev_target), DEVNAME(dev_target)); +#endif + + if (IS_UBI(dev_target)) { + if (ubi_update_start(fd_target, CUR_ENVSIZE) < 0) + return -1; + return ubi_write(fd_target, environment.image, CUR_ENVSIZE); + } + + rc = flash_write_buf(dev_target, fd_target, environment.image, + CUR_ENVSIZE); + if (rc < 0) + return rc; + + if (environment.flag_scheme == FLAG_BOOLEAN) { + /* Have to set obsolete flag */ + off_t offset = DEVOFFSET(dev_current) + + offsetof(struct env_image_redundant, flags); +#ifdef DEBUG + fprintf(stderr, + "Setting obsolete flag in environment at 0x%llx on %s\n", + DEVOFFSET(dev_current), DEVNAME(dev_current)); +#endif + flash_flag_obsolete(dev_current, fd_current, offset); + } + + return 0; +} + +static int flash_read(int fd) +{ + int rc; + + if (IS_UBI(dev_current)) { + DEVTYPE(dev_current) = MTD_ABSENT; + + return ubi_read(fd, environment.image, CUR_ENVSIZE); + } + + rc = flash_read_buf(dev_current, fd, environment.image, CUR_ENVSIZE, + DEVOFFSET(dev_current)); + if (rc != CUR_ENVSIZE) + return -1; + + return 0; +} + +static int flash_open_tempfile(const char **dname, const char **target_temp) +{ + char *dup_name = strdup(DEVNAME(dev_current)); + char *temp_name = NULL; + int rc = -1; + + if (!dup_name) + return -1; + + *dname = dirname(dup_name); + if (!*dname) + goto err; + + rc = asprintf(&temp_name, "%s/XXXXXX", *dname); + if (rc == -1) + goto err; + + rc = mkstemp(temp_name); + if (rc == -1) { + /* fall back to in place write */ + fprintf(stderr, + "Can't create %s: %s\n", temp_name, strerror(errno)); + free(temp_name); + } else { + *target_temp = temp_name; + /* deliberately leak dup_name as dname /might/ point into + * it and we need it for our caller + */ + dup_name = NULL; + } + +err: + if (dup_name) + free(dup_name); + + return rc; +} + +static int flash_io_write(int fd_current) +{ + int fd_target = -1, rc, dev_target; + const char *dname, *target_temp = NULL; + + if (have_redund_env) { + /* switch to next partition for writing */ + dev_target = !dev_current; + /* dev_target: fd_target, erase_target */ + fd_target = open(DEVNAME(dev_target), O_RDWR); + if (fd_target < 0) { + fprintf(stderr, + "Can't open %s: %s\n", + DEVNAME(dev_target), strerror(errno)); + rc = -1; + goto exit; + } + } else { + struct stat sb; + + if (fstat(fd_current, &sb) == 0 && S_ISREG(sb.st_mode)) { + /* if any part of flash_open_tempfile() fails we fall + * back to in-place writes + */ + fd_target = flash_open_tempfile(&dname, &target_temp); + } + dev_target = dev_current; + if (fd_target == -1) + fd_target = fd_current; + } + + rc = flash_write(fd_current, fd_target, dev_target); + + if (fsync(fd_current) && !(errno == EINVAL || errno == EROFS)) { + fprintf(stderr, + "fsync failed on %s: %s\n", + DEVNAME(dev_current), strerror(errno)); + } + + if (fd_current != fd_target) { + if (fsync(fd_target) && + !(errno == EINVAL || errno == EROFS)) { + fprintf(stderr, + "fsync failed on %s: %s\n", + DEVNAME(dev_current), strerror(errno)); + } + + if (close(fd_target)) { + fprintf(stderr, + "I/O error on %s: %s\n", + DEVNAME(dev_target), strerror(errno)); + rc = -1; + } + + if (rc >= 0 && target_temp) { + int dir_fd; + + dir_fd = open(dname, O_DIRECTORY | O_RDONLY); + if (dir_fd == -1) + fprintf(stderr, + "Can't open %s: %s\n", + dname, strerror(errno)); + + if (rename(target_temp, DEVNAME(dev_target))) { + fprintf(stderr, + "rename failed %s => %s: %s\n", + target_temp, DEVNAME(dev_target), + strerror(errno)); + rc = -1; + } + + if (dir_fd != -1 && fsync(dir_fd)) + fprintf(stderr, + "fsync failed on %s: %s\n", + dname, strerror(errno)); + + if (dir_fd != -1 && close(dir_fd)) + fprintf(stderr, + "I/O error on %s: %s\n", + dname, strerror(errno)); + } + } + exit: + return rc; +} + +static int flash_io(int mode) +{ + int fd_current, rc; + + /* dev_current: fd_current, erase_current */ + fd_current = open(DEVNAME(dev_current), mode); + if (fd_current < 0) { + fprintf(stderr, + "Can't open %s: %s\n", + DEVNAME(dev_current), strerror(errno)); + return -1; + } + + if (mode == O_RDWR) { + rc = flash_io_write(fd_current); + } else { + rc = flash_read(fd_current); + } + + if (close(fd_current)) { + fprintf(stderr, + "I/O error on %s: %s\n", + DEVNAME(dev_current), strerror(errno)); + return -1; + } + + return rc; +} + +/* + * Prevent confusion if running from erased flash memory + */ +int fw_env_open(struct env_opts *opts) +{ + int crc0, crc0_ok; + unsigned char flag0; + void *addr0 = NULL; + + int crc1, crc1_ok; + unsigned char flag1; + void *addr1 = NULL; + + int ret; + + struct env_image_single *single; + struct env_image_redundant *redundant; + + if (!opts) + opts = &default_opts; + + if (parse_config(opts)) /* should fill envdevices */ + return -EINVAL; + + addr0 = calloc(1, CUR_ENVSIZE); + if (addr0 == NULL) { + fprintf(stderr, + "Not enough memory for environment (%ld bytes)\n", + CUR_ENVSIZE); + ret = -ENOMEM; + goto open_cleanup; + } + + /* read environment from FLASH to local buffer */ + environment.image = addr0; + + if (have_redund_env) { + redundant = addr0; + environment.crc = &redundant->crc; + environment.flags = &redundant->flags; + environment.data = redundant->data; + } else { + single = addr0; + environment.crc = &single->crc; + environment.flags = NULL; + environment.data = single->data; + } + + dev_current = 0; + if (flash_io(O_RDONLY)) { + ret = -EIO; + goto open_cleanup; + } + + crc0 = crc32(0, (uint8_t *)environment.data, ENV_SIZE); + + crc0_ok = (crc0 == *environment.crc); + if (!have_redund_env) { + if (!crc0_ok) { + fprintf(stderr, + "Warning: Bad CRC, using default environment\n"); + memcpy(environment.data, default_environment, + sizeof(default_environment)); + environment.dirty = 1; + } + } else { + flag0 = *environment.flags; + + dev_current = 1; + addr1 = calloc(1, CUR_ENVSIZE); + if (addr1 == NULL) { + fprintf(stderr, + "Not enough memory for environment (%ld bytes)\n", + CUR_ENVSIZE); + ret = -ENOMEM; + goto open_cleanup; + } + redundant = addr1; + + /* + * have to set environment.image for flash_read(), careful - + * other pointers in environment still point inside addr0 + */ + environment.image = addr1; + if (flash_io(O_RDONLY)) { + ret = -EIO; + goto open_cleanup; + } + + /* Check flag scheme compatibility */ + if (DEVTYPE(dev_current) == MTD_NORFLASH && + DEVTYPE(!dev_current) == MTD_NORFLASH) { + environment.flag_scheme = FLAG_BOOLEAN; + } else if (DEVTYPE(dev_current) == MTD_NANDFLASH && + DEVTYPE(!dev_current) == MTD_NANDFLASH) { + environment.flag_scheme = FLAG_INCREMENTAL; + } else if (DEVTYPE(dev_current) == MTD_DATAFLASH && + DEVTYPE(!dev_current) == MTD_DATAFLASH) { + environment.flag_scheme = FLAG_BOOLEAN; + } else if (DEVTYPE(dev_current) == MTD_UBIVOLUME && + DEVTYPE(!dev_current) == MTD_UBIVOLUME) { + environment.flag_scheme = FLAG_INCREMENTAL; + } else if (DEVTYPE(dev_current) == MTD_ABSENT && + DEVTYPE(!dev_current) == MTD_ABSENT && + IS_UBI(dev_current) == IS_UBI(!dev_current)) { + environment.flag_scheme = FLAG_INCREMENTAL; + } else { + fprintf(stderr, "Incompatible flash types!\n"); + ret = -EINVAL; + goto open_cleanup; + } + + crc1 = crc32(0, (uint8_t *)redundant->data, ENV_SIZE); + + crc1_ok = (crc1 == redundant->crc); + flag1 = redundant->flags; + + /* + * environment.data still points to ((struct + * env_image_redundant *)addr0)->data. If the two + * environments differ, or one has bad crc, force a + * write-out by marking the environment dirty. + */ + if (memcmp(environment.data, redundant->data, ENV_SIZE) || + !crc0_ok || !crc1_ok) + environment.dirty = 1; + + if (crc0_ok && !crc1_ok) { + dev_current = 0; + } else if (!crc0_ok && crc1_ok) { + dev_current = 1; + } else if (!crc0_ok && !crc1_ok) { + fprintf(stderr, + "Warning: Bad CRC, using default environment\n"); + memcpy(environment.data, default_environment, + sizeof(default_environment)); + environment.dirty = 1; + dev_current = 0; + } else { + switch (environment.flag_scheme) { + case FLAG_BOOLEAN: + if (flag0 == ENV_REDUND_ACTIVE && + flag1 == ENV_REDUND_OBSOLETE) { + dev_current = 0; + } else if (flag0 == ENV_REDUND_OBSOLETE && + flag1 == ENV_REDUND_ACTIVE) { + dev_current = 1; + } else if (flag0 == flag1) { + dev_current = 0; + } else if (flag0 == 0xFF) { + dev_current = 0; + } else if (flag1 == 0xFF) { + dev_current = 1; + } else { + dev_current = 0; + } + break; + case FLAG_INCREMENTAL: + if (flag0 == 255 && flag1 == 0) + dev_current = 1; + else if ((flag1 == 255 && flag0 == 0) || + flag0 >= flag1) + dev_current = 0; + else /* flag1 > flag0 */ + dev_current = 1; + break; + default: + fprintf(stderr, "Unknown flag scheme %u\n", + environment.flag_scheme); + return -1; + } + } + + /* + * If we are reading, we don't need the flag and the CRC any + * more, if we are writing, we will re-calculate CRC and update + * flags before writing out + */ + if (dev_current) { + environment.image = addr1; + environment.crc = &redundant->crc; + environment.flags = &redundant->flags; + environment.data = redundant->data; + free(addr0); + } else { + environment.image = addr0; + /* Other pointers are already set */ + free(addr1); + } +#ifdef DEBUG + fprintf(stderr, "Selected env in %s\n", DEVNAME(dev_current)); +#endif + } + return 0; + + open_cleanup: + if (addr0) + free(addr0); + + if (addr1) + free(addr1); + + return ret; +} + +/* + * Simply free allocated buffer with environment + */ +int fw_env_close(struct env_opts *opts) +{ + if (environment.image) + free(environment.image); + + environment.image = NULL; + + return 0; +} + +static int check_device_config(int dev) +{ + struct stat st; + int32_t lnum = 0; + int fd, rc = 0; + + /* Fills in IS_UBI(), converts DEVNAME() with ubi volume name */ + ubi_check_dev(dev); + + fd = open(DEVNAME(dev), O_RDONLY); + if (fd < 0) { + fprintf(stderr, + "Cannot open %s: %s\n", DEVNAME(dev), strerror(errno)); + return -1; + } + + rc = fstat(fd, &st); + if (rc < 0) { + fprintf(stderr, "Cannot stat the file %s\n", DEVNAME(dev)); + goto err; + } + + if (IS_UBI(dev)) { + rc = ioctl(fd, UBI_IOCEBISMAP, &lnum); + if (rc < 0) { + fprintf(stderr, "Cannot get UBI information for %s\n", + DEVNAME(dev)); + goto err; + } + } else if (S_ISCHR(st.st_mode)) { + struct mtd_info_user mtdinfo; + rc = ioctl(fd, MEMGETINFO, &mtdinfo); + if (rc < 0) { + fprintf(stderr, "Cannot get MTD information for %s\n", + DEVNAME(dev)); + goto err; + } + if (mtdinfo.type != MTD_NORFLASH && + mtdinfo.type != MTD_NANDFLASH && + mtdinfo.type != MTD_DATAFLASH && + mtdinfo.type != MTD_UBIVOLUME) { + fprintf(stderr, "Unsupported flash type %u on %s\n", + mtdinfo.type, DEVNAME(dev)); + goto err; + } + DEVTYPE(dev) = mtdinfo.type; + if (DEVESIZE(dev) == 0 && ENVSECTORS(dev) == 0 && + mtdinfo.type == MTD_NORFLASH) + DEVESIZE(dev) = mtdinfo.erasesize; + if (DEVESIZE(dev) == 0) + /* Assume the erase size is the same as the env-size */ + DEVESIZE(dev) = ENVSIZE(dev); + } else { + uint64_t size; + DEVTYPE(dev) = MTD_ABSENT; + if (DEVESIZE(dev) == 0) + /* Assume the erase size to be 512 bytes */ + DEVESIZE(dev) = 0x200; + + /* + * Check for negative offsets, treat it as backwards offset + * from the end of the block device + */ + if (DEVOFFSET(dev) < 0) { + rc = ioctl(fd, BLKGETSIZE64, &size); + if (rc < 0) { + fprintf(stderr, + "Could not get block device size on %s\n", + DEVNAME(dev)); + goto err; + } + + DEVOFFSET(dev) = DEVOFFSET(dev) + size; +#ifdef DEBUG + fprintf(stderr, + "Calculated device offset 0x%llx on %s\n", + DEVOFFSET(dev), DEVNAME(dev)); +#endif + } + } + + if (ENVSECTORS(dev) == 0) + /* Assume enough sectors to cover the environment */ + ENVSECTORS(dev) = DIV_ROUND_UP(ENVSIZE(dev), DEVESIZE(dev)); + + if (DEVOFFSET(dev) % DEVESIZE(dev) != 0) { + fprintf(stderr, + "Environment does not start on (erase) block boundary\n"); + errno = EINVAL; + return -1; + } + + if (ENVSIZE(dev) > ENVSECTORS(dev) * DEVESIZE(dev)) { + fprintf(stderr, + "Environment does not fit into available sectors\n"); + errno = EINVAL; + return -1; + } + + err: + close(fd); + return rc; +} + +static int parse_config(struct env_opts *opts) +{ + int rc; + + if (!opts) + opts = &default_opts; + +#if defined(CONFIG_FILE) + /* Fills in DEVNAME(), ENVSIZE(), DEVESIZE(). Or don't. */ + if (get_config(opts->config_file)) { + fprintf(stderr, "Cannot parse config file '%s': %m\n", + opts->config_file); + return -1; + } +#else + DEVNAME(0) = DEVICE1_NAME; + DEVOFFSET(0) = DEVICE1_OFFSET; + ENVSIZE(0) = ENV1_SIZE; + + /* Set defaults for DEVESIZE, ENVSECTORS later once we + * know DEVTYPE + */ +#ifdef DEVICE1_ESIZE + DEVESIZE(0) = DEVICE1_ESIZE; +#endif +#ifdef DEVICE1_ENVSECTORS + ENVSECTORS(0) = DEVICE1_ENVSECTORS; +#endif + +#ifdef HAVE_REDUND + DEVNAME(1) = DEVICE2_NAME; + DEVOFFSET(1) = DEVICE2_OFFSET; + ENVSIZE(1) = ENV2_SIZE; + + /* Set defaults for DEVESIZE, ENVSECTORS later once we + * know DEVTYPE + */ +#ifdef DEVICE2_ESIZE + DEVESIZE(1) = DEVICE2_ESIZE; +#endif +#ifdef DEVICE2_ENVSECTORS + ENVSECTORS(1) = DEVICE2_ENVSECTORS; +#endif + have_redund_env = 1; +#endif +#endif + rc = check_device_config(0); + if (rc < 0) + return rc; + + if (have_redund_env) { + rc = check_device_config(1); + if (rc < 0) + return rc; + + if (ENVSIZE(0) != ENVSIZE(1)) { + fprintf(stderr, + "Redundant environments have unequal size\n"); + return -1; + } + } + + usable_envsize = CUR_ENVSIZE - sizeof(uint32_t); + if (have_redund_env) + usable_envsize -= sizeof(char); + + return 0; +} + +#if defined(CONFIG_FILE) +static int get_config(char *fname) +{ + FILE *fp; + int i = 0; + int rc; + char *line = NULL; + size_t linesize = 0; + char *devname; + + fp = fopen(fname, "r"); + if (fp == NULL) + return -1; + + while (i < 2 && getline(&line, &linesize, fp) != -1) { + /* Skip comment strings */ + if (line[0] == '#') + continue; + + rc = sscanf(line, "%ms %lli %lx %lx %lx", + &devname, + &DEVOFFSET(i), + &ENVSIZE(i), &DEVESIZE(i), &ENVSECTORS(i)); + + if (rc < 3) + continue; + + DEVNAME(i) = devname; + + /* Set defaults for DEVESIZE, ENVSECTORS later once we + * know DEVTYPE + */ + + i++; + } + free(line); + fclose(fp); + + have_redund_env = i - 1; + if (!i) { /* No valid entries found */ + errno = EINVAL; + return -1; + } else + return 0; +} +#endif diff --git a/roms/u-boot/tools/env/fw_env.config b/roms/u-boot/tools/env/fw_env.config new file mode 100644 index 000000000..053895a2c --- /dev/null +++ b/roms/u-boot/tools/env/fw_env.config @@ -0,0 +1,38 @@ +# Configuration file for fw_(printenv/setenv) utility. +# Up to two entries are valid, in this case the redundant +# environment sector is assumed present. +# Notice, that the "Number of sectors" is not required on NOR and SPI-dataflash. +# Futhermore, if the Flash sector size is omitted, this value is assumed to +# be the same as the Environment size, which is valid for NOR and SPI-dataflash +# Device offset must be prefixed with 0x to be parsed as a hexadecimal value. + +# NOR example +# MTD device name Device offset Env. size Flash sector size Number of sectors +/dev/mtd1 0x0000 0x4000 0x4000 +/dev/mtd2 0x0000 0x4000 0x4000 + +# MTD SPI-dataflash example +# MTD device name Device offset Env. size Flash sector size Number of sectors +#/dev/mtd5 0x4200 0x4200 +#/dev/mtd6 0x4200 0x4200 + +# NAND example +#/dev/mtd0 0x4000 0x4000 0x20000 2 + +# On a block device a negative offset is treated as a backwards offset from the +# end of the device/partition, rather than a forwards offset from the start. + +# Block device example +#/dev/mmcblk0 0xc0000 0x20000 +#/dev/mmcblk0 -0x20000 0x20000 + +# VFAT example +#/boot/uboot.env 0x0000 0x4000 + +# UBI volume +#/dev/ubi0_0 0x0 0x1f000 0x1f000 +#/dev/ubi0_1 0x0 0x1f000 0x1f000 + +# UBI volume by name +#/dev/ubi0:env 0x0 0x1f000 0x1f000 +#/dev/ubi0:env-redund 0x0 0x1f000 0x1f000 diff --git a/roms/u-boot/tools/env/fw_env.h b/roms/u-boot/tools/env/fw_env.h new file mode 100644 index 000000000..78c803c94 --- /dev/null +++ b/roms/u-boot/tools/env/fw_env.h @@ -0,0 +1,161 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * (C) Copyright 2002-2008 + * Wolfgang Denk, DENX Software Engineering, wd@denx.de. + */ + +#include <stdint.h> + +/* + * Programs using the library must check which API is available, + * that varies depending on the U-Boot version. + * This can be changed in future + */ +#define FW_ENV_API_VERSION 1 + +struct env_opts { +#ifdef CONFIG_FILE + char *config_file; +#endif + char *lockname; +}; + +/** + * fw_printenv() - print one or several environment variables + * + * @argc: number of variables names to be printed, prints all if 0 + * @argv: array of variable names to be printed, if argc != 0 + * @value_only: do not repeat the variable name, print the bare value, + * only one variable allowed with this option, argc must be 1 + * @opts: encryption key, configuration file, defaults are used if NULL + * + * Description: + * Uses fw_env_open, fw_getenv + * + * Return: + * 0 on success, -1 on failure (modifies errno) + */ +int fw_printenv(int argc, char *argv[], int value_only, struct env_opts *opts); + +/** + * fw_env_set() - adds or removes one variable to the environment + * + * @argc: number of strings in argv, argv[0] is variable name, + * argc==1 means erase variable, argc > 1 means add a variable + * @argv: argv[0] is variable name, argv[1..argc-1] are concatenated separated + * by single blank and set as the new value of the variable + * @opts: how to retrieve environment from flash, defaults are used if NULL + * + * Description: + * Uses fw_env_open, fw_env_write, fw_env_flush + * + * Return: + * 0 on success, -1 on failure (modifies errno) + * + * ERRORS: + * EROFS - some variables ("ethaddr", "serial#") cannot be modified + */ +int fw_env_set(int argc, char *argv[], struct env_opts *opts); + +/** + * fw_parse_script() - adds or removes multiple variables with a batch script + * + * @fname: batch script file name + * @opts: encryption key, configuration file, defaults are used if NULL + * + * Description: + * Uses fw_env_open, fw_env_write, fw_env_flush + * + * Return: + * 0 success, -1 on failure (modifies errno) + * + * Script Syntax: + * + * key [ [space]+ value] + * + * lines starting with '#' treated as comment + * + * A variable without value will be deleted. Any number of spaces are allowed + * between key and value. The value starts with the first non-space character + * and ends with newline. No comments allowed on these lines. Spaces inside + * the value are preserved verbatim. + * + * Script Example: + * + * netdev eth0 + * + * kernel_addr 400000 + * + * foo spaces are copied verbatim + * + * # delete variable bar + * + * bar + */ +int fw_parse_script(char *fname, struct env_opts *opts); + + +/** + * fw_env_open() - read enviroment from flash into RAM cache + * + * @opts: encryption key, configuration file, defaults are used if NULL + * + * Return: + * 0 on success, -1 on failure (modifies errno) + */ +int fw_env_open(struct env_opts *opts); + +/** + * fw_getenv() - lookup variable in the RAM cache + * + * @name: variable to be searched + * Return: + * pointer to start of value, NULL if not found + */ +char *fw_getenv(char *name); + +/** + * fw_env_write() - modify a variable held in the RAM cache + * + * @name: variable + * @value: delete variable if NULL, otherwise create or overwrite the variable + * + * This is called in sequence to update the environment in RAM without updating + * the copy in flash after each set + * + * Return: + * 0 on success, -1 on failure (modifies errno) + * + * ERRORS: + * EROFS - some variables ("ethaddr", "serial#") cannot be modified + */ +int fw_env_write(char *name, char *value); + +/** + * fw_env_flush - write the environment from RAM cache back to flash + * + * @opts: encryption key, configuration file, defaults are used if NULL + * + * Return: + * 0 on success, -1 on failure (modifies errno) + */ +int fw_env_flush(struct env_opts *opts); + +/** + * fw_env_close - free allocated structure and close env + * + * @opts: encryption key, configuration file, defaults are used if NULL + * + * Return: + * 0 on success, -1 on failure (modifies errno) + */ +int fw_env_close(struct env_opts *opts); + + +/** + * fw_env_version - return the current version of the library + * + * Return: + * version string of the library + */ +char *fw_env_version(void); diff --git a/roms/u-boot/tools/env/fw_env_main.c b/roms/u-boot/tools/env/fw_env_main.c new file mode 100644 index 000000000..1d193bd43 --- /dev/null +++ b/roms/u-boot/tools/env/fw_env_main.c @@ -0,0 +1,284 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * (C) Copyright 2000-2008 + * Wolfgang Denk, DENX Software Engineering, wd@denx.de. + */ + +/* + * Command line user interface to firmware (=U-Boot) environment. + * + * Implements: + * fw_printenv [ -a key ] [[ -n name ] | [ name ... ]] + * - prints the value of a single environment variable + * "name", the ``name=value'' pairs of one or more + * environment variables "name", or the whole + * environment if no names are specified. + * fw_setenv [ -a key ] name [ value ... ] + * - If a name without any values is given, the variable + * with this name is deleted from the environment; + * otherwise, all "value" arguments are concatenated, + * separated by single blank characters, and the + * resulting string is assigned to the environment + * variable "name" + * + * If '-a key' is specified, the env block is encrypted with AES 128 CBC. + * The 'key' argument is in the format of 32 hexadecimal numbers (16 bytes + * of AES key), eg. '-a aabbccddeeff00112233445566778899'. + */ + +#include <env.h> +#include <fcntl.h> +#include <getopt.h> +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <sys/file.h> +#include <unistd.h> +#include <version.h> +#include "fw_env_private.h" +#include "fw_env.h" + +#define CMD_PRINTENV "fw_printenv" +#define CMD_SETENV "fw_setenv" +static int do_printenv; + +static struct option long_options[] = { + {"config", required_argument, NULL, 'c'}, + {"help", no_argument, NULL, 'h'}, + {"script", required_argument, NULL, 's'}, + {"noheader", no_argument, NULL, 'n'}, + {"lock", required_argument, NULL, 'l'}, + {"version", no_argument, NULL, 'v'}, + {NULL, 0, NULL, 0} +}; + +static struct env_opts env_opts; + +/* setenv options */ +static int noheader; + +/* getenv options */ +static char *script_file; + +void usage_printenv(void) +{ + + fprintf(stderr, + "Usage: fw_printenv [OPTIONS]... [VARIABLE]...\n" + "Print variables from U-Boot environment\n" + "\n" + " -h, --help print this help.\n" + " -v, --version display version\n" +#ifdef CONFIG_FILE + " -c, --config configuration file, default:" CONFIG_FILE "\n" +#endif + " -n, --noheader do not repeat variable name in output\n" + " -l, --lock lock node, default:/var/lock\n" + "\n"); +} + +void usage_env_set(void) +{ + fprintf(stderr, + "Usage: fw_setenv [OPTIONS]... [VARIABLE]...\n" + "Modify variables in U-Boot environment\n" + "\n" + " -h, --help print this help.\n" + " -v, --version display version\n" +#ifdef CONFIG_FILE + " -c, --config configuration file, default:" CONFIG_FILE "\n" +#endif + " -l, --lock lock node, default:/var/lock\n" + " -s, --script batch mode to minimize writes\n" + "\n" + "Examples:\n" + " fw_setenv foo bar set variable foo equal bar\n" + " fw_setenv foo clear variable foo\n" + " fw_setenv --script file run batch script\n" + "\n" + "Script Syntax:\n" + " key [space] value\n" + " lines starting with '#' are treated as comment\n" + "\n" + " A variable without value will be deleted. Any number of spaces are\n" + " allowed between key and value. Space inside of the value is treated\n" + " as part of the value itself.\n" + "\n" + "Script Example:\n" + " netdev eth0\n" + " kernel_addr 400000\n" + " foo empty empty empty empty empty empty\n" + " bar\n" + "\n"); +} + +static void parse_common_args(int argc, char *argv[]) +{ + int c; + +#ifdef CONFIG_FILE + env_opts.config_file = CONFIG_FILE; +#endif + + while ((c = getopt_long(argc, argv, ":a:c:l:h:v", long_options, NULL)) != + EOF) { + switch (c) { +#ifdef CONFIG_FILE + case 'c': + env_opts.config_file = optarg; + break; +#endif + case 'l': + env_opts.lockname = optarg; + break; + case 'h': + do_printenv ? usage_printenv() : usage_env_set(); + exit(EXIT_SUCCESS); + break; + case 'v': + fprintf(stderr, "Compiled with " U_BOOT_VERSION "\n"); + exit(EXIT_SUCCESS); + break; + default: + /* ignore unknown options */ + break; + } + } + + /* Reset getopt for the next pass. */ + opterr = 1; + optind = 1; +} + +int parse_printenv_args(int argc, char *argv[]) +{ + int c; + + parse_common_args(argc, argv); + + while ((c = getopt_long(argc, argv, "a:c:ns:l:h:v", long_options, NULL)) + != EOF) { + switch (c) { + case 'n': + noheader = 1; + break; + case 'a': + case 'c': + case 'h': + case 'l': + /* ignore common options */ + break; + default: /* '?' */ + usage_printenv(); + exit(EXIT_FAILURE); + break; + } + } + return 0; +} + +int parse_setenv_args(int argc, char *argv[]) +{ + int c; + + parse_common_args(argc, argv); + + while ((c = getopt_long(argc, argv, "a:c:ns:l:h:v", long_options, NULL)) + != EOF) { + switch (c) { + case 's': + script_file = optarg; + break; + case 'a': + case 'c': + case 'h': + case 'l': + /* ignore common options */ + break; + default: /* '?' */ + usage_env_set(); + exit(EXIT_FAILURE); + break; + } + } + return 0; +} + +int main(int argc, char *argv[]) +{ + char *lockname = "/var/lock/" CMD_PRINTENV ".lock"; + int lockfd = -1; + int retval = EXIT_SUCCESS; + char *_cmdname; + + _cmdname = *argv; + if (strrchr(_cmdname, '/') != NULL) + _cmdname = strrchr(_cmdname, '/') + 1; + + if (strcmp(_cmdname, CMD_PRINTENV) == 0) { + do_printenv = 1; + } else if (strcmp(_cmdname, CMD_SETENV) == 0) { + do_printenv = 0; + } else { + fprintf(stderr, + "Identity crisis - may be called as `%s' or as `%s' but not as `%s'\n", + CMD_PRINTENV, CMD_SETENV, _cmdname); + exit(EXIT_FAILURE); + } + + if (do_printenv) { + if (parse_printenv_args(argc, argv)) + exit(EXIT_FAILURE); + } else { + if (parse_setenv_args(argc, argv)) + exit(EXIT_FAILURE); + } + + /* shift parsed flags, jump to non-option arguments */ + argc -= optind; + argv += optind; + + if (env_opts.lockname) { + lockname = malloc(strlen(env_opts.lockname) + + sizeof(CMD_PRINTENV) + 10); + if (!lockname) { + fprintf(stderr, "Unable allocate memory"); + exit(EXIT_FAILURE); + } + + sprintf(lockname, "%s/%s.lock", + env_opts.lockname, CMD_PRINTENV); + } + + lockfd = open(lockname, O_WRONLY | O_CREAT | O_TRUNC, 0666); + if (-1 == lockfd) { + fprintf(stderr, "Error opening lock file %s\n", lockname); + return EXIT_FAILURE; + } + + if (-1 == flock(lockfd, LOCK_EX)) { + fprintf(stderr, "Error locking file %s\n", lockname); + close(lockfd); + return EXIT_FAILURE; + } + + if (do_printenv) { + if (fw_printenv(argc, argv, noheader, &env_opts) != 0) + retval = EXIT_FAILURE; + } else { + if (!script_file) { + if (fw_env_set(argc, argv, &env_opts) != 0) + retval = EXIT_FAILURE; + } else { + if (fw_parse_script(script_file, &env_opts) != 0) + retval = EXIT_FAILURE; + } + } + + if (env_opts.lockname) + free(lockname); + + flock(lockfd, LOCK_UN); + close(lockfd); + return retval; +} diff --git a/roms/u-boot/tools/env/fw_env_private.h b/roms/u-boot/tools/env/fw_env_private.h new file mode 100644 index 000000000..86be16dab --- /dev/null +++ b/roms/u-boot/tools/env/fw_env_private.h @@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * (C) Copyright 2002-2008 + * Wolfgang Denk, DENX Software Engineering, wd@denx.de. + */ + +/* Pull in the current config to define the default environment */ +#include <linux/kconfig.h> + +#ifndef __ASSEMBLY__ +#define __ASSEMBLY__ /* get only #defines from config.h */ +#include <config.h> +#undef __ASSEMBLY__ +#else +#include <config.h> +#endif + +/* + * To build the utility with the static configuration + * comment out the next line. + * See included "fw_env.config" sample file + * for notes on configuration. + */ +#define CONFIG_FILE "/etc/fw_env.config" + +#ifndef CONFIG_FILE +#define HAVE_REDUND /* For systems with 2 env sectors */ +#define DEVICE1_NAME "/dev/mtd1" +#define DEVICE2_NAME "/dev/mtd2" +#define DEVICE1_OFFSET 0x0000 +#define ENV1_SIZE 0x4000 +#define DEVICE1_ESIZE 0x4000 +#define DEVICE1_ENVSECTORS 2 +#define DEVICE2_OFFSET 0x0000 +#define ENV2_SIZE 0x4000 +#define DEVICE2_ESIZE 0x4000 +#define DEVICE2_ENVSECTORS 2 +#endif + +#ifndef CONFIG_BAUDRATE +#define CONFIG_BAUDRATE 115200 +#endif + +#ifndef CONFIG_BOOTDELAY +#define CONFIG_BOOTDELAY 5 /* autoboot after 5 seconds */ +#endif + +#ifndef CONFIG_BOOTCOMMAND +#define CONFIG_BOOTCOMMAND \ + "bootp; " \ + "setenv bootargs root=/dev/nfs nfsroot=${serverip}:${rootpath} "\ + "ip=${ipaddr}:${serverip}:${gatewayip}:${netmask}:${hostname}::off; "\ + "bootm" +#endif diff --git a/roms/u-boot/tools/env/linux_string.c b/roms/u-boot/tools/env/linux_string.c new file mode 100644 index 000000000..6c01addad --- /dev/null +++ b/roms/u-boot/tools/env/linux_string.c @@ -0,0 +1 @@ +#include "../../lib/linux_string.c" |