diff options
| -rw-r--r-- | util/nvmutil/nvmutil.c | 308 |
1 files changed, 157 insertions, 151 deletions
diff --git a/util/nvmutil/nvmutil.c b/util/nvmutil/nvmutil.c index 7ddb8322..a6790f86 100644 --- a/util/nvmutil/nvmutil.c +++ b/util/nvmutil/nvmutil.c @@ -81,28 +81,56 @@ typedef char static_assert_uint16_t_is_2[(sizeof(uint16_t) == 2) ? 1 : -1]; #endif #endif +/* + * Sanitize command tables. + */ static void sanitize_command_list(void); static void sanitize_command_index(size_t c); static void check_enum_bin(size_t a, const char *a_name, size_t b, const char *b_name); + +/* + * Argument handling (user input) + */ static void set_cmd(int argc, char *argv[]); static void set_cmd_args(int argc, char *argv[]); static size_t conv_argv_part_num(const char *part_str); static int xstrxcmp(const char *a, const char *b, size_t maxlen); + +/* + * Prep files for reading + * + * Portability: /dev/urandom used + * on Linux / old Unix, whereas + * arc4random is used on BSD/MacOS. + */ #ifndef NVMUTIL_ARC4RANDOM_BUF static void open_dev_urandom(void); #endif static void open_gbe_file(void); static void xopen(int *fd, const char *path, int flags, struct stat *st); + +/* + * Read GbE file and verify + * checksums. + * + * After this, we can run commands. + */ static void read_gbe_file(void); -static void read_gbe_file_part(size_t part); -static ssize_t read_gbe_file_exact(int fd, void *buf, size_t len, - off_t off); static void read_checksums(void); static int good_checksum(size_t partnum); + +/* + * Execute user command on GbE data. + * These are stubs that call helpers. + */ static void run_cmd(size_t c); static void check_command_num(size_t c); static uint8_t valid_command(size_t c); + +/* + * Helper functions for command: setmac + */ static void cmd_helper_setmac(void); static void parse_mac_string(void); static size_t xstrxlen(const char *scmp, size_t maxlen); @@ -111,30 +139,60 @@ static void set_mac_nib(size_t mac_str_pos, size_t mac_byte_pos, size_t mac_nib_pos); static uint16_t hextonum(char ch_s); static uint16_t rhex(void); -#ifndef NVMUTIL_ARC4RANDOM_BUF -static ssize_t read_dev_urandom(int fd, void *buf, - size_t len); -#endif static void write_mac_part(size_t partnum); + +/* + * Helper functions for command: dump + */ static void cmd_helper_dump(void); static void print_mac_from_nvm(size_t partnum); static void hexdump(size_t partnum); + +/* + * Helper functions for commands: + * cat, cat16 and cat128 + */ static void cmd_helper_cat(void); static void gbe_cat_buf(uint8_t *b); + +/* + * After command processing, write + * the modified GbE file back. + * + * These are stub functions: check + * below for the actual functions. + */ static void write_gbe_file(void); static void override_part_modified(void); static void set_checksum(size_t part); static uint16_t calculated_checksum(size_t p); + +/* + * Helper functions for accessing + * the NVM area during operation. + */ static uint16_t nvm_word(size_t pos16, size_t part); static void set_nvm_word(size_t pos16, size_t part, uint16_t val16); static void set_part_modified(size_t p); static void check_nvm_bound(size_t pos16, size_t part); static void check_bin(size_t a, const char *a_name); -static void write_gbe_file_part(size_t part); + +/* + * Helper functions for stub functions + * that handle GbE file reads/writes. + */ +static void rw_gbe_file_part(size_t p, int rw_type, + const char *rw_type_str); +static uint8_t *gbe_mem_offset(size_t part, const char *f_op); static off_t gbe_file_offset(size_t part, const char *f_op); -static void *gbe_mem_offset(size_t part, const char *f_op); static off_t gbe_x_offset(size_t part, const char *f_op, const char *d_type, off_t nsize, off_t ncmp); +static void rw_file_exact(int fd, uint8_t *mem, size_t len, + off_t off, int rw_type, const char *path, const char *rw_type_str); + +/* + * Error handling and cleanup + */ static void err(int nvm_errval, const char *msg, ...); static void close_files(void); static const char *getnvmprogname(void); @@ -170,12 +228,6 @@ static void usage(uint8_t usage_exit); #define NVM_CHECKSUM_WORD (NVM_WORDS - 1) /* - * When reading files, we loop on error EINTR - * a maximum number of times as defined, thus: - */ -#define MAX_RETRY_RW 30 - -/* * Portable macro based on BSD nitems. * Used to count the number of commands (see below). */ @@ -228,6 +280,13 @@ static const char *argv0; #define ARGC_3 3 #define ARGC_4 4 +enum { + LESEN, + PLESEN, + SCHREIB, + PSCHREIB +}; + /* * Used as indices for command[] * MUST be in the same order as entries in command[] @@ -516,6 +575,9 @@ sanitize_command_index(size_t c) if (command[c].flags != O_RDONLY && command[c].flags != O_RDWR) err(EINVAL, "invalid cmd.flags setting"); + + if (!((PLESEN > LESEN) && (SCHREIB > PLESEN) && (PSCHREIB > SCHREIB))) + err(EINVAL, "some rw type integers are the same"); } static void @@ -691,58 +753,11 @@ read_gbe_file(void) for (p = 0; p < 2; p++) { if (do_read[p]) - read_gbe_file_part(p); + rw_gbe_file_part(p, PLESEN, "pread"); } } static void -read_gbe_file_part(size_t p) -{ - ssize_t rc; - - size_t gbe_rw_size = command[cmd_index].rw_size; - void *mem_offset = - gbe_mem_offset(p ^ command[cmd_index].invert, "pread"); - - rc = read_gbe_file_exact(gbe_fd, mem_offset, - gbe_rw_size, gbe_file_offset(p, "pread")); - - if (rc != (ssize_t)gbe_rw_size) - err(ECANCELED, "%s: Partial read from p%zu", fname, p); -} - -static ssize_t -read_gbe_file_exact(int fd, - void *buf, size_t len, off_t off) -{ - int retry; - ssize_t rval; - - if (fd == -1) - err(ECANCELED, "Trying to open bad fd: %s", fname); - - for (retry = 0; retry < MAX_RETRY_RW; retry++) { - rval = pread(fd, buf, len, off); - - if (rval == (ssize_t)len) { - errno = 0; - return rval; - } else if (rval != -1) { - err(ECANCELED, - "%s: Short pread of %zd bytes", - fname, rval); - } else if (errno != EINTR) { - err(ECANCELED, - "%s: Could not pread", fname); - } - } - - err(EINTR, "%s: pread: max retries exceeded", fname); - - return -1; -} - -static void read_checksums(void) { size_t p; @@ -973,53 +988,17 @@ rhex(void) static uint8_t rnum[12]; if (!n) { -#ifdef NVMUTIL_ARC4RANDOM_BUF n = sizeof(rnum); +#ifdef NVMUTIL_ARC4RANDOM_BUF arc4random_buf(rnum, n); #else - n = (size_t)read_dev_urandom( - urandom_fd, rnum, sizeof(rnum)); - - if (!n || n > sizeof(rnum)) - err(ECANCELED, "Randomisation failure"); + rw_file_exact(urandom_fd, rnum, n, 0, LESEN, rname, "read"); #endif } return (uint16_t)(rnum[--n] & 0xf); } -#ifndef NVMUTIL_ARC4RANDOM_BUF -static ssize_t -read_dev_urandom(int fd, void *buf, size_t len) -{ - int retry; - ssize_t rval; - - if (fd == -1) - err(ECANCELED, "Trying to open bad fd: %s", rname); - - for (retry = 0; retry < MAX_RETRY_RW; retry++) { - rval = read(fd, buf, len); - - if (rval == -1) { - if (errno == EINTR) - continue; - err(errno, "%s", rname); - } - - if (!rval || (size_t)rval > len) - continue; - - errno = 0; - return rval; - } - - err(EINTR, "%s: read: max retries exceeded: %s", rname); - - return -1; -} -#endif - static void write_mac_part(size_t partnum) { @@ -1041,12 +1020,19 @@ cmd_helper_dump(void) { size_t partnum; - int errval = good_checksum(0); - errval |= good_checksum(1); - if (errval) + part_valid[0] = good_checksum(0); + part_valid[1] = good_checksum(1); + + if (part_valid[0] || part_valid[1]) errno = 0; for (partnum = 0; partnum < 2; partnum++) { + if (!part_valid[partnum]) + fprintf(stderr, + "BAD checksum %04x in part %zu (expected %04x)\n", + nvm_word(NVM_CHECKSUM_WORD, partnum), + partnum, calculated_checksum(partnum)); + printf("MAC (part %zu): ", partnum); print_mac_from_nvm(partnum); hexdump(partnum); @@ -1114,12 +1100,8 @@ cmd_helper_cat(void) static void gbe_cat_buf(uint8_t *b) { - size_t wc; - ssize_t w = 0; - - for (wc = 0; wc < GBE_PART_SIZE; wc += w) - if ((w = write(STDOUT_FILENO, b + wc, GBE_PART_SIZE - wc)) < 1) - err(EIO, "%s: stdout", fname); + rw_file_exact(STDOUT_FILENO, b, GBE_PART_SIZE, 0, + SCHREIB, "stdout", "write"); } static void @@ -1145,7 +1127,7 @@ write_gbe_file(void) if (update_checksum) set_checksum(partnum); - write_gbe_file_part(partnum); + rw_gbe_file_part(partnum, PSCHREIB, "pwrite"); } } @@ -1259,39 +1241,40 @@ check_bin(size_t a, const char *a_name) } static void -write_gbe_file_part(size_t p) +rw_gbe_file_part(size_t p, int rw_type, + const char *rw_type_str) { - int retry; - ssize_t rval; - size_t gbe_rw_size; - - if (gbe_fd == -1) - err(ECANCELED, "%s: Trying to write bad gbe_fd", fname); + size_t gbe_rw_size = command[cmd_index].rw_size; + uint8_t invert = command[cmd_index].invert; - gbe_rw_size = command[cmd_index].rw_size; + uint8_t *mem_offset; - for (retry = 0; retry < MAX_RETRY_RW; retry++) { - rval = pwrite(gbe_fd, gbe_mem_offset(p, "pwrite"), - gbe_rw_size, gbe_file_offset(p, "pwrite")); + if (rw_type == SCHREIB || rw_type == PSCHREIB) + invert = 0; - if (rval == (ssize_t)gbe_rw_size) { - errno = 0; - printf("%s: Wrote %zu bytes to part %zu\n", - fname, gbe_rw_size, p); - return; - } + /* + * Inverted reads are used by copy/swap. + * E.g. read from p0 (file) to p1 (mem). + */ + mem_offset = gbe_mem_offset(p ^ invert, rw_type_str); - if (rval != -1) - err(ECANCELED, - "%s: Short pwrite of %zd bytes", - fname, rval); + rw_file_exact(gbe_fd, mem_offset, + gbe_rw_size, gbe_file_offset(p, rw_type_str), + rw_type, fname, rw_type_str); +} - if (errno != EINTR) - err(ECANCELED, - "%s: pwrite failed on p%zu", fname, p); - } +/* + * This one is similar to gbe_file_offset, + * but used to check Gbe bounds in memory, + * and it is *also* used during file I/O. + */ +static uint8_t * +gbe_mem_offset(size_t p, const char *f_op) +{ + off_t gbe_off = gbe_x_offset(p, f_op, "mem", + GBE_PART_SIZE, GBE_FILE_SIZE); - err(EINTR, "%s: pwrite: max retries exceeded on p%zu", fname, p); + return (uint8_t *)(buf + gbe_off); } /* @@ -1311,20 +1294,6 @@ gbe_file_offset(size_t p, const char *f_op) gbe_file_half_size, gbe_file_size); } -/* - * This one is similar to gbe_file_offset, - * but used to check Gbe bounds in memory, - * and it is *also* used during file I/O. - */ -static void * -gbe_mem_offset(size_t p, const char *f_op) -{ - off_t gbe_off = gbe_x_offset(p, f_op, "mem", - GBE_PART_SIZE, GBE_FILE_SIZE); - - return (void *)(buf + gbe_off); -} - static off_t gbe_x_offset(size_t p, const char *f_op, const char *d_type, off_t nsize, off_t ncmp) @@ -1347,6 +1316,43 @@ gbe_x_offset(size_t p, const char *f_op, const char *d_type, } static void +rw_file_exact(int fd, uint8_t *mem, size_t len, + off_t off, int rw_type, const char *path, + const char *rw_type_str) +{ + ssize_t rval = -1; + ssize_t rc = 0; + + if (fd < 0) + err(EIO, "%s: %s: Bad fd %d", path, rw_type_str, fd); + if (!len) + err(EIO, "%s: %s: Zero length", path, rw_type_str); + + for (rc = 0; rc != (ssize_t)len; rc += rval) { + if (rw_type == PSCHREIB) + rval = pwrite(fd, mem + rc, len - rc, off + rc); + else if (rw_type == SCHREIB) + rval = write(fd, mem + rc, len - rc); + else if (rw_type == PLESEN) + rval = pread(fd, mem + rc, len - rc, off + rc); + else if (rw_type == LESEN) + rval = read(fd, mem + rc, len - rc); + + if (rval > -1) { + if (!rval) /* prevent infinite loop */ + err(EIO, "%s: %s: 0-byte return", + path, rw_type_str); + continue; + } + + if (errno != EINTR || rval < -1) + err(EIO, "%s: %s", path, rw_type_str); + + errno = 0; + } +} + +static void err(int nvm_errval, const char *msg, ...) { if (nvm_errval != -1) |