Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef __LINUX__AIO_H |
| 2 | #define __LINUX__AIO_H |
| 3 | |
| 4 | #include <linux/list.h> |
| 5 | #include <linux/workqueue.h> |
| 6 | #include <linux/aio_abi.h> |
Badari Pulavarty | 027445c | 2006-09-30 23:28:46 -0700 | [diff] [blame] | 7 | #include <linux/uio.h> |
Jens Axboe | abf137d | 2008-12-09 08:11:22 +0100 | [diff] [blame] | 8 | #include <linux/rcupdate.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 9 | |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 10 | #include <linux/atomic.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | struct kioctx; |
Kent Overstreet | 0460fef | 2013-05-07 16:18:49 -0700 | [diff] [blame^] | 13 | struct kiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #define KIOCB_SYNC_KEY (~0U) |
| 16 | |
Kent Overstreet | 0460fef | 2013-05-07 16:18:49 -0700 | [diff] [blame^] | 17 | /* |
| 18 | * We use ki_cancel == KIOCB_CANCELLED to indicate that a kiocb has been either |
| 19 | * cancelled or completed (this makes a certain amount of sense because |
| 20 | * successful cancellation - io_cancel() - does deliver the completion to |
| 21 | * userspace). |
| 22 | * |
| 23 | * And since most things don't implement kiocb cancellation and we'd really like |
| 24 | * kiocb completion to be lockless when possible, we use ki_cancel to |
| 25 | * synchronize cancellation and completion - we only set it to KIOCB_CANCELLED |
| 26 | * with xchg() or cmpxchg(), see batch_complete_aio() and kiocb_cancel(). |
| 27 | */ |
| 28 | #define KIOCB_CANCELLED ((void *) (~0ULL)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | |
Kent Overstreet | 0460fef | 2013-05-07 16:18:49 -0700 | [diff] [blame^] | 30 | typedef int (kiocb_cancel_fn)(struct kiocb *, struct io_event *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | |
Zach Brown | 897f15f | 2005-09-30 11:58:55 -0700 | [diff] [blame] | 32 | /* is there a better place to document function pointer methods? */ |
| 33 | /** |
| 34 | * ki_retry - iocb forward progress callback |
| 35 | * @kiocb: The kiocb struct to advance by performing an operation. |
| 36 | * |
| 37 | * This callback is called when the AIO core wants a given AIO operation |
| 38 | * to make forward progress. The kiocb argument describes the operation |
| 39 | * that is to be performed. As the operation proceeds, perhaps partially, |
| 40 | * ki_retry is expected to update the kiocb with progress made. Typically |
| 41 | * ki_retry is set in the AIO core and it itself calls file_operations |
| 42 | * helpers. |
| 43 | * |
| 44 | * ki_retry's return value determines when the AIO operation is completed |
| 45 | * and an event is generated in the AIO event ring. Except the special |
| 46 | * return values described below, the value that is returned from ki_retry |
| 47 | * is transferred directly into the completion ring as the operation's |
| 48 | * resulting status. Once this has happened ki_retry *MUST NOT* reference |
| 49 | * the kiocb pointer again. |
| 50 | * |
| 51 | * If ki_retry returns -EIOCBQUEUED it has made a promise that aio_complete() |
| 52 | * will be called on the kiocb pointer in the future. The AIO core will |
| 53 | * not ask the method again -- ki_retry must ensure forward progress. |
| 54 | * aio_complete() must be called once and only once in the future, multiple |
| 55 | * calls may result in undefined behaviour. |
Zach Brown | 897f15f | 2005-09-30 11:58:55 -0700 | [diff] [blame] | 56 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | struct kiocb { |
Kent Overstreet | 11599eb | 2013-05-07 16:18:39 -0700 | [diff] [blame] | 58 | atomic_t ki_users; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | unsigned ki_key; /* id of this request */ |
| 60 | |
| 61 | struct file *ki_filp; |
| 62 | struct kioctx *ki_ctx; /* may be NULL for sync ops */ |
Kent Overstreet | 0460fef | 2013-05-07 16:18:49 -0700 | [diff] [blame^] | 63 | kiocb_cancel_fn *ki_cancel; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | ssize_t (*ki_retry)(struct kiocb *); |
| 65 | void (*ki_dtor)(struct kiocb *); |
| 66 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 67 | union { |
| 68 | void __user *user; |
| 69 | struct task_struct *tsk; |
| 70 | } ki_obj; |
Benjamin LaHaise | 59d9136 | 2006-01-08 01:04:34 -0800 | [diff] [blame] | 71 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | __u64 ki_user_data; /* user's data for completion */ |
| 73 | loff_t ki_pos; |
Benjamin LaHaise | 59d9136 | 2006-01-08 01:04:34 -0800 | [diff] [blame] | 74 | |
| 75 | void *private; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | /* State that we remember to be able to restart/retry */ |
| 77 | unsigned short ki_opcode; |
| 78 | size_t ki_nbytes; /* copy of iocb->aio_nbytes */ |
| 79 | char __user *ki_buf; /* remaining iocb->aio_buf */ |
| 80 | size_t ki_left; /* remaining bytes */ |
Badari Pulavarty | 027445c | 2006-09-30 23:28:46 -0700 | [diff] [blame] | 81 | struct iovec ki_inline_vec; /* inline vector */ |
Badari Pulavarty | eed4e51 | 2006-09-30 23:28:49 -0700 | [diff] [blame] | 82 | struct iovec *ki_iovec; |
| 83 | unsigned long ki_nr_segs; |
| 84 | unsigned long ki_cur_seg; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | |
Benjamin LaHaise | 59d9136 | 2006-01-08 01:04:34 -0800 | [diff] [blame] | 86 | struct list_head ki_list; /* the aio core uses this |
| 87 | * for cancellation */ |
Jeff Moyer | 080d676 | 2011-11-02 13:40:10 -0700 | [diff] [blame] | 88 | struct list_head ki_batch; /* batch allocation */ |
Davide Libenzi | 9c3060b | 2007-05-10 22:23:21 -0700 | [diff] [blame] | 89 | |
| 90 | /* |
| 91 | * If the aio_resfd field of the userspace iocb is not zero, |
Davide Libenzi | 1338901 | 2009-06-30 11:41:11 -0700 | [diff] [blame] | 92 | * this is the underlying eventfd context to deliver events to. |
Davide Libenzi | 9c3060b | 2007-05-10 22:23:21 -0700 | [diff] [blame] | 93 | */ |
Davide Libenzi | 1338901 | 2009-06-30 11:41:11 -0700 | [diff] [blame] | 94 | struct eventfd_ctx *ki_eventfd; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | }; |
| 96 | |
Andrew Morton | f7e1bec | 2012-07-30 14:42:56 -0700 | [diff] [blame] | 97 | static inline bool is_sync_kiocb(struct kiocb *kiocb) |
| 98 | { |
| 99 | return kiocb->ki_key == KIOCB_SYNC_KEY; |
| 100 | } |
| 101 | |
| 102 | static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp) |
| 103 | { |
| 104 | *kiocb = (struct kiocb) { |
Kent Overstreet | 11599eb | 2013-05-07 16:18:39 -0700 | [diff] [blame] | 105 | .ki_users = ATOMIC_INIT(1), |
Andrew Morton | f7e1bec | 2012-07-30 14:42:56 -0700 | [diff] [blame] | 106 | .ki_key = KIOCB_SYNC_KEY, |
| 107 | .ki_filp = filp, |
| 108 | .ki_obj.tsk = current, |
| 109 | }; |
| 110 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | /* prototypes */ |
Thomas Petazzoni | ebf3f09 | 2008-10-15 22:05:12 -0700 | [diff] [blame] | 113 | #ifdef CONFIG_AIO |
Harvey Harrison | b3c9752 | 2008-02-13 15:03:15 -0800 | [diff] [blame] | 114 | extern ssize_t wait_on_sync_kiocb(struct kiocb *iocb); |
Kent Overstreet | 2d68449 | 2013-05-07 16:18:29 -0700 | [diff] [blame] | 115 | extern void aio_put_req(struct kiocb *iocb); |
| 116 | extern void aio_complete(struct kiocb *iocb, long res, long res2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | struct mm_struct; |
Harvey Harrison | b3c9752 | 2008-02-13 15:03:15 -0800 | [diff] [blame] | 118 | extern void exit_aio(struct mm_struct *mm); |
Jeff Moyer | 9d85cba | 2010-05-26 14:44:26 -0700 | [diff] [blame] | 119 | extern long do_io_submit(aio_context_t ctx_id, long nr, |
| 120 | struct iocb __user *__user *iocbpp, bool compat); |
Kent Overstreet | 0460fef | 2013-05-07 16:18:49 -0700 | [diff] [blame^] | 121 | void kiocb_set_cancel_fn(struct kiocb *req, kiocb_cancel_fn *cancel); |
Thomas Petazzoni | ebf3f09 | 2008-10-15 22:05:12 -0700 | [diff] [blame] | 122 | #else |
| 123 | static inline ssize_t wait_on_sync_kiocb(struct kiocb *iocb) { return 0; } |
Kent Overstreet | 2d68449 | 2013-05-07 16:18:29 -0700 | [diff] [blame] | 124 | static inline void aio_put_req(struct kiocb *iocb) { } |
| 125 | static inline void aio_complete(struct kiocb *iocb, long res, long res2) { } |
Thomas Petazzoni | ebf3f09 | 2008-10-15 22:05:12 -0700 | [diff] [blame] | 126 | struct mm_struct; |
| 127 | static inline void exit_aio(struct mm_struct *mm) { } |
Jeff Moyer | 9d85cba | 2010-05-26 14:44:26 -0700 | [diff] [blame] | 128 | static inline long do_io_submit(aio_context_t ctx_id, long nr, |
| 129 | struct iocb __user * __user *iocbpp, |
| 130 | bool compat) { return 0; } |
Kent Overstreet | 0460fef | 2013-05-07 16:18:49 -0700 | [diff] [blame^] | 131 | static inline void kiocb_set_cancel_fn(struct kiocb *req, |
| 132 | kiocb_cancel_fn *cancel) { } |
Thomas Petazzoni | ebf3f09 | 2008-10-15 22:05:12 -0700 | [diff] [blame] | 133 | #endif /* CONFIG_AIO */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | static inline struct kiocb *list_kiocb(struct list_head *h) |
| 136 | { |
| 137 | return list_entry(h, struct kiocb, ki_list); |
| 138 | } |
| 139 | |
| 140 | /* for sysctl: */ |
Zach Brown | d55b5fd | 2005-11-07 00:59:31 -0800 | [diff] [blame] | 141 | extern unsigned long aio_nr; |
| 142 | extern unsigned long aio_max_nr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | |
| 144 | #endif /* __LINUX__AIO_H */ |