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

Linus Torvalds committed 10 years ago

Commit a1e21032 parents f31494b 1ea049b10 files · +160 −85Browse files

Unified · Split

10 files

Documentation/block/queue-sysfs.txt +18 −0
drivers/nvme/host/pci.c +8 −12
drivers/nvme/host/rdma.c +45 −38
drivers/nvme/target/admin-cmd.c +1 −5
drivers/nvme/target/core.c +4 −0
drivers/nvme/target/loop.c +1 −3
drivers/nvme/target/nvmet.h +1 −0
drivers/nvme/target/rdma.c +74 −26
fs/fs-writeback.c +6 −0
include/linux/bvec.h +2 −1

Documentation/block/queue-sysfs.txt+18−0

@@ -14,6 +14,12 @@ add_random (RW) · 13 unmodified lines
14	This file allows to turn off the disk entropy contribution. Default	14	This file allows to turn off the disk entropy contribution. Default
15	value of this file is '1'(on).	15	value of this file is '1'(on).
16		16
		17	dax (RO)
		18	--------
		19	This file indicates whether the device supports Direct Access (DAX),
		20	used by CPU-addressable storage to bypass the pagecache. It shows '1'
		21	if true, '0' if not.
		22
17	discard_granularity (RO)	23	discard_granularity (RO)
18	-----------------------	24	-----------------------
19	This shows the size of internal allocation of the device in bytes, if	25	This shows the size of internal allocation of the device in bytes, if
@@ -46,6 +52,12 @@ hw_sector_size (RO) · 26 unmodified lines
46	-------------------	52	-------------------
47	This is the hardware sector size of the device, in bytes.	53	This is the hardware sector size of the device, in bytes.
48		54
		55	io_poll (RW)
		56	------------
		57	When read, this file shows the total number of block IO polls and how
		58	many returned success. Writing '0' to this file will disable polling
		59	for this device. Writing any non-zero value will enable this feature.
		60
49	iostats (RW)	61	iostats (RW)
50	-------------	62	-------------
51	This file is used to control (on/off) the iostats accounting of the	63	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 · 99 unmodified lines
151	setting from "write back" to "write through", since that will also	163	setting from "write back" to "write through", since that will also
152	eliminate cache flushes issued by the kernel.	164	eliminate cache flushes issued by the kernel.
153		165
		166	write_same_max_bytes (RO)
		167	-------------------------
		168	This is the number of bytes the device can write in a single write-same
		169	command. A value of '0' means write-same is not supported by this
		170	device.
		171
154		172
155	Jens Axboe <jens.axboe@oracle.com>, February 2009	173	Jens Axboe <jens.axboe@oracle.com>, February 2009

drivers/nvme/host/pci.c+8−12

@@ -1543,15 +1543,10 @@ static void nvme_disable_io_queues(struct nvme_dev *dev) · 1542 unmodified lines
1543	reinit_completion(&dev->ioq_wait);	1543	reinit_completion(&dev->ioq_wait);
1544	retry:	1544	retry:
1545	timeout = ADMIN_TIMEOUT;	1545	timeout = ADMIN_TIMEOUT;
1546	for (; i > 0; i--) {	1546	for (; i > 0; i--, sent++)
1547	struct nvme_queue *nvmeq = dev->queues[i];	1547	if (nvme_delete_queue(dev->queues[i], opcode))
1548
1549	if (!pass)
1550	nvme_suspend_queue(nvmeq);
1551	if (nvme_delete_queue(nvmeq, opcode))
1552	break;	1548	break;
1553	++sent;	1549
1554	}
1555	while (sent--) {	1550	while (sent--) {
1556	timeout = wait_for_completion_io_timeout(&dev->ioq_wait, timeout);	1551	timeout = wait_for_completion_io_timeout(&dev->ioq_wait, timeout);
1557	if (timeout == 0)	1552	if (timeout == 0)
@@ -1693,11 +1688,12 @@ static void nvme_dev_disable(struct nvme_dev *dev, bool shutdown) · 135 unmodified lines
1693	nvme_stop_queues(&dev->ctrl);	1688	nvme_stop_queues(&dev->ctrl);
1694	csts = readl(dev->bar + NVME_REG_CSTS);	1689	csts = readl(dev->bar + NVME_REG_CSTS);
1695	}	1690	}
		1691
		1692	for (i = dev->queue_count - 1; i > 0; i--)
		1693	nvme_suspend_queue(dev->queues[i]);
		1694
1696	if (csts & NVME_CSTS_CFS \|\| !(csts & NVME_CSTS_RDY)) {	1695	if (csts & NVME_CSTS_CFS \|\| !(csts & NVME_CSTS_RDY)) {
1697	for (i = dev->queue_count - 1; i >= 0; i--) {	1696	nvme_suspend_queue(dev->queues[0]);
1698	struct nvme_queue *nvmeq = dev->queues[i];
1699	nvme_suspend_queue(nvmeq);
1700	}
1701	} else {	1697	} else {
1702	nvme_disable_io_queues(dev);	1698	nvme_disable_io_queues(dev);
1703	nvme_disable_admin_queue(dev, shutdown);	1699	nvme_disable_admin_queue(dev, shutdown);

drivers/nvme/host/rdma.c+45−38

  * 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>
 #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>
 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)
 	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:
 	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");
 {
 	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;
  * 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
+ * of destroying this queue before-hand, destroy the queue resources,
- * after the controller deletion completed with the exception of destroying
+ * then queue the controller deletion which won't destroy this queue and
- * the cm_id implicitely by returning a non-zero rc to the callout.
+ * 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 */
+	/* Own the controller deletion */
-	if (!test_and_clear_bit(NVME_RDMA_Q_CONNECTED, &queue->flags))
+	if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_DELETING))
-		goto out;
+		return 0;
-	/* delete the controller */
+	dev_warn(ctrl->ctrl.device,
-	ret = __nvme_rdma_del_ctrl(ctrl);
+		"Got rdma device removal event, deleting ctrl\n");
-	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 */
+	/* Get rid of reconnect work if its running */
-		ctrl_deleted = 1;
+	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);
+		nvme_rdma_stop_queue(queue);
-		ib_drain_qp(queue->qp);
 		nvme_rdma_destroy_queue_ib(queue);
+		/* Return non-zero so the cm_id will destroy implicitly */
+		ret = 1;
 	}
-out:
+	/* Queue controller deletion */
-	return ctrl_deleted;
+	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,
 		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);
 	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_remove_ctrl(ctrl, true);
-	nvme_rdma_shutdown_ctrl(ctrl);
-	nvme_uninit_ctrl(&ctrl->ctrl);
-	nvme_put_ctrl(&ctrl->ctrl);
 }
 static int __nvme_rdma_del_ctrl(struct nvme_rdma_ctrl *ctrl)
 	struct nvme_rdma_ctrl *ctrl = container_of(work,
 				struct nvme_rdma_ctrl, delete_work);
-	nvme_remove_namespaces(&ctrl->ctrl);
+	__nvme_rdma_remove_ctrl(ctrl, false);
-	nvme_uninit_ctrl(&ctrl->ctrl);
-	nvme_put_ctrl(&ctrl->ctrl);
 }
 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

  */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/module.h>
-#include <linux/random.h>
 #include <generated/utsrelease.h>
 #include "nvmet.h"
 {
 	struct nvmet_ctrl *ctrl = req->sq->ctrl;
 	struct nvme_id_ctrl *id;
-	u64 serial;
 	u16 status = 0;
 	id = kzalloc(sizeof(*id), GFP_KERNEL);
 	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

  */
 #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];
 	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;

drivers/nvme/target/loop.c+1−3

 	struct nvme_loop_ctrl *ctrl = container_of(work,
 				struct nvme_loop_ctrl, delete_work);
-	nvme_remove_namespaces(&ctrl->ctrl);
-	nvme_loop_shutdown_ctrl(ctrl);
 	nvme_uninit_ctrl(&ctrl->ctrl);
+	nvme_loop_shutdown_ctrl(ctrl);
 	nvme_put_ctrl(&ctrl->ctrl);
 }
 	nvme_loop_destroy_admin_queue(ctrl);
 out_disable:
 	dev_warn(ctrl->ctrl.device, "Removing after reset failure\n");
-	nvme_remove_namespaces(&ctrl->ctrl);
 	nvme_uninit_ctrl(&ctrl->ctrl);
 	nvme_put_ctrl(&ctrl->ctrl);
 }

drivers/nvme/target/nvmet.h+1−0

@@ -113,6 +113,7 @@ struct nvmet_ctrl { · 112 unmodified lines
113		113
114	struct mutex lock;	114	struct mutex lock;
115	u64 cap;	115	u64 cap;
		116	u64 serial;
116	u32 cc;	117	u32 cc;
117	u32 csts;	118	u32 csts;
118		119

drivers/nvme/target/rdma.c+74−26

@@ -77,6 +77,7 @@ enum nvmet_rdma_queue_state { · 76 unmodified lines
77	NVMET_RDMA_Q_CONNECTING,	77	NVMET_RDMA_Q_CONNECTING,
78	NVMET_RDMA_Q_LIVE,	78	NVMET_RDMA_Q_LIVE,
79	NVMET_RDMA_Q_DISCONNECTING,	79	NVMET_RDMA_Q_DISCONNECTING,
		80	NVMET_RDMA_IN_DEVICE_REMOVAL,
80	};	81	};
81		82
82	struct nvmet_rdma_queue {	83	struct nvmet_rdma_queue {
@@ -615,15 +616,10 @@ static u16 nvmet_rdma_map_sgl_keyed(struct nvmet_rdma_rsp *rsp, · 532 unmodified lines
615	if (!len)	616	if (!len)
616	return 0;	617	return 0;
617		618
618	/* use the already allocated data buffer if possible */	619	status = nvmet_rdma_alloc_sgl(&rsp->req.sg, &rsp->req.sg_cnt,
619	if (len <= NVMET_RDMA_INLINE_DATA_SIZE && rsp->queue->host_qid) {	620	len);
620	nvmet_rdma_use_inline_sg(rsp, len, 0);	621	if (status)
621	} else {	622	return status;
622	status = nvmet_rdma_alloc_sgl(&rsp->req.sg, &rsp->req.sg_cnt,
623	len);
624	if (status)
625	return status;
626	}
627		623
628	ret = rdma_rw_ctx_init(&rsp->rw, cm_id->qp, cm_id->port_num,	624	ret = rdma_rw_ctx_init(&rsp->rw, cm_id->qp, cm_id->port_num,
629	rsp->req.sg, rsp->req.sg_cnt, 0, addr, key,	625	rsp->req.sg, rsp->req.sg_cnt, 0, addr, key,
@@ -984,7 +980,10 @@ static void nvmet_rdma_release_queue_work(struct work_struct *w) · 354 unmodified lines
984	struct nvmet_rdma_device *dev = queue->dev;	980	struct nvmet_rdma_device *dev = queue->dev;
985		981
986	nvmet_rdma_free_queue(queue);	982	nvmet_rdma_free_queue(queue);
987	rdma_destroy_id(cm_id);	983
		984	if (queue->state != NVMET_RDMA_IN_DEVICE_REMOVAL)
		985	rdma_destroy_id(cm_id);
		986
988	kref_put(&dev->ref, nvmet_rdma_free_dev);	987	kref_put(&dev->ref, nvmet_rdma_free_dev);
989	}	988	}
990		989
@@ -1233,8 +1232,9 @@ static void __nvmet_rdma_queue_disconnect(struct nvmet_rdma_queue *queue) · 242 unmodified lines
1233	switch (queue->state) {	1232	switch (queue->state) {
1234	case NVMET_RDMA_Q_CONNECTING:	1233	case NVMET_RDMA_Q_CONNECTING:
1235	case NVMET_RDMA_Q_LIVE:	1234	case NVMET_RDMA_Q_LIVE:
1236	disconnect = true;
1237	queue->state = NVMET_RDMA_Q_DISCONNECTING;	1235	queue->state = NVMET_RDMA_Q_DISCONNECTING;
		1236	case NVMET_RDMA_IN_DEVICE_REMOVAL:
		1237	disconnect = true;
1238	break;	1238	break;
1239	case NVMET_RDMA_Q_DISCONNECTING:	1239	case NVMET_RDMA_Q_DISCONNECTING:
1240	break;	1240	break;
@@ -1272,6 +1272,62 @@ static void nvmet_rdma_queue_connect_fail(struct rdma_cm_id *cm_id, · 31 unmodified lines
1272	schedule_work(&queue->release_work);	1272	schedule_work(&queue->release_work);
1273	}	1273	}
1274		1274
		1275	/**
		1276	* nvme_rdma_device_removal() - Handle RDMA device removal
		1277	* @queue: nvmet rdma queue (cm id qp_context)
		1278	* @addr: nvmet address (cm_id context)
		1279	*
		1280	* DEVICE_REMOVAL event notifies us that the RDMA device is about
		1281	* to unplug so we should take care of destroying our RDMA resources.
		1282	* This event will be generated for each allocated cm_id.
		1283	*
		1284	* Note that this event can be generated on a normal queue cm_id
		1285	* and/or a device bound listener cm_id (where in this case
		1286	* queue will be null).
		1287	*
		1288	* we claim ownership on destroying the cm_id. For queues we move
		1289	* the queue state to NVMET_RDMA_IN_DEVICE_REMOVAL and for port
		1290	* we nullify the priv to prevent double cm_id destruction and destroying
		1291	* the cm_id implicitely by returning a non-zero rc to the callout.
		1292	*/
		1293	static int nvmet_rdma_device_removal(struct rdma_cm_id *cm_id,
		1294	struct nvmet_rdma_queue *queue)
		1295	{
		1296	unsigned long flags;
		1297
		1298	if (!queue) {
		1299	struct nvmet_port *port = cm_id->context;
		1300
		1301	/*
		1302	* This is a listener cm_id. Make sure that
		1303	* future remove_port won't invoke a double
		1304	* cm_id destroy. use atomic xchg to make sure
		1305	* we don't compete with remove_port.
		1306	*/
		1307	if (xchg(&port->priv, NULL) != cm_id)
		1308	return 0;
		1309	} else {
		1310	/*
		1311	* This is a queue cm_id. Make sure that
		1312	* release queue will not destroy the cm_id
		1313	* and schedule all ctrl queues removal (only
		1314	* if the queue is not disconnecting already).
		1315	*/
		1316	spin_lock_irqsave(&queue->state_lock, flags);
		1317	if (queue->state != NVMET_RDMA_Q_DISCONNECTING)
		1318	queue->state = NVMET_RDMA_IN_DEVICE_REMOVAL;
		1319	spin_unlock_irqrestore(&queue->state_lock, flags);
		1320	nvmet_rdma_queue_disconnect(queue);
		1321	flush_scheduled_work();
		1322	}
		1323
		1324	/*
		1325	* We need to return 1 so that the core will destroy
		1326	* it's own ID. What a great API design..
		1327	*/
		1328	return 1;
		1329	}
		1330
1275	static int nvmet_rdma_cm_handler(struct rdma_cm_id *cm_id,	1331	static int nvmet_rdma_cm_handler(struct rdma_cm_id *cm_id,
1276	struct rdma_cm_event *event)	1332	struct rdma_cm_event *event)
1277	{	1333	{
@@ -1294,20 +1350,11 @@ static int nvmet_rdma_cm_handler(struct rdma_cm_id *cm_id, · 16 unmodified lines
1294	break;	1350	break;
1295	case RDMA_CM_EVENT_ADDR_CHANGE:	1351	case RDMA_CM_EVENT_ADDR_CHANGE:
1296	case RDMA_CM_EVENT_DISCONNECTED:	1352	case RDMA_CM_EVENT_DISCONNECTED:
1297	case RDMA_CM_EVENT_DEVICE_REMOVAL:
1298	case RDMA_CM_EVENT_TIMEWAIT_EXIT:	1353	case RDMA_CM_EVENT_TIMEWAIT_EXIT:
1299	/*	1354	nvmet_rdma_queue_disconnect(queue);
1300	* We can get the device removal callback even for a	1355	break;
1301	* CM ID that we aren't actually using. In that case	1356	case RDMA_CM_EVENT_DEVICE_REMOVAL:
1302	* the context pointer is NULL, so we shouldn't try	1357	ret = nvmet_rdma_device_removal(cm_id, queue);
1303	* to disconnect a non-existing queue. But we also
1304	* need to return 1 so that the core will destroy
1305	* it's own ID. What a great API design..
1306	*/
1307	if (queue)
1308	nvmet_rdma_queue_disconnect(queue);
1309	else
1310	ret = 1;
1311	break;	1358	break;
1312	case RDMA_CM_EVENT_REJECTED:	1359	case RDMA_CM_EVENT_REJECTED:
1313	case RDMA_CM_EVENT_UNREACHABLE:	1360	case RDMA_CM_EVENT_UNREACHABLE:
@@ -1396,9 +1443,10 @@ out_destroy_id: · 82 unmodified lines
1396		1443
1397	static void nvmet_rdma_remove_port(struct nvmet_port *port)	1444	static void nvmet_rdma_remove_port(struct nvmet_port *port)
1398	{	1445	{
1399	struct rdma_cm_id *cm_id = port->priv;	1446	struct rdma_cm_id *cm_id = xchg(&port->priv, NULL);
1400		1447
1401	rdma_destroy_id(cm_id);	1448	if (cm_id)
		1449	rdma_destroy_id(cm_id);
1402	}	1450	}
1403		1451
1404	static struct nvmet_fabrics_ops nvmet_rdma_ops = {	1452	static struct nvmet_fabrics_ops nvmet_rdma_ops = {

fs/fs-writeback.c+6−0

 {
 	struct backing_dev_info *bdi;
+	/*
+	 * If we are expecting writeback progress we must submit plugged IO.
+	 */
+	if (blk_needs_flush_plug(current))
+		blk_schedule_flush_plug(current);
 	if (!nr_pages)
 		nr_pages = get_nr_dirty_pages();

include/linux/bvec.h+2−1

@@ -74,7 +74,8 @@ static inline void bvec_iter_advance(const struct bio_vec *bv, · 73 unmodified lines
74	"Attempted to advance past end of bvec iter\n");	74	"Attempted to advance past end of bvec iter\n");
75		75
76	while (bytes) {	76	while (bytes) {
77	unsigned len = min(bytes, bvec_iter_len(bv, *iter));	77	unsigned iter_len = bvec_iter_len(bv, *iter);
		78	unsigned len = min(bytes, iter_len);
78		79
79	bytes -= len;	80	bytes -= len;
80	iter->bi_size -= len;	81	iter->bi_size -= len;