Commit | Line | Data |
---|---|---|
1da177e4 LT |
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> | |
027445c3 | 7 | #include <linux/uio.h> |
abf137dd | 8 | #include <linux/rcupdate.h> |
1da177e4 | 9 | |
60063497 | 10 | #include <linux/atomic.h> |
1da177e4 | 11 | |
1da177e4 LT |
12 | struct kioctx; |
13 | ||
1da177e4 LT |
14 | #define KIOCB_SYNC_KEY (~0U) |
15 | ||
16 | /* ki_flags bits */ | |
1da177e4 LT |
17 | #define KIF_CANCELLED 2 |
18 | ||
1da177e4 LT |
19 | #define kiocbSetCancelled(iocb) set_bit(KIF_CANCELLED, &(iocb)->ki_flags) |
20 | ||
1da177e4 LT |
21 | #define kiocbClearCancelled(iocb) clear_bit(KIF_CANCELLED, &(iocb)->ki_flags) |
22 | ||
1da177e4 LT |
23 | #define kiocbIsCancelled(iocb) test_bit(KIF_CANCELLED, &(iocb)->ki_flags) |
24 | ||
897f15fb ZB |
25 | /* is there a better place to document function pointer methods? */ |
26 | /** | |
27 | * ki_retry - iocb forward progress callback | |
28 | * @kiocb: The kiocb struct to advance by performing an operation. | |
29 | * | |
30 | * This callback is called when the AIO core wants a given AIO operation | |
31 | * to make forward progress. The kiocb argument describes the operation | |
32 | * that is to be performed. As the operation proceeds, perhaps partially, | |
33 | * ki_retry is expected to update the kiocb with progress made. Typically | |
34 | * ki_retry is set in the AIO core and it itself calls file_operations | |
35 | * helpers. | |
36 | * | |
37 | * ki_retry's return value determines when the AIO operation is completed | |
38 | * and an event is generated in the AIO event ring. Except the special | |
39 | * return values described below, the value that is returned from ki_retry | |
40 | * is transferred directly into the completion ring as the operation's | |
41 | * resulting status. Once this has happened ki_retry *MUST NOT* reference | |
42 | * the kiocb pointer again. | |
43 | * | |
44 | * If ki_retry returns -EIOCBQUEUED it has made a promise that aio_complete() | |
45 | * will be called on the kiocb pointer in the future. The AIO core will | |
46 | * not ask the method again -- ki_retry must ensure forward progress. | |
47 | * aio_complete() must be called once and only once in the future, multiple | |
48 | * calls may result in undefined behaviour. | |
897f15fb | 49 | */ |
1da177e4 | 50 | struct kiocb { |
2ba2d003 | 51 | unsigned long ki_flags; |
11599eba | 52 | atomic_t ki_users; |
1da177e4 LT |
53 | unsigned ki_key; /* id of this request */ |
54 | ||
55 | struct file *ki_filp; | |
56 | struct kioctx *ki_ctx; /* may be NULL for sync ops */ | |
57 | int (*ki_cancel)(struct kiocb *, struct io_event *); | |
58 | ssize_t (*ki_retry)(struct kiocb *); | |
59 | void (*ki_dtor)(struct kiocb *); | |
60 | ||
1da177e4 LT |
61 | union { |
62 | void __user *user; | |
63 | struct task_struct *tsk; | |
64 | } ki_obj; | |
59d9136b | 65 | |
1da177e4 LT |
66 | __u64 ki_user_data; /* user's data for completion */ |
67 | loff_t ki_pos; | |
59d9136b BL |
68 | |
69 | void *private; | |
1da177e4 LT |
70 | /* State that we remember to be able to restart/retry */ |
71 | unsigned short ki_opcode; | |
72 | size_t ki_nbytes; /* copy of iocb->aio_nbytes */ | |
73 | char __user *ki_buf; /* remaining iocb->aio_buf */ | |
74 | size_t ki_left; /* remaining bytes */ | |
027445c3 | 75 | struct iovec ki_inline_vec; /* inline vector */ |
eed4e51f BP |
76 | struct iovec *ki_iovec; |
77 | unsigned long ki_nr_segs; | |
78 | unsigned long ki_cur_seg; | |
1da177e4 | 79 | |
59d9136b BL |
80 | struct list_head ki_list; /* the aio core uses this |
81 | * for cancellation */ | |
080d676d | 82 | struct list_head ki_batch; /* batch allocation */ |
9c3060be DL |
83 | |
84 | /* | |
85 | * If the aio_resfd field of the userspace iocb is not zero, | |
13389010 | 86 | * this is the underlying eventfd context to deliver events to. |
9c3060be | 87 | */ |
13389010 | 88 | struct eventfd_ctx *ki_eventfd; |
1da177e4 LT |
89 | }; |
90 | ||
f7e1becb AM |
91 | static inline bool is_sync_kiocb(struct kiocb *kiocb) |
92 | { | |
93 | return kiocb->ki_key == KIOCB_SYNC_KEY; | |
94 | } | |
95 | ||
96 | static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp) | |
97 | { | |
98 | *kiocb = (struct kiocb) { | |
11599eba | 99 | .ki_users = ATOMIC_INIT(1), |
f7e1becb AM |
100 | .ki_key = KIOCB_SYNC_KEY, |
101 | .ki_filp = filp, | |
102 | .ki_obj.tsk = current, | |
103 | }; | |
104 | } | |
1da177e4 | 105 | |
1da177e4 | 106 | /* prototypes */ |
ebf3f09c | 107 | #ifdef CONFIG_AIO |
b3c97528 | 108 | extern ssize_t wait_on_sync_kiocb(struct kiocb *iocb); |
2d68449e KO |
109 | extern void aio_put_req(struct kiocb *iocb); |
110 | extern void aio_complete(struct kiocb *iocb, long res, long res2); | |
1da177e4 | 111 | struct mm_struct; |
b3c97528 | 112 | extern void exit_aio(struct mm_struct *mm); |
9d85cba7 JM |
113 | extern long do_io_submit(aio_context_t ctx_id, long nr, |
114 | struct iocb __user *__user *iocbpp, bool compat); | |
ebf3f09c TP |
115 | #else |
116 | static inline ssize_t wait_on_sync_kiocb(struct kiocb *iocb) { return 0; } | |
2d68449e KO |
117 | static inline void aio_put_req(struct kiocb *iocb) { } |
118 | static inline void aio_complete(struct kiocb *iocb, long res, long res2) { } | |
ebf3f09c TP |
119 | struct mm_struct; |
120 | static inline void exit_aio(struct mm_struct *mm) { } | |
9d85cba7 JM |
121 | static inline long do_io_submit(aio_context_t ctx_id, long nr, |
122 | struct iocb __user * __user *iocbpp, | |
123 | bool compat) { return 0; } | |
ebf3f09c | 124 | #endif /* CONFIG_AIO */ |
1da177e4 | 125 | |
1da177e4 LT |
126 | static inline struct kiocb *list_kiocb(struct list_head *h) |
127 | { | |
128 | return list_entry(h, struct kiocb, ki_list); | |
129 | } | |
130 | ||
131 | /* for sysctl: */ | |
d55b5fda ZB |
132 | extern unsigned long aio_nr; |
133 | extern unsigned long aio_max_nr; | |
1da177e4 LT |
134 | |
135 | #endif /* __LINUX__AIO_H */ |