Commit a1e21033 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.dk/linux-block 

Pull block fixes from Jens Axboe:

 - an NVMe fix from Gabriel, fixing a suspend/resume issue on some
   setups

 - addition of a few missing entries in the block queue sysfs
   documentation, from Joe

 - a fix for a sparse shadow warning for the bvec iterator, from
   Johannes

 - a writeback deadlock involving raid issuing barriers, and not
   flushing the plug when we wakeup the flusher threads.  From
   Konstantin

 - a set of patches for the NVMe target/loop/rdma code, from Roland and
   Sagi

* 'for-linus' of git://git.kernel.dk/linux-block:
  bvec: avoid variable shadowing warning
  doc: update block/queue-sysfs.txt entries
  nvme: Suspend all queues before deletion
  mm, writeback: flush plugged IO in wakeup_flusher_threads()
  nvme-rdma: Remove unused includes
  nvme-rdma: start async event handler after reconnecting to a controller
  nvmet: Fix controller serial number inconsistency
  nvmet-rdma: Don't use the inline buffer in order to avoid allocation for small reads
  nvmet-rdma: Correctly handle RDMA device hot removal
  nvme-rdma: Make sure to shutdown the controller if we can
  nvme-loop: Remove duplicate call to nvme_remove_namespaces
  nvme-rdma: Free the I/O tags when we delete the controller
  nvme-rdma: Remove duplicate call to nvme_remove_namespaces
  nvme-rdma: Fix device removal handling
  nvme-rdma: Queue ns scanning after a sucessful reconnection
  nvme-rdma: Don't leak uninitialized memory in connect request private data
parents f31494bd 1ea049b2

Documentation/block/queue-sysfs.txt

+18 −0
Original line number Diff line number Diff line
@@ -14,6 +14,12 @@ add_random (RW) 
This file allows to turn off the disk entropy contribution. Default

value of this file is '1'(on).



dax (RO)

--------

This file indicates whether the device supports Direct Access (DAX),

used by CPU-addressable storage to bypass the pagecache.  It shows '1'

if true, '0' if not.



discard_granularity (RO)

-----------------------

This shows the size of internal allocation of the device in bytes, if
@@ -46,6 +52,12 @@ hw_sector_size (RO) 
-------------------

This is the hardware sector size of the device, in bytes.



io_poll (RW)

------------

When read, this file shows the total number of block IO polls and how

many returned success.  Writing '0' to this file will disable polling

for this device.  Writing any non-zero value will enable this feature.



iostats (RW)

-------------

This file is used to control (on/off) the iostats accounting of the
@@ -151,5 +163,11 @@ device state. This means that it might not be safe to toggle the 
setting from "write back" to "write through", since that will also

eliminate cache flushes issued by the kernel.



write_same_max_bytes (RO)

-------------------------

This is the number of bytes the device can write in a single write-same

command.  A value of '0' means write-same is not supported by this

device.





Jens Axboe <jens.axboe@oracle.com>, February 2009

drivers/nvme/host/pci.c

+8 −12
Original line number Diff line number Diff line
@@ -1543,15 +1543,10 @@ static void nvme_disable_io_queues(struct nvme_dev *dev) 
		reinit_completion(&dev->ioq_wait);

 retry:

		timeout = ADMIN_TIMEOUT;

		for (; i > 0; i--) {

			struct nvme_queue *nvmeq = dev->queues[i];



			if (!pass)

				nvme_suspend_queue(nvmeq);

			if (nvme_delete_queue(nvmeq, opcode))

		for (; i > 0; i--, sent++)

			if (nvme_delete_queue(dev->queues[i], opcode))

				break;

			++sent;

		}



		while (sent--) {

			timeout = wait_for_completion_io_timeout(&dev->ioq_wait, timeout);

			if (timeout == 0)
@@ -1693,11 +1688,12 @@ static void nvme_dev_disable(struct nvme_dev *dev, bool shutdown) 
		nvme_stop_queues(&dev->ctrl);

		csts = readl(dev->bar + NVME_REG_CSTS);

	}



	for (i = dev->queue_count - 1; i > 0; i--)

		nvme_suspend_queue(dev->queues[i]);



	if (csts & NVME_CSTS_CFS || !(csts & NVME_CSTS_RDY)) {

		for (i = dev->queue_count - 1; i >= 0; i--) {

			struct nvme_queue *nvmeq = dev->queues[i];

			nvme_suspend_queue(nvmeq);

		}

		nvme_suspend_queue(dev->queues[0]);

	} else {

		nvme_disable_io_queues(dev);

		nvme_disable_admin_queue(dev, shutdown);

drivers/nvme/host/rdma.c

+45 −38
Original line number Diff line number Diff line
@@ -12,13 +12,11 @@ 
 * more details.

 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/delay.h>

#include <linux/module.h>

#include <linux/init.h>

#include <linux/slab.h>

#include <linux/err.h>

#include <linux/string.h>

#include <linux/jiffies.h>

#include <linux/atomic.h>

#include <linux/blk-mq.h>

#include <linux/types.h>
@@ -26,7 +24,6 @@ 
#include <linux/mutex.h>

#include <linux/scatterlist.h>

#include <linux/nvme.h>

#include <linux/t10-pi.h>

#include <asm/unaligned.h>



#include <rdma/ib_verbs.h>
@@ -169,7 +166,6 @@ MODULE_PARM_DESC(register_always, 
static int nvme_rdma_cm_handler(struct rdma_cm_id *cm_id,

		struct rdma_cm_event *event);

static void nvme_rdma_recv_done(struct ib_cq *cq, struct ib_wc *wc);

static int __nvme_rdma_del_ctrl(struct nvme_rdma_ctrl *ctrl);



/* XXX: really should move to a generic header sooner or later.. */

static inline void put_unaligned_le24(u32 val, u8 *p)
@@ -687,11 +683,6 @@ static void nvme_rdma_free_ctrl(struct nvme_ctrl *nctrl) 
	list_del(&ctrl->list);

	mutex_unlock(&nvme_rdma_ctrl_mutex);



	if (ctrl->ctrl.tagset) {

		blk_cleanup_queue(ctrl->ctrl.connect_q);

		blk_mq_free_tag_set(&ctrl->tag_set);

		nvme_rdma_dev_put(ctrl->device);

	}

	kfree(ctrl->queues);

	nvmf_free_options(nctrl->opts);

free_ctrl:
@@ -748,8 +739,11 @@ static void nvme_rdma_reconnect_ctrl_work(struct work_struct *work) 
	changed = nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_LIVE);

	WARN_ON_ONCE(!changed);



	if (ctrl->queue_count > 1)

	if (ctrl->queue_count > 1) {

		nvme_start_queues(&ctrl->ctrl);

		nvme_queue_scan(&ctrl->ctrl);

		nvme_queue_async_events(&ctrl->ctrl);

	}



	dev_info(ctrl->ctrl.device, "Successfully reconnected\n");
@@ -1269,7 +1263,7 @@ static int nvme_rdma_route_resolved(struct nvme_rdma_queue *queue) 
{

	struct nvme_rdma_ctrl *ctrl = queue->ctrl;

	struct rdma_conn_param param = { };

	struct nvme_rdma_cm_req priv;

	struct nvme_rdma_cm_req priv = { };

	int ret;



	param.qp_num = queue->qp->qp_num;
@@ -1318,37 +1312,39 @@ out_destroy_queue_ib: 
 * that caught the event. Since we hold the callout until the controller

 * deletion is completed, we'll deadlock if the controller deletion will

 * call rdma_destroy_id on this queue's cm_id. Thus, we claim ownership

 * of destroying this queue before-hand, destroy the queue resources

 * after the controller deletion completed with the exception of destroying

 * the cm_id implicitely by returning a non-zero rc to the callout.

 * of destroying this queue before-hand, destroy the queue resources,

 * then queue the controller deletion which won't destroy this queue and

 * we destroy the cm_id implicitely by returning a non-zero rc to the callout.

 */

static int nvme_rdma_device_unplug(struct nvme_rdma_queue *queue)

{

	struct nvme_rdma_ctrl *ctrl = queue->ctrl;

	int ret, ctrl_deleted = 0;

	int ret;



	/* First disable the queue so ctrl delete won't free it */

	if (!test_and_clear_bit(NVME_RDMA_Q_CONNECTED, &queue->flags))

		goto out;

	/* Own the controller deletion */

	if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_DELETING))

		return 0;



	/* delete the controller */

	ret = __nvme_rdma_del_ctrl(ctrl);

	if (!ret) {

	dev_warn(ctrl->ctrl.device,

		"Got rdma device removal event, deleting ctrl\n");

		flush_work(&ctrl->delete_work);



		/* Return non-zero so the cm_id will destroy implicitly */

		ctrl_deleted = 1;

	/* Get rid of reconnect work if its running */

	cancel_delayed_work_sync(&ctrl->reconnect_work);



	/* Disable the queue so ctrl delete won't free it */

	if (test_and_clear_bit(NVME_RDMA_Q_CONNECTED, &queue->flags)) {

		/* Free this queue ourselves */

		rdma_disconnect(queue->cm_id);

		ib_drain_qp(queue->qp);

		nvme_rdma_stop_queue(queue);

		nvme_rdma_destroy_queue_ib(queue);



		/* Return non-zero so the cm_id will destroy implicitly */

		ret = 1;

	}



out:

	return ctrl_deleted;

	/* Queue controller deletion */

	queue_work(nvme_rdma_wq, &ctrl->delete_work);

	flush_work(&ctrl->delete_work);

	return ret;

}



static int nvme_rdma_cm_handler(struct rdma_cm_id *cm_id,
@@ -1648,7 +1644,7 @@ static void nvme_rdma_shutdown_ctrl(struct nvme_rdma_ctrl *ctrl) 
		nvme_rdma_free_io_queues(ctrl);

	}



	if (ctrl->ctrl.state == NVME_CTRL_LIVE)

	if (test_bit(NVME_RDMA_Q_CONNECTED, &ctrl->queues[0].flags))

		nvme_shutdown_ctrl(&ctrl->ctrl);



	blk_mq_stop_hw_queues(ctrl->ctrl.admin_q);
@@ -1657,15 +1653,27 @@ static void nvme_rdma_shutdown_ctrl(struct nvme_rdma_ctrl *ctrl) 
	nvme_rdma_destroy_admin_queue(ctrl);

}



static void __nvme_rdma_remove_ctrl(struct nvme_rdma_ctrl *ctrl, bool shutdown)

{

	nvme_uninit_ctrl(&ctrl->ctrl);

	if (shutdown)

		nvme_rdma_shutdown_ctrl(ctrl);



	if (ctrl->ctrl.tagset) {

		blk_cleanup_queue(ctrl->ctrl.connect_q);

		blk_mq_free_tag_set(&ctrl->tag_set);

		nvme_rdma_dev_put(ctrl->device);

	}



	nvme_put_ctrl(&ctrl->ctrl);

}



static void nvme_rdma_del_ctrl_work(struct work_struct *work)

{

	struct nvme_rdma_ctrl *ctrl = container_of(work,

				struct nvme_rdma_ctrl, delete_work);



	nvme_remove_namespaces(&ctrl->ctrl);

	nvme_rdma_shutdown_ctrl(ctrl);

	nvme_uninit_ctrl(&ctrl->ctrl);

	nvme_put_ctrl(&ctrl->ctrl);

	__nvme_rdma_remove_ctrl(ctrl, true);

}



static int __nvme_rdma_del_ctrl(struct nvme_rdma_ctrl *ctrl)
@@ -1698,9 +1706,7 @@ static void nvme_rdma_remove_ctrl_work(struct work_struct *work) 
	struct nvme_rdma_ctrl *ctrl = container_of(work,

				struct nvme_rdma_ctrl, delete_work);



	nvme_remove_namespaces(&ctrl->ctrl);

	nvme_uninit_ctrl(&ctrl->ctrl);

	nvme_put_ctrl(&ctrl->ctrl);

	__nvme_rdma_remove_ctrl(ctrl, false);

}



static void nvme_rdma_reset_ctrl_work(struct work_struct *work)
@@ -1739,6 +1745,7 @@ static void nvme_rdma_reset_ctrl_work(struct work_struct *work) 
	if (ctrl->queue_count > 1) {

		nvme_start_queues(&ctrl->ctrl);

		nvme_queue_scan(&ctrl->ctrl);

		nvme_queue_async_events(&ctrl->ctrl);

	}



	return;

drivers/nvme/target/admin-cmd.c

+1 −5
Original line number Diff line number Diff line
@@ -13,7 +13,6 @@ 
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>

#include <linux/random.h>

#include <generated/utsrelease.h>

#include "nvmet.h"
@@ -83,7 +82,6 @@ static void nvmet_execute_identify_ctrl(struct nvmet_req *req) 
{

	struct nvmet_ctrl *ctrl = req->sq->ctrl;

	struct nvme_id_ctrl *id;

	u64 serial;

	u16 status = 0;



	id = kzalloc(sizeof(*id), GFP_KERNEL);
@@ -96,10 +94,8 @@ static void nvmet_execute_identify_ctrl(struct nvmet_req *req) 
	id->vid = 0;

	id->ssvid = 0;



	/* generate a random serial number as our controllers are ephemeral: */

	get_random_bytes(&serial, sizeof(serial));

	memset(id->sn, ' ', sizeof(id->sn));

	snprintf(id->sn, sizeof(id->sn), "%llx", serial);

	snprintf(id->sn, sizeof(id->sn), "%llx", ctrl->serial);



	memset(id->mn, ' ', sizeof(id->mn));

	strncpy((char *)id->mn, "Linux", sizeof(id->mn));

drivers/nvme/target/core.c

+4 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>

#include <linux/random.h>

#include "nvmet.h"



static struct nvmet_fabrics_ops *nvmet_transports[NVMF_TRTYPE_MAX];
@@ -728,6 +729,9 @@ u16 nvmet_alloc_ctrl(const char *subsysnqn, const char *hostnqn, 
	memcpy(ctrl->subsysnqn, subsysnqn, NVMF_NQN_SIZE);

	memcpy(ctrl->hostnqn, hostnqn, NVMF_NQN_SIZE);



	/* generate a random serial number as our controllers are ephemeral: */

	get_random_bytes(&ctrl->serial, sizeof(ctrl->serial));



	kref_init(&ctrl->ref);

	ctrl->subsys = subsys;

CRA Git | Maintained and supported by SUSTech CRA and CCSE