Commit 0d738971 authored by Jens Axboe's avatar Jens Axboe
Browse files

Merge tag 'nvme-5.21-2020-02-02' of git://git.infradead.org/nvme into for-5.12/drivers 

Pull NVMe updates from Christoph:

"nvme updates for 5.12:

 - failed reconnect fixes (Chao Leng)
 - various tracing improvements (Michal Krakowiak, Johannes Thumshirn)
 - switch the nvmet-fc assoc_list to use RCU protection (Leonid Ravich)
 - resync the status codes with the latest spec (Max Gurtovoy)
 - minor nvme-tcp improvements (Sagi Grimberg)
 - various cleanups (Rikard Falkeborn, Minwoo Im, Chaitanya Kulkarni,
   Israel Rukshin)"

* tag 'nvme-5.21-2020-02-02' of git://git.infradead.org/nvme: (22 commits)
  nvme-tcp: use cancel tagset helper for tear down
  nvme-rdma: use cancel tagset helper for tear down
  nvme-tcp: add clean action for failed reconnection
  nvme-rdma: add clean action for failed reconnection
  nvme-core: add cancel tagset helpers
  nvme-core: get rid of the extra space
  nvme: add tracing of zns commands
  nvme: parse format nvm command details when tracing
  nvme: update enumerations for status codes
  nvmet: add lba to sect conversion helpers
  nvmet: remove extra variable in identify ns
  nvmet: remove extra variable in id-desclist
  nvmet: remove extra variable in smart log nsid
  nvme: refactor ns->ctrl by request
  nvme-tcp: pass multipage bvec to request iov_iter
  nvme-tcp: get rid of unused helper function
  nvme-tcp: fix wrong setting of request iov_iter
  nvme: support command retry delay for admin command
  nvme: constify static attribute_group structs
  nvmet-fc: use RCU proctection for assoc_list
  ...
parents e8628013 563c8158

drivers/nvme/host/core.c

+28 −9
Original line number Diff line number Diff line
@@ -279,14 +279,13 @@ static blk_status_t nvme_error_status(u16 status) 


static void nvme_retry_req(struct request *req)

{

	struct nvme_ns *ns = req->q->queuedata;

	unsigned long delay = 0;

	u16 crd;



	/* The mask and shift result must be <= 3 */

	crd = (nvme_req(req)->status & NVME_SC_CRD) >> 11;

	if (ns && crd)

		delay = ns->ctrl->crdt[crd - 1] * 100;

	if (crd)

		delay = nvme_req(req)->ctrl->crdt[crd - 1] * 100;



	nvme_req(req)->retries++;

	blk_mq_requeue_request(req, false);
@@ -371,6 +370,26 @@ bool nvme_cancel_request(struct request *req, void *data, bool reserved) 
}

EXPORT_SYMBOL_GPL(nvme_cancel_request);



void nvme_cancel_tagset(struct nvme_ctrl *ctrl)

{

	if (ctrl->tagset) {

		blk_mq_tagset_busy_iter(ctrl->tagset,

				nvme_cancel_request, ctrl);

		blk_mq_tagset_wait_completed_request(ctrl->tagset);

	}

}

EXPORT_SYMBOL_GPL(nvme_cancel_tagset);



void nvme_cancel_admin_tagset(struct nvme_ctrl *ctrl)

{

	if (ctrl->admin_tagset) {

		blk_mq_tagset_busy_iter(ctrl->admin_tagset,

				nvme_cancel_request, ctrl);

		blk_mq_tagset_wait_completed_request(ctrl->admin_tagset);

	}

}

EXPORT_SYMBOL_GPL(nvme_cancel_admin_tagset);



bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,

		enum nvme_ctrl_state new_state)

{
@@ -842,11 +861,11 @@ static inline blk_status_t nvme_setup_rw(struct nvme_ns *ns, 
void nvme_cleanup_cmd(struct request *req)

{

	if (req->rq_flags & RQF_SPECIAL_PAYLOAD) {

		struct nvme_ns *ns = req->rq_disk->private_data;

		struct nvme_ctrl *ctrl = nvme_req(req)->ctrl;

		struct page *page = req->special_vec.bv_page;



		if (page == ns->ctrl->discard_page)

			clear_bit_unlock(0, &ns->ctrl->discard_page_busy);

		if (page == ctrl->discard_page)

			clear_bit_unlock(0, &ctrl->discard_page_busy);

		else

			kfree(page_address(page) + req->special_vec.bv_offset);

	}
@@ -2859,7 +2878,7 @@ static struct attribute *nvme_subsys_attrs[] = { 
	NULL,

};



static struct attribute_group nvme_subsys_attrs_group = {

static const struct attribute_group nvme_subsys_attrs_group = {

	.attrs = nvme_subsys_attrs,

};
@@ -3694,7 +3713,7 @@ static umode_t nvme_dev_attrs_are_visible(struct kobject *kobj, 
	return a->mode;

}



static struct attribute_group nvme_dev_attrs_group = {

static const struct attribute_group nvme_dev_attrs_group = {

	.attrs		= nvme_dev_attrs,

	.is_visible	= nvme_dev_attrs_are_visible,

};

drivers/nvme/host/fc.c

+1 −1
Original line number Diff line number Diff line
@@ -3789,7 +3789,7 @@ static struct attribute *nvme_fc_attrs[] = { 
	NULL

};



static struct attribute_group nvme_fc_attr_group = {

static const struct attribute_group nvme_fc_attr_group = {

	.attrs = nvme_fc_attrs,

};

drivers/nvme/host/nvme.h

+2 −0
Original line number Diff line number Diff line
@@ -576,6 +576,8 @@ static inline bool nvme_is_aen_req(u16 qid, __u16 command_id) 


void nvme_complete_rq(struct request *req);

bool nvme_cancel_request(struct request *req, void *data, bool reserved);

void nvme_cancel_tagset(struct nvme_ctrl *ctrl);

void nvme_cancel_admin_tagset(struct nvme_ctrl *ctrl);

bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,

		enum nvme_ctrl_state new_state);

bool nvme_wait_reset(struct nvme_ctrl *ctrl);

drivers/nvme/host/rdma.c

+18 −12
Original line number Diff line number Diff line
@@ -919,12 +919,16 @@ static int nvme_rdma_configure_admin_queue(struct nvme_rdma_ctrl *ctrl, 


	error = nvme_init_identify(&ctrl->ctrl);

	if (error)

		goto out_stop_queue;

		goto out_quiesce_queue;



	return 0;



out_quiesce_queue:

	blk_mq_quiesce_queue(ctrl->ctrl.admin_q);

	blk_sync_queue(ctrl->ctrl.admin_q);

out_stop_queue:

	nvme_rdma_stop_queue(&ctrl->queues[0]);

	nvme_cancel_admin_tagset(&ctrl->ctrl);

out_cleanup_queue:

	if (new)

		blk_cleanup_queue(ctrl->ctrl.admin_q);
@@ -1001,8 +1005,10 @@ static int nvme_rdma_configure_io_queues(struct nvme_rdma_ctrl *ctrl, bool new) 


out_wait_freeze_timed_out:

	nvme_stop_queues(&ctrl->ctrl);

	nvme_sync_io_queues(&ctrl->ctrl);

	nvme_rdma_stop_io_queues(ctrl);

out_cleanup_connect_q:

	nvme_cancel_tagset(&ctrl->ctrl);

	if (new)

		blk_cleanup_queue(ctrl->ctrl.connect_q);

out_free_tag_set:
@@ -1019,11 +1025,7 @@ static void nvme_rdma_teardown_admin_queue(struct nvme_rdma_ctrl *ctrl, 
	blk_mq_quiesce_queue(ctrl->ctrl.admin_q);

	blk_sync_queue(ctrl->ctrl.admin_q);

	nvme_rdma_stop_queue(&ctrl->queues[0]);

	if (ctrl->ctrl.admin_tagset) {

		blk_mq_tagset_busy_iter(ctrl->ctrl.admin_tagset,

			nvme_cancel_request, &ctrl->ctrl);

		blk_mq_tagset_wait_completed_request(ctrl->ctrl.admin_tagset);

	}

	nvme_cancel_admin_tagset(&ctrl->ctrl);

	if (remove)

		blk_mq_unquiesce_queue(ctrl->ctrl.admin_q);

	nvme_rdma_destroy_admin_queue(ctrl, remove);
@@ -1037,11 +1039,7 @@ static void nvme_rdma_teardown_io_queues(struct nvme_rdma_ctrl *ctrl, 
		nvme_stop_queues(&ctrl->ctrl);

		nvme_sync_io_queues(&ctrl->ctrl);

		nvme_rdma_stop_io_queues(ctrl);

		if (ctrl->ctrl.tagset) {

			blk_mq_tagset_busy_iter(ctrl->ctrl.tagset,

				nvme_cancel_request, &ctrl->ctrl);

			blk_mq_tagset_wait_completed_request(ctrl->ctrl.tagset);

		}

		nvme_cancel_tagset(&ctrl->ctrl);

		if (remove)

			nvme_start_queues(&ctrl->ctrl);

		nvme_rdma_destroy_io_queues(ctrl, remove);
@@ -1144,10 +1142,18 @@ static int nvme_rdma_setup_ctrl(struct nvme_rdma_ctrl *ctrl, bool new) 
	return 0;



destroy_io:

	if (ctrl->ctrl.queue_count > 1)

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

		nvme_stop_queues(&ctrl->ctrl);

		nvme_sync_io_queues(&ctrl->ctrl);

		nvme_rdma_stop_io_queues(ctrl);

		nvme_cancel_tagset(&ctrl->ctrl);

		nvme_rdma_destroy_io_queues(ctrl, new);

	}

destroy_admin:

	blk_mq_quiesce_queue(ctrl->ctrl.admin_q);

	blk_sync_queue(ctrl->ctrl.admin_q);

	nvme_rdma_stop_queue(&ctrl->queues[0]);

	nvme_cancel_admin_tagset(&ctrl->ctrl);

	nvme_rdma_destroy_admin_queue(ctrl, new);

	return ret;

}

drivers/nvme/host/tcp.c

+29 −26
Original line number Diff line number Diff line
@@ -206,11 +206,6 @@ static inline size_t nvme_tcp_req_cur_length(struct nvme_tcp_request *req) 
			req->pdu_len - req->pdu_sent);

}



static inline size_t nvme_tcp_req_offset(struct nvme_tcp_request *req)

{

	return req->iter.iov_offset;

}



static inline size_t nvme_tcp_pdu_data_left(struct nvme_tcp_request *req)

{

	return rq_data_dir(blk_mq_rq_from_pdu(req)) == WRITE ?
@@ -229,24 +224,29 @@ static void nvme_tcp_init_iter(struct nvme_tcp_request *req, 
	struct request *rq = blk_mq_rq_from_pdu(req);

	struct bio_vec *vec;

	unsigned int size;

	int nsegs;

	int nr_bvec;

	size_t offset;



	if (rq->rq_flags & RQF_SPECIAL_PAYLOAD) {

		vec = &rq->special_vec;

		nsegs = 1;

		nr_bvec = 1;

		size = blk_rq_payload_bytes(rq);

		offset = 0;

	} else {

		struct bio *bio = req->curr_bio;

		struct bvec_iter bi;

		struct bio_vec bv;



		vec = __bvec_iter_bvec(bio->bi_io_vec, bio->bi_iter);

		nsegs = bio_segments(bio);

		nr_bvec = 0;

		bio_for_each_bvec(bv, bio, bi) {

			nr_bvec++;

		}

		size = bio->bi_iter.bi_size;

		offset = bio->bi_iter.bi_bvec_done;

	}



	iov_iter_bvec(&req->iter, dir, vec, nsegs, size);

	iov_iter_bvec(&req->iter, dir, vec, nr_bvec, size);

	req->iter.iov_offset = offset;

}
@@ -983,7 +983,6 @@ static int nvme_tcp_try_send_cmd_pdu(struct nvme_tcp_request *req) 
			req->state = NVME_TCP_SEND_DATA;

			if (queue->data_digest)

				crypto_ahash_init(queue->snd_hash);

			nvme_tcp_init_iter(req, WRITE);

		} else {

			nvme_tcp_done_send_req(queue);

		}
@@ -1016,8 +1015,6 @@ static int nvme_tcp_try_send_data_pdu(struct nvme_tcp_request *req) 
		req->state = NVME_TCP_SEND_DATA;

		if (queue->data_digest)

			crypto_ahash_init(queue->snd_hash);

		if (!req->data_sent)

			nvme_tcp_init_iter(req, WRITE);

		return 1;

	}

	req->offset += ret;
@@ -1815,8 +1812,10 @@ static int nvme_tcp_configure_io_queues(struct nvme_ctrl *ctrl, bool new) 


out_wait_freeze_timed_out:

	nvme_stop_queues(ctrl);

	nvme_sync_io_queues(ctrl);

	nvme_tcp_stop_io_queues(ctrl);

out_cleanup_connect_q:

	nvme_cancel_tagset(ctrl);

	if (new)

		blk_cleanup_queue(ctrl->connect_q);

out_free_tag_set:
@@ -1878,12 +1877,16 @@ static int nvme_tcp_configure_admin_queue(struct nvme_ctrl *ctrl, bool new) 


	error = nvme_init_identify(ctrl);

	if (error)

		goto out_stop_queue;

		goto out_quiesce_queue;



	return 0;



out_quiesce_queue:

	blk_mq_quiesce_queue(ctrl->admin_q);

	blk_sync_queue(ctrl->admin_q);

out_stop_queue:

	nvme_tcp_stop_queue(ctrl, 0);

	nvme_cancel_admin_tagset(ctrl);

out_cleanup_queue:

	if (new)

		blk_cleanup_queue(ctrl->admin_q);
@@ -1904,11 +1907,7 @@ static void nvme_tcp_teardown_admin_queue(struct nvme_ctrl *ctrl, 
	blk_mq_quiesce_queue(ctrl->admin_q);

	blk_sync_queue(ctrl->admin_q);

	nvme_tcp_stop_queue(ctrl, 0);

	if (ctrl->admin_tagset) {

		blk_mq_tagset_busy_iter(ctrl->admin_tagset,

			nvme_cancel_request, ctrl);

		blk_mq_tagset_wait_completed_request(ctrl->admin_tagset);

	}

	nvme_cancel_admin_tagset(ctrl);

	if (remove)

		blk_mq_unquiesce_queue(ctrl->admin_q);

	nvme_tcp_destroy_admin_queue(ctrl, remove);
@@ -1924,11 +1923,7 @@ static void nvme_tcp_teardown_io_queues(struct nvme_ctrl *ctrl, 
	nvme_stop_queues(ctrl);

	nvme_sync_io_queues(ctrl);

	nvme_tcp_stop_io_queues(ctrl);

	if (ctrl->tagset) {

		blk_mq_tagset_busy_iter(ctrl->tagset,

			nvme_cancel_request, ctrl);

		blk_mq_tagset_wait_completed_request(ctrl->tagset);

	}

	nvme_cancel_tagset(ctrl);

	if (remove)

		nvme_start_queues(ctrl);

	nvme_tcp_destroy_io_queues(ctrl, remove);
@@ -2003,10 +1998,18 @@ static int nvme_tcp_setup_ctrl(struct nvme_ctrl *ctrl, bool new) 
	return 0;



destroy_io:

	if (ctrl->queue_count > 1)

	if (ctrl->queue_count > 1) {

		nvme_stop_queues(ctrl);

		nvme_sync_io_queues(ctrl);

		nvme_tcp_stop_io_queues(ctrl);

		nvme_cancel_tagset(ctrl);

		nvme_tcp_destroy_io_queues(ctrl, new);

	}

destroy_admin:

	blk_mq_quiesce_queue(ctrl->admin_q);

	blk_sync_queue(ctrl->admin_q);

	nvme_tcp_stop_queue(ctrl, 0);

	nvme_cancel_admin_tagset(ctrl);

	nvme_tcp_destroy_admin_queue(ctrl, new);

	return ret;

}
@@ -2268,12 +2271,12 @@ static blk_status_t nvme_tcp_setup_cmd_pdu(struct nvme_ns *ns, 
	req->data_len = blk_rq_nr_phys_segments(rq) ?

				blk_rq_payload_bytes(rq) : 0;

	req->curr_bio = rq->bio;

	if (req->curr_bio)

		nvme_tcp_init_iter(req, rq_data_dir(rq));



	if (rq_data_dir(rq) == WRITE &&

	    req->data_len <= nvme_tcp_inline_data_size(queue))

		req->pdu_len = req->data_len;

	else if (req->curr_bio)

		nvme_tcp_init_iter(req, READ);



	pdu->hdr.type = nvme_tcp_cmd;

	pdu->hdr.flags = 0;