* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*/
/*
* This tool have two working modes
* 1. full mode
* 2. fast mode
- * The full mode is basic mode in which program writes the test pattern
- * on entire disk. The test pattern (device offset and timestamp) is written
- * at the beginning of each 4kB block. When the whole device is full then
- * read operation is performed to verify that the test pattern is correct.
- * In the fast mode the program writes data at the critical locations
+ *
+ * In full mode, the program writes a test pattern on the entire disk.
+ * The test pattern (device offset and timestamp) is written at the
+ * beginning of each 4kB block. When the whole device is full the read
+ * operation is performed to verify that the test pattern is correct.
+ *
+ * In fast mode, the program writes data at the critical locations
* of the device such as start of the device, before and after multiple of 1GB
* offset and at the end.
- * A chunk buffer with default size of 1MB is used to write and read test
+ *
+ * A chunk buffer with default size of 1MB is used to write and read test
* pattern in bulk.
*/
/* Structure for writting test pattern */
struct block_data {
- long long bd_offset;
- time_t bd_time;
+ unsigned long long bd_offset;
+ unsigned long long bd_time;
+ unsigned long long bd_inode;
};
static char *progname; /* name by which this program was run. */
static unsigned verbose = 1; /* prints offset in kB, operation rate */
static int writeoption; /* run test in write_only mode */
const char *devname; /* name of device to be tested. */
static unsigned full = 1; /* flag to full check */
-static int fd;
+static int error_count; /* number of IO errors hit during run */
static int isatty_flag;
static struct option const longopts[] =
{ "verbose", no_argument, 0, 'v' },
{ "write", no_argument, 0, 'w' },
{ "long", no_argument, 0, 'l' },
+ { "full", no_argument, 0, 'l' },
{ 0, 0, 0, 0}
};
void usage(int status)
{
if (status != 0) {
- printf("\nUsage: %s [OPTION]... <device-name> ...\n",
- progname);
- printf("Block device verification tool.\n"
- "\t-t {seconds}, --timestamp, "
- "set test time (default=current time())\n"
- "\t-o {offset}, --offset, "
- "offset in kB of start of test, default=0\n"
- "\t-r, --read run test in verify mode\n"
- "\t-w, --write run test in test-pattern mode, default=rw\n"
- "\t-v, --verbose\n"
- "\t-q, --quiet\n"
- "\t-l, --long, full check of device\n"
- "\t-p, --partial, for partial check (1GB steps)\n"
- "\t-c, --chunksize, IO chunk size, default=1048576\n"
- "\t-f, --force, force test to run without confirmation\n"
- "\t-h, --help display this help and exit\n");
+ printf("\nUsage: %s [OPTION]... <device-name> ...\n",
+ progname);
+ printf("Block device verification tool.\n"
+ "\t-t {seconds}, --timestamp, "
+ "set test time (default=current time())\n"
+ "\t-o {offset}, --offset, "
+ "offset in kB of start of test, default=0\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-q, --quiet\n"
+ "\t-l, --long, --full check of device\n"
+ "\t-p, --partial, for partial check (1GB steps)\n"
+ "\t-c {bytes}, --chunksize, IO size, default=1048576\n"
+ "\t-f, --force, force test to run without confirmation\n"
+ "\t-h, --help, display this help and exit\n");
}
exit(status);
}
*/
static int open_dev(const char *devname, int mode)
{
+ int fd;
#ifdef HAVE_EXT2FS_EXT2FS_H
- int mount_flags;
- char mountpt[80] = "";
+ int mount_flags;
+ char mountpt[80] = "";
if (ext2fs_check_mount_point(devname, &mount_flags, mountpt,
sizeof(mountpt))) {
fprintf(stderr, "%s: Open failed: %s",progname,strerror(errno));
exit(3);
}
- return (fd);
+ return fd;
}
-#undef HAVE_BLKID_BLKID_H /* sigh, RHEL3 systems do not have libblkid.so.1 */
#ifdef HAVE_BLKID_BLKID_H
#include <blkid/blkid.h>
#endif
}
}
fprintf(stderr, "%s: unable to determine size of %s\n",
- progname, devname);
+ progname, devname);
return 0;
#endif
* 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, time_t time_st)
+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;
(char *)chunk_buf < chunk_end;
chunk_buf += BLOCKSIZE, chunk_off += BLOCKSIZE) {
bd = (struct block_data *)chunk_buf;
- if ((bd->bd_offset == chunk_off) && (bd->bd_time == time_st))
+ if ((bd->bd_offset == chunk_off) && (bd->bd_time == time_st) &&
+ (bd->bd_inode == inode_st))
continue;
- fprintf(stderr, "\n%s: verify failed at offset/timestamp "
- "%llu/%lu: found %llu/%lu instead\n", progname,
- chunk_off, time_st, bd->bd_offset, bd->bd_time);
+ 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);
+ error_count++;
return 1;
}
return 0;
* each 4kB(BLOCKSIZE) blocks in chunk_buf.
*/
void fill_chunk(char *chunk_buf, size_t chunksize, loff_t chunk_off,
- time_t time_st)
+ const time_t time_st, const ino_t inode_st)
{
struct block_data *bd;
char *chunk_end;
bd = (struct block_data *)chunk_buf;
bd->bd_offset = chunk_off;
bd->bd_time = time_st;
+ bd->bd_inode = inode_st;
}
}
}
/*
- * 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.
+ */
+size_t 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;
+ 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(unsigned long long offset, unsigned long long write_end,
- char *chunk_buf, size_t chunksize, time_t time_st)
+int write_chunks(int fd, unsigned long long offset,unsigned long long write_end,
+ char *chunk_buf, size_t chunksize, const time_t time_st,
+ const ino_t inode_st, const char *file)
{
unsigned long long stride, count = 0;
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(%llu) failed: %s\n",
- progname, offset, strerror(errno));
- return 1;
+ fprintf(stderr, "\n%s: lseek64(%s+%llu) failed: %s\n",
+ progname, file, offset, strerror(errno));
+ return -errno;
}
if (offset + chunksize > write_end)
chunksize = write_end - offset;
-
if (!full && offset > chunksize) {
- fill_chunk(chunk_buf, chunksize, offset, time_st);
- if (write(fd, chunk_buf, chunksize) < 0) {
- fprintf(stderr, "\n%s: write %llu failed: %s\n",
- progname, offset, strerror(errno));
- return 1;
- }
+ fill_chunk(chunk_buf, chunksize, offset, time_st,
+ inode_st);
+ ret = write_retry(fd, chunk_buf, chunksize,
+ offset, file);
+ if (ret < 0)
+ return ret;
offset += chunksize;
+ count += chunksize;
if (offset + chunksize > write_end)
chunksize = write_end - offset;
}
-
- fill_chunk(chunk_buf, chunksize, offset, time_st);
- if (write(fd, chunk_buf, chunksize) < 0) {
- fprintf(stderr, "\n%s: write %llu failed: %s\n",
- progname, offset, strerror(errno));
- return 1;
- }
+ fill_chunk(chunk_buf, chunksize, offset, time_st, inode_st);
+ ret = write_retry(fd, chunk_buf, chunksize, offset, file);
+ if (ret < 0)
+ return ret;
count += chunksize;
if (verbose > 1)
show_rate("write", offset, &count);
}
+
if (verbose > 1) {
show_rate("write", offset, &count);
printf("\nwrite complete\n");
}
if (fsync(fd) == -1) {
- fprintf(stderr, "%s: fsync faild: %s\n", progname,
+ fprintf(stderr, "%s: fsync failed: %s\n", progname,
strerror(errno));
- return 1;
+ return -errno;
}
return 0;
}
* read_chunk: reads the chunk_buf from the device. The number of read
* operations are based on the parameters read_end, offset, and chunksize.
*/
-int read_chunks(unsigned long long offset, unsigned long long read_end,
- char *chunk_buf, size_t chunksize, time_t time_st)
+int read_chunks(int fd, unsigned long long offset, unsigned long long read_end,
+ char *chunk_buf, size_t chunksize, const time_t time_st,
+ const ino_t inode_st, const char *file)
{
unsigned long long stride, count = 0;
- stride = full ? chunksize : (ONE_GB - chunksize);
-
if (ioctl(fd, BLKFLSBUF, 0) < 0 && verbose)
fprintf(stderr, "%s: ioctl BLKFLSBUF failed: %s (ignoring)\n",
progname, strerror(errno));
+ 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(%llu) failed: %s\n",
progname, offset, strerror(errno));
chunksize = read_end - offset;
if (!full && offset > chunksize) {
- if (read (fd, chunk_buf, chunksize) < 0) {
- fprintf(stderr, "\n%s: read %llu failed: %s\n",
- progname, 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) != 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;
+ count += 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) {
+ nread = read(fd, chunk_buf, chunksize);
+ if (nread < 0) {
fprintf(stderr, "\n%s: read failed: %s\n", progname,
strerror(errno));
+ error_count++;
return 1;
}
+ 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, chunksize, offset, time_st) != 0)
+ if (verify_chunk(chunk_buf, nread, offset, time_st,
+ inode_st, file) != 0)
return 1;
count += chunksize;
unsigned long long dev_size = 0;
char yesno[4];
int mode = O_RDWR; /* mode which device should be opened */
+ int fd;
int error = 0, c;
progname = strrchr(argv[0], '/') == NULL ?
goto close_dev;
}
if (writeoption) {
- if (write_chunks(offset, dev_size, chunk_buf, chunksize,
- time_st)) {
+ c = write_chunks(fd, offset, dev_size, chunk_buf, chunksize,
+ time_st, 0, devname);
+ if (c < 0 && c != -ENOSPC) {
error = 3;
goto chunk_buf;
}
- if (!full) { /* end of device aligned to a block */
+ if (!full) { /* end of device aligned to a block */
offset = ((dev_size - chunksize + BLOCKSIZE - 1) &
~(BLOCKSIZE - 1));
- if (write_chunks(offset, dev_size, chunk_buf, chunksize,
- time_st)) {
+ c = write_chunks(fd, offset, dev_size, chunk_buf,
+ chunksize, time_st, 0, devname);
+ if (c < 0 && c != -ENOSPC) {
error = 3;
goto chunk_buf;
}
offset = offset_orig;
}
if (readoption) {
- if (read_chunks(offset, dev_size, chunk_buf, chunksize,
- time_st)) {
+ if (read_chunks(fd, offset, dev_size, chunk_buf, chunksize,
+ time_st, 0, devname)) {
error = 2;
goto chunk_buf;
}
if (!full) { /* end of device aligned to a block */
offset = ((dev_size - chunksize + BLOCKSIZE - 1) &
~(BLOCKSIZE - 1));
- if (read_chunks(offset, dev_size, chunk_buf, chunksize,
- time_st)) {
+ if (read_chunks(fd, offset, dev_size, chunk_buf,
+ chunksize, time_st, 0, devname)) {
error = 2;
goto chunk_buf;
}
if (verbose)
printf("\n%s: data verified successfully\n", progname);
}
- error = 0;
+ error = error_count;
chunk_buf:
free(chunk_buf);
close_dev:
* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*/
/*
*
* lustre/utils/llverfs.c
*
- * ext3 Filesystem Verification Tool.
- * This program tests the correct operation of ext3 filesystem.
+ * 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
+ *
+ * In full mode, the 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 the
+ * whole filesystem is full and then the tool verifies that the data
+ * in all of the test files is correct.
+ *
+ * In fast 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.
*/
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;
{ "help", no_argument, 0, 'h' },
{ "offset", required_argument, 0, 'o' },
{ "long", no_argument, 0, 'l' },
+ { "full", no_argument, 0, 'l' },
{ "partial", required_argument, 0, 'p' },
{ "quiet", required_argument, 0, 'q' },
{ "read", no_argument, 0, 'r' },
+ { "filesize", no_argument, 0, 's' },
{ "timestamp", required_argument, 0, 't' },
{ "verbose", no_argument, 0, 'v' },
{ "write", no_argument, 0, 'w' },
*/
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);
* 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;
+ 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;
}
{
char tempfile[PATH_MAX];
char tempdir[PATH_MAX];
+ FILE *countfile;
struct stat64 file;
int file_num = 999999999;
ino_t inode_st = 0;
#ifdef HAVE_EXT2FS_EXT2FS_H
if (!full && fsetflags(testdir, EXT2_TOPDIR_FL))
fprintf(stderr,
- "\n%s: can't set TOPDIR_FL on %s: %s (ignoring)\n",
+ "\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));
+ return 6;
+ }
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;
}
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)
+ return 1;
break;
+ }
+
+ 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));
+ }
}
+ fclose(countfile);
if (verbose) {
verbose++;
ino_t inode_st = 0;
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)
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;
if (++file_num >= files_in_dir)
file_num = 0;
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 */
int c;
progname = strrchr(argv[0], '/') ? strrchr(argv[0], '/') + 1 : argv[0];
- while ((c = getopt_long(argc, argv, "t:rwvplo:h",
+ while ((c = getopt_long(argc, argv, "c:hlo:pqrs:t:vw",
longopts, 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) {
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;