fs: add IOCB flags related to passing back dio completions

Async dio completions generally happen from hard/soft IRQ context, which
means that users like iomap may need to defer some of the completion
handling to a workqueue. This is less efficient than having the original
issuer handle it, like we do for sync IO, and it adds latency to the
completions.

Add IOCB_DIO_CALLER_COMP, which the issuer can set if it is able to
safely punt these completions to a safe context. If the dio handler is
aware of this flag, assign a callback handler in kiocb->dio_complete and
associated data io kiocb->private. The issuer will then call this
handler with that data from task context.

No functional changes in this patch.

Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 6867512..1e6dbe3 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -338,6 +338,20 @@ enum rw_hint {
 #define IOCB_NOIO              (1 << 20)
 /* can use bio alloc cache */
 #define IOCB_ALLOC_CACHE       (1 << 21)
+/*
+ * IOCB_DIO_CALLER_COMP can be set by the iocb owner, to indicate that the
+ * iocb completion can be passed back to the owner for execution from a safe
+ * context rather than needing to be punted through a workqueue. If this
+ * flag is set, the bio completion handling may set iocb->dio_complete to a
+ * handler function and iocb->private to context information for that handler.
+ * The issuer should call the handler with that context information from task
+ * context to complete the processing of the iocb. Note that while this
+ * provides a task context for the dio_complete() callback, it should only be
+ * used on the completion side for non-IO generating completions. It's fine to
+ * call blocking functions from this callback, but they should not wait for
+ * unrelated IO (like cache flushing, new IO generation, etc).
+ */
+#define IOCB_DIO_CALLER_COMP   (1 << 22)
 
 /* for use in trace events */
 #define TRACE_IOCB_STRINGS \
@@ -351,7 +365,8 @@ enum rw_hint {
        { IOCB_WRITE,           "WRITE" }, \
        { IOCB_WAITQ,           "WAITQ" }, \
        { IOCB_NOIO,            "NOIO" }, \
-       { IOCB_ALLOC_CACHE,     "ALLOC_CACHE" }
+       { IOCB_ALLOC_CACHE,     "ALLOC_CACHE" }, \
+       { IOCB_DIO_CALLER_COMP, "CALLER_COMP" }
 
 struct kiocb {
        struct file             *ki_filp;
@@ -360,7 +375,23 @@ struct kiocb {
        void                    *private;
        int                     ki_flags;
        u16                     ki_ioprio; /* See linux/ioprio.h */
-       struct wait_page_queue  *ki_waitq; /* for async buffered IO */
+       union {
+               /*
+                * Only used for async buffered reads, where it denotes the
+                * page waitqueue associated with completing the read. Valid
+                * IFF IOCB_WAITQ is set.
+                */
+               struct wait_page_queue  *ki_waitq;
+               /*
+                * Can be used for O_DIRECT IO, where the completion handling
+                * is punted back to the issuer of the IO. May only be set
+                * if IOCB_DIO_CALLER_COMP is set by the issuer, and the issuer
+                * must then check for presence of this handler when ki_complete
+                * is invoked. The data passed in to this handler must be
+                * assigned to ->private when dio_complete is assigned.
+                */
+               ssize_t (*dio_complete)(void *data);
+       };
 };
 
 static inline bool is_sync_kiocb(struct kiocb *kiocb)