xfstests: randholes: only allocate write buffer when needed

If nothing is being written (i.e., in "test" mode), there's no need
for "randholes" to allocate a write buffer.  But to do this we make
this series of changes:
- When "very" verbose (> 1), there's no point in printing the values
  that have just been written to the file.  They are just the file
  offset, and the buffer will not have changed between initializing
  those values and writing it out.
- If we don't print the values at those offsets, then there's no
  need to fill them in at all when we're in test mode.
- Now we only use the write buffer if we're not in test mode,
  so we can skip the allocation.

Signed-off-by: Alex Elder <aelder@sgi.com>
Acked-by: Dave Chinner <david@fromorbit.com>

diff --git a/src/randholes.c b/src/randholes.c
index 7c86f0e614570821f2c32283d337de815bb3023f..4610dfa500b562c5477946b2592e57c62ffcfbcd 100644 (file)
--- a/src/randholes.c
+++ b/src/randholes.c
@@ -233,17 +233,21 @@ writeblks(char *fname, int fd)
        int block;
        struct flock64 fl;
 
-       if (direct)
-               buffer = memalign(diob.d_mem, blocksize);
-       else
-               buffer = malloc(blocksize);
-       if (buffer == NULL) {
-               perror("malloc");
-               exit(1);
+       if (test)
+               buffer = NULL;
+       else {
+               if (direct)
+                       buffer = memalign(diob.d_mem, blocksize);
+               else
+                       buffer = malloc(blocksize);
+               if (buffer == NULL) {
+                       perror("malloc");
+                       exit(1);
+               }
+               memset(buffer, 0, blocksize);
        }
-       memset(buffer, 0, blocksize);
 
-       for (  ; count > 0; count--) {
+       do {
                if (verbose && ((count % 100) == 0)) {
                        printf(".");
                        fflush(stdout);
@@ -285,23 +289,26 @@ bozo!
                                perror("lseek");
                                exit(1);
                        }
-                }
-               *(__uint64_t *)buffer = *(__uint64_t *)(buffer+256) =
-                       fileoffset + offset;
-                if (!test) {
+                       /*
+                        * Before writing, record offset at the base
+                        * of the buffer and at offset 256 bytes
+                        * into it.  We'll verify this when we read
+                        * it back in again.
+                        */
+                       *(__uint64_t *) buffer = fileoffset + offset;
+                       *(__uint64_t *) (buffer + 256) = fileoffset + offset;
+
                        if (write(fd, buffer, blocksize) < blocksize) {
                                perror("write");
                                exit(1);
                        }
                 }
-                if (test && verbose>1) printf("NOT ");
                if (verbose > 1) {
-                       printf("writing data at offset=%llx, value 0x%llx and 0x%llx\n",
-                              (unsigned long long)(fileoffset + offset),
-                              *(unsigned long long *)buffer,
-                              *(unsigned long long *)(buffer+256));
+                       printf("%swriting data at offset=%llx\n",
+                               test ? "NOT " : "",
+                               (unsigned long long) (fileoffset + offset));
                }
-       }
+       } while (--count);
 
        free(buffer);
 }