Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1231140 > unrolled thread

[PATCH 08/15] block, dax, pmem: reference counting infrastructure

Back to article view | Back to linux.kernel

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.

Contents

  [PATCH 08/15] block, dax, pmem: reference counting infrastructure Dan Williams <dan.j.williams@intel.com> - 2015-09-23 06:50 +0200
    Re: [PATCH 08/15] block, dax, pmem: reference counting infrastructure Christoph Hellwig <hch@infradead.org> - 2015-09-24 17:20 +0200
      Re: [PATCH 08/15] block, dax, pmem: reference counting infrastructure Dan Williams <dan.j.williams@intel.com> - 2015-09-25 02:10 +0200
        Re: [PATCH 08/15] block, dax, pmem: reference counting infrastructure Christoph Hellwig <hch@infradead.org> - 2015-09-25 13:40 +0200
          Re: [PATCH 08/15] block, dax, pmem: reference counting  infrastructure "Williams, Dan J" <dan.j.williams@intel.com> - 2015-09-25 23:10 +0200

#1231140 — [PATCH 08/15] block, dax, pmem: reference counting infrastructure

Enable DAX to use a reference count for keeping the virtual address
returned by ->direct_access() valid for the duration of its usage in
fs/dax.c, or otherwise hold off blk_cleanup_queue() while
pmem_make_request is active.  The blk-mq code is already in a position
to need low overhead referece counting for races against request_queue
destruction (blk_cleanup_queue()).  Given DAX-enabled block drivers do
not enable blk-mq, share the storage in 'struct request_queue' between
the two implementations.

Cc: Jens Axboe <axboe@kernel.dk>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
 arch/powerpc/sysdev/axonram.c |    2 -
 block/blk-core.c              |   84 +++++++++++++++++++++++++++++++++++++++++
 block/blk-mq-sysfs.c          |    2 -
 block/blk-mq.c                |   48 ++++++-----------------
 block/blk-sysfs.c             |    9 ++++
 block/blk.h                   |    3 +
 drivers/block/brd.c           |    2 -
 drivers/nvdimm/pmem.c         |    3 +
 drivers/s390/block/dcssblk.c  |    2 -
 include/linux/blkdev.h        |   20 ++++++++--
 10 files changed, 130 insertions(+), 45 deletions(-)

diff --git a/arch/powerpc/sysdev/axonram.c b/arch/powerpc/sysdev/axonram.c
index d2b79bc336c1..24ffab2572e8 100644
--- a/arch/powerpc/sysdev/axonram.c
+++ b/arch/powerpc/sysdev/axonram.c
@@ -228,7 +228,7 @@ static int axon_ram_probe(struct platform_device *device)
 	sprintf(bank->disk->disk_name, "%s%d",
 			AXON_RAM_DEVICE_NAME, axon_ram_bank_id);
 
-	bank->disk->queue = blk_alloc_queue(GFP_KERNEL);
+	bank->disk->queue = blk_dax_init_queue(NUMA_NO_NODE);
 	if (bank->disk->queue == NULL) {
 		dev_err(&device->dev, "Cannot register disk queue\n");
 		rc = -EFAULT;
diff --git a/block/blk-core.c b/block/blk-core.c
index 2eb722d48773..13764f8b22e0 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -26,6 +26,7 @@
 #include <linux/slab.h>
 #include <linux/swap.h>
 #include <linux/writeback.h>
+#include <linux/percpu-refcount.h>
 #include <linux/task_io_accounting_ops.h>
 #include <linux/fault-inject.h>
 #include <linux/list_sort.h>
@@ -497,6 +498,84 @@ void blk_queue_bypass_end(struct request_queue *q)
 }
 EXPORT_SYMBOL_GPL(blk_queue_bypass_end);
 
+int blk_qref_enter(struct request_queue_ref *qref, gfp_t gfp)
+{
+	struct request_queue *q = container_of(qref, typeof(*q), mq_ref);
+
+	while (true) {
+		int ret;
+
+		if (percpu_ref_tryget_live(&qref->count))
+			return 0;
+
+		if (!(gfp & __GFP_WAIT))
+			return -EBUSY;
+
+		ret = wait_event_interruptible(qref->freeze_wq,
+				!atomic_read(&qref->freeze_depth) ||
+				blk_queue_dying(q));
+		if (blk_queue_dying(q))
+			return -ENODEV;
+		if (ret)
+			return ret;
+	}
+}
+
+void blk_qref_release(struct percpu_ref *ref)
+{
+	struct request_queue_ref *qref = container_of(ref, typeof(*qref), count);
+
+	wake_up_all(&qref->freeze_wq);
+}
+
+int blk_dax_get(struct request_queue *q)
+{
+	return blk_qref_enter(&q->dax_ref, GFP_NOWAIT);
+}
+
+void blk_dax_put(struct request_queue *q)
+{
+	percpu_ref_put(&q->dax_ref.count);
+}
+
+static void blk_dax_freeze(struct request_queue *q)
+{
+	if (!blk_queue_dax(q))
+		return;
+
+	if (atomic_inc_return(&q->dax_ref.freeze_depth) == 1)
+		percpu_ref_kill(&q->dax_ref.count);
+
+	wait_event(q->dax_ref.freeze_wq, percpu_ref_is_zero(&q->dax_ref.count));
+}
+
+struct request_queue *blk_dax_init_queue(int nid)
+{
+	struct request_queue *q;
+	int rc;
+
+	q = blk_alloc_queue_node(GFP_KERNEL, nid);
+	if (!q)
+		return ERR_PTR(-ENOMEM);
+	queue_flag_set_unlocked(QUEUE_FLAG_DAX, q);
+
+	rc = percpu_ref_init(&q->dax_ref.count, blk_qref_release, 0,
+			GFP_KERNEL);
+	if (rc) {
+		blk_cleanup_queue(q);
+		return ERR_PTR(rc);
+	}
+	return q;
+}
+EXPORT_SYMBOL(blk_dax_init_queue);
+
+static void blk_dax_exit(struct request_queue *q)
+{
+	if (!blk_queue_dax(q))
+		return;
+	percpu_ref_exit(&q->dax_ref.count);
+}
+
 void blk_set_queue_dying(struct request_queue *q)
 {
 	queue_flag_set_unlocked(QUEUE_FLAG_DYING, q);
@@ -558,6 +637,7 @@ void blk_cleanup_queue(struct request_queue *q)
 		blk_mq_freeze_queue(q);
 		spin_lock_irq(lock);
 	} else {
+		blk_dax_freeze(q);
 		spin_lock_irq(lock);
 		__blk_drain_queue(q, true);
 	}
@@ -570,6 +650,7 @@ void blk_cleanup_queue(struct request_queue *q)
 
 	if (q->mq_ops)
 		blk_mq_free_queue(q);
+	blk_dax_exit(q);
 
 	spin_lock_irq(lock);
 	if (q->queue_lock != &q->__queue_lock)
@@ -688,7 +769,8 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
 	q->bypass_depth = 1;
 	__set_bit(QUEUE_FLAG_BYPASS, &q->queue_flags);
 
-	init_waitqueue_head(&q->mq_freeze_wq);
+	/* this also inits q->dax_ref.freeze_wq in the union */
+	init_waitqueue_head(&q->mq_ref.freeze_wq);
 
 	if (blkcg_init_queue(q))
 		goto fail_bdi;
diff --git a/block/blk-mq-sysfs.c b/block/blk-mq-sysfs.c
index 279c5d674edf..b0fdffa0d4c6 100644
--- a/block/blk-mq-sysfs.c
+++ b/block/blk-mq-sysfs.c
@@ -415,7 +415,7 @@ static void blk_mq_sysfs_init(struct request_queue *q)
 /* see blk_register_queue() */
 void blk_mq_finish_init(struct request_queue *q)
 {
-	percpu_ref_switch_to_percpu(&q->mq_usage_counter);
+	percpu_ref_switch_to_percpu(&q->mq_ref.count);
 }
 
 int blk_mq_register_disk(struct gendisk *disk)
diff --git a/block/blk-mq.c b/block/blk-mq.c
index f2d67b4047a0..494c6e267c9d 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -79,45 +79,21 @@ static void blk_mq_hctx_clear_pending(struct blk_mq_hw_ctx *hctx,
 
 static int blk_mq_queue_enter(struct request_queue *q, gfp_t gfp)
 {
-	while (true) {
-		int ret;
-
-		if (percpu_ref_tryget_live(&q->mq_usage_counter))
-			return 0;
-
-		if (!(gfp & __GFP_WAIT))
-			return -EBUSY;
-
-		ret = wait_event_interruptible(q->mq_freeze_wq,
-				!atomic_read(&q->mq_freeze_depth) ||
-				blk_queue_dying(q));
-		if (blk_queue_dying(q))
-			return -ENODEV;
-		if (ret)
-			return ret;
-	}
+	return blk_qref_enter(&q->mq_ref, gfp);
 }
 
 static void blk_mq_queue_exit(struct request_queue *q)
 {
-	percpu_ref_put(&q->mq_usage_counter);
-}
-
-static void blk_mq_usage_counter_release(struct percpu_ref *ref)
-{
-	struct request_queue *q =
-		container_of(ref, struct request_queue, mq_usage_counter);
-
-	wake_up_all(&q->mq_freeze_wq);
+	percpu_ref_put(&q->mq_ref.count);
 }
 
 void blk_mq_freeze_queue_start(struct request_queue *q)
 {
 	int freeze_depth;
 
-	freeze_depth = atomic_inc_return(&q->mq_freeze_depth);
+	freeze_depth = atomic_inc_return(&q->mq_ref.freeze_depth);
 	if (freeze_depth == 1) {
-		percpu_ref_kill(&q->mq_usage_counter);
+		percpu_ref_kill(&q->mq_ref.count);
 		blk_mq_run_hw_queues(q, false);
 	}
 }
@@ -125,7 +101,7 @@ EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_start);
 
 static void blk_mq_freeze_queue_wait(struct request_queue *q)
 {
-	wait_event(q->mq_freeze_wq, percpu_ref_is_zero(&q->mq_usage_counter));
+	wait_event(q->mq_ref.freeze_wq, percpu_ref_is_zero(&q->mq_ref.count));
 }
 
 /*
@@ -143,11 +119,11 @@ void blk_mq_unfreeze_queue(struct request_queue *q)
 {
 	int freeze_depth;
 
-	freeze_depth = atomic_dec_return(&q->mq_freeze_depth);
+	freeze_depth = atomic_dec_return(&q->mq_ref.freeze_depth);
 	WARN_ON_ONCE(freeze_depth < 0);
 	if (!freeze_depth) {
-		percpu_ref_reinit(&q->mq_usage_counter);
-		wake_up_all(&q->mq_freeze_wq);
+		percpu_ref_reinit(&q->mq_ref.count);
+		wake_up_all(&q->mq_ref.freeze_wq);
 	}
 }
 EXPORT_SYMBOL_GPL(blk_mq_unfreeze_queue);
@@ -166,7 +142,7 @@ void blk_mq_wake_waiters(struct request_queue *q)
 	 * dying, we need to ensure that processes currently waiting on
 	 * the queue are notified as well.
 	 */
-	wake_up_all(&q->mq_freeze_wq);
+	wake_up_all(&q->mq_ref.freeze_wq);
 }
 
 bool blk_mq_can_queue(struct blk_mq_hw_ctx *hctx)
@@ -1983,7 +1959,7 @@ struct request_queue *blk_mq_init_allocated_queue(struct blk_mq_tag_set *set,
 	 * Init percpu_ref in atomic mode so that it's faster to shutdown.
 	 * See blk_register_queue() for details.
 	 */
-	if (percpu_ref_init(&q->mq_usage_counter, blk_mq_usage_counter_release,
+	if (percpu_ref_init(&q->mq_ref.count, blk_qref_release,
 			    PERCPU_REF_INIT_ATOMIC, GFP_KERNEL))
 		goto err_hctxs;
 
@@ -2062,7 +2038,7 @@ void blk_mq_free_queue(struct request_queue *q)
 	blk_mq_exit_hw_queues(q, set, set->nr_hw_queues);
 	blk_mq_free_hw_queues(q, set);
 
-	percpu_ref_exit(&q->mq_usage_counter);
+	percpu_ref_exit(&q->mq_ref.count);
 
 	kfree(q->mq_map);
 
@@ -2076,7 +2052,7 @@ void blk_mq_free_queue(struct request_queue *q)
 /* Basically redo blk_mq_init_queue with queue frozen */
 static void blk_mq_queue_reinit(struct request_queue *q)
 {
-	WARN_ON_ONCE(!atomic_read(&q->mq_freeze_depth));
+	WARN_ON_ONCE(!atomic_read(&q->mq_ref.freeze_depth));
 
 	blk_mq_sysfs_unregister(q);
 
diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
index 3e44a9da2a13..5126a97825de 100644
--- a/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@ -616,6 +616,15 @@ int blk_register_queue(struct gendisk *disk)
 
 	kobject_uevent(&q->kobj, KOBJ_ADD);
 
+	if (q->mq_ops && blk_queue_dax(q)) {
+		/*
+		 * mq_ref and dax_ref share storage in request_queue, so
+		 * we can't have both enabled.
+		 */
+		WARN_ON_ONCE(1);
+		return -EINVAL;
+	}
+
 	if (q->mq_ops)
 		blk_mq_register_disk(disk);
 
diff --git a/block/blk.h b/block/blk.h
index 98614ad37c81..0b898d89e0dd 100644
--- a/block/blk.h
+++ b/block/blk.h
@@ -54,6 +54,9 @@ static inline void __blk_get_queue(struct request_queue *q)
 	kobject_get(&q->kobj);
 }
 
+int blk_qref_enter(struct request_queue_ref *qref, gfp_t gfp);
+void blk_qref_release(struct percpu_ref *percpu_ref);
+
 struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q,
 		int node, int cmd_size);
 void blk_free_flush_queue(struct blk_flush_queue *q);
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index b9794aeeb878..f645a71ae827 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -482,7 +482,7 @@ static struct brd_device *brd_alloc(int i)
 	spin_lock_init(&brd->brd_lock);
 	INIT_RADIX_TREE(&brd->brd_pages, GFP_ATOMIC);
 
-	brd->brd_queue = blk_alloc_queue(GFP_KERNEL);
+	brd->brd_queue = blk_dax_init_queue(NUMA_NO_NODE);
 	if (!brd->brd_queue)
 		goto out_free_dev;
 
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index 9805d311b1d1..a01611d8f351 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -176,9 +176,10 @@ static void pmem_detach_disk(struct pmem_device *pmem)
 static int pmem_attach_disk(struct device *dev,
 		struct nd_namespace_common *ndns, struct pmem_device *pmem)
 {
+	int nid = dev_to_node(dev);
 	struct gendisk *disk;
 
-	pmem->pmem_queue = blk_alloc_queue(GFP_KERNEL);
+	pmem->pmem_queue = blk_dax_init_queue(nid);
 	if (!pmem->pmem_queue)
 		return -ENOMEM;
 
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index 5ed44fe21380..c212ce925ee6 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -610,7 +610,7 @@ dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char
 	}
 	dev_info->gd->major = dcssblk_major;
 	dev_info->gd->fops = &dcssblk_devops;
-	dev_info->dcssblk_queue = blk_alloc_queue(GFP_KERNEL);
+	dev_info->dcssblk_queue = blk_dax_init_queue(NUMA_NO_NODE);
 	dev_info->gd->queue = dev_info->dcssblk_queue;
 	dev_info->gd->private_data = dev_info;
 	dev_info->gd->driverfs_dev = &dev_info->dev;
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 99da9ebc7377..363d7df8d65c 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -277,6 +277,13 @@ struct queue_limits {
 	unsigned char		raid_partial_stripes_expensive;
 };
 
+
+struct request_queue_ref {
+	wait_queue_head_t	freeze_wq;
+	struct percpu_ref	count;
+	atomic_t		freeze_depth;
+};
+
 struct request_queue {
 	/*
 	 * Together with queue_head for cacheline sharing
@@ -436,7 +443,6 @@ struct request_queue {
 	struct mutex		sysfs_lock;
 
 	int			bypass_depth;
-	atomic_t		mq_freeze_depth;
 
 #if defined(CONFIG_BLK_DEV_BSG)
 	bsg_job_fn		*bsg_job_fn;
@@ -449,8 +455,10 @@ struct request_queue {
 	struct throtl_data *td;
 #endif
 	struct rcu_head		rcu_head;
-	wait_queue_head_t	mq_freeze_wq;
-	struct percpu_ref	mq_usage_counter;
+	union {
+		struct request_queue_ref mq_ref;
+		struct request_queue_ref dax_ref;
+	};
 	struct list_head	all_q_node;
 
 	struct blk_mq_tag_set	*tag_set;
@@ -480,6 +488,7 @@ struct request_queue {
 #define QUEUE_FLAG_DEAD        19	/* queue tear-down finished */
 #define QUEUE_FLAG_INIT_DONE   20	/* queue is initialized */
 #define QUEUE_FLAG_NO_SG_MERGE 21	/* don't attempt to merge SG segments*/
+#define QUEUE_FLAG_DAX         22	/* capacity may be direct-mapped */
 
 #define QUEUE_FLAG_DEFAULT	((1 << QUEUE_FLAG_IO_STAT) |		\
 				 (1 << QUEUE_FLAG_STACKABLE)	|	\
@@ -568,6 +577,7 @@ static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
 #define blk_queue_discard(q)	test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
 #define blk_queue_secdiscard(q)	(blk_queue_discard(q) && \
 	test_bit(QUEUE_FLAG_SECDISCARD, &(q)->queue_flags))
+#define blk_queue_dax(q)	test_bit(QUEUE_FLAG_DAX, &(q)->queue_flags)
 
 #define blk_noretry_request(rq) \
 	((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
@@ -1003,6 +1013,10 @@ struct request_queue *blk_alloc_queue_node(gfp_t, int);
 extern void blk_put_queue(struct request_queue *);
 extern void blk_set_queue_dying(struct request_queue *);
 
+struct request_queue *blk_dax_init_queue(int nid);
+int blk_dax_get(struct request_queue *q);
+void blk_dax_put(struct request_queue *q);
+
 /*
  * block layer runtime pm functions
  */

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [next] | [standalone]

#1232184

On Wed, Sep 23, 2015 at 12:41:55AM -0400, Dan Williams wrote:
> Enable DAX to use a reference count for keeping the virtual address
> returned by ->direct_access() valid for the duration of its usage in
> fs/dax.c, or otherwise hold off blk_cleanup_queue() while
> pmem_make_request is active.  The blk-mq code is already in a position
> to need low overhead referece counting for races against request_queue
> destruction (blk_cleanup_queue()).  Given DAX-enabled block drivers do
> not enable blk-mq, share the storage in 'struct request_queue' between
> the two implementations.

Can we just move the refcounting to common code with the same field
name, and even initialize it for non-mq, non-dax queues but just never
tage a reference there (for now)?
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1232500

On Thu, Sep 24, 2015 at 8:15 AM, Christoph Hellwig <hch@infradead.org> wrote:
> On Wed, Sep 23, 2015 at 12:41:55AM -0400, Dan Williams wrote:
>> Enable DAX to use a reference count for keeping the virtual address
>> returned by ->direct_access() valid for the duration of its usage in
>> fs/dax.c, or otherwise hold off blk_cleanup_queue() while
>> pmem_make_request is active.  The blk-mq code is already in a position
>> to need low overhead referece counting for races against request_queue
>> destruction (blk_cleanup_queue()).  Given DAX-enabled block drivers do
>> not enable blk-mq, share the storage in 'struct request_queue' between
>> the two implementations.
>
> Can we just move the refcounting to common code with the same field
> name, and even initialize it for non-mq, non-dax queues but just never
> tage a reference there (for now)?

That makes sense to me, especially because drivers/nvdimm/blk.c is
broken in the same way as drivers/nvdimm/pmem.c and it would be
awkward to have it use blk_dax_get() / blk_dax_put().  The
percpu_refcount should be valid for all queues and it will only ever
be > 1 in the blk_mq and libnvdimm cases (for now).  Will fix.
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1232729

On Thu, Sep 24, 2015 at 05:03:18PM -0700, Dan Williams wrote:
> That makes sense to me, especially because drivers/nvdimm/blk.c is
> broken in the same way as drivers/nvdimm/pmem.c and it would be
> awkward to have it use blk_dax_get() / blk_dax_put().  The
> percpu_refcount should be valid for all queues and it will only ever
> be > 1 in the blk_mq and libnvdimm cases (for now).  Will fix.

Looking at this a bit more it might actually make sense to grab the
referene in common code before calling into ->make_request.

Jens, any opinion on that?
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1233067 — Re: [PATCH 08/15] block, dax, pmem: reference counting infrastructure
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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web