Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 98d82f48 authored by Ross Zwisler's avatar Ross Zwisler Committed by Mike Snitzer
Browse files

dm log writes: add support for DAX 



Now that we have the ability log filesystem writes using a flat buffer, add
support for DAX.

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.

Unfortunately we can't easily track data that has been written via
mmap() now that the dax_flush() abstraction was removed by commit
c3ca015f ("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.

Signed-off-by: default avatarRoss Zwisler <ross.zwisler@linux.intel.com>
Signed-off-by: default avatarMike Snitzer <snitzer@redhat.com>
parent e5a20660

drivers/md/dm-log-writes.c

+87 −1
Original line number Diff line number Diff line
@@ -10,9 +10,11 @@ 
#include <linux/init.h>

#include <linux/blkdev.h>

#include <linux/bio.h>

#include <linux/dax.h>

#include <linux/slab.h>

#include <linux/kthread.h>

#include <linux/freezer.h>

#include <linux/uio.h>



#define DM_MSG_PREFIX "log-writes"
@@ -608,6 +610,51 @@ static int log_mark(struct log_writes_c *lc, char *data) 
	return 0;

}



static int log_dax(struct log_writes_c *lc, sector_t sector, size_t bytes,

		   struct iov_iter *i)

{

	struct pending_block *block;



	if (!bytes)

		return 0;



	block = kzalloc(sizeof(struct pending_block), GFP_KERNEL);

	if (!block) {

		DMERR("Error allocating dax pending block");

		return -ENOMEM;

	}



	block->data = kzalloc(bytes, GFP_KERNEL);

	if (!block->data) {

		DMERR("Error allocating dax data space");

		kfree(block);

		return -ENOMEM;

	}



	/* write data provided via the iterator */

	if (!copy_from_iter(block->data, bytes, i)) {

		DMERR("Error copying dax data");

		kfree(block->data);

		kfree(block);

		return -EIO;

	}



	/* rewind the iterator so that the block driver can use it */

	iov_iter_revert(i, bytes);



	block->datalen = bytes;

	block->sector = bio_to_dev_sectors(lc, sector);

	block->nr_sectors = ALIGN(bytes, lc->sectorsize) >> lc->sectorshift;



	atomic_inc(&lc->pending_blocks);

	spin_lock_irq(&lc->blocks_lock);

	list_add_tail(&block->list, &lc->unflushed_blocks);

	spin_unlock_irq(&lc->blocks_lock);

	wake_up_process(lc->log_kthread);



	return 0;

}



static void log_writes_dtr(struct dm_target *ti)

{

	struct log_writes_c *lc = ti->private;
@@ -873,9 +920,46 @@ static void log_writes_io_hints(struct dm_target *ti, struct queue_limits *limit 
	limits->io_min = limits->physical_block_size;

}



static long log_writes_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,

					 long nr_pages, void **kaddr, pfn_t *pfn)

{

	struct log_writes_c *lc = ti->private;

	sector_t sector = pgoff * PAGE_SECTORS;

	int ret;



	ret = bdev_dax_pgoff(lc->dev->bdev, sector, nr_pages * PAGE_SIZE, &pgoff);

	if (ret)

		return ret;

	return dax_direct_access(lc->dev->dax_dev, pgoff, nr_pages, kaddr, pfn);

}



static size_t log_writes_dax_copy_from_iter(struct dm_target *ti,

					    pgoff_t pgoff, void *addr, size_t bytes,

					    struct iov_iter *i)

{

	struct log_writes_c *lc = ti->private;

	sector_t sector = pgoff * PAGE_SECTORS;

	int err;



	if (bdev_dax_pgoff(lc->dev->bdev, sector, ALIGN(bytes, PAGE_SIZE), &pgoff))

		return 0;



	/* Don't bother doing anything if logging has been disabled */

	if (!lc->logging_enabled)

		goto dax_copy;



	err = log_dax(lc, sector, bytes, i);

	if (err) {

		DMWARN("Error %d logging DAX write", err);

		return 0;

	}

dax_copy:

	return dax_copy_from_iter(lc->dev->dax_dev, pgoff, addr, bytes, i);

}



static struct target_type log_writes_target = {

	.name   = "log-writes",

	.version = {1, 0, 0},

	.version = {1, 1, 0},

	.module = THIS_MODULE,

	.ctr    = log_writes_ctr,

	.dtr    = log_writes_dtr,
@@ -886,6 +970,8 @@ static struct target_type log_writes_target = { 
	.message = log_writes_message,

	.iterate_devices = log_writes_iterate_devices,

	.io_hints = log_writes_io_hints,

	.direct_access = log_writes_dax_direct_access,

	.dax_copy_from_iter = log_writes_dax_copy_from_iter,

};



static int __init dm_log_writes_init(void)