X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=engines%2Fwindowsaio.c;h=2f3fbef2e1eb01d481dadeb1d880bfd9613030bc;hb=2277d5d5ec39cbd06430348780b1ceb7d01710ae;hp=766cc5d4fe6f0b684cfb6f0921a3d4b190aa0c85;hpb=93bcfd20e37cef8cec350fe06d3a086724c9f257;p=fio.git diff --git a/engines/windowsaio.c b/engines/windowsaio.c index 766cc5d4..2f3fbef2 100644 --- a/engines/windowsaio.c +++ b/engines/windowsaio.c @@ -14,15 +14,15 @@ typedef BOOL (WINAPI *CANCELIOEX)(HANDLE hFile, LPOVERLAPPED lpOverlapped); +int geterrno_from_win_error (DWORD code, int deferrno); + struct fio_overlapped { OVERLAPPED o; struct io_u *io_u; BOOL io_complete; - BOOL io_free; }; struct windowsaio_data { - struct fio_overlapped *ovls; struct io_u **aio_events; HANDLE iothread; HANDLE iocomplete_event; @@ -48,6 +48,82 @@ static DWORD WINAPI IoCompletionRoutine(LPVOID lpParameter); static int fio_windowsaio_init(struct thread_data *td); static int fio_windowsaio_open_file(struct thread_data *td, struct fio_file *f); static int fio_windowsaio_close_file(struct thread_data fio_unused *td, struct fio_file *f); +static int win_to_posix_error(DWORD winerr); + +static int win_to_posix_error(DWORD winerr) +{ + switch (winerr) + { + case ERROR_FILE_NOT_FOUND: return ENOENT; + case ERROR_PATH_NOT_FOUND: return ENOENT; + case ERROR_ACCESS_DENIED: return EACCES; + case ERROR_INVALID_HANDLE: return EBADF; + case ERROR_NOT_ENOUGH_MEMORY: return ENOMEM; + case ERROR_INVALID_DATA: return EINVAL; + case ERROR_OUTOFMEMORY: return ENOMEM; + case ERROR_INVALID_DRIVE: return ENODEV; + case ERROR_NOT_SAME_DEVICE: return EXDEV; + case ERROR_WRITE_PROTECT: return EROFS; + case ERROR_BAD_UNIT: return ENODEV; + case ERROR_SHARING_VIOLATION: return EACCES; + case ERROR_LOCK_VIOLATION: return EACCES; + case ERROR_SHARING_BUFFER_EXCEEDED: return ENOLCK; + case ERROR_HANDLE_DISK_FULL: return ENOSPC; + case ERROR_NOT_SUPPORTED: return ENOSYS; + case ERROR_FILE_EXISTS: return EEXIST; + case ERROR_CANNOT_MAKE: return EPERM; + case ERROR_INVALID_PARAMETER: return EINVAL; + case ERROR_NO_PROC_SLOTS: return EAGAIN; + case ERROR_BROKEN_PIPE: return EPIPE; + case ERROR_OPEN_FAILED: return EIO; + case ERROR_NO_MORE_SEARCH_HANDLES: return ENFILE; + case ERROR_CALL_NOT_IMPLEMENTED: return ENOSYS; + case ERROR_INVALID_NAME: return ENOENT; + case ERROR_WAIT_NO_CHILDREN: return ECHILD; + case ERROR_CHILD_NOT_COMPLETE: return EBUSY; + case ERROR_DIR_NOT_EMPTY: return ENOTEMPTY; + case ERROR_SIGNAL_REFUSED: return EIO; + case ERROR_BAD_PATHNAME: return ENOENT; + case ERROR_SIGNAL_PENDING: return EBUSY; + case ERROR_MAX_THRDS_REACHED: return EAGAIN; + case ERROR_BUSY: return EBUSY; + case ERROR_ALREADY_EXISTS: return EEXIST; + case ERROR_NO_SIGNAL_SENT: return EIO; + case ERROR_FILENAME_EXCED_RANGE: return EINVAL; + case ERROR_META_EXPANSION_TOO_LONG: return EINVAL; + case ERROR_INVALID_SIGNAL_NUMBER: return EINVAL; + case ERROR_THREAD_1_INACTIVE: return EINVAL; + case ERROR_BAD_PIPE: return EINVAL; + case ERROR_PIPE_BUSY: return EBUSY; + case ERROR_NO_DATA: return EPIPE; + case ERROR_MORE_DATA: return EAGAIN; + case ERROR_DIRECTORY: return ENOTDIR; + case ERROR_PIPE_CONNECTED: return EBUSY; + case ERROR_NO_TOKEN: return EINVAL; + case ERROR_PROCESS_ABORTED: return EFAULT; + case ERROR_BAD_DEVICE: return ENODEV; + case ERROR_BAD_USERNAME: return EINVAL; + case ERROR_OPEN_FILES: return EAGAIN; + case ERROR_ACTIVE_CONNECTIONS: return EAGAIN; + case ERROR_DEVICE_IN_USE: return EAGAIN; + case ERROR_INVALID_AT_INTERRUPT_TIME: return EINTR; + case ERROR_IO_DEVICE: return EIO; + case ERROR_NOT_OWNER: return EPERM; + case ERROR_END_OF_MEDIA: return ENOSPC; + case ERROR_EOM_OVERFLOW: return ENOSPC; + case ERROR_BEGINNING_OF_MEDIA: return ESPIPE; + case ERROR_SETMARK_DETECTED: return ESPIPE; + case ERROR_NO_DATA_DETECTED: return ENOSPC; + case ERROR_POSSIBLE_DEADLOCK: return EDEADLOCK; + case ERROR_CRC: return EIO; + case ERROR_NEGATIVE_SEEK: return EINVAL; + case ERROR_DISK_FULL: return ENOSPC; + case ERROR_NOACCESS: return EFAULT; + case ERROR_FILE_INVALID: return ENXIO; + } + + return winerr; +} int sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags) @@ -61,7 +137,6 @@ static int fio_windowsaio_init(struct thread_data *td) struct windowsaio_data *wd; HANDLE hKernel32Dll; int rc = 0; - int i; wd = malloc(sizeof(struct windowsaio_data)); if (wd != NULL) @@ -75,25 +150,6 @@ static int fio_windowsaio_init(struct thread_data *td) rc = 1; } - if (!rc) { - wd->ovls = malloc(td->o.iodepth * sizeof(struct fio_overlapped)); - if (wd->ovls == NULL) - rc = 1; - } - - if (!rc) { - for (i = 0; i < td->o.iodepth; i++) { - wd->ovls[i].io_free = TRUE; - wd->ovls[i].io_complete = FALSE; - - wd->ovls[i].o.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); - if (wd->ovls[i].o.hEvent == NULL) { - rc = 1; - break; - } - } - } - if (!rc) { /* Create an auto-reset event */ wd->iocomplete_event = CreateEvent(NULL, FALSE, FALSE, NULL); @@ -103,8 +159,6 @@ static int fio_windowsaio_init(struct thread_data *td) if (rc) { if (wd != NULL) { - if (wd->ovls != NULL) - free(wd->ovls); if (wd->aio_events != NULL) free(wd->aio_events); @@ -121,7 +175,6 @@ static int fio_windowsaio_init(struct thread_data *td) static void fio_windowsaio_cleanup(struct thread_data *td) { - int i; struct windowsaio_data *wd; wd = td->io_ops->data; @@ -133,12 +186,7 @@ static void fio_windowsaio_cleanup(struct thread_data *td) CloseHandle(wd->iothread); CloseHandle(wd->iocomplete_event); - for (i = 0; i < td->o.iodepth; i++) { - CloseHandle(wd->ovls[i].o.hEvent); - } - free(wd->aio_events); - free(wd->ovls); free(wd); td->io_ops->data = NULL; @@ -205,15 +253,27 @@ static int fio_windowsaio_open_file(struct thread_data *td, struct fio_file *f) struct windowsaio_data *wd; hFile = CreateIoCompletionPort(f->hFile, NULL, 0, 0); + if (hFile == INVALID_HANDLE_VALUE) + rc = 1; wd = td->io_ops->data; wd->iothread_running = TRUE; - if (!rc) { + if (!rc) ctx = malloc(sizeof(struct thread_ctx)); + + if (!rc && ctx == NULL) + { + log_err("fio: out of memory in windowsaio\n"); + CloseHandle(hFile); + CloseHandle(f->hFile); + rc = 1; + } + + if (!rc) + { ctx->iocp = hFile; ctx->wd = wd; - wd->iothread = CreateThread(NULL, 0, IoCompletionRoutine, ctx, 0, NULL); } @@ -286,7 +346,7 @@ static int fio_windowsaio_getevents(struct thread_data *td, unsigned int min, if (fov->io_complete) { fov->io_complete = FALSE; - fov->io_free = TRUE; + ResetEvent(fov->o.hEvent); wd->aio_events[dequeued] = io_u; dequeued++; } @@ -297,7 +357,7 @@ static int fio_windowsaio_getevents(struct thread_data *td, unsigned int min, if (dequeued < min) { status = WaitForSingleObject(wd->iocomplete_event, mswait); - if (status != WAIT_OBJECT_0 && dequeued > 0) + if (status != WAIT_OBJECT_0 && dequeued >= min) break; } @@ -310,34 +370,18 @@ static int fio_windowsaio_getevents(struct thread_data *td, unsigned int min, static int fio_windowsaio_queue(struct thread_data *td, struct io_u *io_u) { - LPOVERLAPPED lpOvl = NULL; - struct windowsaio_data *wd; + struct fio_overlapped *o = io_u->engine_data; + LPOVERLAPPED lpOvl = &o->o; DWORD iobytes; BOOL success = FALSE; - int index; int rc = FIO_Q_COMPLETED; fio_ro_check(td, io_u); - wd = td->io_ops->data; - - for (index = 0; index < td->o.iodepth; index++) { - if (wd->ovls[index].io_free) { - wd->ovls[index].io_free = FALSE; - ResetEvent(wd->ovls[index].o.hEvent); - break; - } - } - - assert(index < td->o.iodepth); - - lpOvl = &wd->ovls[index].o; - wd->ovls[index].io_u = io_u; lpOvl->Internal = STATUS_PENDING; lpOvl->InternalHigh = 0; lpOvl->Offset = io_u->offset & 0xFFFFFFFF; lpOvl->OffsetHigh = io_u->offset >> 32; - io_u->engine_data = &wd->ovls[index]; switch (io_u->ddir) { case DDIR_WRITE: @@ -351,7 +395,7 @@ static int fio_windowsaio_queue(struct thread_data *td, struct io_u *io_u) case DDIR_SYNC_FILE_RANGE: success = FlushFileBuffers(io_u->file->hFile); if (!success) - io_u->error = GetLastError(); + io_u->error = win_to_posix_error(GetLastError()); return FIO_Q_COMPLETED; break; @@ -369,7 +413,7 @@ static int fio_windowsaio_queue(struct thread_data *td, struct io_u *io_u) if (success || GetLastError() == ERROR_IO_PENDING) rc = FIO_Q_QUEUED; else { - io_u->error = GetLastError(); + io_u->error = win_to_posix_error(GetLastError()); io_u->resid = io_u->xfer_buflen; } @@ -391,7 +435,7 @@ static DWORD WINAPI IoCompletionRoutine(LPVOID lpParameter) wd = ctx->wd; do { - if (!GetQueuedCompletionStatus(ctx->iocp, &bytes, &ulKey, &ovl, 250)) + if (!GetQueuedCompletionStatus(ctx->iocp, &bytes, &ulKey, &ovl, 250) && ovl == NULL) continue; fov = CONTAINING_RECORD(ovl, struct fio_overlapped, o); @@ -402,7 +446,7 @@ static DWORD WINAPI IoCompletionRoutine(LPVOID lpParameter) io_u->error = 0; } else { io_u->resid = io_u->xfer_buflen; - io_u->error = ovl->Internal; + io_u->error = win_to_posix_error(GetLastError()); } fov->io_complete = TRUE; @@ -433,6 +477,34 @@ static int fio_windowsaio_cancel(struct thread_data *td, return rc; } +static void fio_windowsaio_io_u_free(struct thread_data *td, struct io_u *io_u) +{ + struct fio_overlapped *o = io_u->engine_data; + + if (o) { + CloseHandle(o->o.hEvent); + io_u->engine_data = NULL; + free(o); + } +} + +static int fio_windowsaio_io_u_init(struct thread_data *td, struct io_u *io_u) +{ + struct fio_overlapped *o; + + o = malloc(sizeof(*o)); + o->io_complete = FALSE: + o->io_u = io_u; + o->o.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + if (!o->o.hEvent) { + free(o); + return 1; + } + + io_u->engine_data = o; + return 0; +} + static struct ioengine_ops ioengine = { .name = "windowsaio", .version = FIO_IOOPS_VERSION, @@ -444,7 +516,9 @@ static struct ioengine_ops ioengine = { .cleanup = fio_windowsaio_cleanup, .open_file = fio_windowsaio_open_file, .close_file = fio_windowsaio_close_file, - .get_file_size = generic_get_file_size + .get_file_size = generic_get_file_size, + .io_u_init = fio_windowsaio_io_u_init, + .io_u_free = fio_windowsaio_io_u_free, }; static void fio_init fio_posixaio_register(void)