From 31b015fc08a13a5b63245808f7d1a49eadd8193a Mon Sep 17 00:00:00 2001 From: Drake Dowsett Date: Mon, 6 Nov 2006 16:54:10 +0100 Subject: [MTD] UBI: pfiflash needs to flash raw sections and check CRC Flashing of raw partitions should be possible now. CRC checking of pfi files before flashing the content was added. Signed-off-by: Frank Haverkamp --- ubi-utils/Makefile | 8 +- ubi-utils/src/bootenv.c | 105 +++-- ubi-utils/src/bootenv.h | 9 + ubi-utils/src/error.c | 67 +++- ubi-utils/src/error.h | 2 +- ubi-utils/src/libpfiflash.c | 841 ++++++++++++++++++++++++++++++----------- ubi-utils/src/pfiflash.c | 37 +- ubi-utils/src/pfiflash.h | 13 + ubi-utils/src/pfiflash_error.h | 69 ++++ ubi-utils/src/reader.c | 15 +- ubi-utils/src/reader.h | 2 + 11 files changed, 890 insertions(+), 278 deletions(-) create mode 100644 ubi-utils/src/pfiflash_error.h diff --git a/ubi-utils/Makefile b/ubi-utils/Makefile index 6161f3d..2776c07 100644 --- a/ubi-utils/Makefile +++ b/ubi-utils/Makefile @@ -48,15 +48,15 @@ ubirmvol: ubirmvol.o error.o libubi.o libubi_sysfs.o $(CC) $(LDFLAGS) -o $@ $^ pddcustomize: pddcustomize.o error.o libubimirror.o bootenv.o hashmap.o \ - libubi.o libubi_sysfs.o + libubi.o libubi_sysfs.o crc32.o $(CC) $(LDFLAGS) -o $@ $^ pfiflash: pfiflash.o libpfiflash.o list.o reader.o error.o libubimirror.o \ - bootenv.o hashmap.o pfi.o libubi.o libubi_sysfs.o + bootenv.o hashmap.o pfi.o libubi.o libubi_sysfs.o crc32.o $(CC) $(LDFLAGS) -o $@ $^ ubimirror: ubimirror.o error.o libubimirror.o bootenv.o hashmap.o \ - libubi.o libubi_sysfs.o + libubi.o libubi_sysfs.o crc32.o $(CC) $(LDFLAGS) -o $@ $^ nand2bin: nand2bin.o nandecc.o nandcorr.o @@ -68,7 +68,7 @@ bin2nand: bin2nand.o error.o nandecc.o ubigen: ubigen.o libubigen.o crc32.o $(CC) $(LDFLAGS) -o $@ $^ -mkbootenv: mkbootenv.o bootenv.o hashmap.o error.o +mkbootenv: mkbootenv.o bootenv.o hashmap.o error.o crc32.o $(CC) $(LDFLAGS) -o $@ $^ unubi: unubi.o crc32.o diff --git a/ubi-utils/src/bootenv.c b/ubi-utils/src/bootenv.c index 8871d90..ed15dc7 100644 --- a/ubi-utils/src/bootenv.c +++ b/ubi-utils/src/bootenv.c @@ -27,10 +27,14 @@ #include #include -#include "config.h" #include "hashmap.h" #include "error.h" +#include +#include "crc32.h" + +#define __unused __attribute__((unused)) + #define BOOTENV_MAXLINE 512 /* max line size of a bootenv.txt file */ /* Structures */ @@ -189,9 +193,10 @@ extract_pair(const char *str, bootenv_t env) *val = '\0'; /* split strings */ val++; + rc = bootenv_set(env, key, val); -err: + err: free(key); return rc; } @@ -248,46 +253,36 @@ bootenv_create(bootenv_t* env) static int rd_buffer(bootenv_t env, const char *buf, size_t size) { - const char *curr = buf; /* ptr to current key/value pair */ - uint32_t i = 0; /* current length */ - uint32_t j = 0; /* processed chars */ - uint32_t items = 0; /* processed items */ - int rc = 0; + const char *curr = buf; /* ptr to current key/value pair */ + uint32_t i, j; /* current length, chars processed */ - if (buf[size-1] != '\0') { + if (buf[size - 1] != '\0') /* must end in '\0' */ return BOOTENV_EFMT; - } - while ((i = strlen(curr)) != 0) { - /* there is a key value pair remaining */ - rc = extract_pair(curr, env); - if (rc != 0) { - rc = BOOTENV_EINVAL; - return rc; - } - items++; + for (j = 0; j < size; j += i, curr += i) { + /* strlen returns the size of the string upto + but not including the null terminator; + adding 1 to account for '\0' */ + i = strlen(curr) + 1; - j += i; - if (j >= size) - return 0; /* finished, end of buffer */ - curr += i + 1; + if (i == 1) + return 0; /* no string found */ + + if (extract_pair(curr, env) != 0) + return BOOTENV_EINVAL; } return 0; } -/** - * If we have a single file containing the boot-parameter size should - * be specified either as the size of the file or as BOOTENV_MAXSIZE. - * If the bootparameter are in the middle of a file we need the exact - * length of the data. - */ + int -bootenv_read(FILE* fp, bootenv_t env, size_t size) +bootenv_read_crc(FILE* fp, bootenv_t env, size_t size, uint32_t* ret_crc) { int rc; char *buf = NULL; size_t i = 0; + uint32_t crc32_table[256]; if ((fp == NULL) || (env == NULL)) return -EINVAL; @@ -306,33 +301,47 @@ bootenv_read(FILE* fp, bootenv_t env, size_t size) */ while((i < size) && (!feof(fp))) { int c = fgetc(fp); - if (c == EOF) { + /* FIXME isn't this dangerous, to update + the boot envs with incomplete data? */ buf[i++] = '\0'; break; /* we have enough */ } - - /* log_msg("%c", c); */ /* FIXME DBG */ - - buf[i++] = c; if (ferror(fp)) { rc = -EIO; goto err; } + + buf[i++] = (char)c; + } + + /* calculate crc to return */ + if (ret_crc != NULL) { + init_crc32_table(crc32_table); + *ret_crc = clc_crc32(crc32_table, UBI_CRC32_INIT, buf, size); } /* transfer to hashmap */ rc = rd_buffer(env, buf, size); - /* FIXME DBG */ - /* log_msg("\n%s:%d rc=%d\n", __func__, __LINE__, rc); */ - err: free(buf); return rc; } +/** + * If we have a single file containing the boot-parameter size should + * be specified either as the size of the file or as BOOTENV_MAXSIZE. + * If the bootparameter are in the middle of a file we need the exact + * length of the data. + */ +int +bootenv_read(FILE* fp, bootenv_t env, size_t size) +{ + return bootenv_read_crc(fp, env, size, NULL); +} + int bootenv_read_txt(FILE* fp, bootenv_t env) @@ -390,8 +399,8 @@ err: } static int -fill_output_buffer(bootenv_t env, char *buf, size_t buf_size_max, - size_t *written) +fill_output_buffer(bootenv_t env, char *buf, size_t buf_size_max __unused, + size_t *written) { int rc = 0; size_t keys_size, i; @@ -404,7 +413,7 @@ fill_output_buffer(bootenv_t env, char *buf, size_t buf_size_max, goto err; for (i = 0; i < keys_size; i++) { - if (wr > buf_size_max) { + if (wr > BOOTENV_MAXSIZE) { rc = -ENOSPC; goto err; } @@ -413,7 +422,7 @@ fill_output_buffer(bootenv_t env, char *buf, size_t buf_size_max, if (rc != 0) goto err; - wr += snprintf(buf + wr, buf_size_max - wr, + wr += snprintf(buf + wr, BOOTENV_MAXSIZE - wr, "%s=%s", keys[i], val); wr++; /* for \0 */ } @@ -428,11 +437,12 @@ err: } int -bootenv_write(FILE* fp, bootenv_t env) +bootenv_write_crc(FILE* fp, bootenv_t env, uint32_t* ret_crc) { int rc = 0; size_t size = 0; char *buf = NULL; + uint32_t crc32_table[256]; if ((fp == NULL) || (env == NULL)) return -EINVAL; @@ -441,10 +451,17 @@ bootenv_write(FILE* fp, bootenv_t env) if (buf == NULL) return -ENOMEM; + rc = fill_output_buffer(env, buf, BOOTENV_MAXSIZE, &size); if (rc != 0) goto err; + /* calculate crc to return */ + if (ret_crc != NULL) { + init_crc32_table(crc32_table); + *ret_crc = clc_crc32(crc32_table, UBI_CRC32_INIT, buf, size); + } + if (fwrite(buf, size, 1, fp) != 1) { rc = -EIO; goto err; @@ -456,6 +473,12 @@ err: return rc; } +int +bootenv_write(FILE* fp, bootenv_t env) +{ + return bootenv_write_crc(fp, env, NULL); +} + int bootenv_size(bootenv_t env, size_t *size) { diff --git a/ubi-utils/src/bootenv.h b/ubi-utils/src/bootenv.h index 86743ed..9003d70 100644 --- a/ubi-utils/src/bootenv.h +++ b/ubi-utils/src/bootenv.h @@ -230,6 +230,10 @@ int bootenv_size(bootenv_t env, size_t *size); */ int bootenv_read(FILE* fp, bootenv_t env, size_t size); +/** + * @param ret_crc return value of crc of read data + */ +int bootenv_read_crc(FILE* fp, bootenv_t env, size_t size, uint32_t *ret_crc); /** * @brief Read bootenv data from an text/ascii file. @@ -249,6 +253,11 @@ int bootenv_read_txt(FILE* fp, bootenv_t env); */ int bootenv_write(FILE* fp, bootenv_t env); +/** + * @param ret_crc return value of crc of read data + */ +int bootenv_write_crc(FILE* fp, bootenv_t env, uint32_t* ret_crc); + /** * @brief Write a bootenv structure to the given location (text). * @param fp Filepointer to text file. diff --git a/ubi-utils/src/error.c b/ubi-utils/src/error.c index c8c623c..4aaedad 100644 --- a/ubi-utils/src/error.c +++ b/ubi-utils/src/error.c @@ -25,6 +25,7 @@ #include "error.h" #define MAXLINE 4096 +#define MAXWIDTH 80 static FILE *logfp = NULL; @@ -35,6 +36,9 @@ read_procfile(FILE *fp_out, const char *procfile) { FILE *fp; + if (!fp_out) + return -ENXIO; + fp = fopen(procfile, "r"); if (!fp) return -ENOENT; @@ -57,6 +61,9 @@ read_procfile(FILE *fp_out, const char *procfile) void error_initlog(const char *logfile) { + if (!logfile) + return; + logfp = fopen(logfile, "a+"); read_procfile(logfp, "/proc/cpuinfo"); } @@ -143,7 +150,11 @@ __err_dump(const char *fmt, ...) exit(EXIT_FAILURE); /* shouldn't get here */ } - +/** + * If a logfile is used we must not print on stderr and stdout + * anymore. Since pfilfash might be used in a server context, it is + * even dangerous to write to those descriptors. + */ static void err_doit(int errnoflag, int level __attribute__((unused)), const char *fmt, va_list ap) @@ -166,9 +177,61 @@ err_doit(int errnoflag, int level __attribute__((unused)), if (logfp) { fputs(buf, logfp); fflush(logfp); + return; /* exit when logging completes */ } - fputs(buf, fpout); + if (fpout == stderr) { + /* perform line wrap when outputting to stderr */ + int word_len, post_len, chars; + char *buf_ptr; + const char *frmt = "%*s%n %n"; + + chars = 0; + buf_ptr = buf; + while (sscanf(buf_ptr, frmt, &word_len, &post_len) != EOF) { + int i; + char word[word_len + 1]; + char post[post_len + 1]; + + strncpy(word, buf_ptr, word_len); + word[word_len] = '\0'; + buf_ptr += word_len; + post_len -= word_len; + + if (chars + word_len > MAXWIDTH) { + fputc('\n', fpout); + chars = 0; + } + fputs(word, fpout); + chars += word_len; + + if (post_len > 0) { + strncpy(post, buf_ptr, post_len); + post[post_len] = '\0'; + buf_ptr += post_len; + } + for (i = 0; i < post_len; i++) { + int inc = 1, chars_new; + + if (post[i] == '\t') + inc = 8; + if (post[i] == '\n') { + inc = 0; + chars_new = 0; + } else + chars_new = chars + inc; + + if (chars_new > MAXWIDTH) { + fputc('\n', fpout); + chars_new = inc; + } + fputc(post[i], fpout); + chars = chars_new; + } + } + } + else + fputs(buf, fpout); fflush(fpout); if (fpout != stderr) fclose(fpout); diff --git a/ubi-utils/src/error.h b/ubi-utils/src/error.h index e8d7137..05d8078 100644 --- a/ubi-utils/src/error.h +++ b/ubi-utils/src/error.h @@ -78,7 +78,7 @@ void info_msg(const char *fmt, ...); __err_msg(fmt, ##__VA_ARGS__); \ } while (0) #else -#define dbg_msg(fmt, ...) +#define dbg_msg(fmt, ...) do {} while (0) #endif #endif /* __ERROR_H__ */ diff --git a/ubi-utils/src/libpfiflash.c b/ubi-utils/src/libpfiflash.c index ed2af3c..1dc9f10 100644 --- a/ubi-utils/src/libpfiflash.c +++ b/ubi-utils/src/libpfiflash.c @@ -16,16 +16,13 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -/** - * @file pfiflash.c - * - * @author Oliver Lohmann - * - * @brief This library is provides an interface to the pfiflash utility. - * - * Wed Mar 15 11:39:19 CET 2006 Initial creation. - * - * @TODO Comare data before writing it. This implies that the volume +/* + * Authors: Oliver Lohmann + * Drake Dowsett + * Contact: Andreas Arnez + */ + +/* TODO Compare data before writing it. This implies that the volume * parameters are compared first: size, alignment, name, type, ..., * this is the same, compare the data. Volume deletion is deffered * until the difference has been found out. @@ -40,89 +37,130 @@ #include #include -//#include /* FIXME Is this ok here!!?? */ +#include /* FIXME Is this ok here? */ -#include "config.h" +#include "pfiflash_error.h" #include "ubimirror.h" #include "error.h" #include "reader.h" #include "example_ubi.h" #include "bootenv.h" -static const char copyright [] __attribute__((unused)) = +/* ubi-header.h and crc32.h needed for CRC checking */ +#include /* FIXME Is this ok here? */ +#include "crc32.h" + +#define __unused __attribute__((unused)) + +static const char copyright [] __unused = "Copyright (c) International Business Machines Corp., 2006"; -#define EBUF(fmt...) do { \ - snprintf(err_buf, err_buf_size, fmt); \ +/* simply clear buffer, then write into front of it */ +#define EBUF(fmt...) \ + snprintf(err_buf, err_buf_size, fmt); + +/* make a history of buffer and then prepend something in front */ +#define EBUF_PREPEND(fmt) \ + do { \ + int EBUF_HISTORY_LENGTH = strlen(err_buf); \ + char EBUF_HISTORY[EBUF_HISTORY_LENGTH + 1]; \ + strncpy(EBUF_HISTORY, err_buf, EBUF_HISTORY_LENGTH + 1);\ + EBUF(fmt ": %s", EBUF_HISTORY); \ } while (0) +/* An array of PDD function pointers indexed by the algorithm. */ static pdd_func_t pdd_funcs[PDD_HANDLING_NUM] = { &bootenv_pdd_keep, &bootenv_pdd_merge, &bootenv_pdd_overwrite }; -/**< An array of PDD function pointers indexed by the algorithm. */ - typedef enum ubi_update_process_t { UBI_REMOVE = 0, UBI_WRITE, } ubi_update_process_t; + +/** + * skip_raw_volumes - reads data from pfi to advance fp past raw block + * @pfi: fp to pfi data + * @pfi_raws: header information + * + * Error handling): + * when early EOF in pfi data + * - returns -PFIFLASH_ERR_EOF, err_buf matches text to err + * when file I/O error + * - returns -PFIFLASH_ERR_FIO, err_buf matches text to err + **/ static int -skip_raw_sections(FILE* pfi, list_t pfi_raws, +skip_raw_volumes(FILE* pfi, list_t pfi_raws, char* err_buf, size_t err_buf_size) { - int rc = 0; - + int rc; void *i; list_t ptr; - size_t j, skip_size; if (is_empty(pfi_raws)) return 0; + rc = 0; foreach(i, ptr, pfi_raws) { - skip_size = ((pfi_raw_t)i)->data_size; - for(j = 0; j < skip_size; j++) { - fgetc(pfi); - if (ferror(pfi)) { - EBUF("Cannot skip raw section in PFI."); - rc = -EIO; + size_t j; + pfi_raw_t raw; + + raw = (pfi_raw_t)i; + for(j = 0; j < raw->data_size; j++) { + int c; + + c = fgetc(pfi); + if (c == EOF) + rc = -PFIFLASH_ERR_EOF; + else if (ferror(pfi)) + rc = -PFIFLASH_ERR_FIO; + + if (rc != 0) goto err; - } } } + err: + EBUF(PFIFLASH_ERRSTR[-rc]); return rc; } + /** - * @brief Wraps the ubi_mkvol functions and implements a hook for the bootenv - * update. - * @param devno UBI device number. - * @param s Current seqnum. - * @param u Information about the UBI volume from the PFI. - * @param err_buf An error buffer. - * @param err_buf_size The size of the error buffer. - * @return 0 On Sucess. - * @return else Error. - */ + * my_ubi_mkvol - wraps the ubi_mkvol functions and impl. bootenv update hook + * @devno: UBI device number. + * @s: Current seqnum. + * @u: Information about the UBI volume from the PFI. + * + * Error handling: + * when UBI system couldn't be opened + * - returns -PFIFLASH_ERR_UBI_OPEN, err_buf matches text to err + * when UBI system couldn't create a volume + * - returns -PFIFLASH_ERR_UBI_MKVOL, err_buf matches text to err + **/ static int -my_ubi_mkvol(int devno, int s, pfi_ubi_t u, char *err_buf, size_t err_buf_size) +my_ubi_mkvol(int devno, int s, pfi_ubi_t u, + char *err_buf, size_t err_buf_size) { - int rc = 0; - int type; - ubi_lib_t ulib = NULL; + int rc, type; + ubi_lib_t ulib; + + rc = 0; + ulib = NULL; - log_msg("%s(vol_id=%d, size=%d, data_size=%d, type=%d, " - "alig=%d, nlen=%d, name=%s)", __func__, + log_msg("[ ubimkvol id=%d, size=%d, data_size=%d, type=%d, " + "alig=%d, nlen=%d, name=%s", u->ids[s], u->size, u->data_size, u->type, u->alignment, strnlen(u->names[s], PFI_UBI_VOL_NAME_LEN), u->names[s]); rc = ubi_open(&ulib); if (rc != 0) { + rc = -PFIFLASH_ERR_UBI_OPEN; + EBUF(PFIFLASH_ERRSTR[-rc]); goto err; } @@ -130,7 +168,6 @@ my_ubi_mkvol(int devno, int s, pfi_ubi_t u, char *err_buf, size_t err_buf_size) case pfi_ubi_static: type = UBI_STATIC_VOLUME; break; case pfi_ubi_dynamic: - type = UBI_DYNAMIC_VOLUME; break; default: type = UBI_DYNAMIC_VOLUME; } @@ -138,58 +175,78 @@ my_ubi_mkvol(int devno, int s, pfi_ubi_t u, char *err_buf, size_t err_buf_size) rc = ubi_mkvol(ulib, devno, u->ids[s], type, u->size, u->alignment, u->names[s]); if (rc != 0) { - EBUF("Cannot create volume: %d", u->ids[s]); + rc = -PFIFLASH_ERR_UBI_MKVOL; + EBUF(PFIFLASH_ERRSTR[-rc], u->ids[s]); goto err; } err: if (ulib != NULL) ubi_close(&ulib); + return rc; } + /** - * @brief A wrapper around the UBI library function ubi_rmvol. - * @param devno UBI device number. - * @param s Current seqnum. - * @param u Information about the UBI volume from the PFI. - * @param err_buf An error buffer. - * @param err_buf_size The size of the error buffer. + * my_ubi_rmvol - a wrapper around the UBI library function ubi_rmvol + * @devno UBI device number + * @id UBI volume id to remove * * If the volume does not exist, the function will return success. - */ + * + * Error handling: + * when UBI system couldn't be opened + * - returns -PFIFLASH_ERR_UBI_OPEN, err_buf matches text to err + * when UBI system couldn't update (truncate) a volume + * - returns -PFIFLASH_ERR_UBI_VOL_UPDATE, err_buf matches text to err + * when UBI system couldn't remove a volume + * - returns -PFIFLASH_ERR_UBI_RMVOL, err_buf matches text to err + **/ static int my_ubi_rmvol(int devno, uint32_t id, - char *err_buf __unused, size_t err_buf_size __unused) + char *err_buf, size_t err_buf_size) { - int rc = 0; - ubi_lib_t ulib = NULL; - int fd; + int rc, fd; + ubi_lib_t ulib; - log_msg("%s(id=%d)", __func__, id); + rc = 0; + ulib = NULL; + + log_msg("[ ubirmvol id=%d", id); rc = ubi_open(&ulib); - if (rc != 0) + if (rc != 0) { + rc = -PFIFLASH_ERR_UBI_OPEN; + EBUF(PFIFLASH_ERRSTR[-rc]); goto err; + } - /** - * Truncate if it exist or not. - */ + /* truncate whether it exist or not */ fd = ubi_vol_open(ulib, devno, id, O_RDWR); if (fd == -1) - return 0; /* not existent, return */ + return 0; /* not existent, return 0 */ rc = ubi_vol_update(fd, 0); + ubi_vol_close(fd); if (rc < 0) { - fprintf(stderr, "update failed rc=%d errno=%d\n", rc, errno); - ubi_vol_close(fd); + rc = -PFIFLASH_ERR_UBI_VOL_UPDATE; + EBUF(PFIFLASH_ERRSTR[-rc], id); goto err; /* if EBUSY than empty device, continue */ } - ubi_vol_close(fd); rc = ubi_rmvol(ulib, devno, id); if (rc != 0) { - /* @TODO Define a ubi_rmvol return value which says +#ifdef DEBUG + int rc_old = rc; + dbg_msg("Remove UBI volume %d returned with error: %d " + "errno=%d", id, rc_old, errno); +#endif + + rc = -PFIFLASH_ERR_UBI_RMVOL; + EBUF(PFIFLASH_ERRSTR[-rc], id); + + /* TODO Define a ubi_rmvol return value which says * sth like EUBI_NOSUCHDEV. In this case, a failed * operation is acceptable. Everything else has to be * classified as real error. But talk to Andreas Arnez @@ -198,65 +255,128 @@ my_ubi_rmvol(int devno, uint32_t id, /* if ((errno == EINVAL) || (errno == ENODEV)) return 0; */ /* currently it is EINVAL or ENODEV */ - dbg_msg("Remove UBI volume %d returned with error: %d " - "errno=%d", id, rc, errno); goto err; } + err: if (ulib != NULL) ubi_close(&ulib); + return rc; } + +/** + * read_bootenv_volume - reads the current bootenv data from id into be_old + * @devno UBI device number + * @id UBI volume id to remove + * @bootenv_old to hold old boot_env data + * + * Error handling: + * when UBI system couldn't be opened + * - returns -PFIFLASH_ERR_UBI_OPEN, err_buf matches text to err + * when UBI system couldn't open a volume to read + * - returns -PFIFLASH_ERR_UBI_VOL_FOPEN, err_buf matches text to err + * when couldn't read bootenv data + * - returns -PFIFLASH_ERR_BOOTENV_READ, err_buf matches text to err + **/ static int read_bootenv_volume(int devno, uint32_t id, bootenv_t bootenv_old, char *err_buf, size_t err_buf_size) { - int rc = 0; - ubi_lib_t ulib = NULL; - FILE* fp_in = NULL; + int rc; + FILE* fp_in; + ubi_lib_t ulib; + + rc = 0; + fp_in = NULL; + ulib = NULL; rc = ubi_open(&ulib); - if (rc) - return rc; + if (rc != 0) { + rc = -PFIFLASH_ERR_UBI_OPEN; + EBUF(PFIFLASH_ERRSTR[-rc]); + goto err; + } fp_in = ubi_vol_fopen_read(ulib, devno, id); if (!fp_in) { - EBUF("Cannot open bootenv volume"); - rc = -EIO; + rc = -PFIFLASH_ERR_UBI_VOL_FOPEN; + EBUF(PFIFLASH_ERRSTR[-rc], id); goto err; } - log_msg("%s reading old bootenvs", __func__); + log_msg("[ reading old bootenvs ..."); /* Save old bootenvs for reference */ rc = bootenv_read(fp_in, bootenv_old, BOOTENV_MAXSIZE); - if (rc) - EBUF("Cannot read bootenv_old"); + if (rc != 0) { + rc = -PFIFLASH_ERR_BOOTENV_READ; + EBUF(PFIFLASH_ERRSTR[-rc]); + goto err; + } + err: if (fp_in) fclose(fp_in); if (ulib) ubi_close(&ulib); + return rc; } + +/** + * write_bootenv_volume - writes data from PFI file int to bootenv UBI volume + * @devno UBI device number + * @id UBI volume id + * @bootend_old old PDD data from machine + * @pdd_f function to handle PDD with + * @fp_in new pdd data contained in PFI + * @fp_in_size data size of new pdd data in PFI + * @pfi_crc crc value from PFI header + * + * Error handling: + * when UBI system couldn't be opened + * - returns -PFIFLASH_ERR_UBI_OPEN, err_buf matches text to err + * when bootenv can't be created + * - returns -PFIFLASH_ERR_BOOTENV_CREATE, err_buf matches text to err + * when bootenv can't be read + * - returns -PFIFLASH_ERR_BOOTENV_READ, err_buf matches text to err + * when PDD handling function returns and error + * - passes rc and err_buf data + * when CRC check fails + * - returns -PFIFLASH_ERR_CRC_CHECK, err_buf matches text to err + * when bootenv can't be resized + * - returns -PFIFLASH_ERR_BOOTENV_SIZE, err_buf matches text to err + * when UBI system couldn't open a volume + * - returns -PFIFLASH_ERR_UBI_VOL_FOPEN, err_buf matches text to err + * when couldn't write bootenv data + * - returns -PFIFLASH_ERR_BOOTENV_WRITE, err_buf matches text to err + **/ static int write_bootenv_volume(int devno, uint32_t id, bootenv_t bootenv_old, - pdd_func_t pdd_f, - FILE* fp_in, /* new pdd data contained in pfi */ - size_t fp_in_size, /* data size of new pdd data in pfi */ + pdd_func_t pdd_f, FILE* fp_in, size_t fp_in_size, + uint32_t pfi_crc, char *err_buf, size_t err_buf_size) { - int rc = 0; - int warnings = 0; - ubi_lib_t ulib = NULL; - bootenv_t bootenv_new = NULL; - bootenv_t bootenv_res = NULL; - size_t update_size = 0; - FILE *fp_out = NULL; - - log_msg("%s(id=%d, fp_in=%p)", __func__, id, fp_in); + int rc, warnings; + uint32_t crc; + size_t update_size; + FILE *fp_out; + bootenv_t bootenv_new, bootenv_res; + ubi_lib_t ulib; + + rc = 0; + warnings = 0; + crc = 0; + update_size = 0; + fp_out = NULL; + bootenv_new = NULL; + bootenv_res = NULL; + ulib = NULL; + + log_msg("[ ubiupdatevol bootenv id=%d, fp_in=%p", id, fp_in); /* Workflow: * 1. Apply PDD operation and get the size of the returning @@ -269,43 +389,65 @@ write_bootenv_volume(int devno, uint32_t id, bootenv_t bootenv_old, rc = ubi_open(&ulib); if (rc != 0) { + rc = -PFIFLASH_ERR_UBI_OPEN; + EBUF(PFIFLASH_ERRSTR[-rc]); goto err; } rc = bootenv_create(&bootenv_new); - if (rc != 0) + if (rc != 0) { + rc = -PFIFLASH_ERR_BOOTENV_CREATE; + EBUF(PFIFLASH_ERRSTR[-rc], " 'new'"); goto err; + } + rc = bootenv_create(&bootenv_res); - if (rc != 0) + if (rc != 0) { + rc = -PFIFLASH_ERR_BOOTENV_CREATE; + EBUF(PFIFLASH_ERRSTR[-rc], " 'res'"); goto err; + } - rc = bootenv_read(fp_in, bootenv_new, fp_in_size); - if (rc != 0) + rc = bootenv_read_crc(fp_in, bootenv_new, fp_in_size, &crc); + if (rc != 0) { + rc = -PFIFLASH_ERR_BOOTENV_READ; + EBUF(PFIFLASH_ERRSTR[-rc]); + goto err; + } else if (crc != pfi_crc) { + rc = -PFIFLASH_ERR_CRC_CHECK; + EBUF(PFIFLASH_ERRSTR[-rc], pfi_crc, crc); goto err; + } rc = pdd_f(bootenv_old, bootenv_new, &bootenv_res, &warnings, err_buf, err_buf_size); - if (rc != 0) + if (rc != 0) { + EBUF_PREPEND("handling PDD"); goto err; - if (warnings) { - /* @TODO Do sth with the warning */ + } + else if (warnings) + /* TODO do something with warnings */ dbg_msg("A warning in the PDD operation occured: %d", warnings); - } - log_msg("... (2)"); rc = bootenv_size(bootenv_res, &update_size); - if (rc != 0) + if (rc != 0) { + rc = -PFIFLASH_ERR_BOOTENV_SIZE; + EBUF(PFIFLASH_ERRSTR[-rc]); goto err; + } fp_out = ubi_vol_fopen_update(ulib, devno, id, update_size); - if (fp_out == NULL) + if (!fp_out) { + rc = -PFIFLASH_ERR_UBI_VOL_FOPEN; + EBUF(PFIFLASH_ERRSTR[-rc], id); goto err; + } rc = bootenv_write(fp_out, bootenv_res); if (rc != 0) { - EBUF("Write operation on ubi%d_%d failed.", devno, id); - rc = -EIO; + rc = -PFIFLASH_ERR_BOOTENV_WRITE; + EBUF(PFIFLASH_ERRSTR[-rc], devno, id); goto err; } @@ -318,102 +460,327 @@ write_bootenv_volume(int devno, uint32_t id, bootenv_t bootenv_old, bootenv_destroy(&bootenv_res); if (fp_out) fclose(fp_out); + return rc; } + +/** + * write_normal_volume - writes data from PFI file int to regular UBI volume + * @devno UBI device number + * @id UBI volume id + * @update_size size of data stream + * @fp_in PFI data file pointer + * @pfi_crc CRC data from PFI header + * + * Error handling: + * when UBI system couldn't be opened + * - returns -PFIFLASH_ERR_UBI_OPEN, err_buf matches text to err + * when UBI system couldn't open a volume + * - returns -PFIFLASH_ERR_UBI_VOL_FOPEN, err_buf matches text to err + * when unexpected EOF is encountered + * - returns -PFIFLASH_ERR_EOF, err_buf matches text to err + * when file I/O error + * - returns -PFIFLASH_ERR_FIO, err_buf matches text to err + * when CRC check fails + * - retruns -PFIFLASH_ERR_CRC_CHECK, err_buf matches text to err + **/ static int write_normal_volume(int devno, uint32_t id, size_t update_size, FILE* fp_in, - char *err_buf __unused, size_t err_buf_size __unused) + uint32_t pfi_crc, + char *err_buf, size_t err_buf_size) { - int rc = 0; - ubi_lib_t ulib = NULL; - FILE* fp_out = NULL; - int c; - size_t i; + int rc; + uint32_t crc, crc32_table[256]; + size_t bytes_left; + FILE* fp_out; + ubi_lib_t ulib; - log_msg("%s(id=%d, update_size=%d fp_in=%p)", - __func__, id, update_size, fp_in); + rc = 0; + crc = UBI_CRC32_INIT; + bytes_left = update_size; + fp_out = NULL; + ulib = NULL; + + log_msg("[ ubiupdatevol id=%d, update_size=%d fp_in=%p", + id, update_size, fp_in); rc = ubi_open(&ulib); - if (rc) - return rc; + if (rc != 0) { + rc = -PFIFLASH_ERR_UBI_OPEN; + EBUF(PFIFLASH_ERRSTR[-rc]); + goto err; + } fp_out = ubi_vol_fopen_update(ulib, devno, id, update_size); - if (fp_out == NULL) { - rc = -1; + if (!fp_out) { + rc = -PFIFLASH_ERR_UBI_VOL_FOPEN; + EBUF(PFIFLASH_ERRSTR[-rc], id); goto err; } - log_msg("starting the update ... "); /* FIXME DBG */ - for (i = 0; i < update_size; i++) { - c = getc(fp_in); - if (c == EOF && ferror(fp_in)) { - rc = -EIO; + init_crc32_table(crc32_table); + while (bytes_left) { + char buf[1024]; + size_t to_rw = sizeof buf > bytes_left ? + bytes_left : sizeof buf; + if (fread(buf, 1, to_rw, fp_in) != to_rw) { + rc = -PFIFLASH_ERR_EOF; + EBUF(PFIFLASH_ERRSTR[-rc]); goto err; } - if (putc(c, fp_out) == EOF) { - rc = -EIO; + crc = clc_crc32(crc32_table, crc, buf, to_rw); + if (fwrite(buf, 1, to_rw, fp_out) != to_rw) { + rc = -PFIFLASH_ERR_FIO; + EBUF(PFIFLASH_ERRSTR[-rc]); goto err; } - /* FIXME DBG */ - /* if ((i & 0xFFF) == 0xFFF) log_msg("."); */ + bytes_left -= to_rw; } - /* log_msg("\n"); */ /* FIXME DBG */ + + if (crc != pfi_crc) { + rc = -PFIFLASH_ERR_CRC_CHECK; + EBUF(PFIFLASH_ERRSTR[-rc], pfi_crc, crc); + goto err; + } + err: if (fp_out) fclose(fp_out); if (ulib) ubi_close(&ulib); + return rc; } /** - * @brief ... - * @precondition The PFI file contains at least one ubi_id entry. - * This is assured by the PFI read process. - * @postcondition The used seqnum number is set in the UBI PFI - * header list. - * The UBI volumes specified by seqnum are processed. - */ + * process_raw_volumes - writes the raw sections of the PFI data + * @pfi PFI data file pointer + * @pfi_raws list of PFI raw headers + * @rawdev device to use to write raw data + * + * Error handling: + * when early EOF in PFI data + * - returns -PFIFLASH_ERR_EOF, err_buf matches text to err + * when file I/O error + * - returns -PFIFLASH_ERR_FIO, err_buf matches text to err + * when CRC check fails + * - returns -PFIFLASH_ERR_CRC_CHECK, err_buf matches text to err + * when opening MTD device fails + * - reutrns -PFIFLASH_ERR_MTD_OPEN, err_buf matches text to err + * when closing MTD device fails + * - returns -PFIFLASH_ERR_MTD_CLOSE, err_buf matches text to err + **/ +static int +process_raw_volumes(FILE* pfi, list_t pfi_raws, const char* rawdev, + char* err_buf, size_t err_buf_size) +{ + int rc; + char *pfi_data; + void *i; + uint32_t crc, crc32_table[256]; + size_t j, k; + FILE* mtd; + list_t ptr; + + if (is_empty(pfi_raws)) + return 0; + + if (rawdev == NULL) + return 0; + + rc = 0; + + log_msg("[ rawupdate dev=%s", rawdev); + + crc = UBI_CRC32_INIT; + init_crc32_table(crc32_table); + + /* most likely only one element in list, but just in case */ + foreach(i, ptr, pfi_raws) { + pfi_raw_t r = (pfi_raw_t)i; + + /* read in pfi data */ + pfi_data = malloc(r->data_size * sizeof(char)); + for (j = 0; j < r->data_size; j++) { + int c = fgetc(pfi); + if (c == EOF) { + rc = -PFIFLASH_ERR_EOF; + EBUF(PFIFLASH_ERRSTR[-rc]); + goto err; + } else if (ferror(pfi)) { + rc = -PFIFLASH_ERR_FIO; + EBUF(PFIFLASH_ERRSTR[-rc]); + goto err; + } + pfi_data[j] = (char)c; + } + crc = clc_crc32(crc32_table, crc, pfi_data, r->data_size); + + /* check crc */ + if (crc != r->crc) { + rc = -PFIFLASH_ERR_CRC_CHECK; + EBUF(PFIFLASH_ERRSTR[-rc], r->crc, crc); + goto err; + } + + /* open device */ + mtd = fopen(rawdev, "r+"); + if (mtd == NULL) { + rc = PFIFLASH_ERR_MTD_OPEN; + EBUF(PFIFLASH_ERRSTR[-rc], rawdev); + goto err; + } + + for (j = 0; j < r->starts_size; j++) { + fseek(mtd, r->starts[j], SEEK_SET); + for (k = 0; k < r->data_size; k++) { + int c = fputc((int)pfi_data[k], mtd); + if (c == EOF) { + fclose(mtd); + rc = -PFIFLASH_ERR_EOF; + EBUF(PFIFLASH_ERRSTR[-rc]); + return rc; + } + if ((char)c != pfi_data[k]) { + fclose(mtd); + return -1; + } + } + } + rc = fclose(mtd); + if (rc != 0) { + rc = -PFIFLASH_ERR_MTD_CLOSE; + EBUF(PFIFLASH_ERRSTR[-rc], rawdev); + goto err; + } + } + + err: + return rc; +} + + +/** + * erase_unmapped_ubi_volumes - skip volumes provided by PFI file, clear rest + * @devno UBI device number + * @pfi_ubis list of UBI header data + * + * Error handling: + * when UBI id is out of bounds + * - returns -PFIFLASH_ERR_UBI_VID_OOB, err_buf matches text to err + * when UBI volume can't be removed + * - passes rc, prepends err_buf with contextual aid + **/ +static int +erase_unmapped_ubi_volumes(int devno, list_t pfi_ubis, + char *err_buf, size_t err_buf_size) +{ + int rc; + uint8_t ubi_volumes[PFI_UBI_MAX_VOLUMES]; + size_t i; + list_t ptr; + pfi_ubi_t u; + + rc = 0; + + for (i = 0; i < PFI_UBI_MAX_VOLUMES; i++) + ubi_volumes[i] = 1; + + foreach(u, ptr, pfi_ubis) { + /* iterate over each vol_id */ + for(i = 0; i < u->ids_size; i++) { + if (u->ids[i] > PFI_UBI_MAX_VOLUMES) { + rc = -PFIFLASH_ERR_UBI_VID_OOB; + EBUF(PFIFLASH_ERRSTR[-rc], u->ids[i]); + goto err; + } + /* remove from removal list */ + ubi_volumes[u->ids[i]] = 0; + } + } + + for (i = 0; i < PFI_UBI_MAX_VOLUMES; i++) { + if (ubi_volumes[i]) { + rc = my_ubi_rmvol(devno, i, err_buf, err_buf_size); + if (rc != 0) { + EBUF_PREPEND("remove volume failed"); + goto err; + } + } + } + + err: + return rc; +} + + +/** + * process_ubi_volumes - delegate tasks regarding UBI volumes + * @pfi PFI data file pointer + * @seqnum sequence number + * @pfi_ubis list of UBI header data + * @bootenv_old storage for current system PDD + * @pdd_f function to handle PDD + * @ubi_update_process whether reading or writing + * + * Error handling: + * when and unknown ubi_update_process is given + * - returns -PFIFLASH_ERR_UBI_UNKNOWN, err_buf matches text to err + * otherwise + * - passes rc and err_buf + **/ static int process_ubi_volumes(FILE* pfi, int seqnum, list_t pfi_ubis, bootenv_t bootenv_old, pdd_func_t pdd_f, ubi_update_process_t ubi_update_process, char *err_buf, size_t err_buf_size) { - int rc = 0; + int rc; pfi_ubi_t u; list_t ptr; + rc = 0; + foreach(u, ptr, pfi_ubis) { int s = seqnum; - if (seqnum > ((int)u->ids_size - 1)) { + + if (s > ((int)u->ids_size - 1)) s = 0; /* per default use the first */ - } u->curr_seqnum = s; switch (ubi_update_process) { case UBI_REMOVE: + /* TODO are all these "EXAMPLE" vars okay? */ if ((u->ids[s] == EXAMPLE_BOOTENV_VOL_ID_1) || (u->ids[s] == EXAMPLE_BOOTENV_VOL_ID_2)) { - rc =read_bootenv_volume(EXAMPLE_UBI_DEVICE, - u->ids[s], - bootenv_old, err_buf, - err_buf_size); + rc = read_bootenv_volume(EXAMPLE_UBI_DEVICE, + u->ids[s], bootenv_old, + err_buf, err_buf_size); + /* it's okay if there is no bootenv + * we're going to write one */ + if ((rc == -PFIFLASH_ERR_UBI_VOL_FOPEN) || + (rc == -PFIFLASH_ERR_BOOTENV_READ)) + rc = 0; if (rc != 0) goto err; - } - rc = my_ubi_rmvol(EXAMPLE_UBI_DEVICE, u->ids[s], + } + + rc = my_ubi_rmvol(EXAMPLE_UBI_DEVICE, u->ids[s], err_buf, err_buf_size); if (rc != 0) goto err; + break; case UBI_WRITE: rc = my_ubi_mkvol(EXAMPLE_UBI_DEVICE, s, u, err_buf, err_buf_size); - if (rc != 0) + if (rc != 0) { + EBUF_PREPEND("creating volume"); goto err; + } + if ((u->ids[s] == EXAMPLE_BOOTENV_VOL_ID_1) || (u->ids[s] == EXAMPLE_BOOTENV_VOL_ID_2)) { rc = write_bootenv_volume(EXAMPLE_UBI_DEVICE, @@ -421,87 +788,67 @@ process_ubi_volumes(FILE* pfi, int seqnum, list_t pfi_ubis, bootenv_old, pdd_f, pfi, u->data_size, + u->crc, err_buf, err_buf_size); - } - else { + if (rc != 0) + EBUF_PREPEND("bootenv volume"); + } else { rc = write_normal_volume(EXAMPLE_UBI_DEVICE, u->ids[s], u->data_size, pfi, + u->crc, err_buf, err_buf_size); + if (rc != 0) + EBUF_PREPEND("normal volume"); } if (rc != 0) goto err; + break; default: - EBUF("Invoked unknown UBI operation."); - rc = -1; - goto err; - - } - if (rc != 0) { + rc = -PFIFLASH_ERR_UBI_UNKNOWN; + EBUF(PFIFLASH_ERRSTR[-rc]); goto err; } } - err: - return rc; - -} - -static int -erase_unmapped_ubi_volumes(int devno, list_t pfi_ubis, - char *err_buf, size_t err_buf_size) -{ - int rc = 0; - list_t ptr; - pfi_ubi_t u; - size_t i; - uint8_t ubi_volumes[PFI_UBI_MAX_VOLUMES]; - - for (i = 0; i < PFI_UBI_MAX_VOLUMES; i++) { - ubi_volumes[i] = 1; - } - - foreach(u, ptr, pfi_ubis) { - /* iterate over each vol_id */ - for(i = 0; i < u->ids_size; i++) { - if (u->ids[i] > PFI_UBI_MAX_VOLUMES) { - EBUF("PFI file contains an invalid " - "volume id: %d", u->ids[i]); - goto err; - } - /* remove from removal list */ - ubi_volumes[u->ids[i]] = 0; - } - } - for (i = 0; i < PFI_UBI_MAX_VOLUMES; i++) { - if (ubi_volumes[i]) { - rc = my_ubi_rmvol(devno, i, err_buf, err_buf_size); - if (rc != 0) - goto err; - } - } err: return rc; } + +/** + * mirror_ubi_volumes - mirror redundant pairs of volumes + * @devno UBI device number + * @pfi_ubis list of PFI header data + * + * Error handling: + * when UBI system couldn't be opened + * - returns -PFIFLASH_ERR_UBI_OPEN, err_buf matches text to err + **/ static int mirror_ubi_volumes(uint32_t devno, list_t pfi_ubis, char *err_buf, size_t err_buf_size) { - int rc = 0; - list_t ptr; + int rc; uint32_t j; + list_t ptr; pfi_ubi_t i; - ubi_lib_t ulib = NULL; + ubi_lib_t ulib; - log_msg("%s(...)", __func__); + rc = 0; + ulib = NULL; + + log_msg("[ mirror ..."); rc = ubi_open(&ulib); - if (rc != 0) + if (rc != 0) { + rc = -PFIFLASH_ERR_UBI_OPEN; + EBUF(PFIFLASH_ERRSTR[-rc]); goto err; + } /** * Execute all mirror operations on redundant groups. @@ -510,25 +857,26 @@ mirror_ubi_volumes(uint32_t devno, list_t pfi_ubis, * ubimirror). */ foreach(i, ptr, pfi_ubis) { - for(j = 0; j < i->ids_size; j++) { + for (j = 0; j < i->ids_size; j++) { /* skip self-match */ if (i->ids[j] == i->ids[i->curr_seqnum]) continue; - rc = my_ubi_rmvol(devno, i->ids[j], err_buf, - err_buf_size); + rc = my_ubi_rmvol(devno, i->ids[j], + err_buf, err_buf_size); if (rc != 0) goto err; - rc = my_ubi_mkvol(devno, j, i, err_buf, err_buf_size); + rc = my_ubi_mkvol(devno, j, i, + err_buf, err_buf_size); if (rc != 0) goto err; } } foreach(i, ptr, pfi_ubis) { - rc = ubimirror(devno, i->curr_seqnum, i->ids, - i->ids_size, err_buf, err_buf_size); + rc = ubimirror(devno, i->curr_seqnum, i->ids, i->ids_size, + err_buf, err_buf_size); if (rc != 0) goto err; } @@ -537,44 +885,71 @@ mirror_ubi_volumes(uint32_t devno, list_t pfi_ubis, err: if (ulib != NULL) ubi_close(&ulib); + return rc; } + +/** + * pfiflash_with_raw - exposed func to flash memory with a PFI file + * @pfi PFI data file pointer + * @complete flag to erase unmapped volumes + * @seqnum sequence number + * @pdd_handling method to handle pdd (keep, merge, overwrite...) + * + * Error handling: + * when bootenv can't be created + * - returns -PFIFLASH_ERR_BOOTENV_CREATE, err_buf matches text to err + * when PFI headers can't be read, or + * when fail to skip raw sections, or + * when error occurs while processing raw volumes, or + * when fail to erase unmapped UBI vols, or + * when error occurs while processing UBI volumes, or + * when error occurs while mirroring UBI volumes + * - passes rc, prepends err_buf with contextual aid + **/ int -pfiflash(FILE* pfi, int complete, int seqnum, pdd_handling_t pdd_handling, - char *err_buf, size_t err_buf_size) +pfiflash_with_raw(FILE* pfi, int complete, int seqnum, + pdd_handling_t pdd_handling, const char* rawdev, + char *err_buf, size_t err_buf_size) { - int rc = 0; - pdd_func_t pdd_f = NULL; + int rc; + bootenv_t bootenv; + pdd_func_t pdd_f; if (pfi == NULL) return -EINVAL; - /** - * If the user didnt specify a seqnum we start per default - * with the index 0 - */ + rc = 0; + pdd_f = NULL; + + /* If the user didnt specify a seqnum we start per default + * with the index 0 */ int curr_seqnum = seqnum < 0 ? 0 : seqnum; list_t pfi_raws = mk_empty(); /* list of raw sections from a pfi */ list_t pfi_ubis = mk_empty(); /* list of ubi sections from a pfi */ - bootenv_t bootenv; rc = bootenv_create(&bootenv); if (rc != 0) { - EBUF("Cannot create bootenv variable"); + rc = -PFIFLASH_ERR_BOOTENV_CREATE; + EBUF(PFIFLASH_ERRSTR[-rc], ""); + goto err; } - rc = read_pfi_headers(&pfi_raws, &pfi_ubis, pfi, - err_buf, err_buf_size); + rc = read_pfi_headers(&pfi_raws, &pfi_ubis, pfi, err_buf, err_buf_size); if (rc != 0) { - EBUF("Cannot read PFI headers."); + EBUF_PREPEND("reading PFI header"); goto err; } - /* @TODO: If you want to implement an IPL update - start here. */ - rc = skip_raw_sections(pfi, pfi_raws, err_buf, err_buf_size); + if (rawdev == NULL) + rc = skip_raw_volumes(pfi, pfi_raws, err_buf, err_buf_size); + else + rc = process_raw_volumes(pfi, pfi_raws, rawdev, err_buf, + err_buf_size); if (rc != 0) { + EBUF_PREPEND("handling raw section"); goto err; } @@ -582,33 +957,41 @@ pfiflash(FILE* pfi, int complete, int seqnum, pdd_handling_t pdd_handling, rc = erase_unmapped_ubi_volumes(EXAMPLE_UBI_DEVICE, pfi_ubis, err_buf, err_buf_size); if (rc != 0) { - EBUF("Cannot delete unmapped UBI volumes."); + EBUF_PREPEND("deleting unmapped UBI volumes"); goto err; } } - if (((int)pdd_handling >= 0) && (pdd_handling < PDD_HANDLING_NUM)) { + if (((int)pdd_handling >= 0) && + (pdd_handling < PDD_HANDLING_NUM)) pdd_f = pdd_funcs[pdd_handling]; - } else { - EBUF("Used unknown PDD handling algorithm (pdd_handling)"); + rc = -PFIFLASH_ERR_PDD_UNKNOWN; + EBUF(PFIFLASH_ERRSTR[-rc]); + goto err; } rc = process_ubi_volumes(pfi, curr_seqnum, pfi_ubis, bootenv, pdd_f, UBI_REMOVE, err_buf, err_buf_size); - if (rc != 0) { + if (rc != 0) { + EBUF_PREPEND("removing UBI volumes"); goto err; } + rc = process_ubi_volumes(pfi, curr_seqnum, pfi_ubis, bootenv, pdd_f, UBI_WRITE, err_buf, err_buf_size); if (rc != 0) { + EBUF_PREPEND("writing UBI volumes"); goto err; } + if (seqnum < 0) { /* mirror redundant pairs */ rc = mirror_ubi_volumes(EXAMPLE_UBI_DEVICE, pfi_ubis, err_buf, err_buf_size); - if (rc != 0) + if (rc != 0) { + EBUF_PREPEND("mirroring UBI volumes"); goto err; + } } err: @@ -617,3 +1000,19 @@ pfiflash(FILE* pfi, int complete, int seqnum, pdd_handling_t pdd_handling, bootenv_destroy(&bootenv); return rc; } + + +/** + * pfiflash - passes to pfiflash_with_raw + * @pfi PFI data file pointer + * @complete flag to erase unmapped volumes + * @seqnum sequence number + * @pdd_handling method to handle pdd (keep, merge, overwrite...) + **/ +int +pfiflash(FILE* pfi, int complete, int seqnum, pdd_handling_t pdd_handling, + char *err_buf, size_t err_buf_size) +{ + return pfiflash_with_raw(pfi, complete, seqnum, pdd_handling, + NULL, err_buf, err_buf_size); +} diff --git a/ubi-utils/src/pfiflash.c b/ubi-utils/src/pfiflash.c index 04f62df..c49fb1e 100644 --- a/ubi-utils/src/pfiflash.c +++ b/ubi-utils/src/pfiflash.c @@ -21,6 +21,8 @@ * Process a PFI (partial flash image) and write the data to the * specified UBI volumes. This tool is intended to be used for system * update using PFI files. + * + * 1.1 fixed output to stderr and stdout in logfile mode. */ #include @@ -34,12 +36,15 @@ #include #include +#undef DEBUG #include "error.h" #include "config.h" -const char *argp_program_version = PACKAGE_VERSION; +#define PROGRAM_VERSION "1.2" + +const char *argp_program_version = PROGRAM_VERSION; const char *argp_program_bug_address = PACKAGE_BUGREPORT; -static char doc[] = "\nVersion: " PACKAGE_VERSION "\n\tBuilt on " +static char doc[] = "\nVersion: " PROGRAM_VERSION "\n\tBuilt on " BUILD_CPU" "BUILD_OS" at "__DATE__" "__TIME__"\n" "\n" "pfiflash - a tool for updating a controller with PFI files.\n"; @@ -83,12 +88,17 @@ static struct argp_option options[] = { "'keep', 'merge' or 'overwrite'.", group: 2 }, + { name: "raw-flash", key: 'r', arg: "", flags: 0, + doc: "Flash the raw data. Use the specified mtd device.", + group: 2 }, + { name: NULL, key: 0, arg: NULL, flags: 0, doc: NULL, group: 0 }, }; typedef struct myargs { int verbose; const char *logfile; + const char *raw_dev; pdd_handling_t pdd_handling; int seqnum; @@ -168,7 +178,9 @@ parse_opt(int key, char *arg, struct argp_state *state) "Supported sides are '0' and '1'\n", arg); } break; - + case 'r': + args->raw_dev = arg; + break; case ARGP_KEY_ARG: /* input file */ args->fp_in = fopen(arg, "r"); if ((args->fp_in) == NULL) { @@ -212,9 +224,10 @@ int main (int argc, char** argv) .verbose = 0, .seqnum = -1, .complete = 0, - .logfile = "/tmp/pfiflash.log", + .logfile = NULL, /* "/tmp/pfiflash.log", */ .pdd_handling = PDD_KEEP, - .fp_in = stdin, + .fp_in = stdin, + .raw_dev = NULL, }; argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &args); @@ -227,8 +240,16 @@ int main (int argc, char** argv) goto err; } - rc = pfiflash(args.fp_in, args.complete, args.seqnum, - args.pdd_handling, err_buf, PFIFLASH_MAX_ERR_BUF_SIZE); + if (!args.raw_dev) { + rc = pfiflash(args.fp_in, args.complete, args.seqnum, + args.pdd_handling, err_buf, + PFIFLASH_MAX_ERR_BUF_SIZE); + } else { + rc = pfiflash_with_raw(args.fp_in, args.complete, args.seqnum, + args.pdd_handling, args.raw_dev, err_buf, + PFIFLASH_MAX_ERR_BUF_SIZE); + } + if (rc != 0) { goto err_fp; } @@ -238,6 +259,6 @@ int main (int argc, char** argv) fclose(args.fp_in); err: if (rc != 0) - err_msg("Error: %s\nrc: %d\n", err_buf, rc); + err_msg("pfiflash: %s\nrc: %d\n", err_buf, rc); return rc; } diff --git a/ubi-utils/src/pfiflash.h b/ubi-utils/src/pfiflash.h index fc2eede..a063e7f 100644 --- a/ubi-utils/src/pfiflash.h +++ b/ubi-utils/src/pfiflash.h @@ -44,6 +44,19 @@ typedef enum pdd_handling_t PDD_HANDLING_NUM, /* always the last item */ } pdd_handling_t; /**< Possible PDD handle algorithms. */ +/** + * @brief Flashes a PFI file to UBI Device 0. + * @param complete [0|1] Do a complete system update. + * @param seqnum Index in a redundant group. + * @param pdd_handling The PDD handling algorithm. + * @param rawdev Device to use for raw flashing + * @param err_buf An error buffer. + * @param err_buf_size Size of the error buffer. + */ +int pfiflash_with_raw(FILE* pfi, int complete, int seqnum, + pdd_handling_t pdd_handling, const char* rawdev, + char *err_buf, size_t err_buf_size); + /** * @brief Flashes a PFI file to UBI Device 0. * @param complete [0|1] Do a complete system update. diff --git a/ubi-utils/src/pfiflash_error.h b/ubi-utils/src/pfiflash_error.h new file mode 100644 index 0000000..34b705e --- /dev/null +++ b/ubi-utils/src/pfiflash_error.h @@ -0,0 +1,69 @@ +#ifndef __PFIFLASH_ERROR_H__ +#define __PFIFLASH_ERROR_H__ +/* + * Copyright (c) International Business Machines Corp., 2006 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See + * the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * Author: Drake Dowsett + * Contact: Andreas Arnez + */ + +enum pfiflash_err { + PFIFLASH_ERR_EOF = 1, + PFIFLASH_ERR_FIO, + PFIFLASH_ERR_UBI_OPEN, + PFIFLASH_ERR_UBI_CLOSE, + PFIFLASH_ERR_UBI_MKVOL, + PFIFLASH_ERR_UBI_RMVOL, + PFIFLASH_ERR_UBI_VOL_UPDATE, + PFIFLASH_ERR_UBI_VOL_FOPEN, + PFIFLASH_ERR_UBI_UNKNOWN, + PFIFLASH_ERR_UBI_VID_OOB, + PFIFLASH_ERR_BOOTENV_CREATE, + PFIFLASH_ERR_BOOTENV_READ, + PFIFLASH_ERR_BOOTENV_SIZE, + PFIFLASH_ERR_BOOTENV_WRITE, + PFIFLASH_ERR_PDD_UNKNOWN, + PFIFLASH_ERR_MTD_OPEN, + PFIFLASH_ERR_MTD_CLOSE, + PFIFLASH_ERR_CRC_CHECK +}; + +const char *const PFIFLASH_ERRSTR[] = { + "", + "unexpected EOF", + "file I/O error", + "couldn't open UBI", + "couldn't close UBI", + "couldn't make UBI volume %d", + "couldn't remove UBI volume %d", + "couldn't update UBI volume %d", + "couldn't open UBI volume %d", + "unknown UBI operation", + "PFI data contains out of bounds UBI id %d", + "couldn't create bootenv%s", + "couldn't read bootenv", + "couldn't resize bootenv", + "couldn't write bootenv on ubi%d_%d", + "unknown PDD handling algorithm", + "couldn't open MTD device %s", + "couldn't close MTD device %s", + "CRC check failed: given=0x%08x, calculated=0x%08x" +}; + +#endif /* __PFIFLASH_ERROR_H__ */ diff --git a/ubi-utils/src/reader.c b/ubi-utils/src/reader.c index 5de06d5..975caa1 100644 --- a/ubi-utils/src/reader.c +++ b/ubi-utils/src/reader.c @@ -29,10 +29,11 @@ #include #include -#include "config.h" #include "bootenv.h" #include "reader.h" +#define __unused __attribute__((unused)) + /* @FIXME hard coded offsets right now - get them from Artem? */ #define NAND2048_DEFAULT_VID_HDR_OFF 1984 #define NAND512_DEFAULT_VID_HDR_OFF 448 @@ -152,6 +153,12 @@ read_pfi_raw(pfi_header pfi_hd, FILE* fp_pfi __unused, pfi_raw_t* pfi_raw, goto err; } + rc = pfi_header_getnumber(pfi_hd, "crc", &(res->crc)); + if (rc != 0) { + EBUF_PFI("Cannot read 'crc' from PFI."); + goto err; + } + rc = pfi_header_getstring(pfi_hd, "raw_starts", tmp_str, PFI_KEYWORD_LEN); if (rc != 0) { @@ -212,6 +219,12 @@ read_pfi_ubi(pfi_header pfi_hd, FILE* fp_pfi __unused, pfi_ubi_t* pfi_ubi, goto err; } + rc = pfi_header_getnumber(pfi_hd, "crc", &(res->crc)); + if (rc != 0) { + EBUF_PFI("Cannot read 'crc' from PFI."); + goto err; + } + rc = pfi_header_getstring(pfi_hd, "ubi_ids", tmp_str, PFI_KEYWORD_LEN); if (rc != 0) { EBUF_PFI("Cannot read 'ubi_ids' from PFI."); diff --git a/ubi-utils/src/reader.h b/ubi-utils/src/reader.h index d00fa17..715e464 100644 --- a/ubi-utils/src/reader.h +++ b/ubi-utils/src/reader.h @@ -50,6 +50,7 @@ struct pfi_raw { uint32_t data_size; uint32_t *starts; uint32_t starts_size; + uint32_t crc; }; struct pfi_ubi { @@ -63,6 +64,7 @@ struct pfi_ubi { enum { pfi_ubi_dynamic, pfi_ubi_static } type; int curr_seqnum; /* specifies the seqnum taken in an update, default: 0 (used by pfiflash, ubimirror) */ + uint32_t crc; }; int read_pdd_data(FILE* fp_pdd, pdd_data_t *pdd_data, -- cgit v1.2.3