Commit 7b0800d0 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Dan Williams
Browse files

dax: remove dax_capable 



Just open code the block size and dax_dev == NULL checks in the callers.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Acked-by: default avatarMike Snitzer <snitzer@redhat.com>
Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> [erofs]
Reviewed-by: default avatarDan Williams <dan.j.williams@intel.com>
Reviewed-by: default avatarDarrick J. Wong <djwong@kernel.org>
Link: https://lore.kernel.org/r/20211129102203.2243509-9-hch@lst.de


Signed-off-by: default avatarDan Williams <dan.j.williams@intel.com>
parent 679a9949

drivers/dax/super.c

+0 −36
Original line number Diff line number Diff line
@@ -107,42 +107,6 @@ struct dax_device *fs_dax_get_by_bdev(struct block_device *bdev) 
	return dax_dev;

}

EXPORT_SYMBOL_GPL(fs_dax_get_by_bdev);



bool generic_fsdax_supported(struct dax_device *dax_dev,

		struct block_device *bdev, int blocksize, sector_t start,

		sector_t sectors)

{

	if (blocksize != PAGE_SIZE) {

		pr_info("%pg: error: unsupported blocksize for dax\n", bdev);

		return false;

	}



	if (!dax_dev) {

		pr_debug("%pg: error: dax unsupported by block device\n", bdev);

		return false;

	}



	return true;

}

EXPORT_SYMBOL_GPL(generic_fsdax_supported);



bool dax_supported(struct dax_device *dax_dev, struct block_device *bdev,

		int blocksize, sector_t start, sector_t len)

{

	bool ret = false;

	int id;



	if (!dax_dev)

		return false;



	id = dax_read_lock();

	if (dax_alive(dax_dev) && dax_dev->ops->dax_supported)

		ret = dax_dev->ops->dax_supported(dax_dev, bdev, blocksize,

						  start, len);

	dax_read_unlock(id);

	return ret;

}

EXPORT_SYMBOL_GPL(dax_supported);

#endif /* CONFIG_BLOCK && CONFIG_FS_DAX */



enum dax_device_flags {

drivers/md/dm-table.c

+11 −11
Original line number Diff line number Diff line
@@ -806,12 +806,14 @@ void dm_table_set_type(struct dm_table *t, enum dm_queue_mode type) 
EXPORT_SYMBOL_GPL(dm_table_set_type);



/* validate the dax capability of the target device span */

int device_not_dax_capable(struct dm_target *ti, struct dm_dev *dev,

static int device_not_dax_capable(struct dm_target *ti, struct dm_dev *dev,

			sector_t start, sector_t len, void *data)

{

	int blocksize = *(int *) data;

	if (dev->dax_dev)

		return false;



	return !dax_supported(dev->dax_dev, dev->bdev, blocksize, start, len);

	DMDEBUG("%pg: error: dax unsupported by block device", dev->bdev);

	return true;

}



/* Check devices support synchronous DAX */
@@ -821,8 +823,8 @@ static int device_not_dax_synchronous_capable(struct dm_target *ti, struct dm_de 
	return !dev->dax_dev || !dax_synchronous(dev->dax_dev);

}



bool dm_table_supports_dax(struct dm_table *t,

			   iterate_devices_callout_fn iterate_fn, int *blocksize)

static bool dm_table_supports_dax(struct dm_table *t,

			   iterate_devices_callout_fn iterate_fn)

{

	struct dm_target *ti;

	unsigned i;
@@ -835,7 +837,7 @@ bool dm_table_supports_dax(struct dm_table *t, 
			return false;



		if (!ti->type->iterate_devices ||

		    ti->type->iterate_devices(ti, iterate_fn, blocksize))

		    ti->type->iterate_devices(ti, iterate_fn, NULL))

			return false;

	}
@@ -862,7 +864,6 @@ static int dm_table_determine_type(struct dm_table *t) 
	struct dm_target *tgt;

	struct list_head *devices = dm_table_get_devices(t);

	enum dm_queue_mode live_md_type = dm_get_md_type(t->md);

	int page_size = PAGE_SIZE;



	if (t->type != DM_TYPE_NONE) {

		/* target already set the table's type */
@@ -906,7 +907,7 @@ static int dm_table_determine_type(struct dm_table *t) 
verify_bio_based:

		/* We must use this table as bio-based */

		t->type = DM_TYPE_BIO_BASED;

		if (dm_table_supports_dax(t, device_not_dax_capable, &page_size) ||

		if (dm_table_supports_dax(t, device_not_dax_capable) ||

		    (list_empty(devices) && live_md_type == DM_TYPE_DAX_BIO_BASED)) {

			t->type = DM_TYPE_DAX_BIO_BASED;

		}
@@ -1976,7 +1977,6 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q, 
			      struct queue_limits *limits)

{

	bool wc = false, fua = false;

	int page_size = PAGE_SIZE;

	int r;



	/*
@@ -2010,9 +2010,9 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q, 
	}

	blk_queue_write_cache(q, wc, fua);



	if (dm_table_supports_dax(t, device_not_dax_capable, &page_size)) {

	if (dm_table_supports_dax(t, device_not_dax_capable)) {

		blk_queue_flag_set(QUEUE_FLAG_DAX, q);

		if (dm_table_supports_dax(t, device_not_dax_synchronous_capable, NULL))

		if (dm_table_supports_dax(t, device_not_dax_synchronous_capable))

			set_dax_synchronous(t->md->dax_dev);

	}

	else

drivers/md/dm.c

+0 −21
Original line number Diff line number Diff line
@@ -1027,26 +1027,6 @@ static long dm_dax_direct_access(struct dax_device *dax_dev, pgoff_t pgoff, 
	return ret;

}



static bool dm_dax_supported(struct dax_device *dax_dev, struct block_device *bdev,

		int blocksize, sector_t start, sector_t len)

{

	struct mapped_device *md = dax_get_private(dax_dev);

	struct dm_table *map;

	bool ret = false;

	int srcu_idx;



	map = dm_get_live_table(md, &srcu_idx);

	if (!map)

		goto out;



	ret = dm_table_supports_dax(map, device_not_dax_capable, &blocksize);



out:

	dm_put_live_table(md, srcu_idx);



	return ret;

}



static size_t dm_dax_copy_from_iter(struct dax_device *dax_dev, pgoff_t pgoff,

				    void *addr, size_t bytes, struct iov_iter *i)

{
@@ -3044,7 +3024,6 @@ static const struct block_device_operations dm_rq_blk_dops = { 


static const struct dax_operations dm_dax_ops = {

	.direct_access = dm_dax_direct_access,

	.dax_supported = dm_dax_supported,

	.copy_from_iter = dm_dax_copy_from_iter,

	.copy_to_iter = dm_dax_copy_to_iter,

	.zero_page_range = dm_dax_zero_page_range,

drivers/md/dm.h

+0 −4
Original line number Diff line number Diff line
@@ -73,10 +73,6 @@ bool dm_table_bio_based(struct dm_table *t); 
bool dm_table_request_based(struct dm_table *t);

void dm_table_free_md_mempools(struct dm_table *t);

struct dm_md_mempools *dm_table_get_md_mempools(struct dm_table *t);

bool dm_table_supports_dax(struct dm_table *t, iterate_devices_callout_fn fn,

			   int *blocksize);

int device_not_dax_capable(struct dm_target *ti, struct dm_dev *dev,

			   sector_t start, sector_t len, void *data);



void dm_lock_md_type(struct mapped_device *md);

void dm_unlock_md_type(struct mapped_device *md);

drivers/nvdimm/pmem.c

+0 −1
Original line number Diff line number Diff line
@@ -321,7 +321,6 @@ static size_t pmem_copy_to_iter(struct dax_device *dax_dev, pgoff_t pgoff, 


static const struct dax_operations pmem_dax_ops = {

	.direct_access = pmem_dax_direct_access,

	.dax_supported = generic_fsdax_supported,

	.copy_from_iter = pmem_copy_from_iter,

	.copy_to_iter = pmem_copy_to_iter,

	.zero_page_range = pmem_dax_zero_page_range,