Commit | Line | Data |
---|---|---|
6e7d7dfb | 1 | /* |
2 | * glusterfs engine | |
3 | * | |
cc47f094 | 4 | * common Glusterfs's gfapi interface |
6e7d7dfb | 5 | * |
6 | */ | |
7 | ||
cc47f094 | 8 | #include "gfapi.h" |
d220c761 | 9 | #include "../optgroup.h" |
6e7d7dfb | 10 | |
cc47f094 | 11 | struct fio_option gfapi_options[] = { |
b29c813f JA |
12 | { |
13 | .name = "volume", | |
14 | .lname = "Glusterfs volume", | |
15 | .type = FIO_OPT_STR_STORE, | |
16 | .help = "Name of the Glusterfs volume", | |
17 | .off1 = offsetof(struct gf_options, gf_vol), | |
18 | .category = FIO_OPT_C_ENGINE, | |
19 | .group = FIO_OPT_G_GFAPI, | |
20 | }, | |
21 | { | |
22 | .name = "brick", | |
23 | .lname = "Glusterfs brick name", | |
24 | .type = FIO_OPT_STR_STORE, | |
25 | .help = "Name of the Glusterfs brick to connect", | |
26 | .off1 = offsetof(struct gf_options, gf_brick), | |
27 | .category = FIO_OPT_C_ENGINE, | |
28 | .group = FIO_OPT_G_GFAPI, | |
29 | }, | |
30 | { | |
31 | .name = NULL, | |
32 | }, | |
6e7d7dfb | 33 | }; |
34 | ||
cc47f094 | 35 | int fio_gf_setup(struct thread_data *td) |
6e7d7dfb | 36 | { |
37 | int r = 0; | |
38 | struct gf_data *g = NULL; | |
39 | struct gf_options *opt = td->eo; | |
b29c813f | 40 | struct stat sb = { 0, }; |
7cb57176 | 41 | |
42 | dprint(FD_IO, "fio setup\n"); | |
6e7d7dfb | 43 | |
44 | if (td->io_ops->data) | |
b29c813f | 45 | return 0; |
6e7d7dfb | 46 | |
47 | g = malloc(sizeof(struct gf_data)); | |
b29c813f JA |
48 | if (!g) { |
49 | log_err("malloc failed.\n"); | |
50 | return -ENOMEM; | |
6e7d7dfb | 51 | } |
b29c813f JA |
52 | g->fs = NULL; |
53 | g->fd = NULL; | |
54 | g->aio_events = NULL; | |
55 | ||
56 | g->fs = glfs_new(opt->gf_vol); | |
57 | if (!g->fs) { | |
58 | log_err("glfs_new failed.\n"); | |
59 | goto cleanup; | |
6e7d7dfb | 60 | } |
b29c813f | 61 | glfs_set_logging(g->fs, "/tmp/fio_gfapi.log", 7); |
6e7d7dfb | 62 | /* default to tcp */ |
7cb57176 | 63 | r = glfs_set_volfile_server(g->fs, "tcp", opt->gf_brick, 0); |
b29c813f JA |
64 | if (r) { |
65 | log_err("glfs_set_volfile_server failed.\n"); | |
66 | goto cleanup; | |
6e7d7dfb | 67 | } |
68 | r = glfs_init(g->fs); | |
b29c813f JA |
69 | if (r) { |
70 | log_err("glfs_init failed. Is glusterd running on brick?\n"); | |
71 | goto cleanup; | |
7cb57176 | 72 | } |
73 | sleep(2); | |
b29c813f JA |
74 | r = glfs_lstat(g->fs, ".", &sb); |
75 | if (r) { | |
76 | log_err("glfs_lstat failed.\n"); | |
77 | goto cleanup; | |
6e7d7dfb | 78 | } |
7cb57176 | 79 | dprint(FD_FILE, "fio setup %p\n", g->fs); |
6e7d7dfb | 80 | td->io_ops->data = g; |
93782cbb | 81 | return 0; |
6e7d7dfb | 82 | cleanup: |
93782cbb JA |
83 | if (g->fs) |
84 | glfs_fini(g->fs); | |
85 | free(g); | |
86 | td->io_ops->data = NULL; | |
6e7d7dfb | 87 | return r; |
88 | } | |
89 | ||
cc47f094 | 90 | void fio_gf_cleanup(struct thread_data *td) |
6e7d7dfb | 91 | { |
cc47f094 | 92 | struct gf_data *g = td->io_ops->data; |
93 | ||
94 | if (g) { | |
b29c813f JA |
95 | if (g->aio_events) |
96 | free(g->aio_events); | |
97 | if (g->fd) | |
98 | glfs_close(g->fd); | |
99 | if (g->fs) | |
100 | glfs_fini(g->fs); | |
101 | free(g); | |
102 | td->io_ops->data = NULL; | |
cc47f094 | 103 | } |
6e7d7dfb | 104 | } |
105 | ||
cc47f094 | 106 | int fio_gf_get_file_size(struct thread_data *td, struct fio_file *f) |
6e7d7dfb | 107 | { |
b29c813f JA |
108 | struct stat buf; |
109 | int ret; | |
110 | struct gf_data *g = td->io_ops->data; | |
6e7d7dfb | 111 | |
b29c813f | 112 | dprint(FD_FILE, "get file size %s\n", f->file_name); |
6aa56500 | 113 | |
b29c813f JA |
114 | if (!g || !g->fs) { |
115 | return 0; | |
116 | } | |
117 | if (fio_file_size_known(f)) | |
118 | return 0; | |
6e7d7dfb | 119 | |
b29c813f JA |
120 | ret = glfs_lstat(g->fs, f->file_name, &buf); |
121 | if (ret < 0) { | |
122 | log_err("glfs_lstat failed.\n"); | |
123 | return ret; | |
124 | } | |
6e7d7dfb | 125 | |
b29c813f JA |
126 | f->real_file_size = buf.st_size; |
127 | fio_file_set_size_known(f); | |
6e7d7dfb | 128 | |
b29c813f | 129 | return 0; |
6e7d7dfb | 130 | |
131 | } | |
132 | ||
cc47f094 | 133 | int fio_gf_open_file(struct thread_data *td, struct fio_file *f) |
6e7d7dfb | 134 | { |
a8a93dee | 135 | |
b29c813f JA |
136 | int flags = 0; |
137 | int ret = 0; | |
138 | struct gf_data *g = td->io_ops->data; | |
139 | struct stat sb = { 0, }; | |
140 | ||
141 | if (td_write(td)) { | |
142 | if (!read_only) | |
143 | flags = O_RDWR; | |
144 | } else if (td_read(td)) { | |
145 | if (!read_only) | |
146 | flags = O_RDWR; | |
147 | else | |
148 | flags = O_RDONLY; | |
149 | } | |
65bea10f TM |
150 | |
151 | if (td->o.odirect) | |
152 | flags |= OS_O_DIRECT; | |
153 | if (td->o.sync_io) | |
154 | flags |= O_SYNC; | |
155 | ||
b29c813f | 156 | dprint(FD_FILE, "fio file %s open mode %s td rw %s\n", f->file_name, |
65bea10f | 157 | flags & O_RDONLY ? "ro" : "rw", td_read(td) ? "read" : "write"); |
b29c813f JA |
158 | g->fd = glfs_creat(g->fs, f->file_name, flags, 0644); |
159 | if (!g->fd) { | |
b29c813f | 160 | ret = errno; |
1a889967 TM |
161 | log_err("glfs_creat failed.\n"); |
162 | return ret; | |
b29c813f JA |
163 | } |
164 | /* file for read doesn't exist or shorter than required, create/extend it */ | |
165 | if (td_read(td)) { | |
166 | if (glfs_lstat(g->fs, f->file_name, &sb) | |
167 | || sb.st_size < f->real_file_size) { | |
168 | dprint(FD_FILE, "fio extend file %s from %ld to %ld\n", | |
169 | f->file_name, sb.st_size, f->real_file_size); | |
170 | ret = glfs_ftruncate(g->fd, f->real_file_size); | |
171 | if (ret) { | |
172 | log_err("failed fio extend file %s to %ld\n", | |
173 | f->file_name, f->real_file_size); | |
174 | } else { | |
175 | unsigned long long left; | |
176 | unsigned int bs; | |
177 | char *b; | |
178 | int r; | |
179 | ||
180 | /* fill the file, copied from extend_file */ | |
181 | b = malloc(td->o.max_bs[DDIR_WRITE]); | |
182 | ||
183 | left = f->real_file_size; | |
184 | while (left && !td->terminate) { | |
185 | bs = td->o.max_bs[DDIR_WRITE]; | |
186 | if (bs > left) | |
187 | bs = left; | |
188 | ||
189 | fill_io_buffer(td, b, bs, bs); | |
190 | ||
191 | r = glfs_write(g->fd, b, bs, 0); | |
192 | dprint(FD_IO, | |
193 | "fio write %d of %ld file %s\n", | |
194 | r, f->real_file_size, | |
195 | f->file_name); | |
196 | ||
197 | if (r > 0) { | |
198 | left -= r; | |
199 | continue; | |
200 | } else { | |
201 | if (r < 0) { | |
202 | int __e = errno; | |
203 | ||
204 | if (__e == ENOSPC) { | |
205 | if (td->o. | |
206 | fill_device) | |
207 | break; | |
208 | log_info | |
209 | ("fio: ENOSPC on laying out " | |
210 | "file, stopping\n"); | |
211 | break; | |
212 | } | |
213 | td_verror(td, errno, | |
214 | "write"); | |
215 | } else | |
216 | td_verror(td, EIO, | |
217 | "write"); | |
218 | ||
219 | break; | |
220 | } | |
221 | } | |
222 | ||
223 | if (b) | |
224 | free(b); | |
225 | glfs_lseek(g->fd, 0, SEEK_SET); | |
226 | ||
38ef9c90 | 227 | if (td->terminate && td->o.unlink) { |
b29c813f JA |
228 | dprint(FD_FILE, "terminate unlink %s\n", |
229 | f->file_name); | |
38ef9c90 | 230 | glfs_unlink(g->fs, f->file_name); |
b29c813f JA |
231 | } else if (td->o.create_fsync) { |
232 | if (glfs_fsync(g->fd) < 0) { | |
233 | dprint(FD_FILE, | |
234 | "failed to sync, close %s\n", | |
235 | f->file_name); | |
236 | td_verror(td, errno, "fsync"); | |
237 | glfs_close(g->fd); | |
238 | g->fd = NULL; | |
239 | return 1; | |
240 | } | |
241 | } | |
242 | } | |
243 | } | |
244 | } | |
6fa14b99 | 245 | #if defined(GFAPI_USE_FADVISE) |
b29c813f JA |
246 | { |
247 | int r = 0; | |
248 | if (td_random(td)) { | |
249 | r = glfs_fadvise(g->fd, 0, f->real_file_size, | |
250 | POSIX_FADV_RANDOM); | |
251 | } else { | |
252 | r = glfs_fadvise(g->fd, 0, f->real_file_size, | |
253 | POSIX_FADV_SEQUENTIAL); | |
254 | } | |
255 | if (r) { | |
256 | dprint(FD_FILE, "fio %p fadvise %s status %d\n", g->fs, | |
257 | f->file_name, r); | |
258 | } | |
259 | } | |
6fa14b99 | 260 | #endif |
b29c813f JA |
261 | dprint(FD_FILE, "fio %p created %s\n", g->fs, f->file_name); |
262 | f->fd = -1; | |
263 | f->shadow_fd = -1; | |
e6590c12 | 264 | td->o.open_files ++; |
b29c813f | 265 | return ret; |
6e7d7dfb | 266 | } |
267 | ||
cc47f094 | 268 | int fio_gf_close_file(struct thread_data *td, struct fio_file *f) |
6e7d7dfb | 269 | { |
270 | int ret = 0; | |
271 | struct gf_data *g = td->io_ops->data; | |
272 | ||
273 | dprint(FD_FILE, "fd close %s\n", f->file_name); | |
274 | ||
b29c813f JA |
275 | if (g) { |
276 | if (g->fd && glfs_close(g->fd) < 0) | |
277 | ret = errno; | |
38ef9c90 CF |
278 | g->fd = NULL; |
279 | } | |
280 | ||
281 | return ret; | |
282 | } | |
283 | ||
284 | int fio_gf_unlink_file(struct thread_data *td, struct fio_file *f) | |
285 | { | |
286 | int ret = 0; | |
287 | struct gf_data *g = td->io_ops->data; | |
288 | ||
289 | dprint(FD_FILE, "fd unlink %s\n", f->file_name); | |
290 | ||
291 | if (g) { | |
292 | if (g->fd && glfs_close(g->fd) < 0) | |
293 | ret = errno; | |
294 | ||
295 | glfs_unlink(g->fs, f->file_name); | |
7cb57176 | 296 | |
b29c813f JA |
297 | if (g->fs) |
298 | glfs_fini(g->fs); | |
6e7d7dfb | 299 | |
b29c813f JA |
300 | g->fd = NULL; |
301 | free(g); | |
302 | } | |
7cb57176 | 303 | td->io_ops->data = NULL; |
6e7d7dfb | 304 | |
305 | return ret; | |
306 | } |