target: TMF and recovery fixes
Subsystems (5)
v5 cover target: TMF and recovery fixes
The following patches apply over Martin's 6.4 branches and Linus's tree. They fix a couple regressions in iscsit that occur when there are TMRs executing and a connection is closed. It also includes Dimitry's fixes in related code paths for cmd cleanup when ERL2 is used and the write pending hang during conn cleanup.
This version of the patchset brings it back to just regressions and fixes for bugs we have a lot of users hitting. I'm going to fix isert and get it hooked into iscsit properly in a second patchset, because this one was getting so large. I've also moved my cleanup type of patches for a 3rd patchset.
v5:
- Fix
scsi: target: Fix multiple LUN_RESET handling
so we don't execute a reset before it's submited.
- Move isert changes to separate patchset.
- Add write pending fix.
v4:
- Fix
[PATCH v3 07/14] scsi: target: Fix multiple LUN_RESET handling so it doesn't add back the bug where resets can wait on each other and deadlock.
- Updated
[PATCH v3 06/14] scsi: target: iscsit: Fix TAS handling during conn so it handles the case where commands have passed the STOP checks and have not yet hit them.
- Added patch to handle another hang found while testnig where we wait on the free_compl but never drop a ref due to being in the wrong state. v3:
- Drop patch "iscsit: Fix isert disconnect handling during login"
- Add patch to drop cmd lock in completion callout
- Add patch to clean up recovery commands earlier when ERL2 is used
- Add patch to handle use-after-free in isert
v2:
- Fix wait/stop use during login failures
- Add patches to support isert
PATCH v5 1/9 scsi: target: Move sess cmd counter to new struct
iSCSI needs to wait on outstanding commands like how srp and the FC/fcoe drivers do. It can't use target_stop_session because for MCS support we can't stop the entire session during recovery because if other connections are ok then we want to be able to continue to execute IO on them.
This patch moves the per session cmd counters to a new struct, so iSCSI can allocate it per connection. The xcopy code can also just not allocate it in the future since it doesn't need to track commands.
--- drivers/target/target_core_tpg.c | 2 +- drivers/target/target_core_transport.c | 135 ++++++++++++++++------- include/target/iscsi/iscsi_target_core.h | 1 + include/target/target_core_base.h | 13 ++- 4 files changed, 107 insertions(+), 44 deletions(-)
drivers/target/target_core_tpg.c +1 -1
@@ -328,7 +328,7 @@ static void target_shutdown_sessions(struct se_node_acl *acl) restart:spin_lock_irqsave (&acl->nacl_sess_lock, flags);list_for_each_entry (sess, &acl->acl_sess_list, sess_acl_list) { -if (atomic_read (&sess->stopped)) +if (sess->cmd_cnt &&atomic_read (&sess->cmd_cnt->stopped))continue ;list_del_init (&sess->sess_acl_list);
drivers/target/target_core_transport.c +96 -39
201 lines not on this page · raw message
include/target/iscsi/iscsi_target_core.h +1 -0
@@ -600,6 +600,7 @@ struct iscsit_conn {struct iscsi_tpg_np *tpg_np;/* Pointer to parent session */ struct iscsit_session *sess; +struct target_cmd_counter *cmd_cnt;int bitmap_id;int rx_thread_active;struct task_struct *rx_thread;
include/target/target_core_base.h +9 -4
@@ -494,6 +494,7 @@ struct se_cmd {struct se_lun *se_lun;/* Only used for internal passthrough and legacy TCM fabric modules */ struct se_session *se_sess; +struct target_cmd_counter *cmd_cnt;struct se_tmr_req *se_tmr_req;struct llist_node se_cmd_list;struct completion *free_compl;
@@ -619,22 +620,26 @@ static inline struct se_node_acl *fabric_stat_to_nacl(struct config_item *item) acl_fabric_stat_group); } -struct se_session { +struct target_cmd_counter { +struct percpu_ref refcnt; +wait_queue_head_t refcnt_wq; +struct completion stop_done;atomic_t stopped; +}; + +struct se_session {u64 sess_bin_isid;enum target_prot_op sup_prot_ops;enum target_prot_type sess_prot_type;struct se_node_acl *se_node_acl;struct se_portal_group *se_tpg;void *fabric_sess_ptr; -struct percpu_ref cmd_count;struct list_head sess_list;struct list_head sess_acl_list;spinlock_t sess_cmd_lock; -wait_queue_head_t cmd_count_wq; -struct completion stop_done;void *sess_cmd_map;struct sbitmap_queue sess_tag_pool; +struct target_cmd_counter *cmd_cnt; };struct se_device ;
Signature · 1 line
2.25.1
PATCH v5 2/9 scsi: target: Move cmd counter allocation
In reply to Mike ChristieiSCSI needs to allocate its cmd counter per connection for MCS support where we need to stop and wait on commands running on a connection instead of per session. This moves the cmd counter allocation to target_setup_session which is used by drivers that need the stop+wait behavior per session.
xcopy doesn't need stop+wait at all, so we will be ok moving the cmd counter allocation outside of transport_init_session.
--- drivers/target/iscsi/iscsi_target_login.c | 10 +++++ drivers/target/target_core_internal.h | 1 - drivers/target/target_core_transport.c | 55 +++++++++++------------ drivers/target/target_core_xcopy.c | 15 +------ include/target/target_core_fabric.h | 4 +- 5 files changed, 42 insertions(+), 43 deletions(-)
drivers/target/iscsi/iscsi_target_login.c +10 -0
@@ -324,8 +324,18 @@ static int iscsi_login_zero_tsih_s1( goto free_ops; } +/* +* This is temp for iser. It will be moved to per conn in later +* patches for iscsi. +*/ + sess->se_sess->cmd_cnt =target_alloc_cmd_counter (); +if (!sess->se_sess->cmd_cnt) + goto free_se_sess; +return 0 ; +free_se_sess: +transport_free_session (sess->se_sess); free_ops:kfree (sess->sess_ops); free_id:
drivers/target/target_core_internal.h +0 -1
@@ -138,7 +138,6 @@ int init_se_kmem_caches(void);void release_se_kmem_caches (void );u32 scsi_get_new_index (scsi_index_t );void transport_subsystem_check_init (void ); -void transport_uninit_session (struct se_session *);unsigned char *transport_dump_cmd_direction (struct se_cmd *);void transport_dump_dev_state (struct se_device *,char *,int *); void transport_dump_dev_info(struct se_device *, struct se_lun *,
drivers/target/target_core_transport.c +27 -28
126 lines not on this page · raw message
drivers/target/target_core_xcopy.c +2 -13
@@ -461,8 +461,6 @@ static const struct target_core_fabric_ops xcopy_pt_tfo = {int target_xcopy_setup_pt (void ) { -int ret; - xcopy_wq =alloc_workqueue ("xcopy_wq" ,WQ_MEM_RECLAIM ,0 );if (!xcopy_wq) {pr_err ("Unable to allocate xcopy_wq\n" );
@@ -479,9 +477,7 @@ int target_xcopy_setup_pt(void)INIT_LIST_HEAD (&xcopy_pt_nacl.acl_list);INIT_LIST_HEAD (&xcopy_pt_nacl.acl_sess_list);memset (&xcopy_pt_sess,0 ,sizeof (struct se_session )); - ret =transport_init_session (&xcopy_pt_sess); -if (ret <0 ) - goto destroy_wq; +transport_init_session (&xcopy_pt_sess); xcopy_pt_nacl.se_tpg = &xcopy_pt_tpg; xcopy_pt_nacl.nacl_sess = &xcopy_pt_sess;
@@ -490,19 +486,12 @@ int target_xcopy_setup_pt(void) xcopy_pt_sess.se_node_acl = &xcopy_pt_nacl;return 0 ; - -destroy_wq: -destroy_workqueue (xcopy_wq); - xcopy_wq =NULL ; -return ret; }void target_xcopy_release_pt (void ) { -if (xcopy_wq) { +if (xcopy_wq)destroy_workqueue (xcopy_wq); -transport_uninit_session (&xcopy_pt_sess); - } }/*
include/target/target_core_fabric.h +3 -1
@@ -133,7 +133,9 @@ struct se_session *target_setup_session(struct se_portal_group *, struct se_session *, void *));void target_remove_session (struct se_session *); -int transport_init_session (struct se_session *se_sess); +struct target_cmd_counter *target_alloc_cmd_counter (void ); + +void transport_init_session (struct se_session *se_sess);struct se_session *transport_alloc_session (enum target_prot_op );int transport_alloc_session_tags (struct se_session *,unsigned int ,unsigned int );
Signature · 1 line
2.25.1
PATCH v5 3/9 scsi: target: Pass in cmd counter to use during cmd setup
In reply to Mike ChristieThis allows target_get_sess_cmd users to pass in the cmd counter they want to use. Right now we pass in the session's cmd counter but in the next patch iSCSI will switch from per session to per conn so this patch will be needed for that conversion.
--- drivers/target/iscsi/iscsi_target.c | 10 +++++---- drivers/target/target_core_transport.c | 28 ++++++++++++-------------- drivers/target/target_core_xcopy.c | 8 ++++---- drivers/usb/gadget/function/f_tcm.c | 4 ++-- include/target/target_core_fabric.h | 8 +++++--- 5 files changed, 30 insertions(+), 28 deletions(-)
drivers/target/iscsi/iscsi_target.c +6 -4
@@ -1190,9 +1190,10 @@ int iscsit_setup_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,* Initialize struct se_cmd descriptor from target_core_mod infrastructure */ __target_init_cmd (&cmd->se_cmd, &iscsi_ops, - conn->sess->se_sess,be32_to_cpu (hdr->data_length), - cmd->data_direction, sam_task_attr, - cmd->sense_buffer +2 ,scsilun_to_int (&hdr->lun)); + conn->sess->se_sess,be32_to_cpu (hdr->data_length), + cmd->data_direction, sam_task_attr, + cmd->sense_buffer +2 ,scsilun_to_int (&hdr->lun), + conn->sess->se_sess->cmd_cnt); pr_debug("Got SCSI Command, ITT: 0x%08x, CmdSN: 0x%08x," " ExpXferLen: %u, Length: %u, CID: %hu\n", hdr->itt,
@@ -2055,7 +2056,8 @@ iscsit_handle_task_mgt_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,__target_init_cmd (&cmd->se_cmd, &iscsi_ops, conn->sess->se_sess,0 ,DMA_NONE ,TCM_SIMPLE_TAG , cmd->sense_buffer +2 , -scsilun_to_int (&hdr->lun)); +scsilun_to_int (&hdr->lun), + conn->sess->se_sess->cmd_cnt);target_get_sess_cmd (&cmd->se_cmd, true);
drivers/target/target_core_transport.c +13 -15
@@ -1441,14 +1441,12 @@ target_cmd_size_check(struct se_cmd *cmd, unsigned int size)* * Preserves the value of @cmd->tag. */ -void __target_init_cmd ( -struct se_cmd *cmd, -const struct target_core_fabric_ops *tfo, -struct se_session *se_sess, -u32 data_length, -int data_direction, -int task_attr, -unsigned char *sense_buffer,u64 unpacked_lun) +void __target_init_cmd (struct se_cmd *cmd, +const struct target_core_fabric_ops *tfo, +struct se_session *se_sess,u32 data_length, +int data_direction,int task_attr, +unsigned char *sense_buffer,u64 unpacked_lun, +struct target_cmd_counter *cmd_cnt) {INIT_LIST_HEAD (&cmd->se_delayed_node);INIT_LIST_HEAD (&cmd->se_qf_node);
@@ -1468,6 +1466,7 @@ void __target_init_cmd( cmd->sam_task_attr = task_attr; cmd->sense_buffer = sense_buffer; cmd->orig_fe_lun = unpacked_lun; + cmd->cmd_cnt = cmd_cnt;if (!(cmd->se_cmd_flags &SCF_USE_CPUID )) cmd->cpuid =raw_smp_processor_id ();
@@ -1687,7 +1686,8 @@ int target_init_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,* target_core_fabric_ops->queue_status() callback */ __target_init_cmd (se_cmd, se_tpg->se_tpg_tfo, se_sess, data_length, - data_dir, task_attr, sense, unpacked_lun); + data_dir, task_attr, sense, unpacked_lun, + se_sess->cmd_cnt);/* * Obtain struct se_cmd->cmd_kref reference. A second kref_get here is
@@ -1982,7 +1982,8 @@ int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,BUG_ON (!se_tpg);__target_init_cmd (se_cmd, se_tpg->se_tpg_tfo, se_sess, -0 ,DMA_NONE ,TCM_SIMPLE_TAG , sense, unpacked_lun); +0 ,DMA_NONE ,TCM_SIMPLE_TAG , sense, unpacked_lun, + se_sess->cmd_cnt);/* * FIXME: Currently expect caller to handle se_cmd->se_tmr_req * allocation failure.
@@ -2986,7 +2987,6 @@ EXPORT_SYMBOL(transport_generic_free_cmd);*/ int target_get_sess_cmd (struct se_cmd *se_cmd,bool ack_kref) { -struct se_session *se_sess = se_cmd->se_sess;int ret =0 ;/*
@@ -3003,11 +3003,9 @@ int target_get_sess_cmd(struct se_cmd *se_cmd, bool ack_kref)* Users like xcopy do not use counters since they never do a stop * and wait. */ -if (se_sess->cmd_cnt) { -if (!percpu_ref_tryget_live (&se_sess->cmd_cnt->refcnt)) +if (se_cmd->cmd_cnt) { +if (!percpu_ref_tryget_live (&se_cmd->cmd_cnt->refcnt)) ret = -ESHUTDOWN ; -else - se_cmd->cmd_cnt = se_sess->cmd_cnt; }if (ret && ack_kref)target_put_sess_cmd (se_cmd);
drivers/target/target_core_xcopy.c +4 -4
@@ -591,8 +591,8 @@ static int target_xcopy_read_source( (unsigned long long)src_lba, transfer_length_block, src_bytes);__target_init_cmd (se_cmd, &xcopy_pt_tfo, &xcopy_pt_sess, src_bytes, -DMA_FROM_DEVICE ,0 , &xpt_cmd.sense_buffer[0 ],0 ); - +DMA_FROM_DEVICE ,0 , &xpt_cmd.sense_buffer[0 ],0 , +NULL ); rc =target_xcopy_setup_pt_cmd (&xpt_cmd, xop, src_dev, &cdb[0 ], remote_port);if (rc <0 ) {
@@ -636,8 +636,8 @@ static int target_xcopy_write_destination( (unsigned long long)dst_lba, transfer_length_block, dst_bytes);__target_init_cmd (se_cmd, &xcopy_pt_tfo, &xcopy_pt_sess, dst_bytes, -DMA_TO_DEVICE ,0 , &xpt_cmd.sense_buffer[0 ],0 ); - +DMA_TO_DEVICE ,0 , &xpt_cmd.sense_buffer[0 ],0 , +NULL ); rc =target_xcopy_setup_pt_cmd (&xpt_cmd, xop, dst_dev, &cdb[0 ], remote_port);if (rc <0 ) {
drivers/usb/gadget/function/f_tcm.c +2 -2
@@ -1054,7 +1054,7 @@ static void usbg_cmd_work(struct work_struct *work) tv_nexus->tvn_se_sess->se_tpg->se_tpg_tfo, tv_nexus->tvn_se_sess, cmd->data_len,DMA_NONE , cmd->prio_attr, cmd->sense_iu.sense, - cmd->unpacked_lun); + cmd->unpacked_lun, NULL); goto out; }
@@ -1183,7 +1183,7 @@ static void bot_cmd_work(struct work_struct *work) tv_nexus->tvn_se_sess->se_tpg->se_tpg_tfo, tv_nexus->tvn_se_sess, cmd->data_len,DMA_NONE , cmd->prio_attr, cmd->sense_iu.sense, - cmd->unpacked_lun); + cmd->unpacked_lun, NULL); goto out; }
include/target/target_core_fabric.h +5 -3
@@ -151,9 +151,11 @@ void transport_deregister_session_configfs(struct se_session *);void transport_deregister_session (struct se_session *); -void __target_init_cmd (struct se_cmd *, -const struct target_core_fabric_ops *, -struct se_session *,u32 ,int ,int ,unsigned char *,u64 ); +void __target_init_cmd (struct se_cmd *cmd, +const struct target_core_fabric_ops *tfo, +struct se_session *sess,u32 data_length,int data_direction, +int task_attr,unsigned char *sense_buffer,u64 unpacked_lun, +struct target_cmd_counter *cmd_cnt);int target_init_cmd (struct se_cmd *se_cmd,struct se_session *se_sess,unsigned char *sense,u64 unpacked_lun,u32 data_length,int task_attr,int data_dir,int flags);
Signature · 1 line
2.25.1
PATCH v5 4/9 scsi: target: iscsit/isert: Alloc per conn cmd counter
In reply to Mike ChristieThis has iscsit allocate a per conn cmd counter and converts iscsit/isert to use it instead of the per session one.
--- drivers/infiniband/ulp/isert/ib_isert.c | 4 ++-- drivers/target/iscsi/iscsi_target.c | 4 ++-- drivers/target/iscsi/iscsi_target_login.c | 17 +++++++---------- drivers/target/target_core_transport.c | 9 ++++++--- include/target/target_core_fabric.h | 3 +++ 5 files changed, 20 insertions(+), 17 deletions(-)
drivers/infiniband/ulp/isert/ib_isert.c +2 -2
@@ -2506,8 +2506,8 @@ isert_wait4cmds(struct iscsit_conn *conn)isert_info ("iscsit_conn %p\n" , conn);if (conn->sess) { -target_stop_session (conn->sess->se_sess); -target_wait_for_sess_cmds (conn->sess->se_sess); +target_stop_cmd_counter (conn->cmd_cnt); +target_wait_for_cmds (conn->cmd_cnt); } }
drivers/target/iscsi/iscsi_target.c +2 -2
@@ -1193,7 +1193,7 @@ int iscsit_setup_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd, conn->sess->se_sess,be32_to_cpu (hdr->data_length), cmd->data_direction, sam_task_attr, cmd->sense_buffer +2 ,scsilun_to_int (&hdr->lun), - conn->sess->se_sess->cmd_cnt); + conn->cmd_cnt); pr_debug("Got SCSI Command, ITT: 0x%08x, CmdSN: 0x%08x," " ExpXferLen: %u, Length: %u, CID: %hu\n", hdr->itt,
@@ -2057,7 +2057,7 @@ iscsit_handle_task_mgt_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd, conn->sess->se_sess,0 ,DMA_NONE ,TCM_SIMPLE_TAG , cmd->sense_buffer +2 ,scsilun_to_int (&hdr->lun), - conn->sess->se_sess->cmd_cnt); + conn->cmd_cnt);target_get_sess_cmd (&cmd->se_cmd, true);
drivers/target/iscsi/iscsi_target_login.c +7 -10
@@ -324,18 +324,8 @@ static int iscsi_login_zero_tsih_s1( goto free_ops; } -/* -* This is temp for iser. It will be moved to per conn in later -* patches for iscsi. -*/ - sess->se_sess->cmd_cnt =target_alloc_cmd_counter (); -if (!sess->se_sess->cmd_cnt) - goto free_se_sess; -return 0 ; -free_se_sess: -transport_free_session (sess->se_sess); free_ops:kfree (sess->sess_ops); free_id:
@@ -1157,8 +1147,14 @@ static struct iscsit_conn *iscsit_alloc_conn(struct iscsi_np *np) goto free_conn_cpumask; } + conn->cmd_cnt =target_alloc_cmd_counter (); +if (!conn->cmd_cnt) + goto free_conn_allowed_cpumask; +return conn; +free_conn_allowed_cpumask: +free_cpumask_var (conn->allowed_cpumask); free_conn_cpumask:free_cpumask_var (conn->conn_cpumask); free_conn_ops:
@@ -1172,6 +1168,7 @@ static struct iscsit_conn *iscsit_alloc_conn(struct iscsi_np *np)void iscsit_free_conn (struct iscsit_conn *conn) { +target_free_cmd_counter (conn->cmd_cnt);free_cpumask_var (conn->allowed_cpumask);free_cpumask_var (conn->conn_cpumask);kfree (conn->conn_ops);
drivers/target/target_core_transport.c +6 -3
@@ -254,7 +254,7 @@ struct target_cmd_counter *target_alloc_cmd_counter(void) }EXPORT_SYMBOL_GPL (target_alloc_cmd_counter); -static void target_free_cmd_counter (struct target_cmd_counter *cmd_cnt) +void target_free_cmd_counter (struct target_cmd_counter *cmd_cnt) {/* * Drivers like loop do not call target_stop_session during session
@@ -265,6 +265,7 @@ static void target_free_cmd_counter(struct target_cmd_counter *cmd_cnt)percpu_ref_exit (&cmd_cnt->refcnt); } +EXPORT_SYMBOL_GPL (target_free_cmd_counter);/** * transport_init_session - initialize a session object
@@ -3170,13 +3171,14 @@ static void target_stop_cmd_counter_confirm(struct percpu_ref *ref)* target_stop_cmd_counter - Stop new IO from being added to the counter. * @cmd_cnt: counter to stop */ -static void target_stop_cmd_counter (struct target_cmd_counter *cmd_cnt) +void target_stop_cmd_counter (struct target_cmd_counter *cmd_cnt) {pr_debug ("Stopping command counter.\n" );if (!atomic_cmpxchg (&cmd_cnt->stopped,0 ,1 ))percpu_ref_kill_and_confirm (&cmd_cnt->refcnt, target_stop_cmd_counter_confirm); } +EXPORT_SYMBOL_GPL (target_stop_cmd_counter);/** * target_stop_session - Stop new IO from being queued on the session.
@@ -3192,7 +3194,7 @@ EXPORT_SYMBOL(target_stop_session);* target_wait_for_cmds - Wait for outstanding cmds. * @cmd_cnt: counter to wait for active I/O for. */ -static void target_wait_for_cmds (struct target_cmd_counter *cmd_cnt) +void target_wait_for_cmds (struct target_cmd_counter *cmd_cnt) {int ret;
@@ -3208,6 +3210,7 @@ static void target_wait_for_cmds(struct target_cmd_counter *cmd_cnt)wait_for_completion (&cmd_cnt->stop_done);pr_debug ("Waiting for cmds done.\n" ); } +EXPORT_SYMBOL_GPL (target_wait_for_cmds);/** * target_wait_for_sess_cmds - Wait for outstanding commands
include/target/target_core_fabric.h +3 -0
@@ -133,7 +133,10 @@ struct se_session *target_setup_session(struct se_portal_group *, struct se_session *, void *));void target_remove_session (struct se_session *); +void target_stop_cmd_counter (struct target_cmd_counter *cmd_cnt); +void target_wait_for_cmds (struct target_cmd_counter *cmd_cnt);struct target_cmd_counter *target_alloc_cmd_counter (void ); +void target_free_cmd_counter (struct target_cmd_counter *cmd_cnt);void transport_init_session (struct se_session *se_sess);struct se_session *transport_alloc_session (enum target_prot_op );
Signature · 1 line
2.25.1
PATCH v5 5/9 scsi: target: iscsit: stop/wait on cmds during conn close
In reply to Mike ChristieThis fixes a bug added in:
commit f36199355c64 ("scsi: target: iscsi: Fix cmd abort fabric stop race")
If we have multiple sessions to the same se_device we can hit a race where a LUN_RESET on one session cleans up the se_cmds from under another session which is being closed. This results in the closing session freeing its conn/session structs while they are still in use.
The bug is:
1. Session1 has IO se_cmd1.
2. Session2 can also have se_cmds for IO and optionally TMRs for ABORTS but then gets a LUN_RESET.
3. The LUN_RESET on session2 sees the se_cmds on session1 and during the drain stages marks them all with CMD_T_ABORTED.
4. session1 is now closed so iscsit_release_commands_from_conn only sees se_cmds with the CMD_T_ABORTED bit set and returns immediately even though we have outstanding commands.
5. session1's connection and session are freed.
6. The backend request for se_cmd1 completes and it accesses the freed connection/session.
This hooks the iscsit layer into the cmd counter code, so we can wait for all outstanding se_cmds before freeing the connection.
--- drivers/target/iscsi/iscsi_target.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
drivers/target/iscsi/iscsi_target.c +10 -0
@@ -4245,6 +4245,16 @@ static void iscsit_release_commands_from_conn(struct iscsit_conn *conn)iscsit_free_cmd (cmd, true); } + +/* +* Wait on commands that were cleaned up via the aborted_task path. +* LLDs that implement iscsit_wait_conn will already have waited for +* commands. +*/ +if (!conn->conn_transport->iscsit_wait_conn) { +target_stop_cmd_counter (conn->cmd_cnt); +target_wait_for_cmds (conn->cmd_cnt); + } } static void iscsit_stop_timers_for_cmds(
Signature · 1 line
2.25.1
PATCH v5 6/9 scsi: target: iscsit: free cmds before session free
In reply to Mike ChristieFrom: Dmitry Bogdanov <[email protected]>
Commands from recovery entries are freed after its session has been closed. That leads to use-after-free at command free or NPE with such call trace:
Time2Retain timer expired for SID: 1, cleaning up iSCSI session.
BUG: kernel NULL pointer dereference, address: 0000000000000140 RIP: 0010:sbitmap_queue_clear+0x3a/0xa0 Call Trace: target_release_cmd_kref+0xd1/0x1f0 [target_core_mod] transport_generic_free_cmd+0xd1/0x180 [target_core_mod] iscsit_free_cmd+0x53/0xd0 [iscsi_target_mod] iscsit_free_connection_recovery_entries+0x29d/0x320 [iscsi_target_mod] iscsit_close_session+0x13a/0x140 [iscsi_target_mod] iscsit_check_post_dataout+0x440/0x440 [iscsi_target_mod] call_timer_fn+0x24/0x140
Move cleanup of recovery enrties to before session freeing.
--- drivers/target/iscsi/iscsi_target.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/target/iscsi/iscsi_target.c +3 -3
@@ -4529,6 +4529,9 @@ int iscsit_close_session(struct iscsit_session *sess, bool can_sleep)iscsit_stop_time2retain_timer (sess);spin_unlock_bh (&se_tpg->session_lock); +if (sess->sess_ops->ErrorRecoveryLevel ==2 ) +iscsit_free_connection_recovery_entries (sess); +/* * transport_deregister_session_configfs() will clear the * struct se_node_acl->nacl_sess pointer now as a iscsi_np process context
@@ -4552,9 +4555,6 @@ int iscsit_close_session(struct iscsit_session *sess, bool can_sleep)transport_deregister_session (sess->se_sess); -if (sess->sess_ops->ErrorRecoveryLevel ==2 ) -iscsit_free_connection_recovery_entries (sess); -iscsit_free_all_ooo_cmdsns (sess);spin_lock_bh (&se_tpg->session_lock);
Signature · 1 line
2.25.1
PATCH v5 7/9 scsi: target: Fix multiple LUN_RESET handling
In reply to Mike ChristieThis fixes a bug where an initiator thinks a LUN_RESET has cleaned up running commands when it hasn't. The bug was added in:
commit 51ec502a3266 ("target: Delete tmr from list before processing")
The problem occurs when:
1. We have N IO cmds running in the target layer spread over 2 sessions.
2. The initiator sends a LUN_RESET for each session.
3. session1's LUN_RESET loops over all the running commands from both sessions and moves them to its local drain_task_list.
4. session2's LUN_RESET does not see the LUN_RESET from session1 because the commit above has it remove itself. session2 also does not see any commands since the other reset moved them off the state lists.
5. sessions2's LUN_RESET will then complete with a successful response.
6. sessions2's inititor believes the running commands on its session are now cleaned up due to the successful response and cleans up the running commands from its side. It then restarts them.
7. The commands do eventually complete on the backend and the target starts to return aborted task statuses for them. The initiator will either throw a invalid ITT error or might accidentally lookup a new task if the ITT has been reallocated already.
This fixes the bug by reverting the patch, and serializes the execution of LUN_RESETs and Preempt and Aborts.
The patch also prevents us from waiting on LUN_RESETs in core_tmr_drain_tmr_list, because it turns out the original patch fixed a bug that was not mentioned. For LUN_RESET1 core_tmr_drain_tmr_list can see a second LUN_RESET and wait on it. Then the second reset will run core_tmr_drain_tmr_list and see the first reset and wait on it resulting in a deadlock.
--- drivers/target/target_core_device.c | 1 + drivers/target/target_core_tmr.c | 26 +++++++++++++++++++++++--- include/target/target_core_base.h | 1 + 3 files changed, 25 insertions(+), 3 deletions(-)
drivers/target/target_core_device.c +1 -0
@@ -782,6 +782,7 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name)spin_lock_init (&dev->t10_alua.lba_map_lock);INIT_WORK (&dev->delayed_cmd_work, target_do_delayed_work); +mutex_init (&dev->lun_reset_mutex); dev->t10_wwn.t10_dev = dev;/*
drivers/target/target_core_tmr.c +23 -3
@@ -188,14 +188,23 @@ static void core_tmr_drain_tmr_list(* LUN_RESET tmr.. */ spin_lock_irqsave (&dev->se_tmr_lock, flags); -if (tmr) -list_del_init (&tmr->tmr_list);list_for_each_entry_safe (tmr_p, tmr_pp, &dev->dev_tmr_list, tmr_list) { +if (tmr_p == tmr) +continue ; + cmd = tmr_p->task_cmd;if (!cmd) {pr_err ("Unable to locate struct se_cmd for TMR\n" );continue ; } + +/* +* We only execute one LUN_RESET at a time so we can't wait +* on them below. +*/ +if (tmr_p->function ==TMR_LUN_RESET ) +continue ; +/* * If this function was called with a valid pr_res_key * parameter (eg: for PROUT PREEMPT_AND_ABORT service action
@@ -379,14 +388,25 @@ int core_tmr_lun_reset( tmr_nacl->initiatorname); } } + + +/* +* We only allow one reset or preempt and abort to execute at a time +* to prevent one call from claiming all the cmds causing a second +* call from returning while cmds it should have waited on are still +* running. +*/ +mutex_lock (&dev->lun_reset_mutex); +pr_debug ("LUN_RESET: %s starting for [%s], tas: %d\n" , (preempt_and_abort_list) ?"Preempt" :"TMR" , dev->transport->name, tas); -core_tmr_drain_tmr_list (dev, tmr, preempt_and_abort_list);core_tmr_drain_state_list (dev, prout_cmd, tmr_sess, tas, preempt_and_abort_list); +mutex_unlock (&dev->lun_reset_mutex); +/* * Clear any legacy SPC-2 reservation when called during * LOGICAL UNIT RESET
include/target/target_core_base.h +1 -0
@@ -872,6 +872,7 @@ struct se_device {struct rcu_head rcu_head;int queue_cnt;struct se_device_queue *queues; +struct mutex lun_reset_mutex; };struct target_opcode_descriptor {
Signature · 1 line
2.25.1
PATCH v5 8/9 scsi: target: iscsit: Fix TAS handling during conn cleanup
In reply to Mike ChristieThis fixes a bug added in:
commit f36199355c64 ("scsi: target: iscsi: Fix cmd abort fabric stop race")
If CMD_T_TAS is set on the se_cmd we must call iscsit_free_cmd to do the last put on the cmd and free it, because the connection is down and we will not up sending the response and doing the put from the normal IO path. This patch adds a check for CMD_T_TAS in iscsit_release_commands_from_conn so we now detect this case and run iscsit_free_cmd.
--- drivers/target/iscsi/iscsi_target.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)
drivers/target/iscsi/iscsi_target.c +9 -7
@@ -4220,9 +4220,12 @@ static void iscsit_release_commands_from_conn(struct iscsit_conn *conn)list_for_each_entry_safe (cmd, cmd_tmp, &tmp_list, i_conn_node) {struct se_cmd *se_cmd = &cmd->se_cmd; -if (se_cmd->se_tfo !=NULL ) { -spin_lock_irq (&se_cmd->t_state_lock); -if (se_cmd->transport_state &CMD_T_ABORTED ) { +if (!se_cmd->se_tfo) +continue ; + +spin_lock_irq (&se_cmd->t_state_lock); +if (se_cmd->transport_state &CMD_T_ABORTED ) { +if (!(se_cmd->transport_state &CMD_T_TAS ))/* * LIO's abort path owns the cleanup for this, * so put it back on the list and let
@@ -4230,11 +4233,10 @@ static void iscsit_release_commands_from_conn(struct iscsit_conn *conn)*/ list_move_tail (&cmd->i_conn_node, &conn->conn_cmd_list); - }else { - se_cmd->transport_state |=CMD_T_FABRIC_STOP ; - } -spin_unlock_irq (&se_cmd->t_state_lock); + }else { + se_cmd->transport_state |=CMD_T_FABRIC_STOP ; } +spin_unlock_irq (&se_cmd->t_state_lock); }spin_unlock_bh (&conn->cmd_lock);
Signature · 1 line
2.25.1
PATCH v5 9/9 scsi: target: iscsi: handle abort for WRITE_PENDING cmds
In reply to Mike ChristieFrom: Dmitry Bogdanov <[email protected]>
Sometimes an initiator does not send data for WRITE commands and tries to abort it. The abort hangs waiting for frontend driver completion. iSCSI driver waits for for data and that timeout eventually initiates connection reinstatment. The connection closing releases the commands in the connection, but those aborted commands still did not handle the abort and did not decrease a command ref counter. Because of that the connection reinstatement hangs indefinitely and prevents re-login for that initiator.
This patch adds a handling in TCM of the abort for the WRITE_PENDING commands at connection closing moment to make it possible to release them.
--- drivers/target/iscsi/iscsi_target.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
drivers/target/iscsi/iscsi_target.c +11 -0
@@ -26,6 +26,7 @@#include <target/target_core_base.h> #include <target/target_core_fabric.h> +#include <target/target_core_backend.h> #include <target/iscsi/iscsi_target_core.h> #include "iscsi_target_parameters.h" #include "iscsi_target_seq_pdu_list.h"
@@ -4236,6 +4237,16 @@ static void iscsit_release_commands_from_conn(struct iscsit_conn *conn) }else { se_cmd->transport_state |=CMD_T_FABRIC_STOP ; } + +if (cmd->se_cmd.t_state ==TRANSPORT_WRITE_PENDING ) { +/* +* We never submitted the cmd to LIO core, so we have +* to tell LIO to perform the completion process. +*/ +spin_unlock_irq (&se_cmd->t_state_lock); +target_complete_cmd (&cmd->se_cmd,SAM_STAT_TASK_ABORTED ); +continue ; + }spin_unlock_irq (&se_cmd->t_state_lock); }spin_unlock_bh (&conn->cmd_lock);
Signature · 1 line
2.25.1
Martin K. Petersen
AppliedMike,
Quoted 11 lines
The following patches apply over Martin's 6.4 branches and Linus's tree. They fix a couple regressions in iscsit that occur when there are TMRs executing and a connection is closed. It also includes Dimitry's fixes in related code paths for cmd cleanup when ERL2 is used and the write pending hang during conn cleanup.
This version of the patchset brings it back to just regressions and fixes for bugs we have a lot of users hitting. I'm going to fix isert and get it hooked into iscsit properly in a second patchset, because this one was getting so large. I've also moved my cleanup type of patches for a 3rd patchset.
Applied to 6.4/scsi-staging, thanks!
Signature · 1 line
Martin K. Petersen Oracle Linux Engineering
Martin K. Petersen
AppliedQuoted 6 lines · Mike Christie
The following patches apply over Martin's 6.4 branches and Linus's tree. They fix a couple regressions in iscsit that occur when there are TMRs executing and a connection is closed. It also includes Dimitry's fixes in related code paths for cmd cleanup when ERL2 is used and the write pending hang during conn cleanup.
Quoted 7 lines
This version of the patchset brings it back to just regressions and fixes for bugs we have a lot of users hitting. I'm going to fix isert and get it hooked into iscsit properly in a second patchset, because this one was getting so large. I've also moved my cleanup type of patches for a 3rd patchset.
[...]
Applied to 6.4/scsi-queue, thanks!
[1/9] scsi: target: Move sess cmd counter to new struct
https://git.kernel.org/mkp/scsi/c/becd9be6069e [2/9] scsi: target: Move cmd counter allocation https://git.kernel.org/mkp/scsi/c/4edba7e4a8f3 [3/9] scsi: target: Pass in cmd counter to use during cmd setup https://git.kernel.org/mkp/scsi/c/8e288be8606a [4/9] scsi: target: iscsit/isert: Alloc per conn cmd counter https://git.kernel.org/mkp/scsi/c/6d256bee602b [5/9] scsi: target: iscsit: stop/wait on cmds during conn close https://git.kernel.org/mkp/scsi/c/395cee83d02d [6/9] scsi: target: iscsit: free cmds before session free https://git.kernel.org/mkp/scsi/c/d8990b5a4d06 [7/9] scsi: target: Fix multiple LUN_RESET handling https://git.kernel.org/mkp/scsi/c/673db054d7a2 [8/9] scsi: target: iscsit: Fix TAS handling during conn cleanup https://git.kernel.org/mkp/scsi/c/cc79da306ebb [9/9] scsi: target: iscsi: handle abort for WRITE_PENDING cmds https://git.kernel.org/mkp/scsi/c/ea87981a0ee8
Signature · 1 line
Martin K. Petersen Oracle Linux Engineering