Add strong madvise() hint for cache pruning
[fio.git] / engines / solarisaio.c
CommitLineData
417f0068
JA
1/*
2 * Native Solaris async IO engine
3 *
4 */
5#include <stdio.h>
6#include <stdlib.h>
7#include <unistd.h>
556e831d 8#include <signal.h>
417f0068
JA
9#include <errno.h>
10
11#include "../fio.h"
12
13#ifdef FIO_HAVE_SOLARISAIO
14
15#include <sys/asynch.h>
16
17struct solarisaio_data {
18 struct io_u **aio_events;
556e831d 19 unsigned int aio_pending;
417f0068 20 unsigned int nr;
5cf56c03 21 unsigned int max_depth;
417f0068
JA
22};
23
24static int fio_solarisaio_cancel(struct thread_data fio_unused *td,
25 struct io_u *io_u)
26{
27 return aiocancel(&io_u->resultp);
28}
29
30static int fio_solarisaio_prep(struct thread_data fio_unused *td,
31 struct io_u *io_u)
32{
556e831d
JA
33 struct solarisaio_data *sd = td->io_ops->data;
34
417f0068 35 io_u->resultp.aio_return = AIO_INPROGRESS;
556e831d 36 io_u->engine_data = sd;
417f0068
JA
37 return 0;
38}
39
556e831d
JA
40static void wait_for_event(struct timeval *tv)
41{
42 struct solarisaio_data *sd;
43 struct io_u *io_u;
44 aio_result_t *res;
45
46 res = aiowait(tv);
47 if (res == (aio_result_t *) -1) {
48 int err = errno;
49
50 if (err != EINVAL) {
51 log_err("fio: solarisaio got %d in aiowait\n", err);
52 exit(err);
53 }
54 return;
55 } else if (!res)
56 return;
57
58 io_u = container_of(res, struct io_u, resultp);
59 sd = io_u->engine_data;
60
61 if (io_u->resultp.aio_return >= 0) {
62 io_u->resid = io_u->xfer_buflen - io_u->resultp.aio_return;
63 io_u->error = 0;
64 } else
983b770d 65 io_u->error = io_u->resultp.aio_errno;
556e831d
JA
66
67 /*
68 * For SIGIO, we need a write barrier between the two, so that
69 * the ->aio_pending store is seen after the ->aio_events store
70 */
71 sd->aio_events[sd->aio_pending] = io_u;
44c47feb 72 write_barrier();
556e831d
JA
73 sd->aio_pending++;
74 sd->nr--;
75}
76
417f0068
JA
77static int fio_solarisaio_getevents(struct thread_data *td, unsigned int min,
78 unsigned int max, struct timespec *t)
79{
80 struct solarisaio_data *sd = td->io_ops->data;
81 struct timeval tv;
556e831d 82 int ret;
417f0068 83
556e831d
JA
84 if (!min || !t) {
85 tv.tv_sec = 0;
86 tv.tv_usec = 0;
87 } else {
88 tv.tv_sec = t->tv_sec;
89 tv.tv_usec = t->tv_nsec / 1000;
90 }
91
92 while (sd->aio_pending < min)
93 wait_for_event(&tv);
417f0068 94
556e831d 95 /*
44c47feb 96 * should be OK without locking, as int operations should be atomic
556e831d
JA
97 */
98 ret = sd->aio_pending;
44c47feb 99 sd->aio_pending -= ret;
556e831d 100 return ret;
417f0068
JA
101}
102
103static struct io_u *fio_solarisaio_event(struct thread_data *td, int event)
104{
105 struct solarisaio_data *sd = td->io_ops->data;
106
107 return sd->aio_events[event];
108}
109
110static int fio_solarisaio_queue(struct thread_data fio_unused *td,
111 struct io_u *io_u)
112{
113 struct solarisaio_data *sd = td->io_ops->data;
114 struct fio_file *f = io_u->file;
115 off_t off;
116 int ret;
117
118 fio_ro_check(td, io_u);
119
120 if (io_u->ddir == DDIR_SYNC) {
121 if (sd->nr)
122 return FIO_Q_BUSY;
123 if (fsync(f->fd) < 0)
124 io_u->error = errno;
125
126 return FIO_Q_COMPLETED;
127 }
128
5f9099ea
JA
129 if (io_u->ddir == DDIR_DATASYNC) {
130 if (sd->nr)
131 return FIO_Q_BUSY;
132 if (fdatasync(f->fd) < 0)
133 io_u->error = errno;
134
135 return FIO_Q_COMPLETED;
136 }
137
5cf56c03 138 if (sd->nr == sd->max_depth)
417f0068
JA
139 return FIO_Q_BUSY;
140
141 off = io_u->offset;
142 if (io_u->ddir == DDIR_READ)
143 ret = aioread(f->fd, io_u->xfer_buf, io_u->xfer_buflen, off,
144 SEEK_SET, &io_u->resultp);
145 else
146 ret = aiowrite(f->fd, io_u->xfer_buf, io_u->xfer_buflen, off,
147 SEEK_SET, &io_u->resultp);
148 if (ret) {
149 io_u->error = errno;
150 td_verror(td, io_u->error, "xfer");
151 return FIO_Q_COMPLETED;
152 }
153
154 sd->nr++;
155 return FIO_Q_QUEUED;
156}
157
158static void fio_solarisaio_cleanup(struct thread_data *td)
159{
160 struct solarisaio_data *sd = td->io_ops->data;
161
162 if (sd) {
163 free(sd->aio_events);
164 free(sd);
165 }
166}
167
556e831d 168/*
44c47feb 169 * Set USE_SIGNAL_COMPLETIONS to use SIGIO as completion events.
556e831d 170 */
da28353c
JA
171#ifdef USE_SIGNAL_COMPLETIONS
172static void fio_solarisaio_sigio(int sig)
173{
174 wait_for_event(NULL);
175}
176
556e831d
JA
177static void fio_solarisaio_init_sigio(void)
178{
556e831d
JA
179 struct sigaction act;
180
181 memset(&act, 0, sizeof(act));
182 act.sa_handler = fio_solarisaio_sigio;
183 act.sa_flags = SA_RESTART;
184 sigaction(SIGIO, &act, NULL);
556e831d 185}
da28353c 186#endif
556e831d 187
417f0068
JA
188static int fio_solarisaio_init(struct thread_data *td)
189{
190 struct solarisaio_data *sd = malloc(sizeof(*sd));
5cf56c03
JA
191 unsigned int max_depth;
192
193 max_depth = td->o.iodepth;
194 if (max_depth > MAXASYNCHIO) {
195 max_depth = MAXASYNCHIO;
196 log_info("fio: lower depth to %d due to OS constraints\n",
197 max_depth);
198 }
417f0068
JA
199
200 memset(sd, 0, sizeof(*sd));
5cf56c03
JA
201 sd->aio_events = malloc(max_depth * sizeof(struct io_u *));
202 memset(sd->aio_events, 0, max_depth * sizeof(struct io_u *));
203 sd->max_depth = max_depth;
417f0068 204
da28353c 205#ifdef USE_SIGNAL_COMPLETIONS
556e831d 206 fio_solarisaio_init_sigio();
da28353c 207#endif
556e831d 208
417f0068
JA
209 td->io_ops->data = sd;
210 return 0;
211}
212
213static struct ioengine_ops ioengine = {
214 .name = "solarisaio",
215 .version = FIO_IOOPS_VERSION,
216 .init = fio_solarisaio_init,
217 .prep = fio_solarisaio_prep,
218 .queue = fio_solarisaio_queue,
219 .cancel = fio_solarisaio_cancel,
220 .getevents = fio_solarisaio_getevents,
221 .event = fio_solarisaio_event,
222 .cleanup = fio_solarisaio_cleanup,
223 .open_file = generic_open_file,
224 .close_file = generic_close_file,
df9c26b1 225 .get_file_size = generic_get_file_size,
417f0068
JA
226};
227
228#else /* FIO_HAVE_SOLARISAIO */
229
230/*
231 * When we have a proper configure system in place, we simply wont build
232 * and install this io engine. For now install a crippled version that
233 * just complains and fails to load.
234 */
235static int fio_solarisaio_init(struct thread_data fio_unused *td)
236{
237 fprintf(stderr, "fio: solarisaio not available\n");
238 return 1;
239}
240
241static struct ioengine_ops ioengine = {
242 .name = "solarisaio",
243 .version = FIO_IOOPS_VERSION,
244 .init = fio_solarisaio_init,
245};
246
247#endif
248
249static void fio_init fio_solarisaio_register(void)
250{
251 register_ioengine(&ioengine);
252}
253
254static void fio_exit fio_solarisaio_unregister(void)
255{
256 unregister_ioengine(&ioengine);
257}