dm log writes: Add support for inline data buffers

Now that we have the ability log filesystem writes using a flat buffer, add support for DAX. Unfortunately we can't easily track data that has been written via mmap() now that the dax_flush() abstraction was removed by this commit:

commit c3ca015fab6d ("dax: remove the pmem_dax_ops->flush abstraction")

Otherwise we could just treat each flush as a big write, and store the data that is being synced to media. It may be worthwhile to add the dax_flush() entry point back, just as a notifier so we can do this logging.

The motivation for this support is the need for an xfstest that can test the new MAP_SYNC DAX flag. By logging the filesystem activity with dm-log-writes we can show that the MAP_SYNC page faults are writing out their metadata as they happen, instead of requiring an explicit msync/fsync.

Signed-off-by Ross Zwisler <[email protected]>

---

Quoted 11 lines · Ross Zwisler

Now that we have the ability log filesystem writes using a flat buffer, add support for DAX. Unfortunately we can't easily track data that has been written via mmap() now that the dax_flush() abstraction was removed by this commit:

commit c3ca015fab6d ("dax: remove the pmem_dax_ops->flush abstraction")

Otherwise we could just treat each flush as a big write, and store the data that is being synced to media. It may be worthwhile to add the dax_flush() entry point back, just as a notifier so we can do this logging.

Quoted 8 lines

The motivation for this support is the need for an xfstest that can test the new MAP_SYNC DAX flag. By logging the filesystem activity with dm-log-writes we can show that the MAP_SYNC page faults are writing out their metadata as they happen, instead of requiring an explicit msync/fsync.

Signed-off-by Ross Zwisler <[email protected]>

---

Ok this is just my ignorance of how DAX works shining through, but do we need a new flag to indicate this is DAX data? You are logging it like it's just normal data going to a certain sector, is that good enough? If it is then hooray this looks fine to me, I'm just slightly confused. Thanks,

Josef

Now that we have the ability log filesystem writes using a flat buffer, add support for DAX. Unfortunately we can't easily track data that has been written via mmap() now that the dax_flush() abstraction was removed by this commit:

commit c3ca015fab6d ("dax: remove the pmem_dax_ops->flush abstraction")

Otherwise we could just treat each flush as a big write, and store the data that is being synced to media. It may be worthwhile to add the dax_flush() entry point back, just as a notifier so we can do this logging.

The motivation for this support is the need for an xfstest that can test the new MAP_SYNC DAX flag. By logging the filesystem activity with dm-log-writes we can show that the MAP_SYNC page faults are writing out their metadata as they happen, instead of requiring an explicit msync/fsync.

Signed-off-by Ross Zwisler <[email protected]>

Quoted 11 lines · Ross Zwisler

Now that we have the ability log filesystem writes using a flat buffer, add support for DAX. Unfortunately we can't easily track data that has been written via mmap() now that the dax_flush() abstraction was removed by this commit:

commit c3ca015fab6d ("dax: remove the pmem_dax_ops->flush abstraction")

Otherwise we could just treat each flush as a big write, and store the data that is being synced to media. It may be worthwhile to add the dax_flush() entry point back, just as a notifier so we can do this logging.

Quoted 7 lines

The motivation for this support is the need for an xfstest that can test the new MAP_SYNC DAX flag. By logging the filesystem activity with dm-log-writes we can show that the MAP_SYNC page faults are writing out their metadata as they happen, instead of requiring an explicit msync/fsync.

Signed-off-by Ross Zwisler <[email protected]>

I've picked this up, please see:
https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=for-4.15/dm&id=ae613bbb0144e84cb3c0ebfa9f4fd4d1507c2f0e

I tweaked the header and tweaked a couple whitespace nits. Also switched version bump from 1.0.1 to 1.1.0.

Thanks,
Mike

Add a test that exercises DAX's new MAP_SYNC flag.

This test creates a file and writes to it via an mmap(), but never syncs via fsync/msync. This process is tracked via dm-log-writes, then replayed.

If MAP_SYNC is working the dm-log-writes replay will show the test file with the same size that we wrote via the mmap() because each allocating page fault included an implicit metadata sync. If MAP_SYNC isn't working (which you can test by fiddling with the parameters to mmap()) the file will be smaller or missing entirely.

Note that dm-log-writes doesn't track the data that we write via the mmap(), so we can't do any data integrity checking. We can only verify that the metadata writes for the page faults happened.

Signed-off-by Ross Zwisler <[email protected]>

---

For this test to run successfully you'll need both Jan's MAP_SYNC series:

https://www.spinics.net/lists/linux-xfs/msg11852.html

and my series adding DAX support to dm-log-writes:

https://lists.01.org/pipermail/linux-nvdimm/2017-October/012972.html

---
 .gitignore            |  1 +
 common/dmlogwrites    |  1 -
 src/Makefile          |  3 +-
 src/t_map_sync.c      | 74 +++++++++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466     | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466.out |  3 ++
 tests/generic/group   |  1 +
 7 files changed, 158 insertions(+), 2 deletions(-)
 create mode 100644 src/t_map_sync.c
 create mode 100755 tests/generic/466
 create mode 100644 tests/generic/466.out

.gitignore +1 -0

index 2014c08..9fc0695 100644
@@ -119,6 +119,7 @@
 /src/t_getcwd
 /src/t_holes
 /src/t_immutable
+/src/t_map_sync
 /src/t_mmap_cow_race
 /src/t_mmap_dio
 /src/t_mmap_fallocate

common/dmlogwrites +0 -1

index 247c744..5b57df9 100644
@@ -23,7 +23,6 @@ _require_log_writes()
        [ -z "$LOGWRITES_DEV" -o ! -b "$LOGWRITES_DEV" ] && \
                _notrun "This test requires a valid \$LOGWRITES_DEV"
 
-       _exclude_scratch_mount_option dax
        _require_dm_target log-writes
        _require_test_program "log-writes/replay-log"
 }

src/Makefile +2 -1

index 3eb25b1..af7e7e9 100644
@@ -13,7 +13,8 @@ TARGETS = dirstress fill fill2 getpagesize holes lstat64 \
        multi_open_unlink dmiperf unwritten_sync genhashnames t_holes \
        t_mmap_writev t_truncate_cmtime dirhash_collide t_rename_overwrite \
        holetest t_truncate_self t_mmap_dio af_unix t_mmap_stale_pmd \
-       t_mmap_cow_race t_mmap_fallocate fsync-err t_mmap_write_ro
+       t_mmap_cow_race t_mmap_fallocate fsync-err t_mmap_write_ro \
+       t_map_sync
 
 LINUX_TARGETS = xfsctl bstat t_mtab getdevicesize preallo_rw_pattern_reader \
        preallo_rw_pattern_writer ftrunc trunc fs_perms testx looptest \

src/t_map_sync.c new file +7 -0

new file mode 100644
index 0000000..8190f3c
@@ -0,0 +1,74 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>

src/t_map_sync.c new file +17 -0

+ */
+#define MAP_SYNC 0x80000
+#define MAP_SHARED_VALIDATE 0x3
+
+void err_exit(char *op)
+{
+       fprintf(stderr, "%s: %s\n", op, strerror(errno));
+       exit(1);
+}
+
+int main(int argc, char *argv[])
+{
+       int page_size = getpagesize();
+       int len = MiB(1);
+       int i, fd, err;
+       char *data;
+

src/t_map_sync.c new file +10 -0

+       ftruncate(fd, len);
+
+       data = mmap(NULL, len, PROT_READ|PROT_WRITE,
+                       MAP_SHARED_VALIDATE|MAP_SYNC, fd, 0);
+       if (data == MAP_FAILED)
+               err_exit("mmap");
+
+       /*
+        * We intentionally don't sync 'fd' manually.  If MAP_SYNC is working
+        * these allocating page faults will cause the filesystem to sync its

src/t_map_sync.c new file +10 -0

+       err = munmap(data, len);
+       if (err < 0)
+               err_exit("munmap");
+
+       err = close(fd);
+       if (err < 0)
+               err_exit("close");
+
+       return 0;
+}

tests/generic/466 new file +50 -0

new file mode 100755
index 0000000..f39e6dc
@@ -0,0 +1,77 @@
+#! /bin/bash
+# FS QA Test No. 466
+#
+# Use md_log_writes to verify that MAP_SYNC actually syncs metadata during
+# page faults.
+#
+#-----------------------------------------------------------------------
+# Copyright (c) 2017 Intel Corporation.  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`
+status=1       # failure is the default!
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+_cleanup()
+{
+       _log_writes_cleanup
+}
+
+# get standard environment, filters and checks
+. ./common/rc
+. ./common/filter
+. ./common/dmlogwrites
+
+# remove previous $seqres.full before test
+rm -f $seqres.full
+
+# real QA test starts here
+_supported_fs generic
+_supported_os Linux
+_require_log_writes
+_require_scratch_dax

tests/generic/466 new file +8 -0

+du -sh $SCRATCH_MNT/test | _filter_scratch | _filter_spaces
+
+_scratch_unmount
+_check_scratch_fs
+
+echo "Silence is golden"
+status=0
+exit

tests/generic/466.out new file +3 -0

new file mode 100644
index 0000000..4c54d7a
@@ -0,0 +1,3 @@
+QA output created by 466
+1.0M SCRATCH_MNT/test
+Silence is golden

tests/generic/group +1 -1

index fbe0a7f..65328c6 100644
@@ -468,3 +468,4 @@
 463 auto quick clone dangerous
 464 auto rw
 465 auto rw quick aio
+466 auto quick dax
--

2.9.5

--
To unsubscribe from this list: send the line "unsubscribe fstests" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

Add a test that exercises DAX's new MAP_SYNC flag.

This test creates a file and writes to it via an mmap(), but never syncs via fsync/msync. This process is tracked via dm-log-writes, then replayed.

If MAP_SYNC is working the dm-log-writes replay will show the test file with 1MiB of on-media block allocations. This is because each allocating page fault included an implicit metadata sync. If MAP_SYNC isn't working (which you can test by fiddling with the parameters to mmap()) the file will be smaller or missing entirely.

Note that dm-log-writes doesn't track the data that we write via the mmap(), so we can't do any data integrity checking. We can only verify that the metadata writes for the page faults happened.

Signed-off-by Ross Zwisler <[email protected]>

---

Changes since v1:
- Addressed review feedback from Amir. Thank you for the review!

---
 .gitignore            |  1 +
 common/dmlogwrites    |  1 -
 src/Makefile          |  3 +-
 src/t_map_sync.c      | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466     | 76 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466.out |  3 ++
 tests/generic/group   |  1 +
 7 files changed, 175 insertions(+), 2 deletions(-)
 create mode 100644 src/t_map_sync.c
 create mode 100755 tests/generic/466
 create mode 100644 tests/generic/466.out

.gitignore +1 -0

index 2014c08..9fc0695 100644
@@ -119,6 +119,7 @@
 /src/t_getcwd
 /src/t_holes
 /src/t_immutable
+/src/t_map_sync
 /src/t_mmap_cow_race
 /src/t_mmap_dio
 /src/t_mmap_fallocate

common/dmlogwrites +0 -1

index 247c744..5b57df9 100644
@@ -23,7 +23,6 @@ _require_log_writes()
        [ -z "$LOGWRITES_DEV" -o ! -b "$LOGWRITES_DEV" ] && \
                _notrun "This test requires a valid \$LOGWRITES_DEV"
 
-       _exclude_scratch_mount_option dax
        _require_dm_target log-writes
        _require_test_program "log-writes/replay-log"
 }

src/Makefile +2 -1

index 3eb25b1..af7e7e9 100644
@@ -13,7 +13,8 @@ TARGETS = dirstress fill fill2 getpagesize holes lstat64 \
        multi_open_unlink dmiperf unwritten_sync genhashnames t_holes \
        t_mmap_writev t_truncate_cmtime dirhash_collide t_rename_overwrite \
        holetest t_truncate_self t_mmap_dio af_unix t_mmap_stale_pmd \
-       t_mmap_cow_race t_mmap_fallocate fsync-err t_mmap_write_ro
+       t_mmap_cow_race t_mmap_fallocate fsync-err t_mmap_write_ro \
+       t_map_sync
 
 LINUX_TARGETS = xfsctl bstat t_mtab getdevicesize preallo_rw_pattern_reader \
        preallo_rw_pattern_writer ftrunc trunc fs_perms testx looptest \

src/t_map_sync.c new file +92 -0

new file mode 100644
index 0000000..29b546a
@@ -0,0 +1,92 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define MiB(a) ((a)*1024*1024)
+
+/*
+ * These two defines were added to the kernel via commits entitled
+ * "mm: Define MAP_SYNC and VM_SYNC flags" and
+ * "mm: introduce MAP_SHARED_VALIDATE, a mechanism to safely define new mmap
+ * flags", respectively.
+ */
+#ifndef MAP_SYNC
+#define MAP_SYNC 0x80000
+#endif
+
+#ifndef MAP_SHARED_VALIDATE
+#define MAP_SHARED_VALIDATE 0x3
+#endif
+
+void err_exit(char *op)
+{
+       fprintf(stderr, "%s: %s\n", op, strerror(errno));
+       exit(1);
+}
+
+void mark_log(char *logwrites_name, char *mark_name)
+{
+       char command[256];
+
+       snprintf(command, 256, "dmsetup message %s 0 mark %s",
+                       logwrites_name, mark_name);
+
+       if (system(command))
+               err_exit("mark_log");
+}
+
+int main(int argc, char *argv[])
+{
+       int page_size = getpagesize();
+       int len = MiB(1);
+       int i, fd, err;
+       char *data;
+
+       if (argc < 4) {
+               printf("Usage: %s <file> <logwrites_name> <mark_name>\n",
+                               basename(argv[0]));
+               exit(0);
+       }
+
+       fd = open(argv[1], O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR);
+       if (fd < 0)
+               err_exit("fd");
+
+       ftruncate(fd, len);
+
+       data = mmap(NULL, len, PROT_READ|PROT_WRITE,
+                       MAP_SHARED_VALIDATE|MAP_SYNC, fd, 0);
+       if (data == MAP_FAILED)
+               err_exit("mmap");
+
+       /*
+        * We intentionally don't sync 'fd' manually.  If MAP_SYNC is working
+        * these allocating page faults will cause the filesystem to sync its
+        * metadata so that when we replay the dm-log-writes log the test file
+        * will have 1 MiB worth of block allocations.
+        *
+        * dm-log-writes doesn't track the data that we write via the mmap(),
+        * so we can't check that, we can only verify that the metadata writes
+        * happened.
+        */
+       for (i = 0; i < len; i+=page_size)
+               data[i] = 0xff;
+
+       mark_log(argv[2], argv[3]);
+
+       err = munmap(data, len);
+       if (err < 0)
+               err_exit("munmap");
+
+       err = close(fd);
+       if (err < 0)
+               err_exit("close");
+
+       return 0;
+}

tests/generic/466 new file +76 -0

new file mode 100755
index 0000000..592213f
@@ -0,0 +1,76 @@
+#! /bin/bash
+# FS QA Test No. 466
+#
+# Use md_log_writes to verify that MAP_SYNC actually syncs metadata during
+# page faults.
+#
+#-----------------------------------------------------------------------
+# Copyright (c) 2017 Intel Corporation.  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`
+status=1       # failure is the default!
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+_cleanup()
+{
+       _log_writes_cleanup
+}
+
+# get standard environment, filters and checks
+. ./common/rc
+. ./common/filter
+. ./common/dmlogwrites
+
+# remove previous $seqres.full before test
+rm -f $seqres.full
+
+# real QA test starts here
+_supported_fs generic
+_supported_os Linux
+_require_log_writes
+_require_scratch_dax
+_require_test_program "t_map_sync"
+
+_log_writes_init
+_log_writes_mkfs >> $seqres.full 2>&1
+_log_writes_mount -o dax
+
+src/t_map_sync $SCRATCH_MNT/test $LOGWRITES_NAME pre_unmap
+
+# Unmount the scratch dir and tear down the log writes target
+_log_writes_unmount
+_log_writes_remove
+_check_scratch_fs
+
+# check pre-unmap state
+_log_writes_replay_log pre_unmap
+_scratch_mount
+
+# We should see $SCRATCH_MNT/test as having 1MiB in block allocations
+du -sh $SCRATCH_MNT/test | _filter_scratch | _filter_spaces
+
+_scratch_unmount
+_check_scratch_fs
+
+echo "Silence is golden"
+status=0
+exit

tests/generic/466.out new file +3 -0

new file mode 100644
index 0000000..4c54d7a
@@ -0,0 +1,3 @@
+QA output created by 466
+1.0M SCRATCH_MNT/test
+Silence is golden

tests/generic/group +1 -1

index fbe0a7f..65328c6 100644
@@ -468,3 +468,4 @@
 463 auto quick clone dangerous
 464 auto rw
 465 auto rw quick aio
+466 auto quick dax
--

2.9.5

Quoted 15 lines · Ross Zwisler

Add a test that exercises DAX's new MAP_SYNC flag.

This test creates a file and writes to it via an mmap(), but never syncs via fsync/msync. This process is tracked via dm-log-writes, then replayed.

If MAP_SYNC is working the dm-log-writes replay will show the test file with 1MiB of on-media block allocations. This is because each allocating page fault included an implicit metadata sync. If MAP_SYNC isn't working (which you can test by fiddling with the parameters to mmap()) the file will be smaller or missing entirely.

Note that dm-log-writes doesn't track the data that we write via the mmap(), so we can't do any data integrity checking. We can only verify that the metadata writes for the page faults happened.

Quoted 6 lines

Signed-off-by Ross Zwisler <[email protected]>

---

Changes since v1:
- Addressed review feedback from Amir. Thank you for the review!

Looks good.

Quoted 34 lines

---
 .gitignore            |  1 +
 common/dmlogwrites    |  1 -
 src/Makefile          |  3 +-
 src/t_map_sync.c      | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466     | 76 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466.out |  3 ++
 tests/generic/group   |  1 +
 7 files changed, 175 insertions(+), 2 deletions(-)
 create mode 100644 src/t_map_sync.c
 create mode 100755 tests/generic/466
 create mode 100644 tests/generic/466.out

.gitignore +1 -0

index 2014c08..9fc0695 100644
@@ -119,6 +119,7 @@
 /src/t_getcwd
 /src/t_holes
 /src/t_immutable
+/src/t_map_sync
 /src/t_mmap_cow_race
 /src/t_mmap_dio
 /src/t_mmap_fallocate

common/dmlogwrites +0 -0

index 247c744..5b57df9 100644
@@ -23,7 +23,6 @@ _require_log_writes()
        [ -z "$LOGWRITES_DEV" -o ! -b "$LOGWRITES_DEV" ] && \
                _notrun "This test requires a valid \$LOGWRITES_DEV"
 

common/dmlogwrites _require_log_writes() · line 26

Quoted 1 line

common/dmlogwrites +0 -1

-       _exclude_scratch_mount_option dax

common/dmlogwrites _require_log_writes() · line 28

Quoted 3 lines

common/dmlogwrites +0 -0

        _require_dm_target log-writes
        _require_test_program "log-writes/replay-log"
 }

Quoted 60 lines · Amir Goldstein

Quoted 15 lines · Ross Zwisler

Add a test that exercises DAX's new MAP_SYNC flag.

This test creates a file and writes to it via an mmap(), but never syncs via fsync/msync. This process is tracked via dm-log-writes, then replayed.

If MAP_SYNC is working the dm-log-writes replay will show the test file with 1MiB of on-media block allocations. This is because each allocating page fault included an implicit metadata sync. If MAP_SYNC isn't working (which you can test by fiddling with the parameters to mmap()) the file will be smaller or missing entirely.

Note that dm-log-writes doesn't track the data that we write via the mmap(), so we can't do any data integrity checking. We can only verify that the metadata writes for the page faults happened.

Quoted 6 lines

Signed-off-by Ross Zwisler <[email protected]>

---

Changes since v1:
- Addressed review feedback from Amir. Thank you for the review!

Looks good.

Quoted 34 lines

---
 .gitignore            |  1 +
 common/dmlogwrites    |  1 -
 src/Makefile          |  3 +-
 src/t_map_sync.c      | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466     | 76 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466.out |  3 ++
 tests/generic/group   |  1 +
 7 files changed, 175 insertions(+), 2 deletions(-)
 create mode 100644 src/t_map_sync.c
 create mode 100755 tests/generic/466
 create mode 100644 tests/generic/466.out

.gitignore +1 -0

index 2014c08..9fc0695 100644
@@ -119,6 +119,7 @@
 /src/t_getcwd
 /src/t_holes
 /src/t_immutable
+/src/t_map_sync
 /src/t_mmap_cow_race
 /src/t_mmap_dio
 /src/t_mmap_fallocate

common/dmlogwrites +0 -0

index 247c744..5b57df9 100644
@@ -23,7 +23,6 @@ _require_log_writes()
        [ -z "$LOGWRITES_DEV" -o ! -b "$LOGWRITES_DEV" ] && \
                _notrun "This test requires a valid \$LOGWRITES_DEV"
 

Quoted 1 line

common/dmlogwrites _require_log_writes() · line 26

Quoted 1 line

common/dmlogwrites +0 -1

-       _exclude_scratch_mount_option dax

Wait. It this really ok to relax no dax from _require_log_writes()? Shouldn't you check log-write target version or something to verify that log-writes+dax is really supported?
I think you should.

Add a test that exercises DAX's new MAP_SYNC flag.

This test creates a file and writes to it via an mmap(), but never syncs via fsync/msync. This process is tracked via dm-log-writes, then replayed.

If MAP_SYNC is working the dm-log-writes replay will show the test file with 1MiB of on-media block allocations. This is because each allocating page fault included an implicit metadata sync. If MAP_SYNC isn't working (which you can test by fiddling with the parameters to mmap()) the file will be smaller or missing entirely.

Note that dm-log-writes doesn't track the data that we write via the mmap(), so we can't do any data integrity checking. We can only verify that the metadata writes for the page faults happened.

Signed-off-by Ross Zwisler <[email protected]>

src/t_map_sync.c new file +15 -0

@@ -0,0 +1,92 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define MiB(a) ((a)*1024*1024)
+
+/*
+ * These two defines were added to the kernel via commits entitled
+ * "mm: Define MAP_SYNC and VM_SYNC flags" and

src/t_map_sync.c new file +31 -0

+
+void err_exit(char *op)
+{
+	fprintf(stderr, "%s: %s\n", op, strerror(errno));
+	exit(1);
+}
+
+void mark_log(char *logwrites_name, char *mark_name)
+{
+	char command[256];
+
+	snprintf(command, 256, "dmsetup message %s 0 mark %s",
+			logwrites_name, mark_name);
+
+	if (system(command))
+		err_exit("mark_log");
+}
+
+int main(int argc, char *argv[])
+{
+	int page_size = getpagesize();
+	int len = MiB(1);
+	int i, fd, err;
+	char *data;
+
+	if (argc < 4) {
+		printf("Usage: %s <file> <logwrites_name> <mark_name>\n",
+				basename(argv[0]));
+		exit(0);
+	}
+

Quoted 16 lines · Ross Zwisler

Add a test that exercises DAX's new MAP_SYNC flag.

This test creates a file and writes to it via an mmap(), but never syncs via fsync/msync. This process is tracked via dm-log-writes, then replayed.

If MAP_SYNC is working the dm-log-writes replay will show the test file with 1MiB of on-media block allocations. This is because each allocating page fault included an implicit metadata sync. If MAP_SYNC isn't working (which you can test by fiddling with the parameters to mmap()) the file will be smaller or missing entirely.

Note that dm-log-writes doesn't track the data that we write via the mmap(), so we can't do any data integrity checking. We can only verify that the metadata writes for the page faults happened.

Signed-off-by Ross Zwisler <[email protected]>

.....

Quoted 22 lines

src/t_map_sync.c new file +19 -0

@@ -0,0 +1,92 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define MiB(a) ((a)*1024*1024)
+
+/*
+ * These two defines were added to the kernel via commits entitled
+ * "mm: Define MAP_SYNC and VM_SYNC flags" and
+ * "mm: introduce MAP_SHARED_VALIDATE, a mechanism to safely define new mmap
+ * flags", respectively.
+ */
+#ifndef MAP_SYNC

src/t_map_sync.c line 25

Quoted 6 lines

src/t_map_sync.c new file +6 -0

+#define MAP_SYNC 0x80000
+#endif
+
+#ifndef MAP_SHARED_VALIDATE
+#define MAP_SHARED_VALIDATE 0x3
+#endif

Autoconf rules for detecting supported functionality, please...

Quoted 31 lines

src/t_map_sync.c new file +31 -0

+
+void err_exit(char *op)
+{
+	fprintf(stderr, "%s: %s\n", op, strerror(errno));
+	exit(1);
+}
+
+void mark_log(char *logwrites_name, char *mark_name)
+{
+	char command[256];
+
+	snprintf(command, 256, "dmsetup message %s 0 mark %s",
+			logwrites_name, mark_name);
+
+	if (system(command))
+		err_exit("mark_log");
+}
+
+int main(int argc, char *argv[])
+{
+	int page_size = getpagesize();
+	int len = MiB(1);
+	int i, fd, err;
+	char *data;
+
+	if (argc < 4) {
+		printf("Usage: %s <file> <logwrites_name> <mark_name>\n",
+				basename(argv[0]));
+		exit(0);
+	}
+

src/t_map_sync.c line 66

Quoted 10 lines

src/t_map_sync.c new file +10 -0

+	fd = open(argv[1], O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR);
+	if (fd < 0)
+		err_exit("fd");
+
+	ftruncate(fd, len);
+
+	data = mmap(NULL, len, PROT_READ|PROT_WRITE,
+			MAP_SHARED_VALIDATE|MAP_SYNC, fd, 0);
+	if (data == MAP_FAILED)
+		err_exit("mmap");

As I say to all these sorts of one-off test prgrams: please add the new MAP_SYNC flag to xfs_io rather than writing a one-off test program to set it and write some data.

And if we're going to be adding special custom tests just because we need to insert dm-log marks, add that functionality to xfs_io, too.

That way we can create complex custom dm logwrite tests without needing one-off test programs for them all...

src/t_map_sync.c line 70

Quoted 4 lines

src/t_map_sync.c new file +4 -0

+#! /bin/bash
+# FS QA Test No. 466
+#
+# Use md_log_writes to verify that MAP_SYNC actually syncs metadata during

dm_log_writes?

src/t_map_sync.c line 72

Quoted 2 lines

src/t_map_sync.c new file +2 -0

+# We should see $SCRATCH_MNT/test as having 1MiB in block allocations
+du -sh $SCRATCH_MNT/test | _filter_scratch | _filter_spaces

Perhaps stat -c %b $SCRATCH_MNT/test ?

Quoted 1 line · Dave Chinner

Perhaps stat -c %b $SCRATCH_MNT/test ?

Maybe, but doesn't the output of 'stat -c %b' depend on the block size the filesystem is using? I think to use stat I'd have to check both %b and %B, and account for different block sizes, or do some shell math. I think it may be easier to just use du.

Add a test that exercises DAX's new MAP_SYNC flag.

This test creates a file and writes to it via an mmap(), but never syncs via fsync/msync. This process is tracked via dm-log-writes, then replayed.

If MAP_SYNC is working the dm-log-writes replay will show the test file with 1MiB of on-media block allocations. This is because each allocating page fault included an implicit metadata sync. If MAP_SYNC isn't working (which you can test by fiddling with the parameters to mmap()) the file will be smaller or missing entirely.

Note that dm-log-writes doesn't track the data that we write via the mmap(), so we can't do any data integrity checking. We can only verify that the metadata writes for the page faults happened.

Signed-off-by Ross Zwisler <[email protected]>

---

Changes since v2:
- Fixed _require_log_writes() so that DAX will be disallowed if the version of the dm-log-writes target is older than v1.1.0. (Amir)

---
 .gitignore            |  1 +
 common/dmlogwrites    |  4 ++-
 common/rc             |  6 ++--
 src/Makefile          |  3 +-
 src/t_map_sync.c      | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466     | 76 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466.out |  3 ++
 tests/generic/group   |  1 +
 8 files changed, 182 insertions(+), 4 deletions(-)
 create mode 100644 src/t_map_sync.c
 create mode 100755 tests/generic/466
 create mode 100644 tests/generic/466.out

.gitignore +1 -0

index 2014c08..9fc0695 100644
@@ -119,6 +119,7 @@
 /src/t_getcwd
 /src/t_holes
 /src/t_immutable
+/src/t_map_sync
 /src/t_mmap_cow_race
 /src/t_mmap_dio
 /src/t_mmap_fallocate

common/dmlogwrites +0 -0

index 247c744..71d008d 100644

Quoted 17 lines · Ross Zwisler

Add a test that exercises DAX's new MAP_SYNC flag.

This test creates a file and writes to it via an mmap(), but never syncs via fsync/msync. This process is tracked via dm-log-writes, then replayed.

If MAP_SYNC is working the dm-log-writes replay will show the test file with 1MiB of on-media block allocations. This is because each allocating page fault included an implicit metadata sync. If MAP_SYNC isn't working (which you can test by fiddling with the parameters to mmap()) the file will be smaller or missing entirely.

Note that dm-log-writes doesn't track the data that we write via the mmap(), so we can't do any data integrity checking. We can only verify that the metadata writes for the page faults happened.

Signed-off-by Ross Zwisler <[email protected]>

Quoted 5 lines

---

Changes since v2:
- Fixed _require_log_writes() so that DAX will be disallowed if the version of the dm-log-writes target is older than v1.1.0. (Amir)

It seems like your kernel patch bumped the version to 1.0.1...

Quoted 32 lines

---
 .gitignore            |  1 +
 common/dmlogwrites    |  4 ++-
 common/rc             |  6 ++--
 src/Makefile          |  3 +-
 src/t_map_sync.c      | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466     | 76 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/466.out |  3 ++
 tests/generic/group   |  1 +
 8 files changed, 182 insertions(+), 4 deletions(-)
 create mode 100644 src/t_map_sync.c
 create mode 100755 tests/generic/466
 create mode 100644 tests/generic/466.out

.gitignore +1 -0

index 2014c08..9fc0695 100644
@@ -119,6 +119,7 @@
 /src/t_getcwd
 /src/t_holes
 /src/t_immutable
+/src/t_map_sync
 /src/t_mmap_cow_race
 /src/t_mmap_dio
 /src/t_mmap_fallocate

common/dmlogwrites +0 -0

index 247c744..71d008d 100644

common/dmlogwrites _require_log_writes() · line 29

Quoted 8 lines

common/dmlogwrites +3 -1

@@ -23,8 +23,10 @@ _require_log_writes()
        [ -z "$LOGWRITES_DEV" -o ! -b "$LOGWRITES_DEV" ] && \
                _notrun "This test requires a valid \$LOGWRITES_DEV"
 
-       _exclude_scratch_mount_option dax
        _require_dm_target log-writes
+       if [[ ${DMTARGET_VER[0]} == 1 && ${DMTARGET_VER[1]} < 1 ]]; then
+               _exclude_scratch_mount_option dax
+       fi

IMO, this would be better as:

local z=0
_scratch_has_mount_option dax && z=1
_require_dm_target log-writes 1 0 $z

Or something like that

Currently dm-log-writes supports writing filesystem data via BIOs, and writing internal metadata from a flat buffer via write_metadata().

For DAX writes, though, we won't have a BIO, but will instead have an iterator that we'll want to use to fill a flat data buffer.

So, create write_inline_data() which allows us to write filesystem data using a flat buffer as a source, and wire it up in log_one_block().

Signed-off-by Ross Zwisler <[email protected]>