void
+__attribute__((format(printf, 1, 2)))
prt(char *fmt, ...)
{
va_list args;
va_start(args, fmt);
vfprintf(stdout, fmt, args);
- if (fsxlogf)
- vfprintf(fsxlogf, fmt, args);
va_end(args);
+
+ if (fsxlogf) {
+ va_start(args, fmt);
+ vfprintf(fsxlogf, fmt, args);
+ va_end(args);
+ }
}
void
if (c != t) {
if (n == 0) {
bad = short_at(&temp_buf[i]);
- prt("0x%5x\t0x%04x\t0x%04x", offset,
+ prt("%#07x\t%#06x\t%#06x", offset,
short_at(&good_buf[offset]), bad);
op = temp_buf[offset & 1 ? i+1 : i];
}
size--;
}
if (n) {
- prt("\t0x%5x\n", n);
+ prt("\t%#7x\n", n);
if (bad)
prt("operation# (mod 256) for the bad data"
"may be %u\n", ((unsigned)op & 0xff));
}
}
-int
+int
get_fd(void)
{
struct test_file *tf = get_tf();
return tf->fd;
}
-static const char *basename(const char *path)
+static const char *my_basename(const char *path)
{
char *c = strrchr(path, '/');
return c ? c++ : path;
}
-void
+void
open_test_files(char **argv, int argc)
{
struct test_file *tf;
struct stat statbuf;
int fd = get_fd();
- ftruncate(fd, (off_t)0);
- ftruncate(fd, (off_t)100000);
- fstat(fd, &statbuf);
+ /* should not ignore ftruncate(2)'s return value */
+ if (ftruncate(fd, (off_t)0) < 0) {
+ prterr("trunc_hack: ftruncate(0)");
+ exit(1);
+ }
+ if (ftruncate(fd, (off_t)100000) < 0) {
+ prterr("trunc_hack: ftruncate(100000)");
+ exit(1);
+ }
+ if (fstat(fd, &statbuf)) {
+ prterr("trunc_hack: fstat");
+ statbuf.st_size = -1;
+ }
if (statbuf.st_size != (off_t)100000) {
prt("no extend on truncate! not posix!\n");
exit(130);
}
- ftruncate(fd, 0);
+ if (ftruncate(fd, 0) < 0) {
+ prterr("trunc_hack: ftruncate(0) (2nd call)");
+ exit(1);
+ }
}
static char *tf_buf = NULL;
int len;
len = snprintf(&dummy, 0, "%u ", highest);
- if (len < 0) {
+ if (len < 1) {
prterr("finding max tf_buf");
exit(1);
}
- tf_buf = malloc(len + 1);
+ len++;
+ tf_buf = malloc(len);
if (tf_buf == NULL) {
prterr("allocating tf_buf");
exit(1);
}
- max_tf_len = sprintf(tf_buf, "%u ", highest);
+ max_tf_len = snprintf(tf_buf, len, "%u ", highest);
+ if (max_tf_len < 1) {
+ prterr("fiding max_tv_len\n");
+ exit(1);
+ }
+ if (max_tf_len != len - 1) {
+ warn("snprintf() gave %d instead of %d?\n",
+ max_tf_len, len - 1);
+ exit(1);
+ }
}
char *
if (tf_buf == NULL)
alloc_tf_buf();
- sprintf(tf_buf,"%u ", tf - test_files);
+ sprintf(tf_buf,"%lu ", (unsigned long)(tf - test_files));
return tf_buf;
}
void
-output_line(struct test_file *tf, int op, unsigned long offset,
- unsigned long size, struct timeval *tv)
+output_line(struct test_file *tf, int op, unsigned offset,
+ unsigned size, struct timeval *tv)
{
char *tf_num = "";
(monitorend == -1 || offset <= monitorend)))))))
return;
- prt("%06lu %lu.%06lu %*s%-10s %#08x %s %#08x\t(0x%x bytes)\n",
+ prt("%06lu %lu.%06lu %.*s%-10s %#08x %s %#08x\t(0x%x bytes)\n",
testcalls, tv->tv_sec, tv->tv_usec, max_tf_len,
tf_num, ops[op],
offset, op == OP_TRUNCATE ? " to " : "thru",
if (iret == -1)
prterr("writefileimage: write");
else
- prt("short write: 0x%x bytes instead of 0x%llx\n",
- iret, (unsigned long long)file_size);
+ prt("short write: 0x%lx bytes instead of 0x%llx\n",
+ (unsigned long)iret,
+ (unsigned long long)file_size);
report_failure(172);
}
if (lite ? 0 : ftruncate(fd, file_size) == -1) {
open_test_files(argv, argc);
- strncat(goodfile, dirpath ? basename(fname) : fname, 256);
+ strncat(goodfile, dirpath ? my_basename(fname) : fname, 256);
strcat (goodfile, ".fsxgood");
fsxgoodfd = open(goodfile, O_RDWR|O_CREAT|O_TRUNC, 0666);
if (fsxgoodfd < 0) {
prterr(goodfile);
exit(92);
}
- strncat(logfile, dirpath ? basename(fname) : fname, 256);
+ strncat(logfile, dirpath ? my_basename(fname) : fname, 256);
strcat (logfile, ".fsxlog");
fsxlogf = fopen(logfile, "w");
if (fsxlogf == NULL) {