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