block/win32-aio.c

   1 /*
   2  * Block driver for RAW files (win32)
   3  *
   4  * Copyright (c) 2006 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu-common.h"
  25 #include "qemu/timer.h"
  26 #include "block/block_int.h"
  27 #include "qemu/module.h"
  28 #include "qemu-common.h"
  29 #include "block/aio.h"
  30 #include "raw-aio.h"
  31 #include "qemu/event_notifier.h"
  32 #include <windows.h>
  33 #include <winioctl.h>
  34
  35 #define FTYPE_FILE 0
  36 #define FTYPE_CD     1
  37 #define FTYPE_HARDDISK 2
  38
  39 struct QEMUWin32AIOState {
  40     HANDLE hIOCP;
  41     EventNotifier e;
  42     int count;
  43 };
  44
  45 typedef struct QEMUWin32AIOCB {
  46     BlockDriverAIOCB common;
  47     struct QEMUWin32AIOState *ctx;
  48     int nbytes;
  49     OVERLAPPED ov;
  50     QEMUIOVector *qiov;
  51     void *buf;
  52     bool is_read;
  53     bool is_linear;
  54 } QEMUWin32AIOCB;
  55
  56 /*
  57  * Completes an AIO request (calls the callback and frees the ACB).
  58  */
  59 static void win32_aio_process_completion(QEMUWin32AIOState *s,
  60     QEMUWin32AIOCB *waiocb, DWORD count)
  61 {
  62     int ret;
  63     s->count--;
  64
  65     if (waiocb->ov.Internal != 0) {
  66         ret = -EIO;
  67     } else {
  68         ret = 0;
  69         if (count < waiocb->nbytes) {
  70             /* Short reads mean EOF, pad with zeros. */
  71             if (waiocb->is_read) {
  72                 qemu_iovec_memset(waiocb->qiov, count, 0,
  73                     waiocb->qiov->size - count);
  74             } else {
  75                 ret = -EINVAL;
  76             }
  77        }
  78     }
  79
  80     if (!waiocb->is_linear) {
  81         if (ret == 0 && waiocb->is_read) {
  82             QEMUIOVector *qiov = waiocb->qiov;
  83             char *p = waiocb->buf;
  84             int i;
  85
  86             for (i = 0; i < qiov->niov; ++i) {
  87                 memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len);
  88                 p += qiov->iov[i].iov_len;
  89             }
  90             g_free(waiocb->buf);
  91         }
  92     }
  93
  94
  95     waiocb->common.cb(waiocb->common.opaque, ret);
  96     qemu_aio_release(waiocb);
  97 }
  98
  99 static void win32_aio_completion_cb(EventNotifier *e)
 100 {
 101     QEMUWin32AIOState *s = container_of(e, QEMUWin32AIOState, e);
 102     DWORD count;
 103     ULONG_PTR key;
 104     OVERLAPPED *ov;
 105
 106     event_notifier_test_and_clear(&s->e);
 107     while (GetQueuedCompletionStatus(s->hIOCP, &count, &key, &ov, 0)) {
 108         QEMUWin32AIOCB *waiocb = container_of(ov, QEMUWin32AIOCB, ov);
 109
 110         win32_aio_process_completion(s, waiocb, count);
 111     }
 112 }
 113
 114 static int win32_aio_flush_cb(EventNotifier *e)
 115 {
 116     QEMUWin32AIOState *s = container_of(e, QEMUWin32AIOState, e);
 117
 118     return (s->count > 0) ? 1 : 0;
 119 }
 120
 121 static void win32_aio_cancel(BlockDriverAIOCB *blockacb)
 122 {
 123     QEMUWin32AIOCB *waiocb = (QEMUWin32AIOCB *)blockacb;
 124
 125     /*
 126      * CancelIoEx is only supported in Vista and newer.  For now, just
 127      * wait for completion.
 128      */
 129     while (!HasOverlappedIoCompleted(&waiocb->ov)) {
 130         qemu_aio_wait();
 131     }
 132 }
 133
 134 static const AIOCBInfo win32_aiocb_info = {
 135     .aiocb_size         = sizeof(QEMUWin32AIOCB),
 136     .cancel             = win32_aio_cancel,
 137 };
 138
 139 BlockDriverAIOCB *win32_aio_submit(BlockDriverState *bs,
 140         QEMUWin32AIOState *aio, HANDLE hfile,
 141         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
 142         BlockDriverCompletionFunc *cb, void *opaque, int type)
 143 {
 144     struct QEMUWin32AIOCB *waiocb;
 145     uint64_t offset = sector_num * 512;
 146     DWORD rc;
 147
 148     waiocb = qemu_aio_get(&win32_aiocb_info, bs, cb, opaque);
 149     waiocb->nbytes = nb_sectors * 512;
 150     waiocb->qiov = qiov;
 151     waiocb->is_read = (type == QEMU_AIO_READ);
 152
 153     if (qiov->niov > 1) {
 154         waiocb->buf = qemu_blockalign(bs, qiov->size);
 155         if (type & QEMU_AIO_WRITE) {
 156             char *p = waiocb->buf;
 157             int i;
 158
 159             for (i = 0; i < qiov->niov; ++i) {
 160                 memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len);
 161                 p += qiov->iov[i].iov_len;
 162             }
 163         }
 164         waiocb->is_linear = false;
 165     } else {
 166         waiocb->buf = qiov->iov[0].iov_base;
 167         waiocb->is_linear = true;
 168     }
 169
 170     memset(&waiocb->ov, 0, sizeof(waiocb->ov));
 171     waiocb->ov.Offset = (DWORD)offset;
 172     waiocb->ov.OffsetHigh = (DWORD)(offset >> 32);
 173     waiocb->ov.hEvent = event_notifier_get_handle(&aio->e);
 174
 175     aio->count++;
 176
 177     if (type & QEMU_AIO_READ) {
 178         rc = ReadFile(hfile, waiocb->buf, waiocb->nbytes, NULL, &waiocb->ov);
 179     } else {
 180         rc = WriteFile(hfile, waiocb->buf, waiocb->nbytes, NULL, &waiocb->ov);
 181     }
 182     if(rc == 0 && GetLastError() != ERROR_IO_PENDING) {
 183         goto out_dec_count;
 184     }
 185     return &waiocb->common;
 186
 187 out_dec_count:
 188     aio->count--;
 189     qemu_aio_release(waiocb);
 190     return NULL;
 191 }
 192
 193 int win32_aio_attach(QEMUWin32AIOState *aio, HANDLE hfile)
 194 {
 195     if (CreateIoCompletionPort(hfile, aio->hIOCP, (ULONG_PTR) 0, 0) == NULL) {
 196         return -EINVAL;
 197     } else {
 198         return 0;
 199     }
 200 }
 201
 202 QEMUWin32AIOState *win32_aio_init(void)
 203 {
 204     QEMUWin32AIOState *s;
 205
 206     s = g_malloc0(sizeof(*s));
 207     if (event_notifier_init(&s->e, false) < 0) {
 208         goto out_free_state;
 209     }
 210
 211     s->hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
 212     if (s->hIOCP == NULL) {
 213         goto out_close_efd;
 214     }
 215
 216     qemu_aio_set_event_notifier(&s->e, win32_aio_completion_cb,
 217                                 win32_aio_flush_cb);
 218
 219     return s;
 220
 221 out_close_efd:
 222     event_notifier_cleanup(&s->e);
 223 out_free_state:
 224     g_free(s);
 225     return NULL;
 226 }