diff options
Diffstat (limited to 'util/nvmutil')
| -rw-r--r-- | util/nvmutil/Makefile | 2 | ||||
| -rw-r--r-- | util/nvmutil/nvmutil.c | 620 |
2 files changed, 370 insertions, 252 deletions
diff --git a/util/nvmutil/Makefile b/util/nvmutil/Makefile index 22376c70..bef6f28c 100644 --- a/util/nvmutil/Makefile +++ b/util/nvmutil/Makefile @@ -3,7 +3,7 @@ # SPDX-FileCopyrightText: 2023 Riku Viitanen <riku.viitanen@protonmail.com> CC?=cc -CFLAGS?=-Os -Wall -Wextra -Werror -pedantic -std=c99 +CFLAGS?=-Os -Wall -Wextra -Werror -pedantic -std=c90 DESTDIR?= PREFIX?=/usr/local INSTALL?=install diff --git a/util/nvmutil/nvmutil.c b/util/nvmutil/nvmutil.c index 314d4755..295f13e6 100644 --- a/util/nvmutil/nvmutil.c +++ b/util/nvmutil/nvmutil.c @@ -31,35 +31,43 @@ #include <errno.h> #include <fcntl.h> +#include <limits.h> #include <stdarg.h> +#if defined(__has_include) +#if __has_include(<stdint.h>) #include <stdint.h> +#else +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +#endif +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#include <stdint.h> +#else +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +#endif #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> -#if __STDC_VERSION__ >= 201112L -_Static_assert(sizeof(uint16_t) == 2, "uint16_t must be 16 bits"); -#else -typedef char static_assert_uint16_t_is_2[(sizeof(uint16_t) == 2) ? 1 : -1]; -#endif +typedef char static_assert_char_is_8_bits[(CHAR_BIT == 8) ? 1 : -1]; +typedef char static_assert_uint8_is_1[(sizeof(uint8_t) == 1) ? 1 : -1]; +typedef char static_assert_uint16_is_2[(sizeof(uint16_t) == 2) ? 1 : -1]; +typedef char static_assert_uint32_is_4[(sizeof(uint32_t) == 4) ? 1 : -1]; +typedef char static_assert_int_ge_32[(sizeof(int) >= 4) ? 1 : -1]; +typedef char static_assert_twos_complement[ + ((-1 & 3) == 3) ? 1 : -1 +]; /* - * The BSD versions that could realistically build - * nvmutil almost certainly have arc4random (first - * introduced in 1990s to early 2000s). - * - * If you want it on another platform, e.g. Linux, - * just patch this accordingly. Or patch it to remove - * arc4random on old/weird Unix systems. + * We set _FILE_OFFSET_BITS 64, but we only handle + * files that are 128KB in size at a maximum, so we + * realistically only need 32-bit at a minimum. */ -#if defined(__OpenBSD__) || defined(__FreeBSD__) || \ - defined(__NetBSD__) || defined(__APPLE__) || \ - defined(__DragonFly__) -#ifndef NVMUTIL_ARC4RANDOM_BUF -#define NVMUTIL_ARC4RANDOM_BUF 1 -#endif -#endif +typedef char static_assert_off_t_is_32[(sizeof(off_t) >= 4) ? 1 : -1]; /* * Older versions of BSD to the early 2000s @@ -81,29 +89,58 @@ typedef char static_assert_uint16_t_is_2[(sizeof(uint16_t) == 2) ? 1 : -1]; #endif #endif +#ifndef O_BINARY +#define O_BINARY 0 +#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 void set_io_flags(int argc, char *argv[]); static int xstrxcmp(const char *a, const char *b, size_t maxlen); -#ifndef NVMUTIL_ARC4RANDOM_BUF + +/* + * Prep files for reading + * + * Portability: /dev/urandom used + * on Linux / old Unix, whereas + * arc4random is used on BSD/MacOS. + */ 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); @@ -112,28 +149,63 @@ 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); +static ssize_t prw(int fd, void *mem, size_t count, + off_t offset, int rw_type, const char *path); +static off_t lseek_eintr(int fd, off_t offset, int whence); + +/* + * Error handling and cleanup + */ static void err(int nvm_errval, const char *msg, ...); static void close_files(void); static const char *getnvmprogname(void); @@ -169,22 +241,14 @@ 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). */ #define items(x) (sizeof((x)) / sizeof((x)[0])) -#ifndef NVMUTIL_ARC4RANDOM_BUF static const char newrandom[] = "/dev/urandom"; static const char oldrandom[] = "/dev/random"; /* fallback on OLD unix */ static const char *rname = NULL; -#endif /* * GbE files can be 8KB, 16KB or 128KB, @@ -196,14 +260,12 @@ static const char *rname = NULL; * The code will handle this properly. */ static uint8_t buf[GBE_FILE_SIZE]; +static uint8_t pad[GBE_PART_SIZE]; /* the file that wouldn't die */ static uint16_t mac_buf[3]; static off_t gbe_file_size; -static int gbe_flags; -#ifndef NVMUTIL_ARC4RANDOM_BUF static int urandom_fd = -1; -#endif static int gbe_fd = -1; static size_t part; static uint8_t part_modified[2]; @@ -214,6 +276,14 @@ static const char *mac_str; static const char *fname; static const char *argv0; +#ifndef SIZE_MAX +#define SIZE_MAX ((size_t)-1) +#endif + +#ifndef SSIZE_MAX +#define SSIZE_MAX ((ssize_t)(SIZE_MAX >> 1)) +#endif + /* * Use these for .invert in command[]: * If set to 1: read/write inverter (p0->p1, p1->p0) @@ -227,6 +297,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[] @@ -236,6 +313,9 @@ enum { CMD_SETMAC, CMD_SWAP, CMD_COPY, + CMD_CAT, + CMD_CAT16, + CMD_CAT128 }; /* @@ -276,27 +356,24 @@ struct commands { uint8_t chksum_read; uint8_t chksum_write; size_t rw_size; /* within the 4KB GbE part */ + int flags; /* e.g. O_RDWR or O_RDONLY */ }; /* * Command table, for nvmutil commands */ static const struct commands command[] = { - /* - * Unlike older versions, we require at least - * one checksum to be valid when running dump. - */ { CMD_DUMP, "dump", cmd_helper_dump, ARGC_3, NO_INVERT, SET_MOD_OFF, ARG_NOPART, - CHECKSUM_READ, SKIP_CHECKSUM_WRITE, - NVM_SIZE }, + SKIP_CHECKSUM_READ, SKIP_CHECKSUM_WRITE, + NVM_SIZE, O_RDONLY }, { CMD_SETMAC, "setmac", cmd_helper_setmac, ARGC_3, NO_INVERT, SET_MOD_OFF, ARG_NOPART, CHECKSUM_READ, CHECKSUM_WRITE, - NVM_SIZE }, + NVM_SIZE, O_RDWR }, /* * OPTIMISATION: Read inverted, so no copying is needed. @@ -305,7 +382,7 @@ static const struct commands command[] = { PART_INVERT, SET_MOD_BOTH, ARG_NOPART, CHECKSUM_READ, SKIP_CHECKSUM_WRITE, - GBE_PART_SIZE }, + GBE_PART_SIZE, O_RDWR }, /* * OPTIMISATION: Read inverted, so no copying is needed. @@ -315,7 +392,25 @@ static const struct commands command[] = { PART_INVERT, SET_MOD_N, ARG_PART, CHECKSUM_READ, SKIP_CHECKSUM_WRITE, - GBE_PART_SIZE }, + GBE_PART_SIZE, O_RDWR }, + + { CMD_CAT, "cat", cmd_helper_cat, ARGC_3, + NO_INVERT, SET_MOD_OFF, + ARG_NOPART, + CHECKSUM_READ, SKIP_CHECKSUM_WRITE, + GBE_PART_SIZE, O_RDONLY }, + + { CMD_CAT16, "cat16", cmd_helper_cat, ARGC_3, + NO_INVERT, SET_MOD_OFF, + ARG_NOPART, + CHECKSUM_READ, SKIP_CHECKSUM_WRITE, + GBE_PART_SIZE, O_RDONLY }, + + { CMD_CAT128, "cat128", cmd_helper_cat, ARGC_3, + NO_INVERT, SET_MOD_OFF, + ARG_NOPART, + CHECKSUM_READ, SKIP_CHECKSUM_WRITE, + GBE_PART_SIZE, O_RDONLY }, }; #define MAX_CMD_LEN 50 @@ -352,11 +447,10 @@ main(int argc, char *argv[]) set_cmd(argc, argv); set_cmd_args(argc, argv); - set_io_flags(argc, argv); #ifdef NVMUTIL_PLEDGE #ifdef NVMUTIL_UNVEIL - if (gbe_flags == O_RDONLY) { + if (command[cmd_index].flags == O_RDONLY) { if (unveil(fname, "r") == -1) err(ECANCELED, "%s: unveil ro", fname); if (unveil(NULL, NULL) == -1) @@ -372,21 +466,14 @@ main(int argc, char *argv[]) err(ECANCELED, "pledge rw (kill unveil)"); } #else - if (gbe_flags == O_RDONLY) { + if (command[cmd_index].flags == O_RDONLY) { if (pledge("stdio rpath", NULL) == -1) err(ECANCELED, "pledge ro"); } #endif #endif -#ifndef NVMUTIL_ARC4RANDOM_BUF -#if defined(__OpenBSD__) || defined(__FreeBSD__) || \ - defined(__NetBSD__) || defined(__APPLE__) || \ - defined(__DragonFly__) - err(ECANCELED, "Maintainer error: arc4random disabled on BSD/MacOS"); -#endif open_dev_urandom(); -#endif open_gbe_file(); @@ -395,14 +482,20 @@ main(int argc, char *argv[]) err(ECANCELED, "pledge stdio (main)"); #endif + /* + * Used by CMD_CAT, for padding + */ + memset(pad, 0xff, sizeof(pad)); + read_gbe_file(); read_checksums(); + errno = 0; run_cmd(cmd_index); if (errno) err(errno, "%s: Unhandled error (WRITE SKIPPED)", fname); - else if (gbe_flags != O_RDONLY) + else if (command[cmd_index].flags == O_RDWR) write_gbe_file(); close_files(); @@ -439,17 +532,17 @@ sanitize_command_index(size_t c) err(ECANCELED, "ARGC_4 is not equal to 4"); if (command[c].argc < 3) - err(ECANCELED, "cmd index %zu: argc below 3, %d", + err(ECANCELED, "cmd index %lu: argc below 3, %d", c, command[c].argc); if (command[c].str == NULL) - err(ECANCELED, "cmd index %zu: NULL str", c); + err(ECANCELED, "cmd index %lu: NULL str", c); if (*command[c].str == '\0') - err(ECANCELED, "cmd index %zu: empty str", c); + err(ECANCELED, "cmd index %lu: empty str", c); if (xstrxlen(command[c].str, MAX_CMD_LEN + 1) > MAX_CMD_LEN) { - err(ECANCELED, "cmd index %zu: str too long: %s", + err(ECANCELED, "cmd index %lu: str too long: %s", c, command[c].str); } @@ -483,12 +576,19 @@ sanitize_command_index(size_t c) case NVM_SIZE: break; default: - err(EINVAL, "Unsupported rw_size: %zu", gbe_rw_size); + err(EINVAL, "Unsupported rw_size: %lu", gbe_rw_size); } if (gbe_rw_size > GBE_PART_SIZE) - err(EINVAL, "rw_size larger than GbE part: %zu", + err(EINVAL, "rw_size larger than GbE part: %lu", gbe_rw_size); + + 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 @@ -561,18 +661,6 @@ conv_argv_part_num(const char *part_str) return (size_t)(ch - '0'); } -static void -set_io_flags(int argc, char *argv[]) -{ - gbe_flags = O_RDWR; - - if (argc < 3) - return; - - if (xstrxcmp(argv[2], "dump", MAX_CMD_LEN) == 0) - gbe_flags = O_RDONLY; -} - /* * Portable strcmp() but blocks NULL/empty/unterminated * strings. Even stricter than strncmp(). @@ -608,14 +696,13 @@ xstrxcmp(const char *a, const char *b, size_t maxlen) return -1; } -#ifndef NVMUTIL_ARC4RANDOM_BUF static void open_dev_urandom(void) { struct stat st_urandom_fd; rname = newrandom; - if ((urandom_fd = open(rname, O_RDONLY)) != -1) + if ((urandom_fd = open(rname, O_RDONLY | O_BINARY)) != -1) return; /* @@ -628,16 +715,15 @@ open_dev_urandom(void) errno = 0; rname = oldrandom; - xopen(&urandom_fd, rname, O_RDONLY, &st_urandom_fd); + xopen(&urandom_fd, rname, O_RDONLY | O_BINARY, &st_urandom_fd); } -#endif static void open_gbe_file(void) { struct stat gbe_st; - xopen(&gbe_fd, fname, gbe_flags, &gbe_st); + xopen(&gbe_fd, fname, command[cmd_index].flags | O_BINARY, &gbe_st); gbe_file_size = gbe_st.st_size; @@ -676,59 +762,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) -{ - size_t gbe_rw_size = command[cmd_index].rw_size; - - void *mem_offset = - gbe_mem_offset(p ^ command[cmd_index].invert, "pread"); - - if ((size_t)read_gbe_file_exact(gbe_fd, mem_offset, - gbe_rw_size, gbe_file_offset(p, "pread")) != - gbe_rw_size) - err(ECANCELED, "%s: Partial read from p%zu", fname, p); - - printf("%s: Read %zu bytes from p%zu\n", - fname, gbe_rw_size, 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; @@ -771,9 +809,13 @@ read_checksums(void) if (num_invalid < max_invalid) errno = 0; - if (num_invalid >= max_invalid) + if (num_invalid >= max_invalid) { + if (max_invalid == 1) + err(ECANCELED, "%s: part %lu has a bad checksum", + fname, part); err(ECANCELED, "%s: No valid checksum found in file", fname); + } } static int @@ -782,21 +824,9 @@ good_checksum(size_t partnum) uint16_t expected_checksum = calculated_checksum(partnum); uint16_t current_checksum = nvm_word(NVM_CHECKSUM_WORD, partnum); - size_t real_partnum = partnum ^ command[cmd_index].invert; - if (current_checksum == expected_checksum) return 1; - fprintf(stderr, - "WARNING: BAD checksum in part %zu\n" - "EXPECTED checksum in part %zu: %04x\n" - "CURRENT checksum in part %zu: %04x\n", - real_partnum, - real_partnum, - expected_checksum, - real_partnum, - current_checksum); - set_err(ECANCELED); return 0; } @@ -805,7 +835,7 @@ static void run_cmd(size_t c) { check_command_num(c); - if (command[c].run) + if (command[c].run != NULL) command[c].run(); } @@ -813,7 +843,7 @@ static void check_command_num(size_t c) { if (!valid_command(c)) - err(ECANCELED, "Invalid run_cmd arg: %zu", c); + err(ECANCELED, "Invalid run_cmd arg: %lu", c); } static uint8_t @@ -823,7 +853,7 @@ valid_command(size_t c) return 0; if (c != command[c].chk) - err(ECANCELED, "Invalid cmd chk value (%zu) vs arg: %zu", + err(ECANCELED, "Invalid cmd chk value (%lu) vs arg: %lu", command[c].chk, c); return 1; @@ -834,12 +864,6 @@ cmd_helper_setmac(void) { size_t partnum; -#ifdef NVMUTIL_ARC4RANDOM_BUF - printf("Randomisation method: arc4random_buf\n"); -#else - printf("Randomisation method: %s\n", rname); -#endif - printf("MAC address to be written: %s\n", mac_str); parse_mac_string(); @@ -967,53 +991,13 @@ rhex(void) static uint8_t rnum[12]; if (!n) { -#ifdef NVMUTIL_ARC4RANDOM_BUF n = sizeof(rnum); - 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"); -#endif + rw_file_exact(urandom_fd, rnum, n, 0, LESEN, rname, "read"); } 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) { @@ -1026,7 +1010,7 @@ write_mac_part(size_t partnum) for (w = 0; w < 3; w++) set_nvm_word(w, partnum, mac_buf[w]); - printf("Wrote MAC address to part %zu: ", partnum); + printf("Wrote MAC address to part %lu: ", partnum); print_mac_from_nvm(partnum); } @@ -1035,9 +1019,20 @@ cmd_helper_dump(void) { size_t partnum; + 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 %lu (expected %04x)\n", + nvm_word(NVM_CHECKSUM_WORD, partnum), + partnum, calculated_checksum(partnum)); - printf("MAC (part %zu): ", partnum); + printf("MAC (part %lu): ", partnum); print_mac_from_nvm(partnum); hexdump(partnum); } @@ -1066,7 +1061,7 @@ hexdump(size_t partnum) uint16_t val16; for (row = 0; row < 8; row++) { - printf("%08zx ", (size_t)row << 4); + printf("%08lx ", (size_t)row << 4); for (c = 0; c < 8; c++) { val16 = nvm_word((row << 3) + c, partnum); if (c == 4) @@ -1078,13 +1073,44 @@ hexdump(size_t partnum) } static void +cmd_helper_cat(void) +{ + size_t p; + size_t ff; + size_t n = 0; + + if (cmd_index == CMD_CAT16) + n = 1; + else if (cmd_index == CMD_CAT128) + n = 15; + else if (cmd_index != CMD_CAT) + err(ECANCELED, "cmd_helper_cat called erroneously"); + + fflush(NULL); + + for (p = 0; p < 2; p++) { + gbe_cat_buf(buf + (p * GBE_PART_SIZE)); + + for (ff = 0; ff < n; ff++) + gbe_cat_buf(pad); + } +} + +static void +gbe_cat_buf(uint8_t *b) +{ + rw_file_exact(STDOUT_FILENO, b, GBE_PART_SIZE, 0, + SCHREIB, "stdout", "write"); +} + +static void write_gbe_file(void) { size_t p; size_t partnum; uint8_t update_checksum; - if (gbe_flags == O_RDONLY) + if (command[cmd_index].flags == O_RDONLY) return; update_checksum = command[cmd_index].chksum_write; @@ -1100,7 +1126,7 @@ write_gbe_file(void) if (update_checksum) set_checksum(partnum); - write_gbe_file_part(partnum); + rw_gbe_file_part(partnum, PSCHREIB, "pwrite"); } } @@ -1203,50 +1229,51 @@ check_nvm_bound(size_t c, size_t p) check_bin(p, "part number"); if (c >= NVM_WORDS) - err(EINVAL, "check_nvm_bound: out of bounds %zu", c); + err(EINVAL, "check_nvm_bound: out of bounds %lu", c); } static void check_bin(size_t a, const char *a_name) { if (a > 1) - err(ECANCELED, "%s must be 0 or 1, but is %zu", a_name, a); + err(ECANCELED, "%s must be 0 or 1, but is %lu", a_name, a); } 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); } /* @@ -1266,20 +1293,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) @@ -1288,7 +1301,7 @@ gbe_x_offset(size_t p, const char *f_op, const char *d_type, check_bin(p, "part number"); - off = (off_t)p * nsize; + off = ((off_t)p) * (off_t)nsize; if (off + GBE_PART_SIZE > ncmp) err(ECANCELED, "%s: GbE %s %s out of bounds", @@ -1302,13 +1315,116 @@ 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; + size_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); + if (len > (size_t)SSIZE_MAX) + err(EIO, + "%s: %s: Requested length (%lu) exceeds SSIZE_MAX (%zd)", + path, rw_type_str, len, SSIZE_MAX); + + for (rc = 0; rc != len; rc += rval) { + if (rw_type == PSCHREIB) + rval = prw(fd, mem + rc, len - rc, + off + rc, rw_type, path); + else if (rw_type == SCHREIB) + rval = write(fd, mem + rc, len - rc); + else if (rw_type == PLESEN) + rval = prw(fd, mem + rc, len - rc, + off + rc, rw_type, path); + else if (rw_type == LESEN) + rval = read(fd, mem + rc, len - rc); + else + err(EIO, "%s: %s: Unsupported rw_type", + path, rw_type_str); + + 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 ssize_t +prw(int fd, void *mem, size_t count, + off_t offset, int rw_type, const char *path) +{ + off_t rs; + off_t old; + ssize_t r; + + if ((old = lseek_eintr(fd, (off_t)0, SEEK_CUR)) == (off_t)-1) + return -1; + if ((r = lseek_eintr(fd, offset, SEEK_SET)) == (off_t)-1) + return -1; + + do { + if (rw_type == PLESEN) + r = read(fd, mem, count); + else if (rw_type == PSCHREIB) + r = write(fd, mem, count); + else + err(EIO, "%s: Invalid rw_type", path); + } while (r < 0 && errno == EINTR); + + if (r >= 0) { + if ((rs = lseek_eintr(fd, old, SEEK_SET)) == (off_t)-1) + errno = EIO; + } + + return r; +} + +static off_t +lseek_eintr(int fd, off_t offset, int whence) +{ + off_t old; + + do { + old = lseek(fd, offset, whence); + } while (old == (off_t)-1 && errno == EINTR); + + return old; +} + +static void err(int nvm_errval, const char *msg, ...) { + va_list args; + + /* + * We need to ensure that files are closed + * on exit, including error exits. This + * would otherwise recurse, because the + * close_files() function also calls err(), + * but with -1 on nvm_errval. It's the only + * one that does this. + * + * Since the errval is for setting errno, -1 + * would be incorrect. Therefore, set_err() + * avoids overriding errno if the given value + * is negative. + * + * Be careful modifying err() and close_files(). + */ if (nvm_errval != -1) close_files(); - va_list args; - fprintf(stderr, "%s: ", getnvmprogname()); va_start(args, msg); @@ -1331,13 +1447,11 @@ close_files(void) gbe_fd = -1; } -#ifndef NVMUTIL_ARC4RANDOM_BUF if (urandom_fd > -1) { if (close(urandom_fd) == -1) err(-1, "%s: close failed", rname); urandom_fd = -1; } -#endif } static const char * @@ -1382,8 +1496,12 @@ usage(uint8_t usage_exit) "\t%s FILE dump\n" "\t%s FILE setmac [MAC]\n" "\t%s FILE swap\n" - "\t%s FILE copy 0|1\n", - util, util, util, util); + "\t%s FILE copy 0|1\n" + "\t%s FILE cat\n" + "\t%s FILE cat16\n" + "\t%s FILE cat128\n", + util, util, util, util, + util, util, util); if (usage_exit) err(EINVAL, "Too few arguments"); |