fs: create kiocb_{start,end}_write() helpers

aio, io_uring, cachefiles and overlayfs, all open code an ugly variant
of file_{start,end}_write() to silence lockdep warnings.

Create helpers for this lockdep dance so we can use the helpers in all
the callers.

Suggested-by: Jan Kara <jack@suse.cz>
Signed-off-by: Amir Goldstein <amir73il@gmail.com>
Reviewed-by: Jan Kara <jack@suse.cz>
Reviewed-by: Jens Axboe <axboe@kernel.dk>
Message-Id: <20230817141337.1025891-4-amir73il@gmail.com>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 660ff71..1eac954 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2573,6 +2573,42 @@ static inline void file_end_write(struct file *file)
        sb_end_write(file_inode(file)->i_sb);
 }
 
+/**
+ * kiocb_start_write - get write access to a superblock for async file io
+ * @iocb: the io context we want to submit the write with
+ *
+ * This is a variant of sb_start_write() for async io submission.
+ * Should be matched with a call to kiocb_end_write().
+ */
+static inline void kiocb_start_write(struct kiocb *iocb)
+{
+       struct inode *inode = file_inode(iocb->ki_filp);
+
+       sb_start_write(inode->i_sb);
+       /*
+        * Fool lockdep by telling it the lock got released so that it
+        * doesn't complain about the held lock when we return to userspace.
+        */
+       __sb_writers_release(inode->i_sb, SB_FREEZE_WRITE);
+}
+
+/**
+ * kiocb_end_write - drop write access to a superblock after async file io
+ * @iocb: the io context we sumbitted the write with
+ *
+ * Should be matched with a call to kiocb_start_write().
+ */
+static inline void kiocb_end_write(struct kiocb *iocb)
+{
+       struct inode *inode = file_inode(iocb->ki_filp);
+
+       /*
+        * Tell lockdep we inherited freeze protection from submission thread.
+        */
+       __sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE);
+       sb_end_write(inode->i_sb);
+}
+
 /*
  * This is used for regular files where some users -- especially the
  * currently executed binary in a process, previously handled via