/*
- * Copyright (c) 2000-2003 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2003, 2010 SGI
* All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
#include "global.h"
-unsigned char *valid; /* Bit-vector array showing which blocks have been written */
-int nvalid; /* number of bytes in valid array */
-#define SETBIT(ARRAY, N) ((ARRAY)[(N)/8] |= (1 << ((N)%8)))
-#define BITVAL(ARRAY, N) ((ARRAY)[(N)/8] & (1 << ((N)%8)))
-
#define power_of_2(x) ((x) && !((x) & ((x) - 1)))
#define DEFAULT_FILESIZE ((__uint64_t) (256 * 1024 * 1024))
#define DEFAULT_BLOCKSIZE 512
-__uint64_t filesize;
+#define SETBIT(ARRAY, N) ((ARRAY)[(N)/8] |= (1 << ((N)%8)))
+#define BITVAL(ARRAY, N) ((ARRAY)[(N)/8] & (1 << ((N)%8)))
+
+/* Bit-vector array showing which blocks have been written */
+static unsigned char *valid;
-unsigned int blocksize;
-int count;
-int verbose;
-int wsync;
-int direct;
-int alloconly;
-int rt;
-int extsize; /* used only for real-time */
-int preserve;
-int test;
-__uint64_t fileoffset;
+static __uint64_t filesize;
+static __uint64_t fileoffset;
+static unsigned int blocksize;
+static int count;
+static int verbose;
+static int wsync;
+static int direct;
+static int alloconly;
+static int rt;
+static int extsize; /* used only for real-time */
+static int preserve;
+static int test;
-#define READ_XFER 10 /* block to read at a time when checking */
+#define READ_XFER 256 /* blocks to read at a time when checking */
/*
* Define xfscntl() to mask the difference between the Linux
xfsctl((filename), (fd), XFS_IOC_ ## cmd, (arg))
#endif /* ! __sgi__ */
-void
+static void
usage(char *progname)
{
fprintf(stderr,
}
/* Returns filename if successful or a null pointer if an error occurs */
-
static char *
parseargs(int argc, char *argv[])
{
if ((filesize % blocksize) != 0) {
filesize -= filesize % blocksize;
- printf("filesize not a multiple of blocksize, reducing filesize to %llu\n",
- (unsigned long long)filesize);
+ printf("filesize not a multiple of blocksize, "
+ "reducing filesize to %llu\n",
+ (unsigned long long) filesize);
}
if ((fileoffset % blocksize) != 0) {
fileoffset -= fileoffset % blocksize;
- printf("fileoffset not a multiple of blocksize, reducing fileoffset to %llu\n",
- (unsigned long long)fileoffset);
+ printf("fileoffset not a multiple of blocksize, "
+ "reducing fileoffset to %llu\n",
+ (unsigned long long) fileoffset);
}
if (count > (filesize/blocksize)) {
count = (filesize/blocksize);
- printf("count of blocks written is too large, setting to %d\n",
- count);
+ printf("count of blocks written is too large, "
+ "setting to %d\n", count);
} else if (count < 1) {
count = 1;
- printf("count of blocks written is too small, setting to %d\n",
- count);
+ printf("count of blocks written is too small, "
+ "setting to %d\n", count);
}
- printf("randholes: Seed = %d (use \"-s %d\" to re-execute this test)\n", seed, seed);
+ printf("randholes: Seed = %d (use \"-s %d\" "
+ "to re-execute this test)\n", seed, seed);
srandom(seed);
printf("randholes: blocksize=%d, filesize=%llu, seed=%d\n"
"randholes: count=%d, offset=%llu, extsize=%d\n",
blocksize, (unsigned long long)filesize, seed,
count, (unsigned long long)fileoffset, extsize);
- printf("randholes: verbose=%d, wsync=%d, direct=%d, rt=%d, alloconly=%d, preserve=%d, test=%d\n",
+ printf("randholes: verbose=%d, wsync=%d, direct=%d, "
+ "rt=%d, alloconly=%d, preserve=%d, test=%d\n",
verbose, wsync, direct ? 1 : 0, rt, alloconly, preserve, test);
/* Last argument is the file name. Return it. */
return argv[optind]; /* Success */
}
-int
+/*
+ * Determine the next random block number to which to write.
+ * If an already-written block is selected, choose the next
+ * unused higher-numbered block. Returns the block number,
+ * or -1 if we exhaust available blocks looking for an unused
+ * one.
+ */
+static int
findblock(void)
{
int block, numblocks;
numblocks = filesize / blocksize;
block = random() % numblocks;
- if (BITVAL(valid, block) == 0)
- return(block);
- for ( ; BITVAL(valid, block) != 0; block++) {
- if (block == (numblocks-1))
- block = -1;
+ while (BITVAL(valid, block)) {
+ if (++block == numblocks) {
+ printf("returning block -1\n");
+ return -1;
+ }
}
- if (block == -1)
- printf("returning block -1\n");
- return(block);
+ return block;
}
-void
+static void
dumpblock(int *buffer, __uint64_t offset, int blocksize)
{
int i;
for (i = 0; i < (blocksize / 16); i++) {
printf("%llx: 0x%08x 0x%08x 0x%08x 0x%08x\n",
- (unsigned long long)offset, *buffer, *(buffer + 1), *(buffer + 2),
- *(buffer + 3));
+ (unsigned long long) offset, *buffer, *(buffer + 1),
+ *(buffer + 2), *(buffer + 3));
offset += 16;
buffer += 4;
}
}
-void
+static void
writeblks(char *fname, int fd, size_t alignment)
{
__uint64_t offset;
free(buffer);
}
-int
+static int
readblks(int fd, size_t alignment)
{
__uint64_t offset;
* system; otherwise pointer alignment is fine. Returns the
* alignment multiple, or 0 if an error occurs.
*/
-size_t
+static size_t
get_alignment(char *filename, int fd)
{
struct dioattr dioattr;
int
main(int argc, char *argv[])
{
- int fd, oflags;
- char *filename;
- int r;
- size_t alignment;
+ char *filename;
+ size_t size;
+ int oflags;
+ int fd;
+ size_t alignment;
+ int errors;
filename = parseargs(argc, argv);
if (! filename)
return 1;
/*
- * Open the file, write rand block in random places, read them all
- * back to check for correctness, then close the file.
+ * Allocate a bitmap big enough to track the range of
+ * blocks we'll be dealing with.
*/
- nvalid = (filesize / blocksize) / 8 + 1;
- if ((valid = (unsigned char *)calloc(1, (unsigned)nvalid)) == NULL) {
+ size = (filesize / blocksize) / 8 + 1;
+ valid = malloc(size);
+ if ((valid = malloc(size)) == NULL) {
perror("malloc");
return 1;
}
- oflags=test?(O_RDONLY):(O_RDWR | O_CREAT);
- oflags |= (preserve ? 0 : O_TRUNC) |
- (wsync ? O_SYNC : 0) |
- (direct ? O_DIRECT : 0);
+ /* Lots of arguments affect how we open the file */
+ oflags = test ? O_RDONLY : O_RDWR|O_CREAT;
+ oflags |= preserve ? 0 : O_TRUNC;
+ oflags |= wsync ? O_SYNC : 0;
+ oflags |= direct ? O_DIRECT : 0;
+ /*
+ * Open the file, write rand block in random places, read them all
+ * back to check for correctness, then close the file.
+ */
if ((fd = open(filename, oflags, 0666)) < 0) {
perror("open");
return 1;
}
-
if (rt && realtime_setup(filename, fd))
return 1;
-
alignment = get_alignment(filename, fd);
if (! alignment)
return 1;
- printf(test?"write (skipped)\n":"write\n");
+ printf("write%s\n", test ? " (skipped)" : "");
writeblks(filename, fd, alignment);
+
printf("readback\n");
- r = readblks(fd, alignment);
+ errors = readblks(fd, alignment);
+
if (close(fd) < 0) {
perror("close");
return 1;
}
free(valid);
- if (r) {
- printf("randholes: %d errors found during readback\n", r);
- return 2;
- } else {
- printf("randholes: ok\n");
- return 0;
+ if (errors) {
+ printf("randholes: %d errors found during readback\n", errors);
+ return 2;
}
+
+ printf("randholes: ok\n");
+
+ return 0;
}
+
projects / xfstests-dev.git / commitdiff