Commit 9f27bd70 authored by Christoph Hellwig's avatar Christoph Hellwig
Browse files

nvme: rename the queue quiescing helpers 



Naming the nvme helpers that wrap the block quiesce functionality
_start/_stop is rather confusing.  Switch to using the quiesce naming
used by the block layer instead.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarSagi Grimberg <sagi@grimberg.me>
Reviewed-by: default avatarChaitanya Kulkarni <kch@nvidia.com>
parent c58e28af

drivers/nvme/host/apple.c

+6 −6
Original line number Diff line number Diff line
@@ -821,7 +821,7 @@ static void apple_nvme_disable(struct apple_nvme *anv, bool shutdown) 
	if (!dead && shutdown && freeze)

		nvme_wait_freeze_timeout(&anv->ctrl, NVME_IO_TIMEOUT);



	nvme_stop_queues(&anv->ctrl);

	nvme_quiesce_io_queues(&anv->ctrl);



	if (!dead) {

		if (READ_ONCE(anv->ioq.enabled)) {
@@ -837,7 +837,7 @@ static void apple_nvme_disable(struct apple_nvme *anv, bool shutdown) 
	WRITE_ONCE(anv->ioq.enabled, false);

	WRITE_ONCE(anv->adminq.enabled, false);

	mb(); /* ensure that nvme_queue_rq() sees that enabled is cleared */

	nvme_stop_admin_queue(&anv->ctrl);

	nvme_quiesce_admin_queue(&anv->ctrl);



	/* last chance to complete any requests before nvme_cancel_request */

	spin_lock_irqsave(&anv->lock, flags);
@@ -854,8 +854,8 @@ static void apple_nvme_disable(struct apple_nvme *anv, bool shutdown) 
	 * deadlocking blk-mq hot-cpu notifier.

	 */

	if (shutdown) {

		nvme_start_queues(&anv->ctrl);

		nvme_start_admin_queue(&anv->ctrl);

		nvme_unquiesce_io_queues(&anv->ctrl);

		nvme_unquiesce_admin_queue(&anv->ctrl);

	}

}
@@ -1093,7 +1093,7 @@ static void apple_nvme_reset_work(struct work_struct *work) 


	dev_dbg(anv->dev, "Starting admin queue");

	apple_nvme_init_queue(&anv->adminq);

	nvme_start_admin_queue(&anv->ctrl);

	nvme_unquiesce_admin_queue(&anv->ctrl);



	if (!nvme_change_ctrl_state(&anv->ctrl, NVME_CTRL_CONNECTING)) {

		dev_warn(anv->ctrl.device,
@@ -1127,7 +1127,7 @@ static void apple_nvme_reset_work(struct work_struct *work) 


	anv->ctrl.queue_count = nr_io_queues + 1;



	nvme_start_queues(&anv->ctrl);

	nvme_unquiesce_io_queues(&anv->ctrl);

	nvme_wait_freeze(&anv->ctrl);

	blk_mq_update_nr_hw_queues(&anv->tagset, 1);

	nvme_unfreeze(&anv->ctrl);

drivers/nvme/host/core.c

+12 −12
Original line number Diff line number Diff line
@@ -4610,7 +4610,7 @@ void nvme_remove_namespaces(struct nvme_ctrl *ctrl) 
	 */

	if (ctrl->state == NVME_CTRL_DEAD) {

		nvme_mark_namespaces_dead(ctrl);

		nvme_start_queues(ctrl);

		nvme_unquiesce_io_queues(ctrl);

	}



	/* this is a no-op when called from the controller reset handler */
@@ -4737,7 +4737,7 @@ static void nvme_fw_act_work(struct work_struct *work) 
		fw_act_timeout = jiffies +

				msecs_to_jiffies(admin_timeout * 1000);



	nvme_stop_queues(ctrl);

	nvme_quiesce_io_queues(ctrl);

	while (nvme_ctrl_pp_status(ctrl)) {

		if (time_after(jiffies, fw_act_timeout)) {

			dev_warn(ctrl->device,
@@ -4751,7 +4751,7 @@ static void nvme_fw_act_work(struct work_struct *work) 
	if (!nvme_change_ctrl_state(ctrl, NVME_CTRL_LIVE))

		return;



	nvme_start_queues(ctrl);

	nvme_unquiesce_io_queues(ctrl);

	/* read FW slot information to clear the AER */

	nvme_get_fw_slot_info(ctrl);
@@ -4996,7 +4996,7 @@ void nvme_start_ctrl(struct nvme_ctrl *ctrl) 


	if (ctrl->queue_count > 1) {

		nvme_queue_scan(ctrl);

		nvme_start_queues(ctrl);

		nvme_unquiesce_io_queues(ctrl);

		nvme_mpath_update(ctrl);

	}
@@ -5213,37 +5213,37 @@ void nvme_start_freeze(struct nvme_ctrl *ctrl) 
}

EXPORT_SYMBOL_GPL(nvme_start_freeze);



void nvme_stop_queues(struct nvme_ctrl *ctrl)

void nvme_quiesce_io_queues(struct nvme_ctrl *ctrl)

{

	if (!test_and_set_bit(NVME_CTRL_STOPPED, &ctrl->flags))

		blk_mq_quiesce_tagset(ctrl->tagset);

	else

		blk_mq_wait_quiesce_done(ctrl->tagset);

}

EXPORT_SYMBOL_GPL(nvme_stop_queues);

EXPORT_SYMBOL_GPL(nvme_quiesce_io_queues);



void nvme_start_queues(struct nvme_ctrl *ctrl)

void nvme_unquiesce_io_queues(struct nvme_ctrl *ctrl)

{

	if (test_and_clear_bit(NVME_CTRL_STOPPED, &ctrl->flags))

		blk_mq_unquiesce_tagset(ctrl->tagset);

}

EXPORT_SYMBOL_GPL(nvme_start_queues);

EXPORT_SYMBOL_GPL(nvme_unquiesce_io_queues);



void nvme_stop_admin_queue(struct nvme_ctrl *ctrl)

void nvme_quiesce_admin_queue(struct nvme_ctrl *ctrl)

{

	if (!test_and_set_bit(NVME_CTRL_ADMIN_Q_STOPPED, &ctrl->flags))

		blk_mq_quiesce_queue(ctrl->admin_q);

	else

		blk_mq_wait_quiesce_done(ctrl->admin_q->tag_set);

}

EXPORT_SYMBOL_GPL(nvme_stop_admin_queue);

EXPORT_SYMBOL_GPL(nvme_quiesce_admin_queue);



void nvme_start_admin_queue(struct nvme_ctrl *ctrl)

void nvme_unquiesce_admin_queue(struct nvme_ctrl *ctrl)

{

	if (test_and_clear_bit(NVME_CTRL_ADMIN_Q_STOPPED, &ctrl->flags))

		blk_mq_unquiesce_queue(ctrl->admin_q);

}

EXPORT_SYMBOL_GPL(nvme_start_admin_queue);

EXPORT_SYMBOL_GPL(nvme_unquiesce_admin_queue);



void nvme_sync_io_queues(struct nvme_ctrl *ctrl)

{

drivers/nvme/host/fc.c

+8 −8
Original line number Diff line number Diff line
@@ -2392,7 +2392,7 @@ nvme_fc_ctrl_free(struct kref *ref) 
	list_del(&ctrl->ctrl_list);

	spin_unlock_irqrestore(&ctrl->rport->lock, flags);



	nvme_start_admin_queue(&ctrl->ctrl);

	nvme_unquiesce_admin_queue(&ctrl->ctrl);

	nvme_remove_admin_tag_set(&ctrl->ctrl);



	kfree(ctrl->queues);
@@ -2493,13 +2493,13 @@ __nvme_fc_abort_outstanding_ios(struct nvme_fc_ctrl *ctrl, bool start_queues) 
	 * (but with error status).

	 */

	if (ctrl->ctrl.queue_count > 1) {

		nvme_stop_queues(&ctrl->ctrl);

		nvme_quiesce_io_queues(&ctrl->ctrl);

		nvme_sync_io_queues(&ctrl->ctrl);

		blk_mq_tagset_busy_iter(&ctrl->tag_set,

				nvme_fc_terminate_exchange, &ctrl->ctrl);

		blk_mq_tagset_wait_completed_request(&ctrl->tag_set);

		if (start_queues)

			nvme_start_queues(&ctrl->ctrl);

			nvme_unquiesce_io_queues(&ctrl->ctrl);

	}



	/*
@@ -2517,13 +2517,13 @@ __nvme_fc_abort_outstanding_ios(struct nvme_fc_ctrl *ctrl, bool start_queues) 
	/*

	 * clean up the admin queue. Same thing as above.

	 */

	nvme_stop_admin_queue(&ctrl->ctrl);

	nvme_quiesce_admin_queue(&ctrl->ctrl);

	blk_sync_queue(ctrl->ctrl.admin_q);

	blk_mq_tagset_busy_iter(&ctrl->admin_tag_set,

				nvme_fc_terminate_exchange, &ctrl->ctrl);

	blk_mq_tagset_wait_completed_request(&ctrl->admin_tag_set);

	if (start_queues)

		nvme_start_admin_queue(&ctrl->ctrl);

		nvme_unquiesce_admin_queue(&ctrl->ctrl);

}



static void
@@ -3105,7 +3105,7 @@ nvme_fc_create_association(struct nvme_fc_ctrl *ctrl) 
	ctrl->ctrl.max_hw_sectors = ctrl->ctrl.max_segments <<

						(ilog2(SZ_4K) - 9);



	nvme_start_admin_queue(&ctrl->ctrl);

	nvme_unquiesce_admin_queue(&ctrl->ctrl);



	ret = nvme_init_ctrl_finish(&ctrl->ctrl, false);

	if (ret || test_bit(ASSOC_FAILED, &ctrl->flags))
@@ -3251,10 +3251,10 @@ nvme_fc_delete_association(struct nvme_fc_ctrl *ctrl) 
	nvme_fc_free_queue(&ctrl->queues[0]);



	/* re-enable the admin_q so anything new can fast fail */

	nvme_start_admin_queue(&ctrl->ctrl);

	nvme_unquiesce_admin_queue(&ctrl->ctrl);



	/* resume the io queues so that things will fast fail */

	nvme_start_queues(&ctrl->ctrl);

	nvme_unquiesce_io_queues(&ctrl->ctrl);



	nvme_fc_ctlr_inactive_on_rport(ctrl);

}

drivers/nvme/host/nvme.h

+4 −4
Original line number Diff line number Diff line
@@ -752,10 +752,10 @@ void nvme_remove_namespaces(struct nvme_ctrl *ctrl); 
void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status,

		volatile union nvme_result *res);



void nvme_stop_queues(struct nvme_ctrl *ctrl);

void nvme_start_queues(struct nvme_ctrl *ctrl);

void nvme_stop_admin_queue(struct nvme_ctrl *ctrl);

void nvme_start_admin_queue(struct nvme_ctrl *ctrl);

void nvme_quiesce_io_queues(struct nvme_ctrl *ctrl);

void nvme_unquiesce_io_queues(struct nvme_ctrl *ctrl);

void nvme_quiesce_admin_queue(struct nvme_ctrl *ctrl);

void nvme_unquiesce_admin_queue(struct nvme_ctrl *ctrl);

void nvme_mark_namespaces_dead(struct nvme_ctrl *ctrl);

void nvme_sync_queues(struct nvme_ctrl *ctrl);

void nvme_sync_io_queues(struct nvme_ctrl *ctrl);

drivers/nvme/host/pci.c

+8 −8
Original line number Diff line number Diff line
@@ -1481,7 +1481,7 @@ static int nvme_suspend_queue(struct nvme_queue *nvmeq) 


	nvmeq->dev->online_queues--;

	if (!nvmeq->qid && nvmeq->dev->ctrl.admin_q)

		nvme_stop_admin_queue(&nvmeq->dev->ctrl);

		nvme_quiesce_admin_queue(&nvmeq->dev->ctrl);

	if (!test_and_clear_bit(NVMEQ_POLLED, &nvmeq->flags))

		pci_free_irq(to_pci_dev(nvmeq->dev->dev), nvmeq->cq_vector, nvmeq);

	return 0;
@@ -1741,7 +1741,7 @@ static void nvme_dev_remove_admin(struct nvme_dev *dev) 
		 * user requests may be waiting on a stopped queue. Start the

		 * queue to flush these to completion.

		 */

		nvme_start_admin_queue(&dev->ctrl);

		nvme_unquiesce_admin_queue(&dev->ctrl);

		blk_mq_destroy_queue(dev->ctrl.admin_q);

		blk_put_queue(dev->ctrl.admin_q);

		blk_mq_free_tag_set(&dev->admin_tagset);
@@ -2703,7 +2703,7 @@ static void nvme_dev_disable(struct nvme_dev *dev, bool shutdown) 
	if (!dead && shutdown && freeze)

		nvme_wait_freeze_timeout(&dev->ctrl, NVME_IO_TIMEOUT);



	nvme_stop_queues(&dev->ctrl);

	nvme_quiesce_io_queues(&dev->ctrl);



	if (!dead && dev->ctrl.queue_count > 0) {

		nvme_disable_io_queues(dev);
@@ -2723,9 +2723,9 @@ static void nvme_dev_disable(struct nvme_dev *dev, bool shutdown) 
	 * deadlocking blk-mq hot-cpu notifier.

	 */

	if (shutdown) {

		nvme_start_queues(&dev->ctrl);

		nvme_unquiesce_io_queues(&dev->ctrl);

		if (dev->ctrl.admin_q && !blk_queue_dying(dev->ctrl.admin_q))

			nvme_start_admin_queue(&dev->ctrl);

			nvme_unquiesce_admin_queue(&dev->ctrl);

	}

	mutex_unlock(&dev->shutdown_lock);

}
@@ -2822,7 +2822,7 @@ static void nvme_reset_work(struct work_struct *work) 
	result = nvme_pci_enable(dev);

	if (result)

		goto out_unlock;

	nvme_start_admin_queue(&dev->ctrl);

	nvme_unquiesce_admin_queue(&dev->ctrl);

	mutex_unlock(&dev->shutdown_lock);



	/*
@@ -2856,7 +2856,7 @@ static void nvme_reset_work(struct work_struct *work) 
	 * controller around but remove all namespaces.

	 */

	if (dev->online_queues > 1) {

		nvme_start_queues(&dev->ctrl);

		nvme_unquiesce_io_queues(&dev->ctrl);

		nvme_wait_freeze(&dev->ctrl);

		nvme_pci_update_nr_queues(dev);

		nvme_dbbuf_set(dev);
@@ -2864,7 +2864,7 @@ static void nvme_reset_work(struct work_struct *work) 
	} else {

		dev_warn(dev->ctrl.device, "IO queues lost\n");

		nvme_mark_namespaces_dead(&dev->ctrl);

		nvme_start_queues(&dev->ctrl);

		nvme_unquiesce_io_queues(&dev->ctrl);

		nvme_remove_namespaces(&dev->ctrl);

		nvme_free_tagset(dev);

	}