inode: remove __I_DIO_WAKEUP

Afaict, we can just rely on inode->i_dio_count for waiting instead of
this awkward indirection through __I_DIO_WAKEUP. This survives LTP dio
and xfstests dio tests.

Link: https://lore.kernel.org/r/20240816-vfs-misc-dio-v1-1-80fe21a2c710@kernel.org
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/inode.c b/fs/inode.c
index de0969d6009c61b8d6557d349ad5a23b433af70e..248a131a02c3b2a72cecb9de4bca7a2c0d386d46 100644 (file)
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -2500,18 +2500,11 @@ EXPORT_SYMBOL(inode_owner_or_capable);
 /*
  * Direct i/o helper functions
  */
-static void __inode_dio_wait(struct inode *inode)
+bool inode_dio_finished(const struct inode *inode)
 {
-       wait_queue_head_t *wq = bit_waitqueue(&inode->i_state, __I_DIO_WAKEUP);
-       DEFINE_WAIT_BIT(q, &inode->i_state, __I_DIO_WAKEUP);
-
-       do {
-               prepare_to_wait(wq, &q.wq_entry, TASK_UNINTERRUPTIBLE);
-               if (atomic_read(&inode->i_dio_count))
-                       schedule();
-       } while (atomic_read(&inode->i_dio_count));
-       finish_wait(wq, &q.wq_entry);
+       return atomic_read(&inode->i_dio_count) == 0;
 }
+EXPORT_SYMBOL(inode_dio_finished);
 
 /**
  * inode_dio_wait - wait for outstanding DIO requests to finish
@@ -2525,11 +2518,17 @@ static void __inode_dio_wait(struct inode *inode)
  */
 void inode_dio_wait(struct inode *inode)
 {
-       if (atomic_read(&inode->i_dio_count))
-               __inode_dio_wait(inode);
+       wait_var_event(&inode->i_dio_count, inode_dio_finished(inode));
 }
 EXPORT_SYMBOL(inode_dio_wait);
 
+void inode_dio_wait_interruptible(struct inode *inode)
+{
+       wait_var_event_interruptible(&inode->i_dio_count,
+                                    inode_dio_finished(inode));
+}
+EXPORT_SYMBOL(inode_dio_wait_interruptible);
+
 /*
  * inode_set_flags - atomically set some inode flags
  *

diff --git a/fs/netfs/locking.c b/fs/netfs/locking.c
index 75dc52a49b3a4646d907cd1da3b0ddcd63374201..21eab56ee2f94f2d9a87ac11f99888cbe1da83fc 100644 (file)
--- a/fs/netfs/locking.c
+++ b/fs/netfs/locking.c
@@ -19,25 +19,13 @@
  * Must be called under a lock that serializes taking new references
  * to i_dio_count, usually by inode->i_mutex.
  */
-static int inode_dio_wait_interruptible(struct inode *inode)
+static int netfs_inode_dio_wait_interruptible(struct inode *inode)
 {
-       if (!atomic_read(&inode->i_dio_count))
+       if (inode_dio_finished(inode))
                return 0;
 
-       wait_queue_head_t *wq = bit_waitqueue(&inode->i_state, __I_DIO_WAKEUP);
-       DEFINE_WAIT_BIT(q, &inode->i_state, __I_DIO_WAKEUP);
-
-       for (;;) {
-               prepare_to_wait(wq, &q.wq_entry, TASK_INTERRUPTIBLE);
-               if (!atomic_read(&inode->i_dio_count))
-                       break;
-               if (signal_pending(current))
-                       break;
-               schedule();
-       }
-       finish_wait(wq, &q.wq_entry);
-
-       return atomic_read(&inode->i_dio_count) ? -ERESTARTSYS : 0;
+       inode_dio_wait_interruptible(inode);
+       return !inode_dio_finished(inode) ? -ERESTARTSYS : 0;
 }
 
 /* Call with exclusively locked inode->i_rwsem */
@@ -46,7 +34,7 @@ static int netfs_block_o_direct(struct netfs_inode *ictx)
        if (!test_bit(NETFS_ICTX_ODIRECT, &ictx->flags))
                return 0;
        clear_bit(NETFS_ICTX_ODIRECT, &ictx->flags);
-       return inode_dio_wait_interruptible(&ictx->inode);
+       return netfs_inode_dio_wait_interruptible(&ictx->inode);
 }
 
 /**

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 0145bda465ff02e4e27519e627e630ac8b14ba6a..8f8d274929d7aa3f5a76f8b36e972d0c3335fbe0 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2373,8 +2373,6 @@ static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,
  *
  * I_REFERENCED                Marks the inode as recently references on the LRU list.
  *
- * I_DIO_WAKEUP                Never set.  Only used as a key for wait_on_bit().
- *
  * I_WB_SWITCH         Cgroup bdi_writeback switching in progress.  Used to
  *                     synchronize competing switching instances and to tell
  *                     wb stat updates to grab the i_pages lock.  See
@@ -2409,8 +2407,6 @@ static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,
 #define __I_SYNC               7
 #define I_SYNC                 (1 << __I_SYNC)
 #define I_REFERENCED           (1 << 8)
-#define __I_DIO_WAKEUP         9
-#define I_DIO_WAKEUP           (1 << __I_DIO_WAKEUP)
 #define I_LINKABLE             (1 << 10)
 #define I_DIRTY_TIME           (1 << 11)
 #define I_WB_SWITCH            (1 << 13)
@@ -3227,7 +3223,9 @@ static inline ssize_t blockdev_direct_IO(struct kiocb *iocb,
 }
 #endif
 
+bool inode_dio_finished(const struct inode *inode);
 void inode_dio_wait(struct inode *inode);
+void inode_dio_wait_interruptible(struct inode *inode);
 
 /**
  * inode_dio_begin - signal start of a direct I/O requests
@@ -3251,7 +3249,7 @@ static inline void inode_dio_begin(struct inode *inode)
 static inline void inode_dio_end(struct inode *inode)
 {
        if (atomic_dec_and_test(&inode->i_dio_count))
-               wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
+               wake_up_var(&inode->i_dio_count);
 }
 
 extern void inode_set_flags(struct inode *inode, unsigned int flags,