1 /*
2 * ioe_e4defrag: ioengine for git://git.kernel.dk/fio.git
3 *
4 * IO engine that does regular EXT4_IOC_MOVE_EXT ioctls to simulate
5 * defragment activity
6 *
7 */
8
9 #include <sys/types.h>
10 #include <sys/stat.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <unistd.h>
14 #include <sys/uio.h>
15 #include <errno.h>
16 #include <assert.h>
17 #include <fcntl.h>
18
19 #include "../fio.h"
20
21 #ifndef EXT4_IOC_MOVE_EXT
22 #define EXT4_IOC_MOVE_EXT _IOWR('f', 15, struct move_extent)
23 struct move_extent {
24 __u32 reserved; /* should be zero */
25 __u32 donor_fd; /* donor file descriptor */
26 __u64 orig_start; /* logical start offset in block for orig */
27 __u64 donor_start; /* logical start offset in block for donor */
28 __u64 len; /* block length to be moved */
29 __u64 moved_len; /* moved block length */
30 };
31 #endif
32
33 struct e4defrag_data {
34 int donor_fd;
35 int bsz;
36 };
37
38 struct e4defrag_options {
39 void *pad;
40 unsigned int inplace;
41 char * donor_name;
42 };
43
44 static struct fio_option options[] = {
45 {
46 .name = "donorname",
47 .type = FIO_OPT_STR_STORE,
48 .off1 = offsetof(struct e4defrag_options, donor_name),
49 .help = "File used as a block donor",
50 .category = FIO_OPT_C_ENGINE,
51 .group = FIO_OPT_G_E4DEFRAG,
52 },
53 {
54 .name = "inplace",
55 .type = FIO_OPT_INT,
56 .off1 = offsetof(struct e4defrag_options, inplace),
57 .minval = 0,
58 .maxval = 1,
59 .help = "Alloc and free space inside defrag event",
60 .category = FIO_OPT_C_ENGINE,
61 .group = FIO_OPT_G_E4DEFRAG,
62 },
63 {
64 .name = NULL,
65 },
66 };
67
fio_e4defrag_init(struct thread_data * td)68 static int fio_e4defrag_init(struct thread_data *td)
69 {
70 int r, len = 0;
71 struct e4defrag_options *o = td->eo;
72 struct e4defrag_data *ed;
73 struct stat stub;
74 char donor_name[PATH_MAX];
75
76 if (!strlen(o->donor_name)) {
77 log_err("'donorname' options required\n");
78 return 1;
79 }
80
81 ed = malloc(sizeof(*ed));
82 if (!ed) {
83 td_verror(td, ENOMEM, "io_queue_init");
84 return 1;
85 }
86 memset(ed, 0 ,sizeof(*ed));
87
88 if (td->o.directory)
89 len = sprintf(donor_name, "%s/", td->o.directory);
90 sprintf(donor_name + len, "%s", o->donor_name);
91
92 ed->donor_fd = open(donor_name, O_CREAT|O_WRONLY, 0644);
93 if (ed->donor_fd < 0) {
94 td_verror(td, errno, "io_queue_init");
95 log_err("Can't open donor file %s err:%d", donor_name, ed->donor_fd);
96 free(ed);
97 return 1;
98 }
99
100 if (!o->inplace) {
101 long long __len = td->o.file_size_high - td->o.start_offset;
102 r = fallocate(ed->donor_fd, 0, td->o.start_offset, __len);
103 if (r)
104 goto err;
105 }
106 r = fstat(ed->donor_fd, &stub);
107 if (r)
108 goto err;
109
110 ed->bsz = stub.st_blksize;
111 td->io_ops->data = ed;
112 return 0;
113 err:
114 td_verror(td, errno, "io_queue_init");
115 close(ed->donor_fd);
116 free(ed);
117 return 1;
118 }
119
fio_e4defrag_cleanup(struct thread_data * td)120 static void fio_e4defrag_cleanup(struct thread_data *td)
121 {
122 struct e4defrag_data *ed = td->io_ops->data;
123 if (ed) {
124 if (ed->donor_fd >= 0)
125 close(ed->donor_fd);
126 free(ed);
127 }
128 }
129
130
fio_e4defrag_queue(struct thread_data * td,struct io_u * io_u)131 static int fio_e4defrag_queue(struct thread_data *td, struct io_u *io_u)
132 {
133
134 int ret;
135 unsigned long long len;
136 struct move_extent me;
137 struct fio_file *f = io_u->file;
138 struct e4defrag_data *ed = td->io_ops->data;
139 struct e4defrag_options *o = td->eo;
140
141 fio_ro_check(td, io_u);
142
143 /* Theoretically defragmentation should not change data, but it
144 * changes data layout. So this function handle only DDIR_WRITE
145 * in order to satisfy strict read only access pattern
146 */
147 if (io_u->ddir != DDIR_WRITE) {
148 io_u->error = EINVAL;
149 return FIO_Q_COMPLETED;
150 }
151
152 if (o->inplace) {
153 ret = fallocate(ed->donor_fd, 0, io_u->offset, io_u->xfer_buflen);
154 if (ret)
155 goto out;
156 }
157
158 memset(&me, 0, sizeof(me));
159 me.donor_fd = ed->donor_fd;
160 me.orig_start = io_u->offset / ed->bsz;
161 me.donor_start = me.orig_start;
162 len = (io_u->offset + io_u->xfer_buflen + ed->bsz -1);
163 me.len = len / ed->bsz - me.orig_start;
164
165 ret = ioctl(f->fd, EXT4_IOC_MOVE_EXT, &me);
166 len = me.moved_len * ed->bsz;
167
168 if (len > io_u->xfer_buflen)
169 len = io_u->xfer_buflen;
170
171 if (len != io_u->xfer_buflen) {
172 io_u->resid = io_u->xfer_buflen - len;
173 io_u->error = 0;
174 }
175 if (ret)
176 io_u->error = errno;
177
178 if (o->inplace)
179 ret = ftruncate(ed->donor_fd, 0);
180 out:
181 if (ret && !io_u->error)
182 io_u->error = errno;
183
184 return FIO_Q_COMPLETED;
185 }
186
187 static struct ioengine_ops ioengine = {
188 .name = "e4defrag",
189 .version = FIO_IOOPS_VERSION,
190 .init = fio_e4defrag_init,
191 .queue = fio_e4defrag_queue,
192 .open_file = generic_open_file,
193 .close_file = generic_close_file,
194 .get_file_size = generic_get_file_size,
195 .flags = FIO_SYNCIO,
196 .cleanup = fio_e4defrag_cleanup,
197 .options = options,
198 .option_struct_size = sizeof(struct e4defrag_options),
199
200 };
201
fio_syncio_register(void)202 static void fio_init fio_syncio_register(void)
203 {
204 register_ioengine(&ioengine);
205 }
206
fio_syncio_unregister(void)207 static void fio_exit fio_syncio_unregister(void)
208 {
209 unregister_ioengine(&ioengine);
210 }
211