/*
- * ext3 Filesystem Verification Tool.
- * This program tests the correct operation of ext3 filesystem.
+ * GPL HEADER START
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 only,
+ * as published by the Free Software Foundation.
+ *
+ * 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 version 2 for more details (a copy is included
+ * in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 2 along with this program; If not, see
+ * http://www.gnu.org/licenses/gpl-2.0.html
+ *
+ * GPL HEADER END
+ */
+/*
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Use is subject to license terms.
+ *
+ * Copyright (c) 2011, Intel Corporation.
+ */
+/*
+ * This file is part of Lustre, http://www.lustre.org/
+ * Lustre is a trademark of Sun Microsystems, Inc.
+ *
+ * lustre/utils/llverfs.c
+ *
+ * Filesystem Verification Tool.
+ * This program tests the correct operation of large filesystems and
+ * the underlying block storage device(s).
* This tool have two working modes
* 1. full mode
- * 2. fast mode
- * The full mode is basic mode in which program creates a subdirectory
- * in the test fileysytem, writes n(files_in_dir, default=16) large(4GB) files
- * to the directory with the test pattern at the start of each 4kb block.
- * The test pattern contains timestamp, relative file offset and per file
- * unique idenfifier(inode number). this continues until whole filesystem is
- * full and then this tooll verifies that the data in all of the test files
- * is correct.
- * In the fast mode the tool creates a test directories with
- * EXT3_TOPDIR_FL flag set. the number of directories equals to the number
- * of block groups in the filesystem(e.g. 65536 directories for 8TB filesystem)
- * and then writes a single 1MB file in each directory. The tool then verifies
+ * 2. partial mode
+ *
+ * In full mode, the program creates a subdirectory in the test
+ * filesystem, writes n(files_in_dir, default=32) large(4GB) files to
+ * the directory with the test pattern at the start of each 4kb block.
+ * The test pattern contains timestamp, relative file offset and per
+ * file unique identifier(inode number). This continues until the
+ * whole filesystem is full and then the tool verifies that the data
+ * in all of the test files is correct.
+ *
+ * In partial mode, the tool creates test directories with the
+ * EXT3_TOPDIR_FL flag set (if supported) to spread the directory data
+ * around the block device instead of localizing it in a single place.
+ * The number of directories equals to the number of block groups in the
+ * filesystem (e.g. 65536 directories for 8TB ext3/ext4 filesystem) and
+ * then writes a single 1MB file in each directory. The tool then verifies
* that the data in each file is correct.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/vfs.h>
+#include <sys/time.h>
#include <gnu/stubs.h>
#include <gnu/stubs.h>
static int writeoption; /* run test in write_only mode */
char *testdir; /* name of device to be tested. */
static unsigned full = 1; /* flag to full check */
-static int errno_local; /* local copy of errno */
-static unsigned long num_files; /* Total number of files for read/write */
+static int error_count; /* number of IO errors hit during run */
+char filecount[PATH_MAX]; /* file with total number of files written*/
+static unsigned long num_files; /* Total number of files for read/write */
static loff_t file_size = 4*ONE_GB; /* Size of each file */
static unsigned files_in_dir = 32; /* number of files in each directioy */
static unsigned num_dirs = 30000; /* total number of directories */
const int dirmode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
-static int fd = -1;
static int isatty_flag;
static int perms = S_IRWXU | S_IRGRP | S_IROTH;
-static struct option const longopts[] =
-{
- { "chunksize", required_argument, 0, 'c' },
- { "help", no_argument, 0, 'h' },
- { "offset", required_argument, 0, 'o' },
- { "long", no_argument, 0, 'l' },
- { "partial", required_argument, 0, 'p' },
- { "quiet", required_argument, 0, 'q' },
- { "read", no_argument, 0, 'r' },
- { "timestamp", required_argument, 0, 't' },
- { "verbose", no_argument, 0, 'v' },
- { "write", no_argument, 0, 'w' },
- { 0, 0, 0, 0}
-};
+static struct option const long_opts[] = {
+ { .val = 'c', .name = "chunksize", .has_arg = required_argument },
+ { .val = 'h', .name = "help", .has_arg = no_argument },
+ { .val = 'l', .name = "long", .has_arg = no_argument },
+ { .val = 'l', .name = "full", .has_arg = no_argument },
+ { .val = 'o', .name = "offset", .has_arg = required_argument },
+ { .val = 'p', .name = "partial", .has_arg = required_argument },
+ { .val = 'q', .name = "quiet", .has_arg = required_argument },
+ { .val = 'r', .name = "read", .has_arg = no_argument },
+ { .val = 's', .name = "filesize", .has_arg = no_argument },
+ { .val = 't', .name = "timestamp", .has_arg = required_argument },
+ { .val = 'v', .name = "verbose", .has_arg = no_argument },
+ { .val = 'w', .name = "write", .has_arg = no_argument },
+ { .name = NULL } };
/*
* Usages: displays help information, whenever user supply --help option in
*/
void usage(int status)
{
- if (status != 0)
- {
- printf("\nUsage: %s [OPTION]... <filesystem path> ...\n",
- progname);
- printf("ext3 filesystem verification tool.\n"
- "\t-t {seconds} for --timestamp, set test time"
- "(default=current time())\n"
- "\t-o {offset} for --offset, directory starting offset"
- " from which tests should start\n"
- "\t-r run test in read (verify) mode\n"
- "\t-w run test in write (test-pattern) mode (default=r&w)\n"
- "\t-v for verbose\n"
- "\t-p for --partial, for partial check (1MB files)\n"
- "\t-l for --long, full check (4GB file with 4k blocks)\n"
- "\t-c for --chunksize, IO chunk size (default=1048576)\n"
- "\t-h display this help and exit\n"
- "\t--help display this help and exit\n");
+ if (status != 0) {
+ printf("\nUsage: %s [OPTION]... <filesystem path> ...\n",
+ progname);
+ printf("Filesystem verification tool.\n"
+ "\t-t {seconds}, --timestamp, set test time"
+ "(default=current time())\n"
+ "\t-o {offset}, --offset, directory starting offset"
+ " from which tests should start\n"
+ "\t-r, --read, run in verify mode\n"
+ "\t-w, --write, run in test-pattern mode, default=rw\n"
+ "\t-v, --verbose\n"
+ "\t-p, --partial, for partial check (1MB files)\n"
+ "\t-l, --long, --full check (4GB file with 4k blocks)\n"
+ "\t-c, --chunksize, IO chunk size in MB (default=1)\n"
+ "\t-s, --filesize, file size in MB (default=4096)\n"
+ "\t-h, --help, display this help and exit\n");
}
exit(status);
}
*/
static int open_file(const char *file, int flag)
{
- fd = open(file, flag, perms);
+ int fd = open(file, flag, perms);
if (fd < 0) {
fprintf(stderr, "\n%s: Open '%s' failed:%s\n",
progname, file, strerror(errno));
- exit(3);
}
return (fd);
}
* Verify_chunk: Verifies test pattern in each 4kB (BLOCKSIZE) is correct.
* Returns 0 if test offset and timestamp is correct otherwise 1.
*/
-int verify_chunk(char *chunk_buf, size_t chunksize,unsigned long long chunk_off,
- unsigned long long time_st, unsigned long long inode_st,
- char *file)
+int verify_chunk(char *chunk_buf, const size_t chunksize,
+ unsigned long long chunk_off, const unsigned long long time_st,
+ const unsigned long long inode_st, const char *file)
{
struct block_data *bd;
char *chunk_end;
if ((bd->bd_offset == chunk_off) && (bd->bd_time == time_st) &&
(bd->bd_inode == inode_st))
continue;
- fprintf(stderr,"\n%s: verify %s failed offset/timestamp/inode "
+ fprintf(stderr, "\n%s: verify %s failed offset/timestamp/inode "
"%llu/%llu/%llu: found %llu/%llu/%llu instead\n",
progname, file, chunk_off, time_st, inode_st,
bd->bd_offset, bd->bd_time, bd->bd_inode);
/*
* fill_chunk: Fills the chunk with current or user specified timestamp
- * and offset. The test patters is filled at the beginning of
+ * and offset. The test pattern is filled at the beginning of
* each 4kB(BLOCKSIZE) blocks in chunk_buf.
*/
void fill_chunk(char *chunk_buf, size_t chunksize, loff_t chunk_off,
- time_t time_st, ino_t inode_st)
+ const time_t time_st, const ino_t inode_st)
{
struct block_data *bd;
char *chunk_end;
}
/*
- * write_chunk: write the chunk_buf on the device. The number of write
+ * Write a chunk to disk, handling errors, interrupted writes, etc.
+ *
+ * If there is an IO error hit during the write, it is possible that
+ * this will just show up as a short write, and a subsequent write
+ * will return the actual error. We want to continue in the face of
+ * minor media errors so that we can validate the whole device if
+ * possible, but if there are many errors we don't want to loop forever.
+ *
+ * The error count will be returned upon exit to ensure that the
+ * media errors are detected even if nobody is looking at the output.
+ *
+ * Returns 0 on success, or -ve errno on failure.
+ */
+int write_retry(int fd, const char *chunk_buf, size_t nrequested,
+ unsigned long long offset, const char *file)
+{
+ long nwritten;
+
+retry:
+ nwritten = write(fd, chunk_buf, nrequested);
+ if (nwritten < 0) {
+ if (errno != ENOSPC) {
+ fprintf(stderr, "\n%s: write %s@%llu+%zi failed: %s\n",
+ progname, file, offset, nrequested,
+ strerror(errno));
+ if (error_count++ < 100)
+ return 0;
+ }
+ return -errno;
+ }
+ if (nwritten < nrequested) {
+ fprintf(stderr, "\n%s: write %s@%llu+%zi short: %ld written\n",
+ progname, file, offset, nrequested, nwritten);
+ offset += nwritten;
+ chunk_buf += nwritten;
+ nrequested -= nwritten;
+ goto retry;
+ }
+
+ return 0;
+}
+
+/*
+ * write_chunks: write the chunk_buf on the device. The number of write
* operations are based on the parameters write_end, offset, and chunksize.
+ *
+ * Returns 0 on success, or -ve error number on failure.
*/
int write_chunks(int fd, unsigned long long offset,unsigned long long write_end,
- char *chunk_buf, size_t chunksize, time_t time_st,
- ino_t inode_st, const char *file)
+ char *chunk_buf, size_t chunksize, const time_t time_st,
+ const ino_t inode_st, const char *file)
{
unsigned long long stride;
stride = full ? chunksize : (ONE_GB - chunksize);
for (offset = offset & ~(chunksize - 1); offset < write_end;
offset += stride) {
+ int ret;
+
if (lseek64(fd, offset, SEEK_SET) == -1) {
fprintf(stderr, "\n%s: lseek64(%s+%llu) failed: %s\n",
progname, file, offset, strerror(errno));
- return 1;
+ return -errno;
}
if (offset + chunksize > write_end)
chunksize = write_end - offset;
if (!full && offset > chunksize) {
fill_chunk(chunk_buf, chunksize, offset, time_st,
- inode_st);
- if (write(fd, chunk_buf, chunksize) < 0) {
- if (errno == ENOSPC) {
- errno_local = errno;
- return 0;
- }
- fprintf(stderr,
- "\n%s: write %s+%llu failed: %s\n",
- progname, file, offset,strerror(errno));
- return errno;
- }
+ inode_st);
+ ret = write_retry(fd, chunk_buf, chunksize,offset,file);
+ if (ret < 0)
+ return ret;
offset += chunksize;
if (offset + chunksize > write_end)
chunksize = write_end - offset;
}
fill_chunk(chunk_buf, chunksize, offset, time_st, inode_st);
- if (write(fd, (char *) chunk_buf, chunksize) < 0) {
- if (errno == ENOSPC) {
- errno_local = errno;
- return 0;
- }
- fprintf(stderr, "\n%s: write %s+%llu failed: %s\n",
- progname, file, offset, strerror(errno));
- return 1;
- }
+ ret = write_retry(fd, chunk_buf, chunksize, offset, file);
+ if (ret < 0)
+ return ret;
}
return 0;
}
* operations are based on the parameters read_end, offset, and chunksize.
*/
int read_chunks(int fd, unsigned long long offset, unsigned long long read_end,
- char *chunk_buf, size_t chunksize, time_t time_st,
- ino_t inode_st, char *file)
+ char *chunk_buf, size_t chunksize, const time_t time_st,
+ const ino_t inode_st, const char *file)
{
unsigned long long stride;
stride = full ? chunksize : (ONE_GB - chunksize);
for (offset = offset & ~(chunksize - 1); offset < read_end;
offset += stride) {
+ ssize_t nread;
+
if (lseek64(fd, offset, SEEK_SET) == -1) {
fprintf(stderr, "\n%s: lseek64(%s+%llu) failed: %s\n",
progname, file, offset, strerror(errno));
}
if (offset + chunksize > read_end)
chunksize = read_end - offset;
+
if (!full && offset > chunksize) {
- if (read(fd, chunk_buf, chunksize) < 0) {
- fprintf(stderr,
- "\n%s: read %s+%llu failed: %s\n",
- progname, file, offset,strerror(errno));
+ nread = read(fd, chunk_buf, chunksize);
+ if (nread < 0) {
+ fprintf(stderr,"\n%s: read %s@%llu+%zi failed: "
+ "%s\n", progname, file, offset,
+ chunksize, strerror(errno));
+ error_count++;
return 1;
}
- if (verify_chunk(chunk_buf, chunksize, offset,
- time_st, inode_st, file) != 0)
+ if (nread < chunksize) {
+ fprintf(stderr, "\n%s: read %s@%llu+%zi short: "
+ "%zi read\n", progname, file, offset,
+ chunksize, nread);
+ error_count++;
+ }
+ if (verify_chunk(chunk_buf, nread, offset, time_st,
+ inode_st, file) != 0) {
return 1;
+ }
offset += chunksize;
+
+ /* Need to reset position after read error */
+ if (nread < chunksize &&
+ lseek64(fd, offset, SEEK_SET) == -1) {
+ fprintf(stderr,
+ "\n%s: lseek64(%s@%llu) failed: %s\n",
+ progname, file, offset,strerror(errno));
+ return 1;
+ }
if (offset + chunksize >= read_end)
chunksize = read_end - offset;
}
- if (read(fd, chunk_buf, chunksize) < 0) {
- fprintf(stderr, "\n%s: read %s+%llu failed: %s\n",
- progname, file, offset, strerror(errno));
+ nread = read(fd, chunk_buf, chunksize);
+ if (nread < 0) {
+ fprintf(stderr, "\n%s: read %s@%llu+%zi failed: %s\n",
+ progname, file, offset, chunksize,
+ strerror(errno));
+ error_count++;
return 1;
}
- if (verify_chunk(chunk_buf, chunksize, offset, time_st,
- inode_st, file) != 0)
+ if (nread < chunksize) {
+ fprintf(stderr, "\n%s: read %s@%llu+%zi short: "
+ "%zi read\n", progname, file, offset,
+ chunksize, nread);
+ error_count++;
+ }
+
+ if (verify_chunk(chunk_buf, nread, offset, time_st,
+ inode_st, file) != 0) {
return 1;
+ }
}
return 0;
}
}
/*
- * show_filename: Displays name of current file read/write
+ * calc_total_bytes: calculates total bytes that need to be
+ * written into or read from the filesystem.
*/
-void show_filename(char *op, char *filename)
+static unsigned long long calc_total_bytes(const char *op)
{
- static time_t last;
- time_t now;
- double diff;
+ unsigned long long total_bytes = 0;
+ struct statfs64 statbuf;
+
+ if (full) {
+ if (statfs64(testdir, &statbuf) == 0) {
+ if (strcmp(op, "write") == 0)
+ total_bytes = (unsigned long long)
+ (statbuf.f_bavail * statbuf.f_bsize);
+ else if (strcmp(op, "read") == 0)
+ total_bytes = (unsigned long long)
+ (statbuf.f_blocks * statbuf.f_bsize);
+ else {
+ fprintf(stderr, "\n%s: invalid operation: %s\n",
+ progname, op);
+ return -1;
+ }
+ } else {
+ fprintf(stderr, "\n%s: unable to stat %s: %s\n",
+ progname, testdir, strerror(errno));
+ return -errno;
+ }
+ } else {
+ total_bytes = num_dirs * files_in_dir * file_size;
+ }
+
+ return total_bytes;
+}
+
+/*
+ * show_rate: displays the current read/write file name and performance,
+ * along with an estimate of how long the whole read/write operation
+ * will continue.
+ */
+void show_rate(char *op, char *filename, const struct timeval *start_time,
+ const unsigned long long total_bytes,
+ const unsigned long long curr_bytes)
+{
+ static struct timeval last_time;
+ static unsigned long long last_bytes;
+ static char last_op;
+ struct timeval curr_time;
+ double curr_delta, overall_delta, curr_rate, overall_rate;
+ double total_time, remain_time;
+ int remain_hours, remain_minutes, remain_seconds;
+
+ if (last_time.tv_sec == 0)
+ last_time = *start_time;
+
+ if (last_op != op[0]) {
+ last_bytes = 0;
+ last_time = *start_time;
+ last_op = op[0];
+ }
+
+ gettimeofday(&curr_time, NULL);
+
+ curr_delta = (curr_time.tv_sec - last_time.tv_sec) +
+ (double)(curr_time.tv_usec - last_time.tv_usec) / 1000000;
+
+ overall_delta = (curr_time.tv_sec - start_time->tv_sec) +
+ (double)(curr_time.tv_usec - start_time->tv_usec) / 1000000;
+
+ curr_rate = (curr_bytes - last_bytes) / curr_delta;
+ overall_rate = curr_bytes / overall_delta;
+
+ if (curr_rate == 0) {
+ last_time = curr_time;
+ return;
+ }
+ total_time = total_bytes / curr_rate;
+ remain_time = total_time - overall_delta;
- now = time(NULL);
- diff = now - last;
- if (diff > 4 || verbose > 2) {
+ remain_hours = remain_time / 3600;
+ remain_minutes = (remain_time - remain_hours * 3600) / 60;
+ remain_seconds = (remain_time - remain_hours * 3600 -
+ remain_minutes * 60);
+
+ if (curr_delta > 4 || verbose > 2) {
if (isatty_flag)
printf("\r");
- printf("%s File name: %s ", op, filename);
+
+ printf("%s filename: %s, current %5g MB/s, overall %5g MB/s, "
+ "est %u:%u:%u left", op, filename,
+ curr_rate / ONE_MB, overall_rate / ONE_MB,
+ remain_hours, remain_minutes, remain_seconds);
+
if (isatty_flag)
fflush(stdout);
else
printf("\n");
- last = now;
}
+
+ last_time = curr_time;
+ last_bytes = curr_bytes;
}
/*
* dir_write: This function writes directories and files on device.
- * it works for both full and fast modes.
+ * it works for both full and partial modes.
*/
static int dir_write(char *chunk_buf, size_t chunksize,
time_t time_st, unsigned long dir_num)
{
char tempfile[PATH_MAX];
char tempdir[PATH_MAX];
+ FILE *countfile;
struct stat64 file;
int file_num = 999999999;
ino_t inode_st = 0;
+ struct timeval start_time;
+ unsigned long long total_bytes;
+ unsigned long long curr_bytes = 0;
+ int rc = 0;
#ifdef HAVE_EXT2FS_EXT2FS_H
if (!full && fsetflags(testdir, EXT2_TOPDIR_FL))
"\n%s: can't set TOPDIR_FL on %s: %s (ignoring)",
progname, testdir, strerror(errno));
#endif
+ countfile = fopen(filecount, "w");
+ if (countfile == NULL) {
+ fprintf(stderr, "\n%s: creating %s failed :%s\n",
+ progname, filecount, strerror(errno));
+ return 5;
+ }
+ /* reserve space for the countfile */
+ if (fprintf(countfile, "%lu", num_files) < 1 ||
+ fflush(countfile) != 0) {
+ fprintf(stderr, "\n%s: writing %s failed :%s\n",
+ progname, filecount, strerror(errno));
+ rc = 6;
+ goto out;
+ }
+
+ /* calculate total bytes that need to be written */
+ total_bytes = calc_total_bytes("write");
+ if (total_bytes <= 0) {
+ fprintf(stderr, "\n%s: unable to calculate total bytes\n",
+ progname);
+ rc = 7;
+ goto out;
+ }
+
+ if (!full && (dir_num != 0))
+ total_bytes -= dir_num * files_in_dir * file_size;
+
+ gettimeofday(&start_time, NULL);
for (; dir_num < num_dirs; num_files++, file_num++) {
+ int fd, ret;
+
if (file_num >= files_in_dir) {
if (dir_num == num_dirs - 1)
break;
fprintf(stderr, "\n%s: mkdir %s : %s\n",
progname, tempdir,
strerror(errno));
- return 1;
+ rc = 1;
+ goto out;
}
}
dir_num++;
}
+
fd = open_file(new_file(tempfile, tempdir, file_num),
O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE);
-
- if (fd >= 0 && fstat64(fd, &file) == 0) {
- inode_st = file.st_ino;
+ if (fd >= 0) {
+ if (fstat64(fd, &file) == 0) {
+ inode_st = file.st_ino;
+ } else {
+ fprintf(stderr, "\n%s: write stat '%s': %s",
+ progname, tempfile, strerror(errno));
+ close(fd);
+ break;
+ }
} else {
- fprintf(stderr, "\n%s: write stat64 to file %s: %s",
- progname, tempfile, strerror(errno));
- exit(1);
+ break;
}
- if (verbose > 1)
- show_filename("write", tempfile);
-
- if (write_chunks(fd, 0, file_size, chunk_buf, chunksize,
- time_st, inode_st, tempfile)) {
- close(fd);
- return 1;
- }
+ ret = write_chunks(fd, 0, file_size, chunk_buf, chunksize,
+ time_st, inode_st, tempfile);
close(fd);
-
- if (errno_local == ENOSPC)
+ if (ret < 0) {
+ if (ret != -ENOSPC) {
+ rc = 1;
+ goto out;
+ }
+ curr_bytes = total_bytes;
break;
+ }
+
+ curr_bytes += file_size;
+ if (verbose > 1)
+ show_rate("write", tempfile, &start_time,
+ total_bytes, curr_bytes);
+
+ fseek(countfile, 0, SEEK_SET);
+ if (fprintf(countfile, "%lu", num_files) < 1 ||
+ fflush(countfile) != 0) {
+ fprintf(stderr, "\n%s: writing %s failed :%s\n",
+ progname, filecount, strerror(errno));
+ }
}
if (verbose) {
verbose++;
- show_filename("write", tempfile);
+ show_rate("write", tempfile, &start_time,
+ total_bytes, curr_bytes);
printf("\nwrite complete\n");
verbose--;
}
- return 0;
+out:
+ fclose(countfile);
+
+ return rc;
}
/*
* dir_read: This function reads directories and files on device.
- * it works for both full and fast modes.
+ * it works for both full and partial modes.
*/
static int dir_read(char *chunk_buf, size_t chunksize,
time_t time_st, unsigned long dir_num)
struct stat64 file;
int file_num = 0;
ino_t inode_st = 0;
+ struct timeval start_time;
+ unsigned long long total_bytes;
+ unsigned long long curr_bytes = 0;
+
+ /* calculate total bytes that need to be read */
+ total_bytes = calc_total_bytes("read");
+ if (total_bytes <= 0) {
+ fprintf(stderr, "\n%s: unable to calculate total bytes\n",
+ progname);
+ return 1;
+ }
+
+ if (dir_num != 0)
+ total_bytes -= dir_num * files_in_dir * file_size;
+ gettimeofday(&start_time, NULL);
for (count = 0; count < num_files && dir_num < num_dirs; count++) {
+ int fd, ret;
+
if (file_num == 0) {
if (dir_num == num_dirs - 1)
break;
fd = open_file(new_file(tempfile, tempdir, file_num),
O_RDONLY | O_LARGEFILE);
- if (fd >= 0 && fstat64(fd, &file) == 0) {
- inode_st = file.st_ino;
+ if (fd >= 0) {
+ if (fstat64(fd, &file) == 0) {
+ inode_st = file.st_ino;
+ } else {
+ fprintf(stderr, "\n%s: read stat '%s': %s\n",
+ progname, tempfile, strerror(errno));
+ close(fd);
+ return 1;
+ }
} else {
- fprintf(stderr, "\n%s: read stat64 file '%s': %s\n",
- progname, tempfile, strerror(errno));
- return 1;
+ break;
}
- if (verbose > 1)
- show_filename("read", tempfile);
-
if (count == num_files)
file_size = file.st_size;
- if (read_chunks(fd, 0, file_size, chunk_buf, chunksize,
- time_st, inode_st, tempfile)) {
- close(fd);
- return 1;
- }
+ ret = read_chunks(fd, 0, file_size, chunk_buf, chunksize,
+ time_st, inode_st, tempfile);
close(fd);
+ if (ret)
+ return 1;
+
+ curr_bytes += file_size;
+ if (verbose > 1)
+ show_rate("read", tempfile, &start_time,
+ total_bytes, curr_bytes);
if (++file_num >= files_in_dir)
file_num = 0;
}
if (verbose > 1){
verbose++;
- show_filename("read", tempfile);
+ show_rate("read", tempfile, &start_time,
+ total_bytes, curr_bytes);
printf("\nread complete\n");
verbose--;
}
char *chunk_buf; /* chunk buffer */
int error = 0;
FILE *countfile = NULL;
- char filecount[PATH_MAX];
unsigned long dir_num = 0, dir_num_orig = 0;/* starting directory */
- char c;
+ int c;
progname = strrchr(argv[0], '/') ? strrchr(argv[0], '/') + 1 : argv[0];
- while ((c = (char)getopt_long(argc, argv, "t:rwvplo:h",
- longopts, NULL)) != -1) {
+ while ((c = getopt_long(argc, argv, "c:hlo:pqrs:t:vw",
+ long_opts, NULL)) != -1) {
switch (c) {
case 'c':
- chunksize = (strtoul(optarg, NULL, 0) * ONE_MB);
- if (!chunksize) {
- fprintf(stderr, "%s: Chunk size value should be"
- "a multiple of 1MB\n", progname);
+ chunksize = strtoul(optarg, NULL, 0) * ONE_MB;
+ if (chunksize == 0) {
+ fprintf(stderr, "%s: bad chunk size '%s'\n",
+ optarg, progname);
return -1;
}
break;
dir_num = strtoul(optarg, NULL, 0);
break;
case 'p':
+ file_size = ONE_MB;
+ chunksize = ONE_MB;
+ files_in_dir = 1;
full = 0;
break;
case 'q':
case 'r':
readoption = 1;
break;
+ case 's':
+ file_size = strtoul(optarg, NULL, 0) * ONE_MB;
+ if (file_size == 0) {
+ fprintf(stderr, "%s: bad file size '%s'\n",
+ optarg, progname);
+ return -1;
+ }
+ break;
case 't':
time_st = (time_t)strtoul(optarg, NULL, 0);
break;
- case 'w':
- writeoption = 1;
- break;
case 'v':
verbose++;
break;
+ case 'w':
+ writeoption = 1;
+ break;
case 'h':
default:
fs->super->s_blocks_per_group);
ext2fs_close(fs);
#else
- goto guess;
+ goto guess;
#endif
if (0) { /* ugh */
struct statfs64 statbuf;
- guess:
+guess:
if (statfs64(testdir, &statbuf) == 0) {
num_dirs = (long long)statbuf.f_blocks *
statbuf.f_bsize / (128ULL << 20);
printf("dirs: %u\n", num_dirs);
}
}
-
- file_size = ONE_MB;
- chunksize = ONE_MB;
- files_in_dir = 1;
}
chunk_buf = (char *)calloc(chunksize, 1);
if (chunk_buf == NULL) {
fprintf(stderr, "Memory allocation failed for chunk_buf\n");
return 4;
}
- sprintf(filecount, "%s/%s.filecount", testdir, progname);
+ snprintf(filecount, sizeof(filecount), "%s/%s.filecount",
+ testdir, progname);
if (writeoption) {
(void)mkdir(testdir, dirmode);
error = 3;
goto out;
}
- countfile = fopen(filecount, "w");
- if (countfile != NULL) {
- if (fprintf(countfile, "%lu", num_files) < 1 ||
- fflush(countfile) != 0) {
- fprintf(stderr, "\n%s: writing %s failed :%s\n",
- progname, filecount, strerror(errno));
- }
- fclose(countfile);
- }
dir_num = dir_num_orig;
}
if (readoption) {
if (!writeoption) {
countfile = fopen(filecount, "r");
if (countfile == NULL ||
- fscanf(countfile, "%lu", &num_files) != 1) {
+ fscanf(countfile, "%lu", &num_files) != 1 ||
+ num_files == 0) {
fprintf(stderr, "\n%s: reading %s failed :%s\n",
progname, filecount, strerror(errno));
num_files = num_dirs * files_in_dir;
goto out;
}
}
- error = 0;
+ error = error_count;
out:
free(chunk_buf);
return error;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff