nvme: double reset prevention
v3 cover nvme: double reset prevention
The main objective of this series is to prevent double resets. This sort of thing is known to have happened if a timeout occurs at roughly the same time as a user intiated reset, like through through PCIe's FLR.
The double reset could happen because the controller disabling had been occuring outside of the RESETTING state when we can't schedule the reset_work, which is to occur later. When another reset schedules in between these events, the controller ends up in the wrong state.
The end result of this series is simply to block subsequent resets by initializing the controller state to RESETTING without actually scheduling the reset_work.
v2 -> v3:
Added received reviews for patches that have not been significantly modified from the previous version.
Changelog updates.
Merged to most current linux mainline.
Added code comments for the less obvious interactions.
Collapsed the patch that introduced the new nvme_reset_continue() function with the "processing paused" patch that first uses it.
Renamed nvme_reset_continue() to nvme_reset_schedule() and documented its usage in comments.
Renamed nvme_state_transient() to nvme_state_terminal() and updated the logic accordingly.
Keith Busch (5):
nvme-pci: Free tagset if no IO queues
nvme: Remove ADMIN_ONLY state
nvme: Restart request timers in resetting state
nvme: Prevent resets during paused controller state
nvme: Wait for reset state when required
drivers/nvme/host/core.c | 90 +++++++++++++++++++++++++++---------- drivers/nvme/host/fabrics.h | 3 +- drivers/nvme/host/nvme.h | 5 ++- drivers/nvme/host/pci.c | 78 +++++++++++++++++++------------- drivers/nvme/host/rdma.c | 8 ++++ drivers/nvme/host/tcp.c | 8 ++++ 6 files changed, 133 insertions(+), 59 deletions(-)
Signature · 7 lines
2.21.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Keith Busch
maintainerPATCH v3 1/5 nvme-pci: Free tagset if no IO queues
If a controller becomes degraded after a reset, we will not be able to perform any IO. We currently teardown previously created request queues and namespaces, but we had kept the unusable tagset. Free it after all queues using it have been released.
--- drivers/nvme/host/pci.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)
drivers/nvme/host/pci.c +9 -2
@@ -2490,14 +2490,20 @@ static void nvme_release_prp_pools(struct nvme_dev *dev)dma_pool_destroy (dev->prp_small_pool); } +static void nvme_free_tagset (struct nvme_dev *dev) +{ +if (dev->tagset.tags) +blk_mq_free_tag_set (&dev->tagset); + dev->ctrl.tagset =NULL ; +} +static void nvme_pci_free_ctrl (struct nvme_ctrl *ctrl) {struct nvme_dev *dev =to_nvme_dev (ctrl);nvme_dbbuf_dma_free (dev);put_device (dev->dev); -if (dev->tagset.tags) -blk_mq_free_tag_set (&dev->tagset); +nvme_free_tagset (dev);if (dev->ctrl.admin_q)blk_put_queue (dev->ctrl.admin_q);kfree (dev->queues);
@@ -2616,6 +2622,7 @@ static void nvme_reset_work(struct work_struct *work)nvme_kill_queues (&dev->ctrl);nvme_remove_namespaces (&dev->ctrl); new_state =NVME_CTRL_ADMIN_ONLY ; +nvme_free_tagset (dev); }else {nvme_start_queues (&dev->ctrl);nvme_wait_freeze (&dev->ctrl);
Signature · 7 lines
2.21.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Keith Busch
maintainerPATCH v3 2/5 nvme: Remove ADMIN_ONLY state
In reply to Keith BuschThe admin only state was intended to fence off actions that don't apply to a non-IO capable controller. The only actual user of this is the scan_work, and pci was the only transport to ever set this state. The consequence of having this state is placing an additional burden on every other action that applies to both live and admin only controllers.
Remove the admin only state and place the admin only burden on the only place that actually cares: scan_work.
This also prepares to make it easier to temporarily pause a LIVE state so that we don't need to remember which state the controller had been in prior to the pause.
--- drivers/nvme/host/core.c | 23 ++++------------------- drivers/nvme/host/fabrics.h | 3 +-- drivers/nvme/host/nvme.h | 1 - drivers/nvme/host/pci.c | 21 ++++++--------------- 4 files changed, 11 insertions(+), 37 deletions(-)
drivers/nvme/host/core.c +4 -19
@@ -116,7 +116,7 @@ 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 ) +if (ctrl->state ==NVME_CTRL_LIVE && ctrl->tagset)queue_work (nvme_wq, &ctrl->scan_work); }
@@ -137,8 +137,7 @@ int nvme_reset_ctrl_sync(struct nvme_ctrl *ctrl) ret =nvme_reset_ctrl (ctrl);if (!ret) {flush_work (&ctrl->reset_work); -if (ctrl->state !=NVME_CTRL_LIVE && - ctrl->state !=NVME_CTRL_ADMIN_ONLY ) +if (ctrl->state !=NVME_CTRL_LIVE ) ret = -ENETRESET ; }
@@ -315,15 +314,6 @@ bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl, old_state = ctrl->state;switch (new_state) { -case NVME_CTRL_ADMIN_ONLY : -switch (old_state) { -case NVME_CTRL_CONNECTING : - changed = true; -/* FALLTHRU */ -default : -break ; - } -break ;case NVME_CTRL_LIVE :switch (old_state) {case NVME_CTRL_NEW :
@@ -339,7 +329,6 @@ bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,switch (old_state) {case NVME_CTRL_NEW :case NVME_CTRL_LIVE : -case NVME_CTRL_ADMIN_ONLY : changed = true;/* FALLTHRU */ default :
@@ -359,7 +348,6 @@ bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,case NVME_CTRL_DELETING :switch (old_state) {case NVME_CTRL_LIVE : -case NVME_CTRL_ADMIN_ONLY :case NVME_CTRL_RESETTING :case NVME_CTRL_CONNECTING : changed = true;
@@ -2874,7 +2862,6 @@ static int nvme_dev_open(struct inode *inode, struct file *file)switch (ctrl->state) {case NVME_CTRL_LIVE : -case NVME_CTRL_ADMIN_ONLY :break ;default :return -EWOULDBLOCK ;
@@ -3168,7 +3155,6 @@ static ssize_t nvme_sysfs_show_state(struct device *dev,static const char *const state_name[] = { [NVME_CTRL_NEW ] ="new" , [NVME_CTRL_LIVE ] ="live" , - [NVME_CTRL_ADMIN_ONLY ] ="only-admin" , [NVME_CTRL_RESETTING ] ="resetting" , [NVME_CTRL_CONNECTING ] ="connecting" , [NVME_CTRL_DELETING ] ="deleting" ,
@@ -3679,11 +3665,10 @@ static void nvme_scan_work(struct work_struct *work)struct nvme_id_ctrl *id;unsigned nn; -if (ctrl->state !=NVME_CTRL_LIVE ) +/* No tagset on a live ctrl means IO queues could not created */ +if (ctrl->state !=NVME_CTRL_LIVE || !ctrl->tagset)return ; -WARN_ON_ONCE (!ctrl->tagset); -if (test_and_clear_bit (NVME_AER_NOTICE_NS_CHANGED , &ctrl->events)) {dev_info (ctrl->device,"rescanning namespaces.\n" );nvme_clear_changed_ns_log (ctrl);
drivers/nvme/host/fabrics.h +1 -2
@@ -182,8 +182,7 @@ bool nvmf_ip_options_match(struct nvme_ctrl *ctrl,static inline bool nvmf_check_ready (struct nvme_ctrl *ctrl,struct request *rq,bool queue_live) { -if (likely (ctrl->state ==NVME_CTRL_LIVE || - ctrl->state ==NVME_CTRL_ADMIN_ONLY )) +if (likely (ctrl->state ==NVME_CTRL_LIVE ))return true;return __nvmf_check_ready (ctrl, rq, queue_live); }
drivers/nvme/host/nvme.h +0 -1
@@ -161,7 +161,6 @@ static inline u16 nvme_req_qid(struct request *req)enum nvme_ctrl_state {NVME_CTRL_NEW ,NVME_CTRL_LIVE , -NVME_CTRL_ADMIN_ONLY ,/* Only admin queue live */ NVME_CTRL_RESETTING ,NVME_CTRL_CONNECTING ,NVME_CTRL_DELETING ,
drivers/nvme/host/pci.c +6 -15
@@ -2263,10 +2263,7 @@ static bool __nvme_disable_io_queues(struct nvme_dev *dev, u8 opcode)return true; } -/* -* return error value only when tagset allocation failed -*/ -static int nvme_dev_add (struct nvme_dev *dev) +static void nvme_dev_add (struct nvme_dev *dev) {int ret;
@@ -2296,7 +2293,7 @@ static int nvme_dev_add(struct nvme_dev *dev)if (ret) {dev_warn (dev->ctrl.device,"IO queues tagset allocation failed %d\n" , ret); -return ret; +return ; } dev->ctrl.tagset = &dev->tagset; }else {
@@ -2307,7 +2304,6 @@ static int nvme_dev_add(struct nvme_dev *dev) }nvme_dbbuf_set (dev); -return 0 ; }static int nvme_pci_enable (struct nvme_dev *dev)
@@ -2527,7 +2523,6 @@ static void nvme_reset_work(struct work_struct *work) container_of(work, struct nvme_dev, ctrl.reset_work);bool was_suspend = !!(dev->ctrl.ctrl_config &NVME_CC_SHN_NORMAL );int result; -enum nvme_ctrl_state new_state =NVME_CTRL_LIVE ;if (WARN_ON (dev->ctrl.state !=NVME_CTRL_RESETTING )) { result = -ENODEV ;
@@ -2621,14 +2616,11 @@ static void nvme_reset_work(struct work_struct *work)dev_warn (dev->ctrl.device,"IO queues not created\n" );nvme_kill_queues (&dev->ctrl);nvme_remove_namespaces (&dev->ctrl); - new_state =NVME_CTRL_ADMIN_ONLY ;nvme_free_tagset (dev); }else {nvme_start_queues (&dev->ctrl);nvme_wait_freeze (&dev->ctrl); -/* hit this only when allocate tagset fails */ -if (nvme_dev_add (dev)) - new_state =NVME_CTRL_ADMIN_ONLY ; +nvme_dev_add (dev);nvme_unfreeze (&dev->ctrl); }
@@ -2636,9 +2628,9 @@ static void nvme_reset_work(struct work_struct *work)* If only admin queue live, keep it to do further investigation or * recovery. */ -if (!nvme_change_ctrl_state (&dev->ctrl, new_state)) { +if (!nvme_change_ctrl_state (&dev->ctrl,NVME_CTRL_LIVE )) {dev_warn (dev->ctrl.device, -"failed to mark controller state %d\n" , new_state); +"failed to mark controller live state\n" ); result = -ENODEV ; goto out; }
@@ -2945,8 +2937,7 @@ static int nvme_suspend(struct device *dev)nvme_wait_freeze (ctrl);nvme_sync_queues (ctrl); -if (ctrl->state !=NVME_CTRL_LIVE && - ctrl->state !=NVME_CTRL_ADMIN_ONLY ) +if (ctrl->state !=NVME_CTRL_LIVE ) goto unfreeze; ret =nvme_get_power_state (ctrl, &ndev->last_ps);
Signature · 7 lines
2.21.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Keith Busch
maintainerPATCH v3 3/5 nvme: Restart request timers in resetting state
In reply to Keith BuschA controller in the resetting state has not yet completed its recovery actions. The pci and fc transports were already handling this, so update the remaining transports to not attempt additional recovery in this state by just restarting the request timer.
--- drivers/nvme/host/rdma.c | 8 ++++++++ drivers/nvme/host/tcp.c | 8 ++++++++ 2 files changed, 16 insertions(+)
drivers/nvme/host/rdma.c +8 -0
@@ -1701,6 +1701,14 @@ nvme_rdma_timeout(struct request *rq, bool reserved)dev_warn (ctrl->ctrl.device,"I/O %d QID %d timeout\n" , rq->tag,nvme_rdma_queue_idx (queue)); +/* +* Restart the timer if a controller reset is already scheduled. Any +* timed out commands would be handled before entering the connecting +* state. +*/ +if (ctrl->ctrl.state ==NVME_CTRL_RESETTING ) +return BLK_EH_RESET_TIMER ; +if (ctrl->ctrl.state !=NVME_CTRL_LIVE ) {/* * Teardown immediately if controller times out while starting
drivers/nvme/host/tcp.c +8 -0
@@ -2044,6 +2044,14 @@ nvme_tcp_timeout(struct request *rq, bool reserved)struct nvme_tcp_ctrl *ctrl = req->queue->ctrl;struct nvme_tcp_cmd_pdu *pdu = req->pdu; +/* +* Restart the timer if a controller reset is already scheduled. Any +* timed out commands would be handled before entering the connecting +* state. +*/ +if (ctrl->ctrl.state ==NVME_CTRL_RESETTING ) +return BLK_EH_RESET_TIMER ; +dev_warn (ctrl->ctrl.device,"queue %d: timeout request %#x type %d\n" ,nvme_tcp_queue_id (req->queue), rq->tag, pdu->hdr.type);
Signature · 7 lines
2.21.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Keith Busch
maintainerPATCH v3 4/5 nvme: Prevent resets during paused controller state
In reply to Keith BuschA paused controller is doing critical internal activation work in the background. Prevent subsequent controller resets from occurring during this period by setting the controller state to RESETTING first. A helper function, nvme_reset_schedule(), is introduced for these paths so they may continue with scheduling the reset work after they've completed their uninterruptible critical section.
--- drivers/nvme/host/core.c | 28 ++++++++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-)
drivers/nvme/host/core.c +24 -4
@@ -120,6 +120,20 @@ static void nvme_queue_scan(struct nvme_ctrl *ctrl)queue_work (nvme_wq, &ctrl->scan_work); } +/* +* Use this function to proceed with scheduling reset_work for a controller +* that had previously been set to the resetting state. This is intended for +* code paths that can't be interrupted by other reset attempts. +*/ +static int nvme_reset_schedule (struct nvme_ctrl *ctrl) +{ +if (ctrl->state !=NVME_CTRL_RESETTING ) +return -EBUSY ; +if (!queue_work (nvme_reset_wq, &ctrl->reset_work)) +return -EBUSY ; +return 0 ; +} +int nvme_reset_ctrl (struct nvme_ctrl *ctrl) {if (!nvme_change_ctrl_state (ctrl,NVME_CTRL_RESETTING ))
@@ -3829,13 +3843,13 @@ static void nvme_fw_act_work(struct work_struct *work)if (time_after (jiffies, fw_act_timeout)) {dev_warn (ctrl->device,"Fw activation timeout, reset controller\n" ); -nvme_reset_ctrl (ctrl); -break ; +nvme_reset_schedule (ctrl); +return ; }msleep (100 ); } -if (ctrl->state !=NVME_CTRL_LIVE ) +if (!nvme_change_ctrl_state (ctrl,NVME_CTRL_LIVE ))return ;nvme_start_queues (ctrl);
@@ -3855,7 +3869,13 @@ static void nvme_handle_aen_notice(struct nvme_ctrl *ctrl, u32 result)nvme_queue_scan (ctrl);break ;case NVME_AER_NOTICE_FW_ACT_STARTING : -queue_work (nvme_wq, &ctrl->fw_act_work); +/* +* We are (ab)using the RESETTING state to prevent subsequent +* recovery actions from interfering with the controller's +* firmware activation. +*/ +if (nvme_change_ctrl_state (ctrl,NVME_CTRL_RESETTING )) +queue_work (nvme_wq, &ctrl->fw_act_work);break ;#ifdef CONFIG_NVME_MULTIPATH case NVME_AER_NOTICE_ANA :
Signature · 7 lines
2.21.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Keith Busch
maintainerPATCH v3 5/5 nvme: Wait for reset state when required
In reply to Keith BuschPrevent simultaneous controller disabling/enabling tasks from interfering with each other through a method to wait until the task successfully transitioned the controller to the RESETTING state. This ensures disabling the controller will not be interrupted by another reset path, otherwise a concurrent reset would leave the controller in the wrong state.
--- drivers/nvme/host/core.c | 41 +++++++++++++++++++++++++++++++++-- drivers/nvme/host/nvme.h | 4 ++++ drivers/nvme/host/pci.c | 46 +++++++++++++++++++++++++++------------- 3 files changed, 74 insertions(+), 17 deletions(-)
drivers/nvme/host/core.c +39 -2
@@ -125,7 +125,7 @@ static void nvme_queue_scan(struct nvme_ctrl *ctrl)* that had previously been set to the resetting state. This is intended for * code paths that can't be interrupted by other reset attempts. */ -static int nvme_reset_schedule (struct nvme_ctrl *ctrl) +int nvme_reset_schedule (struct nvme_ctrl *ctrl) {if (ctrl->state !=NVME_CTRL_RESETTING )return -EBUSY ;
@@ -133,6 +133,7 @@ static int nvme_reset_schedule(struct nvme_ctrl *ctrl)return -EBUSY ;return 0 ; } +EXPORT_SYMBOL_GPL (nvme_reset_schedule);int nvme_reset_ctrl (struct nvme_ctrl *ctrl) {
@@ -383,8 +384,10 @@ bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,break ; } -if (changed) +if (changed) { ctrl->state = new_state; +wake_up_all (&ctrl->state_wq); + }spin_unlock_irqrestore (&ctrl->lock, flags);if (changed && ctrl->state ==NVME_CTRL_LIVE )
@@ -393,6 +396,39 @@ bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl, }EXPORT_SYMBOL_GPL (nvme_change_ctrl_state); +/* +* Returns true for sink states that can't ever transition back to live. +*/ +static bool nvme_state_terminal (struct nvme_ctrl *ctrl) +{ +switch (ctrl->state) { +case NVME_CTRL_NEW : +case NVME_CTRL_LIVE : +case NVME_CTRL_RESETTING : +case NVME_CTRL_CONNECTING : +return false; +case NVME_CTRL_DELETING : +case NVME_CTRL_DEAD : +return true; +default : +WARN_ONCE (1 ,"Unhandled ctrl state:%d" , ctrl->state); +return true; + } +} + +/* +* Waits for the controller state to be resetting, or returns false if it is +* not possible to ever transition to that state. +*/ +bool nvme_wait_reset (struct nvme_ctrl *ctrl) +{ +wait_event (ctrl->state_wq, +nvme_change_ctrl_state (ctrl,NVME_CTRL_RESETTING ) || +nvme_state_terminal (ctrl)); +return ctrl->state ==NVME_CTRL_RESETTING ; +} +EXPORT_SYMBOL_GPL (nvme_wait_reset); +static void nvme_free_ns_head (struct kref *ref) { struct nvme_ns_head *head =
@@ -3998,6 +4034,7 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct device *dev,INIT_WORK (&ctrl->async_event_work, nvme_async_event_work);INIT_WORK (&ctrl->fw_act_work, nvme_fw_act_work);INIT_WORK (&ctrl->delete_work, nvme_delete_ctrl_work); +init_waitqueue_head (&ctrl->state_wq);INIT_DELAYED_WORK (&ctrl->ka_work, nvme_keep_alive_work);memset (&ctrl->ka_cmd,0 ,sizeof (ctrl->ka_cmd));
drivers/nvme/host/nvme.h +4 -0
@@ -15,6 +15,7 @@#include <linux/sed-opal.h> #include <linux/fault-inject.h> #include <linux/rcupdate.h> +#include <linux/wait.h> #include <trace/events/block.h>
@@ -198,6 +199,7 @@ struct nvme_ctrl {struct cdev cdev;struct work_struct reset_work;struct work_struct delete_work; +wait_queue_head_t state_wq;struct nvme_subsystem *subsys;struct list_head subsys_entry;
@@ -448,6 +450,7 @@ void nvme_complete_rq(struct request *req);bool nvme_cancel_request (struct request *req,void *data,bool reserved);bool nvme_change_ctrl_state (struct nvme_ctrl *ctrl,enum nvme_ctrl_state new_state); +bool nvme_wait_reset (struct nvme_ctrl *ctrl);int nvme_disable_ctrl (struct nvme_ctrl *ctrl);int nvme_enable_ctrl (struct nvme_ctrl *ctrl);int nvme_shutdown_ctrl (struct nvme_ctrl *ctrl);
@@ -498,6 +501,7 @@ int nvme_set_queue_count(struct nvme_ctrl *ctrl, int *count);void nvme_stop_keep_alive (struct nvme_ctrl *ctrl);int nvme_reset_ctrl (struct nvme_ctrl *ctrl);int nvme_reset_ctrl_sync (struct nvme_ctrl *ctrl); +int nvme_reset_schedule (struct nvme_ctrl *ctrl);int nvme_delete_ctrl (struct nvme_ctrl *ctrl); int nvme_get_log(struct nvme_ctrl *ctrl, u32 nsid, u8 log_page, u8 lsp,
drivers/nvme/host/pci.c +31 -15
105 lines not on this page · raw message
Signature · 7 lines
2.21.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Christoph Hellwig
maintainerRe: [PATCHv3 4/5] nvme: Prevent resets during paused controller state
In reply to Keith BuschQuoted 18 lines · Keith Busch
drivers/nvme/host/core.c +14
-0+/* +* Use this function to proceed with scheduling reset_work for a controller +* that had previously been set to the resetting state. This is intended for +* code paths that can't be interrupted by other reset attempts. +*/ +static int nvme_reset_schedule (struct nvme_ctrl *ctrl) +{ +if (ctrl->state !=NVME_CTRL_RESETTING ) +return -EBUSY ; +if (!queue_work (nvme_reset_wq, &ctrl->reset_work)) +return -EBUSY ; +return 0 ; +} +int nvme_reset_ctrl (struct nvme_ctrl *ctrl) {if (!nvme_change_ctrl_state (ctrl,NVME_CTRL_RESETTING ))
drivers/nvme/host/core.c static void nvme_fw_act_work(struct work_struct *work) · line 3847
Quoted 7 lines
drivers/nvme/host/core.c +2
-2@@ -3829,13 +3843,13 @@ static void nvme_fw_act_work(struct work_struct *work)if (time_after (jiffies, fw_act_timeout)) {dev_warn (ctrl->device,"Fw activation timeout, reset controller\n" ); -nvme_reset_ctrl (ctrl); -break ; +nvme_reset_schedule (ctrl); +return ;
I don't really see a point in that nvme_reset_schedule helper, especially as the name is a little confusing. Moving the comment here and just open coding a
if (ctrl->state == NVME_CTRL_RESETTING) queue_work(nvme_reset_wq, &ctrl->reset_work))
would seem much more obvious and matches the nvme_handle_aen_notice side.
_______________________________________________
Linux-nvme mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-nvme
Keith Busch
maintainerRe: [PATCHv3 4/5] nvme: Prevent resets during paused controller state
Quoted 31 lines · Christoph Hellwig
Quoted 18 lines · Keith Busch
drivers/nvme/host/core.c +14
-0+/* +* Use this function to proceed with scheduling reset_work for a controller +* that had previously been set to the resetting state. This is intended for +* code paths that can't be interrupted by other reset attempts. +*/ +static int nvme_reset_schedule (struct nvme_ctrl *ctrl) +{ +if (ctrl->state !=NVME_CTRL_RESETTING ) +return -EBUSY ; +if (!queue_work (nvme_reset_wq, &ctrl->reset_work)) +return -EBUSY ; +return 0 ; +} +int nvme_reset_ctrl (struct nvme_ctrl *ctrl) {if (!nvme_change_ctrl_state (ctrl,NVME_CTRL_RESETTING ))drivers/nvme/host/core.c static void nvme_fw_act_work(struct work_struct *work) · line 3847
Quoted 7 lines
drivers/nvme/host/core.c +2
-2@@ -3829,13 +3843,13 @@ static void nvme_fw_act_work(struct work_struct *work)if (time_after (jiffies, fw_act_timeout)) {dev_warn (ctrl->device,"Fw activation timeout, reset controller\n" ); -nvme_reset_ctrl (ctrl); -break ; +nvme_reset_schedule (ctrl); +return ;I don't really see a point in that
nvme_reset_schedulehelper, especially as the name is a little confusing. Moving the comment here and just open coding a
Quoted 5 lines
if (ctrl->state == NVME_CTRL_RESETTING) queue_work(nvme_reset_wq, &ctrl->reset_work))would seem much more obvious and matches the
nvme_handle_aen_noticeside.
Until a moment ago, I thought nvme_reset_wq was a local static, which is why I needed to provide an exportable function so drivers can schedule on it. I see now that symbolis exported for some reason despite no external users, but since it is exported, we can duplicate this "if (RESETTING) queue_work()" stuff from the pci driver.
_______________________________________________
Linux-nvme mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-nvme
Christoph Hellwig
maintainerRe: [PATCHv3 5/5] nvme: Wait for reset state when required
In reply to Keith Buschdrivers/nvme/host/core.c static int nvme_reset_schedule(struct nvme_ctrl *ctrl) · line 136
Quoted 9 lines
drivers/nvme/host/core.c +2
-0+int nvme_reset_schedule (struct nvme_ctrl *ctrl) {if (ctrl->state !=NVME_CTRL_RESETTING )return -EBUSY ;@@ -133,6 +133,7 @@ static int nvme_reset_schedule(struct nvme_ctrl *ctrl)return -EBUSY ;return 0 ; } +EXPORT_SYMBOL_GPL (nvme_reset_schedule);
Oh well, forgot we grow more users later. The naming of the thing still puzlles me, though. Maybe something like nvme_schedule_reset_work is a little better? Not that I'm fully happy with that either.
drivers/nvme/host/pci.c static int nvme_probe(struct pci_dev *pdev, const struct pci_device_id *id) · line 2866
Quoted 7 lines
drivers/nvme/host/pci.c +3
-1static void nvme_reset_done (struct pci_dev *pdev) {struct nvme_dev *dev =pci_get_drvdata (pdev); -nvme_reset_ctrl_sync (&dev->ctrl); + +if (!nvme_reset_schedule (&dev->ctrl)) +flush_work (&dev->ctrl.reset_work);
Do we need a comment on the flush?
_______________________________________________
Linux-nvme mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-nvme
Keith Busch
maintainerRe: [PATCHv3 5/5] nvme: Wait for reset state when required
Quoted 5 lines · Christoph Hellwig
Quoted 5 lines
drivers/nvme/host/core.c +1
-0+int nvme_reset_schedule (struct nvme_ctrl *ctrl) {if (ctrl->state !=NVME_CTRL_RESETTING )return -EBUSY ;@@ -133,6 +133,7 @@ static int nvme_reset_schedule(struct nvme_ctrl *ctrl)
Quoted 8 lines
drivers/nvme/host/core.c static int nvme_reset_schedule(struct nvme_ctrl *ctrl) · line 136
Quoted 4 lines
drivers/nvme/host/core.c +1
-0return -EBUSY ;return 0 ; } +EXPORT_SYMBOL_GPL (nvme_reset_schedule);Oh well, forgot we grow more users later. The naming of the thing still puzlles me, though. Maybe something like
nvme_schedule_reset_workis a little better? Not that I'm fully happy with that either.
I'm struggling to discover the right name here. Something like nvme_schedule_reset_work_if_resetting() really captures it, but is a bit verbose. Maybe nvme_try_sched_reset_work()?
Quoted 9 lines
drivers/nvme/host/pci.c static int nvme_probe(struct pci_dev *pdev, const struct pci_device_id *id) · line 2866
Quoted 7 lines
drivers/nvme/host/pci.c +3
-1static void nvme_reset_done (struct pci_dev *pdev) {struct nvme_dev *dev =pci_get_drvdata (pdev); -nvme_reset_ctrl_sync (&dev->ctrl); + +if (!nvme_reset_schedule (&dev->ctrl)) +flush_work (&dev->ctrl.reset_work);Do we need a comment on the flush?
Will do.
_______________________________________________
Linux-nvme mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-nvme