1 /* 2 * Custom fio(1) engine that submits synchronous atomic writes to file. 3 * 4 * Copyright (C) 2013 Fusion-io, Inc. 5 * Author: Santhosh Kumar Koundinya (skoundinya (at) fusionio.com). 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License as published by the Free 9 * Software Foundation; under version 2 of the License. 10 * 11 * This program is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License version 14 * 2 for more details. 15 * 16 * You should have received a copy of the GNU General Public License Version 2 17 * along with this program; if not see <http://www.gnu.org/licenses/> 18 */ 19 20 #include <stdlib.h> 21 #include <stdint.h> 22 23 #include "../fio.h" 24 25 #include <nvm/nvm_primitives.h> 26 27 #define NUM_ATOMIC_CAPABILITIES (5) 28 29 struct fas_data { 30 nvm_handle_t nvm_handle; 31 size_t xfer_buf_align; 32 size_t xfer_buflen_align; 33 size_t xfer_buflen_max; 34 size_t sector_size; 35 }; 36 37 static int queue(struct thread_data *td, struct io_u *io_u) 38 { 39 int rc; 40 struct fas_data *d = (struct fas_data *) io_u->file->engine_data; 41 42 if (io_u->ddir != DDIR_WRITE) { 43 td_vmsg(td, EINVAL, "only writes supported", "io_u->ddir"); 44 rc = -EINVAL; 45 goto out; 46 } 47 48 if ((size_t) io_u->xfer_buf % d->xfer_buf_align) { 49 td_vmsg(td, EINVAL, "unaligned data buffer", "io_u->xfer_buf"); 50 rc = -EINVAL; 51 goto out; 52 } 53 54 if (io_u->xfer_buflen % d->xfer_buflen_align) { 55 td_vmsg(td, EINVAL, "unaligned data size", "io_u->xfer_buflen"); 56 rc = -EINVAL; 57 goto out; 58 } 59 60 if (io_u->xfer_buflen > d->xfer_buflen_max) { 61 td_vmsg(td, EINVAL, "data too big", "io_u->xfer_buflen"); 62 rc = -EINVAL; 63 goto out; 64 } 65 66 rc = nvm_atomic_write(d->nvm_handle, (uint64_t) io_u->xfer_buf, 67 io_u->xfer_buflen, io_u->offset / d->sector_size); 68 if (rc == -1) { 69 td_verror(td, errno, "nvm_atomic_write"); 70 rc = -errno; 71 goto out; 72 } 73 rc = FIO_Q_COMPLETED; 74 out: 75 if (rc < 0) 76 io_u->error = -rc; 77 78 return rc; 79 } 80 81 static int open_file(struct thread_data *td, struct fio_file *f) 82 { 83 int rc; 84 int fio_unused close_file_rc; 85 struct fas_data *d; 86 nvm_version_t nvm_version; 87 nvm_capability_t nvm_capability[NUM_ATOMIC_CAPABILITIES]; 88 89 90 d = malloc(sizeof(*d)); 91 if (!d) { 92 td_verror(td, ENOMEM, "malloc"); 93 rc = ENOMEM; 94 goto error; 95 } 96 d->nvm_handle = -1; 97 f->engine_data = (uintptr_t) d; 98 99 rc = generic_open_file(td, f); 100 101 if (rc) 102 goto free_engine_data; 103 104 /* Set the version of the library as seen when engine is compiled */ 105 nvm_version.major = NVM_PRIMITIVES_API_MAJOR; 106 nvm_version.minor = NVM_PRIMITIVES_API_MINOR; 107 nvm_version.micro = NVM_PRIMITIVES_API_MICRO; 108 109 d->nvm_handle = nvm_get_handle(f->fd, &nvm_version); 110 if (d->nvm_handle == -1) { 111 td_vmsg(td, errno, "nvm_get_handle failed", "nvm_get_handle"); 112 rc = errno; 113 goto close_file; 114 } 115 116 nvm_capability[0].cap_id = NVM_CAP_ATOMIC_WRITE_START_ALIGN_ID; 117 nvm_capability[1].cap_id = NVM_CAP_ATOMIC_WRITE_MULTIPLICITY_ID; 118 nvm_capability[2].cap_id = NVM_CAP_ATOMIC_WRITE_MAX_VECTOR_SIZE_ID; 119 nvm_capability[3].cap_id = NVM_CAP_SECTOR_SIZE_ID; 120 nvm_capability[4].cap_id = NVM_CAP_ATOMIC_MAX_IOV_ID; 121 rc = nvm_get_capabilities(d->nvm_handle, nvm_capability, 122 NUM_ATOMIC_CAPABILITIES, false); 123 if (rc == -1) { 124 td_vmsg(td, errno, "error in getting atomic write capabilities", "nvm_get_capabilities"); 125 rc = errno; 126 goto close_file; 127 } else if (rc < NUM_ATOMIC_CAPABILITIES) { 128 td_vmsg(td, EINVAL, "couldn't get all the atomic write capabilities" , "nvm_get_capabilities"); 129 rc = ECANCELED; 130 goto close_file; 131 } 132 /* Reset rc to 0 because we got all capabilities we needed */ 133 rc = 0; 134 d->xfer_buf_align = nvm_capability[0].cap_value; 135 d->xfer_buflen_align = nvm_capability[1].cap_value; 136 d->xfer_buflen_max = d->xfer_buflen_align * nvm_capability[2].cap_value * nvm_capability[4].cap_value; 137 d->sector_size = nvm_capability[3].cap_value; 138 139 out: 140 return rc; 141 close_file: 142 close_file_rc = generic_close_file(td, f); 143 free_engine_data: 144 free(d); 145 error: 146 f->fd = -1; 147 f->engine_data = 0; 148 goto out; 149 } 150 151 static int close_file(struct thread_data *td, struct fio_file *f) 152 { 153 struct fas_data *d = (struct fas_data *) f->engine_data; 154 155 if (d) { 156 if (d->nvm_handle != -1) 157 nvm_release_handle(d->nvm_handle); 158 free(d); 159 f->engine_data = 0; 160 } 161 162 return generic_close_file(td, f); 163 } 164 165 static struct ioengine_ops ioengine = { 166 .name = "fusion-aw-sync", 167 .version = FIO_IOOPS_VERSION, 168 .queue = queue, 169 .open_file = open_file, 170 .close_file = close_file, 171 .get_file_size = generic_get_file_size, 172 .flags = FIO_SYNCIO | FIO_RAWIO | FIO_MEMALIGN 173 }; 174 175 static void fio_init fio_fusion_aw_init(void) 176 { 177 register_ioengine(&ioengine); 178 } 179 180 static void fio_exit fio_fusion_aw_exit(void) 181 { 182 unregister_ioengine(&ioengine); 183 } 184
