Commit 84e92c13 authored by Jens Axboe's avatar Jens Axboe
Browse files

Merge branch 'nvme-4.18' of git://git.infradead.org/nvme into for-4.18/block 

Pull NVMe changes from Christoph:

"Below is another set of NVMe updates for 4.18.  Besides the usual bug
 fixes this includes more feature completness in terms of AEN and log
 page handling on the target."

* 'nvme-4.18' of git://git.infradead.org/nvme:
  nvme: use the changed namespaces list log to clear ns data changed AENs
  nvme: mark nvme_queue_scan static
  nvme: submit AEN event configuration on startup
  nvmet: mask pending AENs
  nvmet: add AEN configuration support
  nvmet: implement the changed namespaces log
  nvmet: split log page implementation
  nvmet: add a new nvmet_zero_sgl helper
  nvme.h: add AEN configuration symbols
  nvme.h: add the changed namespace list log
  nvme.h: untangle AEN notice definitions
  nvmet: fix error return code in nvmet_file_ns_enable()
  nvmet: fix a typo in nvmet_file_ns_enable()
  nvme-fabrics: allow internal passthrough command on deleting controllers
  nvme-loop: add support for multiple ports
  nvme-pci: simplify __nvme_submit_cmd
  nvme-pci: Rate limit the nvme timeout warnings
  nvme: allow duplicate controller if prior controller being deleted
parents 131d08e1 30d90964

drivers/nvme/host/core.c

+90 −25
Original line number Diff line number Diff line
@@ -100,6 +100,15 @@ static struct class *nvme_subsys_class; 
static void nvme_ns_remove(struct nvme_ns *ns);

static int nvme_revalidate_disk(struct gendisk *disk);



static void nvme_queue_scan(struct nvme_ctrl *ctrl)

{

	/*

	 * Only new queue scan work when admin and IO queues are both alive

	 */

	if (ctrl->state == NVME_CTRL_LIVE)

		queue_work(nvme_wq, &ctrl->scan_work);

}



int nvme_reset_ctrl(struct nvme_ctrl *ctrl)

{

	if (!nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING))
@@ -1027,6 +1036,21 @@ int nvme_set_queue_count(struct nvme_ctrl *ctrl, int *count) 
}

EXPORT_SYMBOL_GPL(nvme_set_queue_count);



#define NVME_AEN_SUPPORTED \

	(NVME_AEN_CFG_NS_ATTR | NVME_AEN_CFG_FW_ACT)



static void nvme_enable_aen(struct nvme_ctrl *ctrl)

{

	u32 result;

	int status;



	status = nvme_set_features(ctrl, NVME_FEAT_ASYNC_EVENT,

			ctrl->oaes & NVME_AEN_SUPPORTED, NULL, 0, &result);

	if (status)

		dev_warn(ctrl->device, "Failed to configure AEN (cfg %x)\n",

			 ctrl->oaes & NVME_AEN_SUPPORTED);

}



static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio)

{

	struct nvme_user_io io;
@@ -2344,6 +2368,7 @@ int nvme_init_identify(struct nvme_ctrl *ctrl) 


	ctrl->oacs = le16_to_cpu(id->oacs);

	ctrl->oncs = le16_to_cpup(&id->oncs);

	ctrl->oaes = le32_to_cpu(id->oaes);

	atomic_set(&ctrl->abort_limit, id->acl + 1);

	ctrl->vwc = id->vwc;

	ctrl->cntlid = le16_to_cpup(&id->cntlid);
@@ -3166,6 +3191,42 @@ static void nvme_scan_ns_sequential(struct nvme_ctrl *ctrl, unsigned nn) 
	nvme_remove_invalid_namespaces(ctrl, nn);

}



static bool nvme_scan_changed_ns_log(struct nvme_ctrl *ctrl)

{

	size_t log_size = NVME_MAX_CHANGED_NAMESPACES * sizeof(__le32);

	__le32 *log;

	int error, i;

	bool ret = false;



	log = kzalloc(log_size, GFP_KERNEL);

	if (!log)

		return false;



	error = nvme_get_log(ctrl, NVME_LOG_CHANGED_NS, log, log_size);

	if (error) {

		dev_warn(ctrl->device,

			"reading changed ns log failed: %d\n", error);

		goto out_free_log;

	}



	if (log[0] == cpu_to_le32(0xffffffff))

		goto out_free_log;



	for (i = 0; i < NVME_MAX_CHANGED_NAMESPACES; i++) {

		u32 nsid = le32_to_cpu(log[i]);



		if (nsid == 0)

			break;

		dev_info(ctrl->device, "rescanning namespace %d.\n", nsid);

		nvme_validate_ns(ctrl, nsid);

	}

	ret = true;



out_free_log:

	kfree(log);

	return ret;

}



static void nvme_scan_work(struct work_struct *work)

{

	struct nvme_ctrl *ctrl =
@@ -3178,6 +3239,12 @@ static void nvme_scan_work(struct work_struct *work) 


	WARN_ON_ONCE(!ctrl->tagset);



	if (test_and_clear_bit(EVENT_NS_CHANGED, &ctrl->events)) {

		if (nvme_scan_changed_ns_log(ctrl))

			goto out_sort_namespaces;

		dev_info(ctrl->device, "rescanning namespaces.\n");

	}



	if (nvme_identify_ctrl(ctrl, &id))

		return;
@@ -3185,25 +3252,16 @@ static void nvme_scan_work(struct work_struct *work) 
	if (ctrl->vs >= NVME_VS(1, 1, 0) &&

	    !(ctrl->quirks & NVME_QUIRK_IDENTIFY_CNS)) {

		if (!nvme_scan_ns_list(ctrl, nn))

			goto done;

			goto out_free_id;

	}

	nvme_scan_ns_sequential(ctrl, nn);

 done:

out_free_id:

	kfree(id);

out_sort_namespaces:

	down_write(&ctrl->namespaces_rwsem);

	list_sort(NULL, &ctrl->namespaces, ns_cmp);

	up_write(&ctrl->namespaces_rwsem);

	kfree(id);

}



void nvme_queue_scan(struct nvme_ctrl *ctrl)

{

	/*

	 * Only new queue scan work when admin and IO queues are both alive

	 */

	if (ctrl->state == NVME_CTRL_LIVE)

		queue_work(nvme_wq, &ctrl->scan_work);

}

EXPORT_SYMBOL_GPL(nvme_queue_scan);



/*

 * This function iterates the namespace list unlocked to allow recovery from
@@ -3318,6 +3376,21 @@ static void nvme_fw_act_work(struct work_struct *work) 
	nvme_get_fw_slot_info(ctrl);

}



static void nvme_handle_aen_notice(struct nvme_ctrl *ctrl, u32 result)

{

	switch ((result & 0xff00) >> 8) {

	case NVME_AER_NOTICE_NS_CHANGED:

		set_bit(EVENT_NS_CHANGED, &ctrl->events);

		nvme_queue_scan(ctrl);

		break;

	case NVME_AER_NOTICE_FW_ACT_STARTING:

		queue_work(nvme_wq, &ctrl->fw_act_work);

		break;

	default:

		dev_warn(ctrl->device, "async event result %08x\n", result);

	}

}



void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status,

		volatile union nvme_result *res)

{
@@ -3327,6 +3400,9 @@ void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status, 
		return;



	switch (result & 0x7) {

	case NVME_AER_NOTICE:

		nvme_handle_aen_notice(ctrl, result);

		break;

	case NVME_AER_ERROR:

	case NVME_AER_SMART:

	case NVME_AER_CSS:
@@ -3336,18 +3412,6 @@ void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status, 
	default:

		break;

	}



	switch (result & 0xff07) {

	case NVME_AER_NOTICE_NS_CHANGED:

		dev_info(ctrl->device, "rescanning\n");

		nvme_queue_scan(ctrl);

		break;

	case NVME_AER_NOTICE_FW_ACT_STARTING:

		queue_work(nvme_wq, &ctrl->fw_act_work);

		break;

	default:

		dev_warn(ctrl->device, "async event result %08x\n", result);

	}

	queue_work(nvme_wq, &ctrl->async_event_work);

}

EXPORT_SYMBOL_GPL(nvme_complete_async_event);
@@ -3370,6 +3434,7 @@ void nvme_start_ctrl(struct nvme_ctrl *ctrl) 


	if (ctrl->queue_count > 1) {

		nvme_queue_scan(ctrl);

		nvme_enable_aen(ctrl);

		queue_work(nvme_wq, &ctrl->async_event_work);

		nvme_start_queues(ctrl);

	}

drivers/nvme/host/fabrics.c

+31 −48
Original line number Diff line number Diff line
@@ -545,71 +545,54 @@ blk_status_t nvmf_check_if_ready(struct nvme_ctrl *ctrl, struct request *rq, 
		return BLK_STS_OK;



	switch (ctrl->state) {

	case NVME_CTRL_DELETING:

		goto reject_io;



	case NVME_CTRL_NEW:

	case NVME_CTRL_CONNECTING:

		if (!is_connected)

	case NVME_CTRL_DELETING:

		/*

			 * This is the case of starting a new

			 * association but connectivity was lost

			 * before it was fully created. We need to

			 * error the commands used to initialize the

			 * controller so the reconnect can go into a

			 * retry attempt. The commands should all be

			 * marked REQ_FAILFAST_DRIVER, which will hit

			 * the reject path below. Anything else will

			 * be queued while the state settles.

		 * This is the case of starting a new or deleting an association

		 * but connectivity was lost before it was fully created or torn

		 * down. We need to error the commands used to initialize the

		 * controller so the reconnect can go into a retry attempt.  The

		 * commands should all be marked REQ_FAILFAST_DRIVER, which will

		 * hit the reject path below. Anything else will be queued while

		 * the state settles.

		 */

			goto reject_or_queue_io;

		if (!is_connected)

			break;



		if ((queue_live &&

		     !(nvme_req(rq)->flags & NVME_REQ_USERCMD)) ||

		    (!queue_live && blk_rq_is_passthrough(rq) &&

		     cmd->common.opcode == nvme_fabrics_command &&

		     cmd->fabrics.fctype == nvme_fabrics_type_connect))

		/*

			 * If queue is live, allow only commands that

			 * are internally generated pass through. These

			 * are commands on the admin queue to initialize

			 * the controller. This will reject any ioctl

			 * admin cmds received while initializing.

			 *

			 * If the queue is not live, allow only a

			 * connect command. This will reject any ioctl

			 * admin cmd as well as initialization commands

			 * if the controller reverted the queue to non-live.

		 * If queue is live, allow only commands that are internally

		 * generated pass through.  These are commands on the admin

		 * queue to initialize the controller. This will reject any

		 * ioctl admin cmds received while initializing.

		 */

		if (queue_live && !(nvme_req(rq)->flags & NVME_REQ_USERCMD))

			return BLK_STS_OK;



		/*

		 * fall-thru to the reject_or_queue_io clause

		 * If the queue is not live, allow only a connect command.  This

		 * will reject any ioctl admin cmd as well as initialization

		 * commands if the controller reverted the queue to non-live.

		 */

		if (!queue_live && blk_rq_is_passthrough(rq) &&

		     cmd->common.opcode == nvme_fabrics_command &&

		     cmd->fabrics.fctype == nvme_fabrics_type_connect)

			return BLK_STS_OK;

		break;



	/* these cases fall-thru

	 * case NVME_CTRL_LIVE:

	 * case NVME_CTRL_RESETTING:

	 */

	default:

		break;

	}



reject_or_queue_io:

	/*

	 * Any other new io is something we're not in a state to send

	 * to the device. Default action is to busy it and retry it

	 * after the controller state is recovered. However, anything

	 * marked for failfast or nvme multipath is immediately failed.

	 * Note: commands used to initialize the controller will be

	 *  marked for failfast.

	 * Any other new io is something we're not in a state to send to the

	 * device.  Default action is to busy it and retry it after the

	 * controller state is recovered. However, anything marked for failfast

	 * or nvme multipath is immediately failed.  Note: commands used to

	 * initialize the controller will be marked for failfast.

	 * Note: nvme cli/ioctl commands are marked for failfast.

	 */

	if (!blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH))

		return BLK_STS_RESOURCE;



reject_io:

	nvme_req(rq)->status = NVME_SC_ABORT_REQ;

	return BLK_STS_IOERR;

}

drivers/nvme/host/fabrics.h

+3 −1
Original line number Diff line number Diff line
@@ -139,7 +139,9 @@ static inline bool 
nvmf_ctlr_matches_baseopts(struct nvme_ctrl *ctrl,

			struct nvmf_ctrl_options *opts)

{

	if (strcmp(opts->subsysnqn, ctrl->opts->subsysnqn) ||

	if (ctrl->state == NVME_CTRL_DELETING ||

	    ctrl->state == NVME_CTRL_DEAD ||

	    strcmp(opts->subsysnqn, ctrl->opts->subsysnqn) ||

	    strcmp(opts->host->nqn, ctrl->opts->host->nqn) ||

	    memcmp(&opts->host->id, &ctrl->opts->host->id, sizeof(uuid_t)))

		return false;

drivers/nvme/host/nvme.h

+3 −1
Original line number Diff line number Diff line
@@ -176,6 +176,7 @@ struct nvme_ctrl { 
	u16 kas;

	u8 npss;

	u8 apsta;

	u32 oaes;

	u32 aen_result;

	unsigned int shutdown_timeout;

	unsigned int kato;
@@ -188,6 +189,8 @@ struct nvme_ctrl { 
	struct delayed_work ka_work;

	struct nvme_command ka_cmd;

	struct work_struct fw_act_work;

#define EVENT_NS_CHANGED		(1 << 0)

	unsigned long events;



	/* Power saving configuration */

	u64 ps_max_latency_us;
@@ -394,7 +397,6 @@ void nvme_stop_ctrl(struct nvme_ctrl *ctrl); 
void nvme_put_ctrl(struct nvme_ctrl *ctrl);

int nvme_init_identify(struct nvme_ctrl *ctrl);



void nvme_queue_scan(struct nvme_ctrl *ctrl);

void nvme_remove_namespaces(struct nvme_ctrl *ctrl);



int nvme_sec_submit(void *data, u16 spsp, u8 secp, void *buffer, size_t len,

drivers/nvme/host/pci.c

+15 −24
Original line number Diff line number Diff line
@@ -421,28 +421,25 @@ static int nvme_pci_map_queues(struct blk_mq_tag_set *set) 
}



/**

 * __nvme_submit_cmd() - Copy a command into a queue and ring the doorbell

 * nvme_submit_cmd() - Copy a command into a queue and ring the doorbell

 * @nvmeq: The queue to use

 * @cmd: The command to send

 *

 * Safe to use from interrupt context

 */

static void __nvme_submit_cmd(struct nvme_queue *nvmeq,

						struct nvme_command *cmd)

static void nvme_submit_cmd(struct nvme_queue *nvmeq, struct nvme_command *cmd)

{

	u16 tail = nvmeq->sq_tail;



	spin_lock(&nvmeq->sq_lock);

	if (nvmeq->sq_cmds_io)

		memcpy_toio(&nvmeq->sq_cmds_io[tail], cmd, sizeof(*cmd));

		memcpy_toio(&nvmeq->sq_cmds_io[nvmeq->sq_tail], cmd,

				sizeof(*cmd));

	else

		memcpy(&nvmeq->sq_cmds[tail], cmd, sizeof(*cmd));

		memcpy(&nvmeq->sq_cmds[nvmeq->sq_tail], cmd, sizeof(*cmd));



	if (++tail == nvmeq->q_depth)

		tail = 0;

	if (nvme_dbbuf_update_and_check_event(tail, nvmeq->dbbuf_sq_db,

					      nvmeq->dbbuf_sq_ei))

		writel(tail, nvmeq->q_db);

	nvmeq->sq_tail = tail;

	if (++nvmeq->sq_tail == nvmeq->q_depth)

		nvmeq->sq_tail = 0;

	if (nvme_dbbuf_update_and_check_event(nvmeq->sq_tail,

			nvmeq->dbbuf_sq_db, nvmeq->dbbuf_sq_ei))

		writel(nvmeq->sq_tail, nvmeq->q_db);

	spin_unlock(&nvmeq->sq_lock);

}



static void **nvme_pci_iod_list(struct request *req)
@@ -895,10 +892,7 @@ static blk_status_t nvme_queue_rq(struct blk_mq_hw_ctx *hctx, 
	}



	blk_mq_start_request(req);



	spin_lock(&nvmeq->sq_lock);

	__nvme_submit_cmd(nvmeq, &cmnd);

	spin_unlock(&nvmeq->sq_lock);

	nvme_submit_cmd(nvmeq, &cmnd);

	return BLK_STS_OK;

out_cleanup_iod:

	nvme_free_iod(dev, req);
@@ -1058,10 +1052,7 @@ static void nvme_pci_submit_async_event(struct nvme_ctrl *ctrl) 
	memset(&c, 0, sizeof(c));

	c.common.opcode = nvme_admin_async_event;

	c.common.command_id = NVME_AQ_BLK_MQ_DEPTH;



	spin_lock(&nvmeq->sq_lock);

	__nvme_submit_cmd(nvmeq, &c);

	spin_unlock(&nvmeq->sq_lock);

	nvme_submit_cmd(nvmeq, &c);

}



static int adapter_delete_queue(struct nvme_dev *dev, u8 opcode, u16 id)
@@ -1227,7 +1218,7 @@ static enum blk_eh_timer_return nvme_timeout(struct request *req, bool reserved) 
	switch (dev->ctrl.state) {

	case NVME_CTRL_CONNECTING:

	case NVME_CTRL_RESETTING:

		dev_warn(dev->ctrl.device,

		dev_warn_ratelimited(dev->ctrl.device,

			 "I/O %d QID %d timeout, disable controller\n",

			 req->tag, nvmeq->qid);

		nvme_dev_disable(dev, false);

CRA Git | Maintained and supported by SUSTech CRA and CCSE