generic: Add more SEEK_HOLE tests

Add tests for bugs found in ext4 & xfs SEEK_HOLE implementations
fixed by following patches:

xfs: Fix missed holes in SEEK_HOLE implementation
ext4: Fix SEEK_HOLE

We add tests to seek_sanity_test as it is easiest to reuse its
infrastructure for seek tests, however not to regress generic/285
which uses seek_sanity_test we don't run new tests by default.
Instead we add options to select a range of tests to run and run new
tests from this new test.

[eguan: add $tmp definition and cleanup $tmp.* on exit]

Signed-off-by: Jan Kara <jack@suse.cz>
Reviewed-by: Eryu Guan <eguan@redhat.com>
Signed-off-by: Eryu Guan <eguan@redhat.com>

diff --git a/src/seek_sanity_test.c b/src/seek_sanity_test.c
index 0f5c22e7f4506139b0b1d5c3049ff7ebad1771de..d52e2b6dab795232dfb03f1bef67b17f9e2fa8c5 100644 (file)
--- a/src/seek_sanity_test.c
+++ b/src/seek_sanity_test.c
@@ -245,6 +245,201 @@ out:
        return ret;
 }
 
+/*
+ * test file with unwritten extents, having non-contiguous dirty pages in
+ * the unwritten extent.
+ */
+static int test16(int fd, int testnum)
+{
+       int ret = 0;
+       char *buf = NULL;
+       int bufsz = sysconf(_SC_PAGE_SIZE);
+       int filsz = 4 << 20;
+
+       /* HOLE - unwritten DATA in dirty page */
+       /* Each unit is bufsz */
+       buf = do_malloc(bufsz);
+       if (!buf)
+               goto out;
+       memset(buf, 'a', bufsz);
+
+       /* preallocate 4M space to file */
+       ret = do_fallocate(fd, 0, filsz, 0);
+       if (ret < 0) {
+               /* Report success if fs doesn't support fallocate */
+               if (errno == EOPNOTSUPP) {
+                       fprintf(stdout, "Test skipped as fs doesn't support fallocate.\n");
+                       ret = 0;
+               }
+               goto out;
+       }
+
+       ret = do_pwrite(fd, buf, bufsz, 0);
+       if (ret)
+               goto out;
+
+       ret = do_pwrite(fd, buf, bufsz, filsz/2);
+       if (ret)
+               goto out;
+
+       /* offset at the beginning */
+       ret += do_lseek(testnum,  1, fd, filsz, SEEK_HOLE, 0, bufsz);
+       ret += do_lseek(testnum,  2, fd, filsz, SEEK_HOLE, 1, bufsz);
+       ret += do_lseek(testnum,  3, fd, filsz, SEEK_DATA, 0, 0);
+       ret += do_lseek(testnum,  4, fd, filsz, SEEK_DATA, 1, 1);
+       ret += do_lseek(testnum,  5, fd, filsz, SEEK_DATA, bufsz, filsz/2);
+       ret += do_lseek(testnum,  6, fd, filsz, SEEK_HOLE, filsz/2,
+                       filsz/2 + bufsz);
+
+out:
+       do_free(buf);
+       return ret;
+}
+
+/*
+ * test file with unwritten extents, having page just after end of unwritten
+ * extent.
+ */
+static int test15(int fd, int testnum)
+{
+       int ret = 0;
+       char *buf = NULL;
+       int bufsz = sysconf(_SC_PAGE_SIZE);
+       int filsz = 4 << 20;
+
+       /* HOLE - unwritten DATA in dirty page */
+       /* Each unit is bufsz */
+       buf = do_malloc(bufsz);
+       if (!buf)
+               goto out;
+       memset(buf, 'a', bufsz);
+
+       /* preallocate 4M space to file */
+       ret = do_fallocate(fd, 0, filsz, 0);
+       if (ret < 0) {
+               /* Report success if fs doesn't support fallocate */
+               if (errno == EOPNOTSUPP) {
+                       fprintf(stdout, "Test skipped as fs doesn't support fallocate.\n");
+                       ret = 0;
+               }
+               goto out;
+       }
+
+       ret = do_pwrite(fd, buf, bufsz, 0);
+       if (ret)
+               goto out;
+
+       /* One page written just after end of unwritten extent... */
+       ret = do_pwrite(fd, buf, bufsz, filsz);
+       if (ret)
+               goto out;
+
+       /* offset at the beginning */
+       ret += do_lseek(testnum,  1, fd, filsz, SEEK_HOLE, 0, bufsz);
+       ret += do_lseek(testnum,  2, fd, filsz, SEEK_HOLE, 1, bufsz);
+       ret += do_lseek(testnum,  3, fd, filsz, SEEK_DATA, 0, 0);
+       ret += do_lseek(testnum,  4, fd, filsz, SEEK_DATA, 1, 1);
+       ret += do_lseek(testnum,  5, fd, filsz, SEEK_DATA, bufsz, filsz);
+
+out:
+       do_free(buf);
+       return ret;
+}
+
+/*
+ * test file with unwritten extents, only have pagevec worth of dirty pages
+ * in page cache, a hole and then another page.
+ */
+static int test14(int fd, int testnum)
+{
+       int ret = 0;
+       char *buf = NULL;
+       int bufsz = sysconf(_SC_PAGE_SIZE) * 14;
+       int filsz = 4 << 20;
+
+       /* HOLE - unwritten DATA in dirty page */
+       /* Each unit is bufsz */
+       buf = do_malloc(bufsz);
+       if (!buf)
+               goto out;
+       memset(buf, 'a', bufsz);
+
+       /* preallocate 4M space to file */
+       ret = do_fallocate(fd, 0, filsz, 0);
+       if (ret < 0) {
+               /* Report success if fs doesn't support fallocate */
+               if (errno == EOPNOTSUPP) {
+                       fprintf(stdout, "Test skipped as fs doesn't support fallocate.\n");
+                       ret = 0;
+               }
+               goto out;
+       }
+
+       ret = do_pwrite(fd, buf, bufsz, 0);
+       if (ret)
+               goto out;
+
+       ret = do_pwrite(fd, buf, bufsz, 3 * bufsz);
+       if (ret)
+               goto out;
+
+       /* offset at the beginning */
+       ret += do_lseek(testnum,  1, fd, filsz, SEEK_HOLE, 0, bufsz);
+       ret += do_lseek(testnum,  2, fd, filsz, SEEK_HOLE, 1, bufsz);
+       ret += do_lseek(testnum,  3, fd, filsz, SEEK_HOLE, 3 * bufsz, 4 * bufsz);
+       ret += do_lseek(testnum,  4, fd, filsz, SEEK_DATA, 0, 0);
+       ret += do_lseek(testnum,  5, fd, filsz, SEEK_DATA, 1, 1);
+       ret += do_lseek(testnum,  6, fd, filsz, SEEK_DATA, bufsz, 3 * bufsz);
+
+out:
+       do_free(buf);
+       return ret;
+}
+
+/*
+ * test file with unwritten extents, only have pagevec worth of dirty pages
+ * in page cache.
+ */
+static int test13(int fd, int testnum)
+{
+       int ret = 0;
+       char *buf = NULL;
+       int bufsz = sysconf(_SC_PAGE_SIZE) * 14;
+       int filsz = 4 << 20;
+
+       /* HOLE - unwritten DATA in dirty page */
+       /* Each unit is bufsz */
+       buf = do_malloc(bufsz);
+       if (!buf)
+               goto out;
+       memset(buf, 'a', bufsz);
+
+       /* preallocate 4M space to file */
+       ret = do_fallocate(fd, 0, filsz, 0);
+       if (ret < 0) {
+               /* Report success if fs doesn't support fallocate */
+               if (errno == EOPNOTSUPP) {
+                       fprintf(stdout, "Test skipped as fs doesn't support fallocate.\n");
+                       ret = 0;
+               }
+               goto out;
+       }
+
+       ret = do_pwrite(fd, buf, bufsz, 0);
+       if (ret)
+               goto out;
+
+       /* offset at the beginning */
+       ret += do_lseek(testnum,  1, fd, filsz, SEEK_HOLE, 0, bufsz);
+       ret += do_lseek(testnum,  2, fd, filsz, SEEK_HOLE, 1, bufsz);
+       ret += do_lseek(testnum,  3, fd, filsz, SEEK_DATA, 0, 0);
+       ret += do_lseek(testnum,  4, fd, filsz, SEEK_DATA, 1, 1);
+
+out:
+       do_free(buf);
+       return ret;
+}
+
 /*
  * Test huge file to check for overflows of block counts due to usage of
  * 32-bit types.
@@ -678,6 +873,10 @@ struct testrec seek_tests[] = {
        { 10, test10, "Test a huge file for offset overflow" },
        { 11, test11, "Test a huge file for block number signed" },
        { 12, test12, "Test a huge file for block number overflow" },
+       { 13, test13, "Test file with unwritten extents, only have pagevec dirty pages" },
+       { 14, test14, "Test file with unwritten extents, small hole after pagevec dirty pages" },
+       { 15, test15, "Test file with unwritten extents, page after unwritten extent" },
+       { 16, test16, "Test file with unwritten extents, non-contiguous dirty pages" },
 };
 
 static int run_test(struct testrec *tr)
@@ -786,7 +985,7 @@ out:
 
 void usage(char *cmd)
 {
-       fprintf(stdout, "Usage: %s [-t] base_file_path\n", cmd);
+       fprintf(stdout, "Usage: %s [-t] [-s <starttest>] [-e <endtest>] base_file_path\n", cmd);
        exit(1);
 }
 
@@ -797,12 +996,37 @@ int main(int argc, char **argv)
        int opt;
        int check_support = 0;
        int numtests = sizeof(seek_tests) / sizeof(struct testrec);
+       int teststart, testend;
 
-       while ((opt = getopt(argc, argv, "t")) != -1) {
+       /*
+        * First twelve tests are used by generic/285. To run these is the
+        * default. Further tests are run e.g. by generic/436. They are not
+        * run by default in order to not regress older kernels.
+        */
+       teststart = 1;
+       testend = 12;
+
+       while ((opt = getopt(argc, argv, "ts:e:")) != -1) {
                switch (opt) {
                case 't':
                        check_support++;
                        break;
+               case 's':
+                       teststart = strtol(optarg, NULL, 10);
+                       if (teststart <= 0 || teststart > numtests) {
+                               fprintf(stdout, "Invalid starting test: %s\n",
+                                       optarg);
+                               usage(argv[0]);
+                       }
+                       break;
+               case 'e':
+                       testend = strtol(optarg, NULL, 10);
+                       if (testend <= 0 || testend > numtests) {
+                               fprintf(stdout, "Invalid final test: %s\n",
+                                       optarg);
+                               usage(argv[0]);
+                       }
+                       break;
                default:
                        usage(argv[0]);
                }
@@ -812,6 +1036,11 @@ int main(int argc, char **argv)
        if (optind != argc - 1)
                usage(argv[0]);
 
+       if (teststart > testend) {
+               fprintf(stdout, "Starting test is larger than final test!\n");
+               usage(argv[0]);
+       }
+
        base_file_path = (char *)strdup(argv[optind]);
 
        ret = test_basic_support();
@@ -819,9 +1048,12 @@ int main(int argc, char **argv)
                goto out;
 
        for (i = 0; i < numtests; ++i) {
-               ret = run_test(&seek_tests[i]);
-               if (ret)
-                       break;
+               if (seek_tests[i].test_num >= teststart &&
+                   seek_tests[i].test_num <= testend) {
+                       ret = run_test(&seek_tests[i]);
+                       if (ret)
+                               break;
+               }
        }
 
 out:

diff --git a/tests/generic/436 b/tests/generic/436
new file mode 100755 (executable)
index 0000000..bcd6ddc
--- /dev/null
+++ b/tests/generic/436
@@ -0,0 +1,64 @@
+#! /bin/bash
+# FS QA Test No. 436
+#
+# More SEEK_DATA/SEEK_HOLE sanity tests.
+#
+#-----------------------------------------------------------------------
+# Copyright (c) 2017 SUSE.  All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it would 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 for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write the Free Software Foundation,
+# Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#-----------------------------------------------------------------------
+#
+
+seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+echo "QA output created by $seq"
+
+here=`pwd`
+tmp=$$
+status=1       # failure is the default!
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common/rc
+. ./common/filter
+
+_supported_fs generic
+_supported_os Linux
+
+_require_test
+_require_seek_data_hole
+
+BASE_TEST_FILE=$TEST_DIR/seek_sanity_testfile
+
+_require_test_program "seek_sanity_test"
+
+# Disable extent zeroing for ext4 as that change where holes are created
+if [ "$FSTYP" = "ext4" ]; then
+       DEV=`_short_dev $TEST_DEV`
+       echo 0 >/sys/fs/ext4/$DEV/extent_max_zeroout_kb
+fi
+
+_cleanup()
+{
+       rm -f $tmp.* $BASE_TEST_FILE.*
+}
+
+$here/src/seek_sanity_test -s 13 -e 16 $BASE_TEST_FILE > $seqres.full 2>&1 ||
+       _fail "seek sanity check failed!"
+
+# success, all done
+echo "Silence is golden"
+status=0
+exit

diff --git a/tests/generic/436.out b/tests/generic/436.out
new file mode 100644 (file)
index 0000000..47cd8e1
--- /dev/null
+++ b/tests/generic/436.out
@@ -0,0 +1,2 @@
+QA output created by 436
+Silence is golden

diff --git a/tests/generic/group b/tests/generic/group
index c772f43caa5d826bb49cfdd31f99844950388945..2f97ae749cdeba1338c3b45076536dd2a573d135 100644 (file)
--- a/tests/generic/group
+++ b/tests/generic/group
@@ -438,3 +438,4 @@
 433 auto quick copy
 434 auto quick copy
 435 auto encrypt
+436 auto quick rw