return 0;
}
-typedef struct {
+typedef struct QCowAIOCB {
+ BlockDriverAIOCB common;
int64_t sector_num;
uint8_t *buf;
int nb_sectors;
uint64_t cluster_offset;
uint8_t *cluster_data;
BlockDriverAIOCB *hd_aiocb;
- BlockDriverAIOCB *backing_hd_aiocb;
} QCowAIOCB;
-static void qcow_aio_delete(BlockDriverAIOCB *acb);
-
-static int qcow_aio_new(BlockDriverAIOCB *acb)
-{
- BlockDriverState *bs = acb->bs;
- BDRVQcowState *s = bs->opaque;
- QCowAIOCB *acb1;
- acb1 = qemu_mallocz(sizeof(QCowAIOCB));
- if (!acb1)
- return -1;
- acb->opaque = acb1;
- acb1->hd_aiocb = bdrv_aio_new(s->hd);
- if (!acb1->hd_aiocb)
- goto fail;
- if (bs->backing_hd) {
- acb1->backing_hd_aiocb = bdrv_aio_new(bs->backing_hd);
- if (!acb1->backing_hd_aiocb)
- goto fail;
- }
- return 0;
- fail:
- qcow_aio_delete(acb);
- return -1;
-}
-
static void qcow_aio_read_cb(void *opaque, int ret)
{
- BlockDriverAIOCB *acb = opaque;
- BlockDriverState *bs = acb->bs;
+ QCowAIOCB *acb = opaque;
+ BlockDriverState *bs = acb->common.bs;
BDRVQcowState *s = bs->opaque;
- QCowAIOCB *acb1 = acb->opaque;
int index_in_cluster;
+ acb->hd_aiocb = NULL;
if (ret < 0) {
fail:
- acb->cb(acb->cb_opaque, ret);
+ acb->common.cb(acb->common.opaque, ret);
+ qemu_aio_release(acb);
return;
}
redo:
/* post process the read buffer */
- if (!acb1->cluster_offset) {
+ if (!acb->cluster_offset) {
/* nothing to do */
- } else if (acb1->cluster_offset & QCOW_OFLAG_COMPRESSED) {
+ } else if (acb->cluster_offset & QCOW_OFLAG_COMPRESSED) {
/* nothing to do */
} else {
if (s->crypt_method) {
- encrypt_sectors(s, acb1->sector_num, acb1->buf, acb1->buf,
- acb1->n, 0,
+ encrypt_sectors(s, acb->sector_num, acb->buf, acb->buf,
+ acb->n, 0,
&s->aes_decrypt_key);
}
}
- acb1->nb_sectors -= acb1->n;
- acb1->sector_num += acb1->n;
- acb1->buf += acb1->n * 512;
+ acb->nb_sectors -= acb->n;
+ acb->sector_num += acb->n;
+ acb->buf += acb->n * 512;
- if (acb1->nb_sectors == 0) {
+ if (acb->nb_sectors == 0) {
/* request completed */
- acb->cb(acb->cb_opaque, 0);
+ acb->common.cb(acb->common.opaque, 0);
+ qemu_aio_release(acb);
return;
}
/* prepare next AIO request */
- acb1->cluster_offset = get_cluster_offset(bs,
- acb1->sector_num << 9,
- 0, 0, 0, 0);
- index_in_cluster = acb1->sector_num & (s->cluster_sectors - 1);
- acb1->n = s->cluster_sectors - index_in_cluster;
- if (acb1->n > acb1->nb_sectors)
- acb1->n = acb1->nb_sectors;
-
- if (!acb1->cluster_offset) {
+ acb->cluster_offset = get_cluster_offset(bs, acb->sector_num << 9,
+ 0, 0, 0, 0);
+ index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);
+ acb->n = s->cluster_sectors - index_in_cluster;
+ if (acb->n > acb->nb_sectors)
+ acb->n = acb->nb_sectors;
+
+ if (!acb->cluster_offset) {
if (bs->backing_hd) {
/* read from the base image */
- ret = bdrv_aio_read(acb1->backing_hd_aiocb, acb1->sector_num,
- acb1->buf, acb1->n, qcow_aio_read_cb, acb);
- if (ret < 0)
+ acb->hd_aiocb = bdrv_aio_read(bs->backing_hd,
+ acb->sector_num, acb->buf, acb->n, qcow_aio_read_cb, acb);
+ if (acb->hd_aiocb == NULL)
goto fail;
} else {
/* Note: in this case, no need to wait */
- memset(acb1->buf, 0, 512 * acb1->n);
+ memset(acb->buf, 0, 512 * acb->n);
goto redo;
}
- } else if (acb1->cluster_offset & QCOW_OFLAG_COMPRESSED) {
+ } else if (acb->cluster_offset & QCOW_OFLAG_COMPRESSED) {
/* add AIO support for compressed blocks ? */
- if (decompress_cluster(s, acb1->cluster_offset) < 0)
+ if (decompress_cluster(s, acb->cluster_offset) < 0)
goto fail;
- memcpy(acb1->buf,
- s->cluster_cache + index_in_cluster * 512, 512 * acb1->n);
+ memcpy(acb->buf,
+ s->cluster_cache + index_in_cluster * 512, 512 * acb->n);
goto redo;
} else {
- if ((acb1->cluster_offset & 511) != 0) {
+ if ((acb->cluster_offset & 511) != 0) {
ret = -EIO;
goto fail;
}
- ret = bdrv_aio_read(acb1->hd_aiocb,
- (acb1->cluster_offset >> 9) + index_in_cluster,
- acb1->buf, acb1->n, qcow_aio_read_cb, acb);
- if (ret < 0)
+ acb->hd_aiocb = bdrv_aio_read(s->hd,
+ (acb->cluster_offset >> 9) + index_in_cluster,
+ acb->buf, acb->n, qcow_aio_read_cb, acb);
+ if (acb->hd_aiocb == NULL)
goto fail;
}
}
-static int qcow_aio_read(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors)
+static BlockDriverAIOCB *qcow_aio_read(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- QCowAIOCB *acb1 = acb->opaque;
-
- acb1->sector_num = sector_num;
- acb1->buf = buf;
- acb1->nb_sectors = nb_sectors;
- acb1->n = 0;
- acb1->cluster_offset = 0;
+ QCowAIOCB *acb;
+
+ acb = qemu_aio_get(bs, cb, opaque);
+ if (!acb)
+ return NULL;
+ acb->hd_aiocb = NULL;
+ acb->sector_num = sector_num;
+ acb->buf = buf;
+ acb->nb_sectors = nb_sectors;
+ acb->n = 0;
+ acb->cluster_offset = 0;
qcow_aio_read_cb(acb, 0);
- return 0;
+ return &acb->common;
}
static void qcow_aio_write_cb(void *opaque, int ret)
{
- BlockDriverAIOCB *acb = opaque;
- BlockDriverState *bs = acb->bs;
+ QCowAIOCB *acb = opaque;
+ BlockDriverState *bs = acb->common.bs;
BDRVQcowState *s = bs->opaque;
- QCowAIOCB *acb1 = acb->opaque;
int index_in_cluster;
uint64_t cluster_offset;
const uint8_t *src_buf;
-
+
+ acb->hd_aiocb = NULL;
+
if (ret < 0) {
fail:
- acb->cb(acb->cb_opaque, ret);
+ acb->common.cb(acb->common.opaque, ret);
+ qemu_aio_release(acb);
return;
}
- acb1->nb_sectors -= acb1->n;
- acb1->sector_num += acb1->n;
- acb1->buf += acb1->n * 512;
+ acb->nb_sectors -= acb->n;
+ acb->sector_num += acb->n;
+ acb->buf += acb->n * 512;
- if (acb1->nb_sectors == 0) {
+ if (acb->nb_sectors == 0) {
/* request completed */
- acb->cb(acb->cb_opaque, 0);
+ acb->common.cb(acb->common.opaque, 0);
+ qemu_aio_release(acb);
return;
}
- index_in_cluster = acb1->sector_num & (s->cluster_sectors - 1);
- acb1->n = s->cluster_sectors - index_in_cluster;
- if (acb1->n > acb1->nb_sectors)
- acb1->n = acb1->nb_sectors;
- cluster_offset = get_cluster_offset(bs, acb1->sector_num << 9, 1, 0,
+ index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);
+ acb->n = s->cluster_sectors - index_in_cluster;
+ if (acb->n > acb->nb_sectors)
+ acb->n = acb->nb_sectors;
+ cluster_offset = get_cluster_offset(bs, acb->sector_num << 9, 1, 0,
index_in_cluster,
- index_in_cluster + acb1->n);
+ index_in_cluster + acb->n);
if (!cluster_offset || (cluster_offset & 511) != 0) {
ret = -EIO;
goto fail;
}
if (s->crypt_method) {
- if (!acb1->cluster_data) {
- acb1->cluster_data = qemu_mallocz(s->cluster_size);
- if (!acb1->cluster_data) {
+ if (!acb->cluster_data) {
+ acb->cluster_data = qemu_mallocz(s->cluster_size);
+ if (!acb->cluster_data) {
ret = -ENOMEM;
goto fail;
}
}
- encrypt_sectors(s, acb1->sector_num, acb1->cluster_data, acb1->buf,
- acb1->n, 1, &s->aes_encrypt_key);
- src_buf = acb1->cluster_data;
+ encrypt_sectors(s, acb->sector_num, acb->cluster_data, acb->buf,
+ acb->n, 1, &s->aes_encrypt_key);
+ src_buf = acb->cluster_data;
} else {
- src_buf = acb1->buf;
+ src_buf = acb->buf;
}
- ret = bdrv_aio_write(acb1->hd_aiocb,
- (cluster_offset >> 9) + index_in_cluster,
- src_buf, acb1->n,
- qcow_aio_write_cb, acb);
- if (ret < 0)
+ acb->hd_aiocb = bdrv_aio_write(s->hd,
+ (cluster_offset >> 9) + index_in_cluster,
+ src_buf, acb->n,
+ qcow_aio_write_cb, acb);
+ if (acb->hd_aiocb == NULL)
goto fail;
}
-static int qcow_aio_write(BlockDriverAIOCB *acb, int64_t sector_num,
- const uint8_t *buf, int nb_sectors)
+static BlockDriverAIOCB *qcow_aio_write(BlockDriverState *bs,
+ int64_t sector_num, const uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- QCowAIOCB *acb1 = acb->opaque;
- BlockDriverState *bs = acb->bs;
BDRVQcowState *s = bs->opaque;
+ QCowAIOCB *acb;
s->cluster_cache_offset = -1; /* disable compressed cache */
- acb1->sector_num = sector_num;
- acb1->buf = (uint8_t *)buf;
- acb1->nb_sectors = nb_sectors;
- acb1->n = 0;
+ acb = qemu_aio_get(bs, cb, opaque);
+ if (!acb)
+ return NULL;
+ acb->hd_aiocb = NULL;
+ acb->sector_num = sector_num;
+ acb->buf = (uint8_t *)buf;
+ acb->nb_sectors = nb_sectors;
+ acb->n = 0;
qcow_aio_write_cb(acb, 0);
- return 0;
-}
-
-static void qcow_aio_cancel(BlockDriverAIOCB *acb)
-{
- QCowAIOCB *acb1 = acb->opaque;
- if (acb1->hd_aiocb)
- bdrv_aio_cancel(acb1->hd_aiocb);
- if (acb1->backing_hd_aiocb)
- bdrv_aio_cancel(acb1->backing_hd_aiocb);
+ return &acb->common;
}
-static void qcow_aio_delete(BlockDriverAIOCB *acb)
+static void qcow_aio_cancel(BlockDriverAIOCB *blockacb)
{
- QCowAIOCB *acb1 = acb->opaque;
- if (acb1->hd_aiocb)
- bdrv_aio_delete(acb1->hd_aiocb);
- if (acb1->backing_hd_aiocb)
- bdrv_aio_delete(acb1->backing_hd_aiocb);
- qemu_free(acb1->cluster_data);
- qemu_free(acb1);
+ QCowAIOCB *acb = (QCowAIOCB *)blockacb;
+ if (acb->hd_aiocb)
+ bdrv_aio_cancel(acb->hd_aiocb);
+ qemu_aio_release(acb);
}
static void qcow_close(BlockDriverState *bs)
qcow_set_key,
qcow_make_empty,
- .bdrv_aio_new = qcow_aio_new,
.bdrv_aio_read = qcow_aio_read,
.bdrv_aio_write = qcow_aio_write,
.bdrv_aio_cancel = qcow_aio_cancel,
- .bdrv_aio_delete = qcow_aio_delete,
+ .aiocb_size = sizeof(QCowAIOCB),
.bdrv_write_compressed = qcow_write_compressed,
.bdrv_get_info = qcow_get_info,
};
return 0;
}
-typedef struct {
+typedef struct QCowAIOCB {
+ BlockDriverAIOCB common;
int64_t sector_num;
uint8_t *buf;
int nb_sectors;
uint64_t cluster_offset;
uint8_t *cluster_data;
BlockDriverAIOCB *hd_aiocb;
- BlockDriverAIOCB *backing_hd_aiocb;
} QCowAIOCB;
-static void qcow_aio_delete(BlockDriverAIOCB *acb);
-
-static int qcow_aio_new(BlockDriverAIOCB *acb)
-{
- BlockDriverState *bs = acb->bs;
- BDRVQcowState *s = bs->opaque;
- QCowAIOCB *acb1;
- acb1 = qemu_mallocz(sizeof(QCowAIOCB));
- if (!acb1)
- return -1;
- acb->opaque = acb1;
- acb1->hd_aiocb = bdrv_aio_new(s->hd);
- if (!acb1->hd_aiocb)
- goto fail;
- if (bs->backing_hd) {
- acb1->backing_hd_aiocb = bdrv_aio_new(bs->backing_hd);
- if (!acb1->backing_hd_aiocb)
- goto fail;
- }
- return 0;
- fail:
- qcow_aio_delete(acb);
- return -1;
-}
-
static void qcow_aio_read_cb(void *opaque, int ret)
{
- BlockDriverAIOCB *acb = opaque;
- BlockDriverState *bs = acb->bs;
+ QCowAIOCB *acb = opaque;
+ BlockDriverState *bs = acb->common.bs;
BDRVQcowState *s = bs->opaque;
- QCowAIOCB *acb1 = acb->opaque;
int index_in_cluster, n1;
+ acb->hd_aiocb = NULL;
if (ret < 0) {
fail:
- acb->cb(acb->cb_opaque, ret);
+ acb->common.cb(acb->common.opaque, ret);
+ qemu_aio_release(acb);
return;
}
redo:
/* post process the read buffer */
- if (!acb1->cluster_offset) {
+ if (!acb->cluster_offset) {
/* nothing to do */
- } else if (acb1->cluster_offset & QCOW_OFLAG_COMPRESSED) {
+ } else if (acb->cluster_offset & QCOW_OFLAG_COMPRESSED) {
/* nothing to do */
} else {
if (s->crypt_method) {
- encrypt_sectors(s, acb1->sector_num, acb1->buf, acb1->buf,
- acb1->n, 0,
+ encrypt_sectors(s, acb->sector_num, acb->buf, acb->buf,
+ acb->n, 0,
&s->aes_decrypt_key);
}
}
- acb1->nb_sectors -= acb1->n;
- acb1->sector_num += acb1->n;
- acb1->buf += acb1->n * 512;
+ acb->nb_sectors -= acb->n;
+ acb->sector_num += acb->n;
+ acb->buf += acb->n * 512;
- if (acb1->nb_sectors == 0) {
+ if (acb->nb_sectors == 0) {
/* request completed */
- acb->cb(acb->cb_opaque, 0);
+ acb->common.cb(acb->common.opaque, 0);
+ qemu_aio_release(acb);
return;
}
/* prepare next AIO request */
- acb1->cluster_offset = get_cluster_offset(bs,
- acb1->sector_num << 9,
- 0, 0, 0, 0);
- index_in_cluster = acb1->sector_num & (s->cluster_sectors - 1);
- acb1->n = s->cluster_sectors - index_in_cluster;
- if (acb1->n > acb1->nb_sectors)
- acb1->n = acb1->nb_sectors;
-
- if (!acb1->cluster_offset) {
+ acb->cluster_offset = get_cluster_offset(bs, acb->sector_num << 9,
+ 0, 0, 0, 0);
+ index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);
+ acb->n = s->cluster_sectors - index_in_cluster;
+ if (acb->n > acb->nb_sectors)
+ acb->n = acb->nb_sectors;
+
+ if (!acb->cluster_offset) {
if (bs->backing_hd) {
/* read from the base image */
- n1 = backing_read1(bs->backing_hd, acb1->sector_num,
- acb1->buf, acb1->n);
+ n1 = backing_read1(bs->backing_hd, acb->sector_num,
+ acb->buf, acb->n);
if (n1 > 0) {
- ret = bdrv_aio_read(acb1->backing_hd_aiocb, acb1->sector_num,
- acb1->buf, n1, qcow_aio_read_cb, acb);
- if (ret < 0)
+ acb->hd_aiocb = bdrv_aio_read(bs->backing_hd, acb->sector_num,
+ acb->buf, acb->n, qcow_aio_read_cb, acb);
+ if (acb->hd_aiocb == NULL)
goto fail;
} else {
goto redo;
}
} else {
/* Note: in this case, no need to wait */
- memset(acb1->buf, 0, 512 * acb1->n);
+ memset(acb->buf, 0, 512 * acb->n);
goto redo;
}
- } else if (acb1->cluster_offset & QCOW_OFLAG_COMPRESSED) {
+ } else if (acb->cluster_offset & QCOW_OFLAG_COMPRESSED) {
/* add AIO support for compressed blocks ? */
- if (decompress_cluster(s, acb1->cluster_offset) < 0)
+ if (decompress_cluster(s, acb->cluster_offset) < 0)
goto fail;
- memcpy(acb1->buf,
- s->cluster_cache + index_in_cluster * 512, 512 * acb1->n);
+ memcpy(acb->buf,
+ s->cluster_cache + index_in_cluster * 512, 512 * acb->n);
goto redo;
} else {
- if ((acb1->cluster_offset & 511) != 0) {
+ if ((acb->cluster_offset & 511) != 0) {
ret = -EIO;
goto fail;
}
- ret = bdrv_aio_read(acb1->hd_aiocb,
- (acb1->cluster_offset >> 9) + index_in_cluster,
- acb1->buf, acb1->n, qcow_aio_read_cb, acb);
- if (ret < 0)
+ acb->hd_aiocb = bdrv_aio_read(s->hd,
+ (acb->cluster_offset >> 9) + index_in_cluster,
+ acb->buf, acb->n, qcow_aio_read_cb, acb);
+ if (acb->hd_aiocb == NULL)
goto fail;
}
}
-static int qcow_aio_read(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors)
+static QCowAIOCB *qcow_aio_setup(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- QCowAIOCB *acb1 = acb->opaque;
-
- acb1->sector_num = sector_num;
- acb1->buf = buf;
- acb1->nb_sectors = nb_sectors;
- acb1->n = 0;
- acb1->cluster_offset = 0;
+ QCowAIOCB *acb;
+
+ acb = qemu_aio_get(bs, cb, opaque);
+ if (!acb)
+ return NULL;
+ acb->hd_aiocb = NULL;
+ acb->sector_num = sector_num;
+ acb->buf = buf;
+ acb->nb_sectors = nb_sectors;
+ acb->n = 0;
+ acb->cluster_offset = 0;
+ return acb;
+}
+
+static BlockDriverAIOCB *qcow_aio_read(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
+{
+ QCowAIOCB *acb;
+
+ acb = qcow_aio_setup(bs, sector_num, buf, nb_sectors, cb, opaque);
+ if (!acb)
+ return NULL;
qcow_aio_read_cb(acb, 0);
- return 0;
+ return &acb->common;
}
static void qcow_aio_write_cb(void *opaque, int ret)
{
- BlockDriverAIOCB *acb = opaque;
- BlockDriverState *bs = acb->bs;
+ QCowAIOCB *acb = opaque;
+ BlockDriverState *bs = acb->common.bs;
BDRVQcowState *s = bs->opaque;
- QCowAIOCB *acb1 = acb->opaque;
int index_in_cluster;
uint64_t cluster_offset;
const uint8_t *src_buf;
-
+
+ acb->hd_aiocb = NULL;
+
if (ret < 0) {
fail:
- acb->cb(acb->cb_opaque, ret);
+ acb->common.cb(acb->common.opaque, ret);
+ qemu_aio_release(acb);
return;
}
- acb1->nb_sectors -= acb1->n;
- acb1->sector_num += acb1->n;
- acb1->buf += acb1->n * 512;
+ acb->nb_sectors -= acb->n;
+ acb->sector_num += acb->n;
+ acb->buf += acb->n * 512;
- if (acb1->nb_sectors == 0) {
+ if (acb->nb_sectors == 0) {
/* request completed */
- acb->cb(acb->cb_opaque, 0);
+ acb->common.cb(acb->common.opaque, 0);
+ qemu_aio_release(acb);
return;
}
- index_in_cluster = acb1->sector_num & (s->cluster_sectors - 1);
- acb1->n = s->cluster_sectors - index_in_cluster;
- if (acb1->n > acb1->nb_sectors)
- acb1->n = acb1->nb_sectors;
- cluster_offset = get_cluster_offset(bs, acb1->sector_num << 9, 1, 0,
+ index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);
+ acb->n = s->cluster_sectors - index_in_cluster;
+ if (acb->n > acb->nb_sectors)
+ acb->n = acb->nb_sectors;
+ cluster_offset = get_cluster_offset(bs, acb->sector_num << 9, 1, 0,
index_in_cluster,
- index_in_cluster + acb1->n);
+ index_in_cluster + acb->n);
if (!cluster_offset || (cluster_offset & 511) != 0) {
ret = -EIO;
goto fail;
}
if (s->crypt_method) {
- if (!acb1->cluster_data) {
- acb1->cluster_data = qemu_mallocz(s->cluster_size);
- if (!acb1->cluster_data) {
+ if (!acb->cluster_data) {
+ acb->cluster_data = qemu_mallocz(s->cluster_size);
+ if (!acb->cluster_data) {
ret = -ENOMEM;
goto fail;
}
}
- encrypt_sectors(s, acb1->sector_num, acb1->cluster_data, acb1->buf,
- acb1->n, 1, &s->aes_encrypt_key);
- src_buf = acb1->cluster_data;
+ encrypt_sectors(s, acb->sector_num, acb->cluster_data, acb->buf,
+ acb->n, 1, &s->aes_encrypt_key);
+ src_buf = acb->cluster_data;
} else {
- src_buf = acb1->buf;
+ src_buf = acb->buf;
}
- ret = bdrv_aio_write(acb1->hd_aiocb,
- (cluster_offset >> 9) + index_in_cluster,
- src_buf, acb1->n,
- qcow_aio_write_cb, acb);
- if (ret < 0)
+ acb->hd_aiocb = bdrv_aio_write(s->hd,
+ (cluster_offset >> 9) + index_in_cluster,
+ src_buf, acb->n,
+ qcow_aio_write_cb, acb);
+ if (acb->hd_aiocb == NULL)
goto fail;
}
-static int qcow_aio_write(BlockDriverAIOCB *acb, int64_t sector_num,
- const uint8_t *buf, int nb_sectors)
+static BlockDriverAIOCB *qcow_aio_write(BlockDriverState *bs,
+ int64_t sector_num, const uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- QCowAIOCB *acb1 = acb->opaque;
- BlockDriverState *bs = acb->bs;
BDRVQcowState *s = bs->opaque;
+ QCowAIOCB *acb;
s->cluster_cache_offset = -1; /* disable compressed cache */
- acb1->sector_num = sector_num;
- acb1->buf = (uint8_t *)buf;
- acb1->nb_sectors = nb_sectors;
- acb1->n = 0;
+ acb = qcow_aio_setup(bs, sector_num, (uint8_t*)buf, nb_sectors, cb, opaque);
+ if (!acb)
+ return NULL;
qcow_aio_write_cb(acb, 0);
- return 0;
-}
-
-static void qcow_aio_cancel(BlockDriverAIOCB *acb)
-{
- QCowAIOCB *acb1 = acb->opaque;
- if (acb1->hd_aiocb)
- bdrv_aio_cancel(acb1->hd_aiocb);
- if (acb1->backing_hd_aiocb)
- bdrv_aio_cancel(acb1->backing_hd_aiocb);
+ return &acb->common;
}
-static void qcow_aio_delete(BlockDriverAIOCB *acb)
+static void qcow_aio_cancel(BlockDriverAIOCB *blockacb)
{
- QCowAIOCB *acb1 = acb->opaque;
- if (acb1->hd_aiocb)
- bdrv_aio_delete(acb1->hd_aiocb);
- if (acb1->backing_hd_aiocb)
- bdrv_aio_delete(acb1->backing_hd_aiocb);
- qemu_free(acb1->cluster_data);
- qemu_free(acb1);
+ QCowAIOCB *acb = (QCowAIOCB *)blockacb;
+ if (acb->hd_aiocb)
+ bdrv_aio_cancel(acb->hd_aiocb);
+ qemu_aio_release(acb);
}
static void qcow_close(BlockDriverState *bs)
qcow_set_key,
qcow_make_empty,
- .bdrv_aio_new = qcow_aio_new,
.bdrv_aio_read = qcow_aio_read,
.bdrv_aio_write = qcow_aio_write,
.bdrv_aio_cancel = qcow_aio_cancel,
- .bdrv_aio_delete = qcow_aio_delete,
+ .aiocb_size = sizeof(QCowAIOCB),
.bdrv_write_compressed = qcow_write_compressed,
.bdrv_snapshot_create = qcow_snapshot_create,
/* Unix AOP using POSIX AIO */
typedef struct RawAIOCB {
+ BlockDriverAIOCB common;
struct aiocb aiocb;
- int busy; /* only used for debugging */
- BlockDriverAIOCB *next;
+ struct RawAIOCB *next;
} RawAIOCB;
static int aio_sig_num = SIGUSR2;
-static BlockDriverAIOCB *first_aio; /* AIO issued */
+static RawAIOCB *first_aio; /* AIO issued */
static int aio_initialized = 0;
static void aio_signal_handler(int signum)
void qemu_aio_poll(void)
{
- BlockDriverAIOCB *acb, **pacb;
- RawAIOCB *acb1;
+ RawAIOCB *acb, **pacb;
int ret;
for(;;) {
acb = *pacb;
if (!acb)
goto the_end;
- acb1 = acb->opaque;
- ret = aio_error(&acb1->aiocb);
+ ret = aio_error(&acb->aiocb);
if (ret == ECANCELED) {
/* remove the request */
- acb1->busy = 0;
- *pacb = acb1->next;
+ *pacb = acb->next;
+ qemu_aio_release(acb);
} else if (ret != EINPROGRESS) {
/* end of aio */
if (ret == 0) {
- ret = aio_return(&acb1->aiocb);
- if (ret == acb1->aiocb.aio_nbytes)
+ ret = aio_return(&acb->aiocb);
+ if (ret == acb->aiocb.aio_nbytes)
ret = 0;
else
ret = -1;
ret = -ret;
}
/* remove the request */
- acb1->busy = 0;
- *pacb = acb1->next;
+ *pacb = acb->next;
/* call the callback */
- acb->cb(acb->cb_opaque, ret);
+ acb->common.cb(acb->common.opaque, ret);
+ qemu_aio_release(acb);
break;
} else {
- pacb = &acb1->next;
+ pacb = &acb->next;
}
}
}
sigprocmask(SIG_SETMASK, &wait_oset, NULL);
}
-static int raw_aio_new(BlockDriverAIOCB *acb)
+static RawAIOCB *raw_aio_setup(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- RawAIOCB *acb1;
- BDRVRawState *s = acb->bs->opaque;
-
- acb1 = qemu_mallocz(sizeof(RawAIOCB));
- if (!acb1)
- return -1;
- acb->opaque = acb1;
- acb1->aiocb.aio_fildes = s->fd;
- acb1->aiocb.aio_sigevent.sigev_signo = aio_sig_num;
- acb1->aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
- return 0;
+ BDRVRawState *s = bs->opaque;
+ RawAIOCB *acb;
+
+ acb = qemu_aio_get(bs, cb, opaque);
+ if (!acb)
+ return NULL;
+ acb->aiocb.aio_fildes = s->fd;
+ acb->aiocb.aio_sigevent.sigev_signo = aio_sig_num;
+ acb->aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+ acb->aiocb.aio_buf = buf;
+ acb->aiocb.aio_nbytes = nb_sectors * 512;
+ acb->aiocb.aio_offset = sector_num * 512;
+ acb->next = first_aio;
+ first_aio = acb;
+ return acb;
}
-static int raw_aio_read(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors)
+static BlockDriverAIOCB *raw_aio_read(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- RawAIOCB *acb1 = acb->opaque;
+ RawAIOCB *acb;
- assert(acb1->busy == 0);
- acb1->busy = 1;
- acb1->aiocb.aio_buf = buf;
- acb1->aiocb.aio_nbytes = nb_sectors * 512;
- acb1->aiocb.aio_offset = sector_num * 512;
- acb1->next = first_aio;
- first_aio = acb;
- if (aio_read(&acb1->aiocb) < 0) {
- acb1->busy = 0;
- return -errno;
+ acb = raw_aio_setup(bs, sector_num, buf, nb_sectors, cb, opaque);
+ if (!acb)
+ return NULL;
+ if (aio_read(&acb->aiocb) < 0) {
+ qemu_aio_release(acb);
+ return NULL;
}
- return 0;
+ return &acb->common;
}
-static int raw_aio_write(BlockDriverAIOCB *acb, int64_t sector_num,
- const uint8_t *buf, int nb_sectors)
+static BlockDriverAIOCB *raw_aio_write(BlockDriverState *bs,
+ int64_t sector_num, const uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- RawAIOCB *acb1 = acb->opaque;
+ RawAIOCB *acb;
- assert(acb1->busy == 0);
- acb1->busy = 1;
- acb1->aiocb.aio_buf = (uint8_t *)buf;
- acb1->aiocb.aio_nbytes = nb_sectors * 512;
- acb1->aiocb.aio_offset = sector_num * 512;
- acb1->next = first_aio;
- first_aio = acb;
- if (aio_write(&acb1->aiocb) < 0) {
- acb1->busy = 0;
- return -errno;
+ acb = raw_aio_setup(bs, sector_num, (uint8_t*)buf, nb_sectors, cb, opaque);
+ if (!acb)
+ return NULL;
+ if (aio_write(&acb->aiocb) < 0) {
+ qemu_aio_release(acb);
+ return NULL;
}
- return 0;
+ return &acb->common;
}
-static void raw_aio_cancel(BlockDriverAIOCB *acb)
+static void raw_aio_cancel(BlockDriverAIOCB *blockacb)
{
- RawAIOCB *acb1 = acb->opaque;
int ret;
- BlockDriverAIOCB **pacb;
+ RawAIOCB *acb = (RawAIOCB *)blockacb;
+ RawAIOCB **pacb;
- ret = aio_cancel(acb1->aiocb.aio_fildes, &acb1->aiocb);
+ ret = aio_cancel(acb->aiocb.aio_fildes, &acb->aiocb);
if (ret == AIO_NOTCANCELED) {
/* fail safe: if the aio could not be canceled, we wait for
it */
- while (aio_error(&acb1->aiocb) == EINPROGRESS);
+ while (aio_error(&acb->aiocb) == EINPROGRESS);
}
/* remove the callback from the queue */
if (*pacb == NULL) {
break;
} else if (*pacb == acb) {
- acb1->busy = 0;
- *pacb = acb1->next;
+ *pacb = acb->next;
+ qemu_aio_release(acb);
break;
}
- acb1 = (*pacb)->opaque;
- pacb = &acb1->next;
+ pacb = &acb->next;
}
}
-static void raw_aio_delete(BlockDriverAIOCB *acb)
-{
- RawAIOCB *acb1 = acb->opaque;
- raw_aio_cancel(acb);
- qemu_free(acb1);
-}
-
static void raw_close(BlockDriverState *bs)
{
BDRVRawState *s = bs->opaque;
raw_create,
raw_flush,
- .bdrv_aio_new = raw_aio_new,
.bdrv_aio_read = raw_aio_read,
.bdrv_aio_write = raw_aio_write,
.bdrv_aio_cancel = raw_aio_cancel,
- .bdrv_aio_delete = raw_aio_delete,
+ .aiocb_size = sizeof(RawAIOCB),
.protocol_name = "file",
.bdrv_pread = raw_pread,
.bdrv_pwrite = raw_pwrite,
} BDRVRawState;
typedef struct RawAIOCB {
+ BlockDriverAIOCB common;
HANDLE hEvent;
OVERLAPPED ov;
int count;
{
BDRVRawState *s = bs->opaque;
int access_flags, create_flags;
+ DWORD overlapped;
if ((flags & BDRV_O_ACCESS) == O_RDWR) {
access_flags = GENERIC_READ | GENERIC_WRITE;
} else {
create_flags = OPEN_EXISTING;
}
+#ifdef QEMU_TOOL
+ overlapped = 0;
+#else
+ overlapped = FILE_FLAG_OVERLAPPED;
+#endif
s->hfile = CreateFile(filename, access_flags,
FILE_SHARE_READ, NULL,
- create_flags, FILE_FLAG_OVERLAPPED, 0);
+ create_flags, overlapped, 0);
if (s->hfile == INVALID_HANDLE_VALUE)
return -1;
return 0;
return ret_count;
}
-static int raw_aio_new(BlockDriverAIOCB *acb)
-{
- RawAIOCB *acb1;
-
- acb1 = qemu_mallocz(sizeof(RawAIOCB));
- if (!acb1)
- return -ENOMEM;
- acb->opaque = acb1;
- acb1->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
- if (!acb1->hEvent)
- return -ENOMEM;
- return 0;
-}
#ifndef QEMU_TOOL
static void raw_aio_cb(void *opaque)
{
- BlockDriverAIOCB *acb = opaque;
- BlockDriverState *bs = acb->bs;
+ RawAIOCB *acb = opaque;
+ BlockDriverState *bs = acb->common.bs;
BDRVRawState *s = bs->opaque;
- RawAIOCB *acb1 = acb->opaque;
DWORD ret_count;
int ret;
- ret = GetOverlappedResult(s->hfile, &acb1->ov, &ret_count, TRUE);
- if (!ret || ret_count != acb1->count) {
- acb->cb(acb->cb_opaque, -EIO);
+ ret = GetOverlappedResult(s->hfile, &acb->ov, &ret_count, TRUE);
+ if (!ret || ret_count != acb->count) {
+ acb->common.cb(acb->common.opaque, -EIO);
} else {
- acb->cb(acb->cb_opaque, 0);
+ acb->common.cb(acb->common.opaque, 0);
}
}
#endif
-static int raw_aio_read(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors)
+
+static RawAIOCB *raw_aio_setup(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- BlockDriverState *bs = acb->bs;
- BDRVRawState *s = bs->opaque;
- RawAIOCB *acb1 = acb->opaque;
- int ret;
+ RawAIOCB *acb;
int64_t offset;
- memset(&acb1->ov, 0, sizeof(acb1->ov));
+ acb = qemu_aio_get(bs, cb, opaque);
+ if (acb->hEvent) {
+ acb->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+ if (!acb->hEvent) {
+ qemu_aio_release(acb);
+ return NULL;
+ }
+ }
+ memset(&acb->ov, 0, sizeof(acb->ov));
offset = sector_num * 512;
- acb1->ov.Offset = offset;
- acb1->ov.OffsetHigh = offset >> 32;
- acb1->ov.hEvent = acb1->hEvent;
- acb1->count = nb_sectors * 512;
+ acb->ov.Offset = offset;
+ acb->ov.OffsetHigh = offset >> 32;
+ acb->ov.hEvent = acb->hEvent;
+ acb->count = nb_sectors * 512;
#ifndef QEMU_TOOL
- qemu_add_wait_object(acb1->ov.hEvent, raw_aio_cb, acb);
+ qemu_add_wait_object(acb->ov.hEvent, raw_aio_cb, acb);
#endif
- ret = ReadFile(s->hfile, buf, acb1->count, NULL, &acb1->ov);
- if (!ret)
- return -EIO;
- return 0;
+ return acb;
}
-static int raw_aio_write(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors)
+static BlockDriverAIOCB *raw_aio_read(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- BlockDriverState *bs = acb->bs;
BDRVRawState *s = bs->opaque;
- RawAIOCB *acb1 = acb->opaque;
+ RawAIOCB *acb;
int ret;
- int64_t offset;
- memset(&acb1->ov, 0, sizeof(acb1->ov));
- offset = sector_num * 512;
- acb1->ov.Offset = offset;
- acb1->ov.OffsetHigh = offset >> 32;
- acb1->ov.hEvent = acb1->hEvent;
- acb1->count = nb_sectors * 512;
-#ifndef QEMU_TOOL
- qemu_add_wait_object(acb1->ov.hEvent, raw_aio_cb, acb);
+ acb = raw_aio_setup(bs, sector_num, buf, nb_sectors, cb, opaque);
+ if (!acb)
+ return NULL;
+ ret = ReadFile(s->hfile, buf, acb->count, NULL, &acb->ov);
+ if (!ret) {
+ qemu_aio_release(acb);
+ return NULL;
+ }
+#ifdef QEMU_TOOL
+ qemu_aio_release(acb);
#endif
- ret = ReadFile(s->hfile, buf, acb1->count, NULL, &acb1->ov);
- if (!ret)
- return -EIO;
- return 0;
+ return (BlockDriverAIOCB *)acb;
}
-static void raw_aio_cancel(BlockDriverAIOCB *acb)
+static BlockDriverAIOCB *raw_aio_write(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- BlockDriverState *bs = acb->bs;
BDRVRawState *s = bs->opaque;
-#ifndef QEMU_TOOL
- RawAIOCB *acb1 = acb->opaque;
+ RawAIOCB *acb;
+ int ret;
- qemu_del_wait_object(acb1->ov.hEvent, raw_aio_cb, acb);
+ acb = raw_aio_setup(bs, sector_num, buf, nb_sectors, cb, opaque);
+ if (!acb)
+ return NULL;
+ ret = WriteFile(s->hfile, buf, acb->count, NULL, &acb->ov);
+ if (!ret) {
+ qemu_aio_release(acb);
+ return NULL;
+ }
+#ifdef QEMU_TOOL
+ qemu_aio_release(acb);
#endif
- /* XXX: if more than one async I/O it is not correct */
- CancelIo(s->hfile);
+ return (BlockDriverAIOCB *)acb;
}
-static void raw_aio_delete(BlockDriverAIOCB *acb)
+static void raw_aio_cancel(BlockDriverAIOCB *blockacb)
{
- RawAIOCB *acb1 = acb->opaque;
- raw_aio_cancel(acb);
- CloseHandle(acb1->hEvent);
- qemu_free(acb1);
+#ifndef QEMU_TOOL
+ RawAIOCB *acb = (RawAIOCB *)blockacb;
+ BlockDriverState *bs = acb->common.bs;
+ BDRVRawState *s = bs->opaque;
+
+ qemu_del_wait_object(acb->ov.hEvent, raw_aio_cb, acb);
+ /* XXX: if more than one async I/O it is not correct */
+ CancelIo(s->hfile);
+ qemu_aio_release(acb);
+#endif
}
static void raw_flush(BlockDriverState *bs)
raw_flush,
#if 0
- .bdrv_aio_new = raw_aio_new,
.bdrv_aio_read = raw_aio_read,
.bdrv_aio_write = raw_aio_write,
.bdrv_aio_cancel = raw_aio_cancel,
- .bdrv_aio_delete = raw_aio_delete,
+ .aiocb_size = sizeof(RawAIOCB);
#endif
.protocol_name = "file",
.bdrv_pread = raw_pread,
#define SECTOR_BITS 9
#define SECTOR_SIZE (1 << SECTOR_BITS)
-static int bdrv_aio_new_em(BlockDriverAIOCB *acb);
-static int bdrv_aio_read_em(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors);
-static int bdrv_aio_write_em(BlockDriverAIOCB *acb, int64_t sector_num,
- const uint8_t *buf, int nb_sectors);
+static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque);
+static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
+ int64_t sector_num, const uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque);
static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);
-static void bdrv_aio_delete_em(BlockDriverAIOCB *acb);
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
uint8_t *buf, int nb_sectors);
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
void bdrv_register(BlockDriver *bdrv)
{
- if (!bdrv->bdrv_aio_new) {
+ if (!bdrv->bdrv_aio_read) {
/* add AIO emulation layer */
- bdrv->bdrv_aio_new = bdrv_aio_new_em;
bdrv->bdrv_aio_read = bdrv_aio_read_em;
bdrv->bdrv_aio_write = bdrv_aio_write_em;
bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em;
- bdrv->bdrv_aio_delete = bdrv_aio_delete_em;
} else if (!bdrv->bdrv_read && !bdrv->bdrv_pread) {
/* add synchronous IO emulation layer */
bdrv->bdrv_read = bdrv_read_em;
"ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
} else {
ti = sn->date_sec;
+#ifndef _WIN32
localtime_r(&ti, &tm);
+#endif
strftime(date_buf, sizeof(date_buf),
"%Y-%m-%d %H:%M:%S", &tm);
secs = sn->vm_clock_nsec / 1000000000;
/**************************************************************/
/* async I/Os */
-BlockDriverAIOCB *bdrv_aio_new(BlockDriverState *bs)
+BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
+ uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
BlockDriver *drv = bs->drv;
- BlockDriverAIOCB *acb;
- acb = qemu_mallocz(sizeof(BlockDriverAIOCB));
- if (!acb)
- return NULL;
-
- acb->bs = bs;
- if (drv->bdrv_aio_new(acb) < 0) {
- qemu_free(acb);
- return NULL;
- }
- return acb;
-}
-
-int bdrv_aio_read(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors,
- BlockDriverCompletionFunc *cb, void *opaque)
-{
- BlockDriverState *bs = acb->bs;
- BlockDriver *drv = bs->drv;
if (!bs->inserted)
- return -1;
+ return NULL;
/* XXX: we assume that nb_sectors == 0 is suppored by the async read */
if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
buf += 512;
}
- acb->cb = cb;
- acb->cb_opaque = opaque;
- return drv->bdrv_aio_read(acb, sector_num, buf, nb_sectors);
+ return drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque);
}
-int bdrv_aio_write(BlockDriverAIOCB *acb, int64_t sector_num,
- const uint8_t *buf, int nb_sectors,
- BlockDriverCompletionFunc *cb, void *opaque)
+BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
+ const uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- BlockDriverState *bs = acb->bs;
BlockDriver *drv = bs->drv;
if (!bs->inserted)
- return -1;
+ return NULL;
if (bs->read_only)
- return -1;
+ return NULL;
if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
memcpy(bs->boot_sector_data, buf, 512);
}
- acb->cb = cb;
- acb->cb_opaque = opaque;
- return drv->bdrv_aio_write(acb, sector_num, buf, nb_sectors);
+ return drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);
}
void bdrv_aio_cancel(BlockDriverAIOCB *acb)
- {
- BlockDriverState *bs = acb->bs;
- BlockDriver *drv = bs->drv;
-
- drv->bdrv_aio_cancel(acb);
- }
-
-void bdrv_aio_delete(BlockDriverAIOCB *acb)
{
- BlockDriverState *bs = acb->bs;
- BlockDriver *drv = bs->drv;
+ BlockDriver *drv = acb->bs->drv;
- drv->bdrv_aio_delete(acb);
- qemu_free(acb);
+ drv->bdrv_aio_cancel(acb);
}
+
/**************************************************************/
/* async block device emulation */
#ifdef QEMU_TOOL
-static int bdrv_aio_new_em(BlockDriverAIOCB *acb)
-{
- return 0;
-}
-
-static int bdrv_aio_read_em(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors)
+static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
int ret;
- ret = bdrv_read(acb->bs, sector_num, buf, nb_sectors);
- acb->cb(acb->cb_opaque, ret);
- return 0;
+ ret = bdrv_read(bs, sector_num, buf, nb_sectors);
+ cb(opaque, ret);
+ return NULL;
}
-static int bdrv_aio_write_em(BlockDriverAIOCB *acb, int64_t sector_num,
- const uint8_t *buf, int nb_sectors)
+static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
+ int64_t sector_num, const uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
int ret;
- ret = bdrv_write(acb->bs, sector_num, buf, nb_sectors);
- acb->cb(acb->cb_opaque, ret);
- return 0;
+ ret = bdrv_write(bs, sector_num, buf, nb_sectors);
+ cb(opaque, ret);
+ return NULL;
}
static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb)
{
}
-
-static void bdrv_aio_delete_em(BlockDriverAIOCB *acb)
-{
-}
#else
typedef struct BlockDriverAIOCBSync {
+ BlockDriverAIOCB common;
QEMUBH *bh;
int ret;
} BlockDriverAIOCBSync;
-static void bdrv_aio_bh_cb(void *opaque)
-{
- BlockDriverAIOCB *acb = opaque;
- BlockDriverAIOCBSync *acb1 = acb->opaque;
- acb->cb(acb->cb_opaque, acb1->ret);
-}
+static BlockDriverAIOCBSync *free_acb = NULL;
-static int bdrv_aio_new_em(BlockDriverAIOCB *acb)
+static void bdrv_aio_bh_cb(void *opaque)
{
- BlockDriverAIOCBSync *acb1;
-
- acb1 = qemu_mallocz(sizeof(BlockDriverAIOCBSync));
- if (!acb1)
- return -1;
- acb->opaque = acb1;
- acb1->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
- return 0;
+ BlockDriverAIOCBSync *acb = opaque;
+ acb->common.cb(acb->common.opaque, acb->ret);
+ qemu_aio_release(acb);
}
-static int bdrv_aio_read_em(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors)
+static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- BlockDriverAIOCBSync *acb1 = acb->opaque;
+ BlockDriverAIOCBSync *acb;
int ret;
-
- ret = bdrv_read(acb->bs, sector_num, buf, nb_sectors);
- acb1->ret = ret;
- qemu_bh_schedule(acb1->bh);
- return 0;
+
+ acb = qemu_aio_get(bs, cb, opaque);
+ if (!acb->bh)
+ acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
+ ret = bdrv_read(bs, sector_num, buf, nb_sectors);
+ acb->ret = ret;
+ qemu_bh_schedule(acb->bh);
+ return &acb->common;
}
-static int bdrv_aio_write_em(BlockDriverAIOCB *acb, int64_t sector_num,
- const uint8_t *buf, int nb_sectors)
+static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
+ int64_t sector_num, const uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque)
{
- BlockDriverAIOCBSync *acb1 = acb->opaque;
+ BlockDriverAIOCBSync *acb;
int ret;
-
- ret = bdrv_write(acb->bs, sector_num, buf, nb_sectors);
- acb1->ret = ret;
- qemu_bh_schedule(acb1->bh);
- return 0;
-}
-static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb)
-{
- BlockDriverAIOCBSync *acb1 = acb->opaque;
- qemu_bh_cancel(acb1->bh);
+ acb = qemu_aio_get(bs, cb, opaque);
+ if (!acb->bh)
+ acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
+ ret = bdrv_write(bs, sector_num, buf, nb_sectors);
+ acb->ret = ret;
+ qemu_bh_schedule(acb->bh);
+ return &acb->common;
}
-static void bdrv_aio_delete_em(BlockDriverAIOCB *acb)
+static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
{
- BlockDriverAIOCBSync *acb1 = acb->opaque;
- qemu_bh_delete(acb1->bh);
+ BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
+ qemu_bh_cancel(acb->bh);
+ qemu_aio_release(acb);
}
#endif /* !QEMU_TOOL */
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
uint8_t *buf, int nb_sectors)
{
- int async_ret, ret;
+ int async_ret;
+ BlockDriverAIOCB *acb;
- if (!bs->sync_aiocb) {
- bs->sync_aiocb = bdrv_aio_new(bs);
- if (!bs->sync_aiocb)
- return -1;
- }
async_ret = NOT_DONE;
qemu_aio_wait_start();
- ret = bdrv_aio_read(bs->sync_aiocb, sector_num, buf, nb_sectors,
+ acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors,
bdrv_rw_em_cb, &async_ret);
- if (ret < 0) {
+ if (acb == NULL) {
qemu_aio_wait_end();
- return ret;
+ return -1;
}
while (async_ret == NOT_DONE) {
qemu_aio_wait();
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
const uint8_t *buf, int nb_sectors)
{
- int async_ret, ret;
+ int async_ret;
+ BlockDriverAIOCB *acb;
- if (!bs->sync_aiocb) {
- bs->sync_aiocb = bdrv_aio_new(bs);
- if (!bs->sync_aiocb)
- return -1;
- }
async_ret = NOT_DONE;
qemu_aio_wait_start();
- ret = bdrv_aio_write(bs->sync_aiocb, sector_num, buf, nb_sectors,
+ acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,
bdrv_rw_em_cb, &async_ret);
- if (ret < 0) {
+ if (acb == NULL) {
qemu_aio_wait_end();
- return ret;
+ return -1;
}
while (async_ret == NOT_DONE) {
qemu_aio_wait();
bdrv_register(&bdrv_vvfat);
bdrv_register(&bdrv_qcow2);
}
+
+void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
+ void *opaque)
+{
+ BlockDriver *drv;
+ BlockDriverAIOCB *acb;
+
+ drv = bs->drv;
+ if (drv->free_aiocb) {
+ acb = drv->free_aiocb;
+ drv->free_aiocb = acb->next;
+ } else {
+ acb = qemu_mallocz(drv->aiocb_size);
+ if (!acb)
+ return NULL;
+ }
+ acb->bs = bs;
+ acb->cb = cb;
+ acb->opaque = opaque;
+ return acb;
+}
+
+void qemu_aio_release(void *p)
+{
+ BlockDriverAIOCB *acb = p;
+ BlockDriver *drv = acb->bs->drv;
+ acb->next = drv->free_aiocb;
+ drv->free_aiocb = acb;
+}
int (*bdrv_set_key)(BlockDriverState *bs, const char *key);
int (*bdrv_make_empty)(BlockDriverState *bs);
/* aio */
- int (*bdrv_aio_new)(BlockDriverAIOCB *acb);
- int (*bdrv_aio_read)(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors);
- int (*bdrv_aio_write)(BlockDriverAIOCB *acb, int64_t sector_num,
- const uint8_t *buf, int nb_sectors);
+ BlockDriverAIOCB *(*bdrv_aio_read)(BlockDriverState *bs,
+ int64_t sector_num, uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque);
+ BlockDriverAIOCB *(*bdrv_aio_write)(BlockDriverState *bs,
+ int64_t sector_num, const uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque);
void (*bdrv_aio_cancel)(BlockDriverAIOCB *acb);
- void (*bdrv_aio_delete)(BlockDriverAIOCB *acb);
+ int aiocb_size;
const char *protocol_name;
int (*bdrv_pread)(BlockDriverState *bs, int64_t offset,
QEMUSnapshotInfo **psn_info);
int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi);
+ BlockDriverAIOCB *free_aiocb;
struct BlockDriver *next;
};
int is_temporary;
BlockDriverState *backing_hd;
- /* sync read/write emulation */
+ /* async read/write emulation */
- BlockDriverAIOCB *sync_aiocb;
+ void *sync_aiocb;
/* NOTE: the following infos are only hints for real hardware
drivers. They are not used by the block driver */
struct BlockDriverAIOCB {
BlockDriverState *bs;
BlockDriverCompletionFunc *cb;
- void *cb_opaque;
-
- void *opaque; /* driver opaque */
+ void *opaque;
+ BlockDriverAIOCB *next;
};
void get_tmp_filename(char *filename, int size);
+void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
+ void *opaque);
+void qemu_aio_release(void *p);
+
#endif /* BLOCK_INT_H */
typedef struct BlockDriverAIOCB BlockDriverAIOCB;
typedef void BlockDriverCompletionFunc(void *opaque, int ret);
-BlockDriverAIOCB *bdrv_aio_new(BlockDriverState *bs);
-int bdrv_aio_read(BlockDriverAIOCB *acb, int64_t sector_num,
- uint8_t *buf, int nb_sectors,
- BlockDriverCompletionFunc *cb, void *opaque);
-int bdrv_aio_write(BlockDriverAIOCB *acb, int64_t sector_num,
- const uint8_t *buf, int nb_sectors,
- BlockDriverCompletionFunc *cb, void *opaque);
+BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
+ uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque);
+BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
+ const uint8_t *buf, int nb_sectors,
+ BlockDriverCompletionFunc *cb, void *opaque);
void bdrv_aio_cancel(BlockDriverAIOCB *acb);
-void bdrv_aio_delete(BlockDriverAIOCB *acb);
void qemu_aio_init(void);
void qemu_aio_poll(void);
projects / qemu / commitdiff