From: Nicholas Bellinger <[email protected]>

Short of reverting commit 00d909a107 for v4.19, target-core needs a
wait_event_t marco can be executed using TASK_UNINTERRUPTIBLE to
function correctly with existing fabric drivers that expect to run
with signals pending during session shutdown and active se_cmd I/O
quiesce.

The most notable is iscsi-target/iser-target, while ibmvscsi_tgt invokes
session shutdown logic from userspace via configfs attribute that could
also potentially have signals pending.

So go ahead and introduce wait_event_lock_irq_timeout() to achieve this,
and update + rename __wait_event_lock_irq_timeout() to make it accept
'state' as a parameter.

Fixes: 00d909a107 ("scsi: target: Make the session shutdown code also wait for 
commands that are being aborted")
Cc: Bart Van Assche <[email protected]>
Cc: Mike Christie <[email protected]>
Cc: Hannes Reinecke <[email protected]>
Cc: Christoph Hellwig <[email protected]>
Cc: Sagi Grimberg <[email protected]>
Cc: Bryant G. Ly <[email protected]>
Cc: Peter Zijlstra (Intel) <[email protected]>
Tested-by: Nicholas Bellinger <[email protected]>
Signed-off-by: Nicholas Bellinger <[email protected]>
---
 include/linux/wait.h | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/include/linux/wait.h b/include/linux/wait.h
index d9f131e..ed7c122 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -1052,10 +1052,9 @@ void __wake_up_locked_key_bookmark(struct 
wait_queue_head *wq_head,
        __ret;                                                                  
\
 })
 
-#define __wait_event_interruptible_lock_irq_timeout(wq_head, condition,        
        \
-                                                   lock, timeout)              
\
+#define __wait_event_lock_irq_timeout(wq_head, condition, lock, timeout, 
state)        \
        ___wait_event(wq_head, ___wait_cond_timeout(condition),                 
\
-                     TASK_INTERRUPTIBLE, 0, timeout,                           
\
+                     state, 0, timeout,                                        
\
                      spin_unlock_irq(&lock);                                   
\
                      __ret = schedule_timeout(__ret);                          
\
                      spin_lock_irq(&lock));
@@ -1089,8 +1088,19 @@ void __wake_up_locked_key_bookmark(struct 
wait_queue_head *wq_head,
 ({                                                                             
\
        long __ret = timeout;                                                   
\
        if (!___wait_cond_timeout(condition))                                   
\
-               __ret = __wait_event_interruptible_lock_irq_timeout(            
\
-                                       wq_head, condition, lock, timeout);     
\
+               __ret = __wait_event_lock_irq_timeout(                          
\
+                                       wq_head, condition, lock, timeout,      
\
+                                       TASK_INTERRUPTIBLE);                    
\
+       __ret;                                                                  
\
+})
+
+#define wait_event_lock_irq_timeout(wq_head, condition, lock, timeout)         
\
+({                                                                             
\
+       long __ret = timeout;                                                   
\
+       if (!___wait_cond_timeout(condition))                                   
\
+               __ret = __wait_event_lock_irq_timeout(                          
\
+                                       wq_head, condition, lock, timeout,      
\
+                                       TASK_UNINTERRUPTIBLE);                  
\
        __ret;                                                                  
\
 })
 
-- 
1.9.1

Reply via email to