xfs
[Top] [All Lists]

[PATCH] xfsqa: make hole tests independent of speculative allocation pat

To: xfs@xxxxxxxxxxx
Subject: [PATCH] xfsqa: make hole tests independent of speculative allocation patterns
From: Dave Chinner <david@xxxxxxxxxxxxx>
Date: Tue, 21 Dec 2010 20:02:00 +1100
From: Dave Chinner <dchinner@xxxxxxxxxx>

Many of the "count-the-holes" tests (008, 012, etc) do writes that extend the
file and hence allocation patterns are dependent on speculative allocation
beyond EOF behaviour. Hence if we change that behaviour, these tests all fail
because there is a different pattern of holes.

Make the tests independent of EOF preallocation behaviour by first truncating
the file to the size the test is defined to use. This prevents speculative
prealocation from occurring, and hence changes in such behaviour will not cause
the tests to fail.

Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
---
 203             |    4 ++++
 src/holes.c     |   11 +++++++++++
 src/randholes.c |   10 ++++++++++
 3 files changed, 25 insertions(+), 0 deletions(-)

diff --git a/203 b/203
index 6fae361..be69dfa 100755
--- a/203
+++ b/203
@@ -36,6 +36,10 @@ _write_holes()
        file=$1
        holes=$2
        let writes=$holes+1
+       let fsize=$(($writes * 0x100000))
+
+       # prevent EOF preallocation from affecting results
+       xfs_io -f $file -c "truncate $fsize"
 
        offset=0
        for i in `seq 0 $writes`; do
diff --git a/src/holes.c b/src/holes.c
index 1ad5093..3be8a66 100644
--- a/src/holes.c
+++ b/src/holes.c
@@ -79,6 +79,17 @@ main(int argc, char *argv[])
                perror("open");
                return 1;
        }
+
+       /*
+        * Avoid allocation patterns being perturbed by different speculative
+        * preallocation beyond EOF configurations by first truncating the file
+        * to the expected maximum file size.
+        */
+       if (ftruncate(fd, filesize) < 0) {
+               perror("ftruncate");
+               exit(EXIT_FAILURE);
+       }
+
        for (i = 0; i < count; i++) {
                writeblks(fd, filesize, blocksize, interleave, i, rev);
        }
diff --git a/src/randholes.c b/src/randholes.c
index b7c89b3..b43da81 100644
--- a/src/randholes.c
+++ b/src/randholes.c
@@ -208,6 +208,16 @@ writeblks(char *fname, int fd, size_t alignment)
                memset(buffer, 0, blocksize);
        }
 
+       /*
+        * Avoid allocation patterns being perturbed by different speculative
+        * preallocation beyond EOF configurations by first truncating the file
+        * to the expected maximum file size.
+        */
+       if (ftruncate(fd, filesize) < 0) {
+               perror("ftruncate");
+               exit(EXIT_FAILURE);
+       }
+
        do {
                if (verbose && ((count % 100) == 0)) {
                        printf(".");
-- 
1.7.2.3

<Prev in Thread] Current Thread [Next in Thread>