X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=engines%2Fmmap.c;h=53fd358c364f8ec30300c470906a9897dfa9170f;hp=08bbd991463d4e8546ea40a31d14b9213ffd0d11;hb=a1c58075279454a91ec43366846b93e8dcf9753c;hpb=948f9b2eed7aeee6367957ea30be7a2da94d5b1b diff --git a/engines/mmap.c b/engines/mmap.c index 08bbd991..53fd358c 100644 --- a/engines/mmap.c +++ b/engines/mmap.c @@ -1,75 +1,206 @@ /* - * regular read/write sync io engine + * mmap engine + * + * IO engine that reads/writes from files by doing memcpy to/from + * a memory mapped region of the file. * */ #include #include #include #include -#include #include #include "../fio.h" -#include "../os.h" +#include "../verify.h" + +/* + * Limits us to 1GB of mapped files in total + */ +#define MMAP_TOTAL_SZ (1 * 1024 * 1024 * 1024UL) + +static unsigned long mmap_map_size; +static unsigned long mmap_map_mask; + +static int fio_mmap_file(struct thread_data *td, struct fio_file *f, + size_t length, off_t off) +{ + int flags = 0; + + if (td_rw(td)) + flags = PROT_READ | PROT_WRITE; + else if (td_write(td)) { + flags = PROT_WRITE; + + if (td->o.verify != VERIFY_NONE) + flags |= PROT_READ; + } else + flags = PROT_READ; + + f->mmap_ptr = mmap(NULL, length, flags, MAP_SHARED, f->fd, off); + if (f->mmap_ptr == MAP_FAILED) { + f->mmap_ptr = NULL; + td_verror(td, errno, "mmap"); + goto err; + } + + if (!td_random(td)) { + if (madvise(f->mmap_ptr, length, MADV_SEQUENTIAL) < 0) { + td_verror(td, errno, "madvise"); + goto err; + } + } else { + if (madvise(f->mmap_ptr, length, MADV_RANDOM) < 0) { + td_verror(td, errno, "madvise"); + goto err; + } + } + +err: + if (td->error && f->mmap_ptr) + munmap(f->mmap_ptr, length); + + return td->error; +} + +/* + * Just mmap an appropriate portion, we cannot mmap the full extent + */ +static int fio_mmapio_prep_limited(struct thread_data *td, struct io_u *io_u) +{ + struct fio_file *f = io_u->file; + + if (io_u->buflen > mmap_map_size) { + log_err("fio: bs too big for mmap engine\n"); + return EIO; + } + + f->mmap_sz = mmap_map_size; + if (f->mmap_sz > f->io_size) + f->mmap_sz = f->io_size; + + f->mmap_off = io_u->offset; + + return fio_mmap_file(td, f, f->mmap_sz, f->mmap_off); +} + +/* + * Attempt to mmap the entire file + */ +static int fio_mmapio_prep_full(struct thread_data *td, struct io_u *io_u) +{ + struct fio_file *f = io_u->file; + int ret; + + if (fio_file_partial_mmap(f)) + return EINVAL; + + f->mmap_sz = f->io_size; + f->mmap_off = 0; + + ret = fio_mmap_file(td, f, f->mmap_sz, f->mmap_off); + if (ret) + fio_file_set_partial_mmap(f); + + return ret; +} + +static int fio_mmapio_prep(struct thread_data *td, struct io_u *io_u) +{ + struct fio_file *f = io_u->file; + int ret; + + /* + * It fits within existing mapping, use it + */ + if (io_u->offset >= f->mmap_off && + io_u->offset + io_u->buflen < f->mmap_off + f->mmap_sz) + goto done; + + /* + * unmap any existing mapping + */ + if (f->mmap_ptr) { + if (munmap(f->mmap_ptr, f->mmap_sz) < 0) + return errno; + f->mmap_ptr = NULL; + } + + if (fio_mmapio_prep_full(td, io_u)) { + td_clear_error(td); + ret = fio_mmapio_prep_limited(td, io_u); + if (ret) + return ret; + } + +done: + io_u->mmap_data = f->mmap_ptr + io_u->offset - f->mmap_off - + f->file_offset; + return 0; +} static int fio_mmapio_queue(struct thread_data *td, struct io_u *io_u) { struct fio_file *f = io_u->file; - unsigned long long real_off = io_u->offset - f->file_offset; + + fio_ro_check(td, io_u); if (io_u->ddir == DDIR_READ) - memcpy(io_u->xfer_buf, f->mmap + real_off, io_u->xfer_buflen); + memcpy(io_u->xfer_buf, io_u->mmap_data, io_u->xfer_buflen); else if (io_u->ddir == DDIR_WRITE) - memcpy(f->mmap + real_off, io_u->xfer_buf, io_u->xfer_buflen); - else if (io_u->ddir == DDIR_SYNC) { - if (msync(f->mmap, f->file_size, MS_SYNC)) + memcpy(io_u->mmap_data, io_u->xfer_buf, io_u->xfer_buflen); + else if (ddir_sync(io_u->ddir)) { + if (msync(f->mmap_ptr, f->mmap_sz, MS_SYNC)) { io_u->error = errno; + td_verror(td, io_u->error, "msync"); + } } /* * not really direct, but should drop the pages from the cache */ - if (td->odirect && io_u->ddir != DDIR_SYNC) { - if (msync(f->mmap + real_off, io_u->xfer_buflen, MS_SYNC) < 0) + if (td->o.odirect && !ddir_sync(io_u->ddir)) { + if (msync(io_u->mmap_data, io_u->xfer_buflen, MS_SYNC) < 0) { io_u->error = errno; - if (madvise(f->mmap + real_off, io_u->xfer_buflen, MADV_DONTNEED) < 0) + td_verror(td, io_u->error, "msync"); + } + if (madvise(io_u->mmap_data, io_u->xfer_buflen, MADV_DONTNEED) < 0) { io_u->error = errno; + td_verror(td, io_u->error, "madvise"); + } } - if (io_u->error) - td_verror(td, io_u->error); - return FIO_Q_COMPLETED; } static int fio_mmapio_init(struct thread_data *td) { - struct fio_file *f; - int i; - - if (td->ddir == DDIR_READ && !td_rw(td)) - return 0; - - /* - * We need to truncate the files to the right size, if - * we are writing to it. - */ - for_each_file(td, f, i) { - if (ftruncate(f->fd, f->file_size) < 0) { - td_verror(td, errno); - return 1; - } - } + unsigned long shift, mask; + mmap_map_size = MMAP_TOTAL_SZ / td->o.nr_files; + mask = mmap_map_size; + shift = 0; + do { + mask >>= 1; + if (!mask) + break; + shift++; + } while (1); + + mmap_map_mask = 1UL << shift; return 0; } static struct ioengine_ops ioengine = { .name = "mmap", .version = FIO_IOOPS_VERSION, - .queue = fio_mmapio_queue, .init = fio_mmapio_init, - .flags = FIO_SYNCIO | FIO_MMAPIO, + .prep = fio_mmapio_prep, + .queue = fio_mmapio_queue, + .open_file = generic_open_file, + .close_file = generic_close_file, + .get_file_size = generic_get_file_size, + .flags = FIO_SYNCIO | FIO_NOEXTEND, }; static void fio_init fio_mmapio_register(void)