Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
422 | giacomo | 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> |
||
7 | |||
8 | #include <asm/atomic.h> |
||
9 | |||
10 | #define AIO_MAXSEGS 4 |
||
11 | #define AIO_KIOGRP_NR_ATOMIC 8 |
||
12 | |||
13 | struct kioctx; |
||
14 | |||
15 | /* Notes on cancelling a kiocb: |
||
16 | * If a kiocb is cancelled, aio_complete may return 0 to indicate |
||
17 | * that cancel has not yet disposed of the kiocb. All cancel |
||
18 | * operations *must* call aio_put_req to dispose of the kiocb |
||
19 | * to guard against races with the completion code. |
||
20 | */ |
||
21 | #define KIOCB_C_CANCELLED 0x01 |
||
22 | #define KIOCB_C_COMPLETE 0x02 |
||
23 | |||
24 | #define KIOCB_SYNC_KEY (~0U) |
||
25 | |||
26 | #define KIOCB_PRIVATE_SIZE (24 * sizeof(long)) |
||
27 | |||
28 | /* ki_flags bits */ |
||
29 | #define KIF_LOCKED 0 |
||
30 | #define KIF_KICKED 1 |
||
31 | #define KIF_CANCELLED 2 |
||
32 | |||
33 | #define kiocbTryLock(iocb) test_and_set_bit(KIF_LOCKED, &(iocb)->ki_flags) |
||
34 | #define kiocbTryKick(iocb) test_and_set_bit(KIF_KICKED, &(iocb)->ki_flags) |
||
35 | |||
36 | #define kiocbSetLocked(iocb) set_bit(KIF_LOCKED, &(iocb)->ki_flags) |
||
37 | #define kiocbSetKicked(iocb) set_bit(KIF_KICKED, &(iocb)->ki_flags) |
||
38 | #define kiocbSetCancelled(iocb) set_bit(KIF_CANCELLED, &(iocb)->ki_flags) |
||
39 | |||
40 | #define kiocbClearLocked(iocb) clear_bit(KIF_LOCKED, &(iocb)->ki_flags) |
||
41 | #define kiocbClearKicked(iocb) clear_bit(KIF_KICKED, &(iocb)->ki_flags) |
||
42 | #define kiocbClearCancelled(iocb) clear_bit(KIF_CANCELLED, &(iocb)->ki_flags) |
||
43 | |||
44 | #define kiocbIsLocked(iocb) test_bit(KIF_LOCKED, &(iocb)->ki_flags) |
||
45 | #define kiocbIsKicked(iocb) test_bit(KIF_KICKED, &(iocb)->ki_flags) |
||
46 | #define kiocbIsCancelled(iocb) test_bit(KIF_CANCELLED, &(iocb)->ki_flags) |
||
47 | |||
48 | struct kiocb { |
||
49 | struct list_head ki_run_list; |
||
50 | long ki_flags; |
||
51 | int ki_users; |
||
52 | unsigned ki_key; /* id of this request */ |
||
53 | |||
54 | struct file *ki_filp; |
||
55 | struct kioctx *ki_ctx; /* may be NULL for sync ops */ |
||
56 | int (*ki_cancel)(struct kiocb *, struct io_event *); |
||
57 | long (*ki_retry)(struct kiocb *); |
||
58 | |||
59 | struct list_head ki_list; /* the aio core uses this |
||
60 | * for cancellation */ |
||
61 | |||
62 | void *ki_user_obj; /* pointer to userland's iocb */ |
||
63 | __u64 ki_user_data; /* user's data for completion */ |
||
64 | loff_t ki_pos; |
||
65 | |||
66 | char private[KIOCB_PRIVATE_SIZE]; |
||
67 | }; |
||
68 | |||
69 | #define is_sync_kiocb(iocb) ((iocb)->ki_key == KIOCB_SYNC_KEY) |
||
70 | #define init_sync_kiocb(x, filp) \ |
||
71 | do { \ |
||
72 | struct task_struct *tsk = current; \ |
||
73 | (x)->ki_flags = 0; \ |
||
74 | (x)->ki_users = 1; \ |
||
75 | (x)->ki_key = KIOCB_SYNC_KEY; \ |
||
76 | (x)->ki_filp = (filp); \ |
||
77 | (x)->ki_ctx = &tsk->active_mm->default_kioctx; \ |
||
78 | (x)->ki_cancel = NULL; \ |
||
79 | (x)->ki_user_obj = tsk; \ |
||
80 | } while (0) |
||
81 | |||
82 | #define AIO_RING_MAGIC 0xa10a10a1 |
||
83 | #define AIO_RING_COMPAT_FEATURES 1 |
||
84 | #define AIO_RING_INCOMPAT_FEATURES 0 |
||
85 | struct aio_ring { |
||
86 | unsigned id; /* kernel internal index number */ |
||
87 | unsigned nr; /* number of io_events */ |
||
88 | unsigned head; |
||
89 | unsigned tail; |
||
90 | |||
91 | unsigned magic; |
||
92 | unsigned compat_features; |
||
93 | unsigned incompat_features; |
||
94 | unsigned header_length; /* size of aio_ring */ |
||
95 | |||
96 | |||
97 | struct io_event io_events[0]; |
||
98 | }; /* 128 bytes + ring size */ |
||
99 | |||
100 | #define aio_ring_avail(info, ring) (((ring)->head + (info)->nr - 1 - (ring)->tail) % (info)->nr) |
||
101 | |||
102 | #define AIO_RING_PAGES 8 |
||
103 | struct aio_ring_info { |
||
104 | unsigned long mmap_base; |
||
105 | unsigned long mmap_size; |
||
106 | |||
107 | struct page **ring_pages; |
||
108 | spinlock_t ring_lock; |
||
109 | long nr_pages; |
||
110 | |||
111 | unsigned nr, tail; |
||
112 | |||
113 | struct page *internal_pages[AIO_RING_PAGES]; |
||
114 | }; |
||
115 | |||
116 | struct kioctx { |
||
117 | atomic_t users; |
||
118 | int dead; |
||
119 | struct mm_struct *mm; |
||
120 | |||
121 | /* This needs improving */ |
||
122 | unsigned long user_id; |
||
123 | struct kioctx *next; |
||
124 | |||
125 | wait_queue_head_t wait; |
||
126 | |||
127 | spinlock_t ctx_lock; |
||
128 | |||
129 | int reqs_active; |
||
130 | struct list_head active_reqs; /* used for cancellation */ |
||
131 | struct list_head run_list; /* used for kicked reqs */ |
||
132 | |||
133 | unsigned max_reqs; |
||
134 | |||
135 | struct aio_ring_info ring_info; |
||
136 | |||
137 | struct work_struct wq; |
||
138 | }; |
||
139 | |||
140 | /* prototypes */ |
||
141 | extern unsigned aio_max_size; |
||
142 | |||
143 | extern ssize_t FASTCALL(wait_on_sync_kiocb(struct kiocb *iocb)); |
||
144 | extern int FASTCALL(aio_put_req(struct kiocb *iocb)); |
||
145 | extern void FASTCALL(kick_iocb(struct kiocb *iocb)); |
||
146 | extern int FASTCALL(aio_complete(struct kiocb *iocb, long res, long res2)); |
||
147 | extern void FASTCALL(__put_ioctx(struct kioctx *ctx)); |
||
148 | struct mm_struct; |
||
149 | extern void FASTCALL(exit_aio(struct mm_struct *mm)); |
||
150 | extern struct kioctx *lookup_ioctx(unsigned long ctx_id); |
||
151 | extern int FASTCALL(io_submit_one(struct kioctx *ctx, |
||
152 | struct iocb *user_iocb, struct iocb *iocb)); |
||
153 | |||
154 | /* semi private, but used by the 32bit emulations: */ |
||
155 | struct kioctx *lookup_ioctx(unsigned long ctx_id); |
||
156 | int FASTCALL(io_submit_one(struct kioctx *ctx, struct iocb *user_iocb, |
||
157 | struct iocb *iocb)); |
||
158 | |||
159 | #define get_ioctx(kioctx) do { if (unlikely(atomic_read(&(kioctx)->users) <= 0)) BUG(); atomic_inc(&(kioctx)->users); } while (0) |
||
160 | #define put_ioctx(kioctx) do { if (unlikely(atomic_dec_and_test(&(kioctx)->users))) __put_ioctx(kioctx); else if (unlikely(atomic_read(&(kioctx)->users) < 0)) BUG(); } while (0) |
||
161 | |||
162 | #include <linux/aio_abi.h> |
||
163 | |||
164 | static inline struct kiocb *list_kiocb(struct list_head *h) |
||
165 | { |
||
166 | return list_entry(h, struct kiocb, ki_list); |
||
167 | } |
||
168 | |||
169 | /* for sysctl: */ |
||
170 | extern unsigned aio_max_nr, aio_max_size, aio_max_pinned; |
||
171 | |||
172 | #endif /* __LINUX__AIO_H */ |