system/qemu
system/qemu
1
0
Fork 0
mirror of https://gitlab.com/qemu-project/qemu synced 2024-10-06 11:09:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

block: Rename BlockDriverCompletionFunc to BlockCompletionFunc

Browse source 
I'll use it with block backends shortly, and the name is going to fit
badly there.  It's a block layer thing anyway, not just a block driver
thing.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Markus Armbruster 2014-10-07 13:59:15 +02:00 committed by Kevin Wolf
parent 7c84b1b831
commit 097310b53e
42 changed files with 132 additions and 132 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
block.c
View file

@ -63,10 +63,10 @@ struct BdrvDirtyBitmap {
static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load); static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs, static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int64_t sector_num, int nb_sectors,
QEMUIOVector *iov); QEMUIOVector *iov);
@ -84,7 +84,7 @@ static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
QEMUIOVector *qiov, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BdrvRequestFlags flags, BdrvRequestFlags flags,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, void *opaque,
bool is_write); bool is_write);
static void coroutine_fn bdrv_co_do_rw(void *opaque); static void coroutine_fn bdrv_co_do_rw(void *opaque);
@ -4415,7 +4415,7 @@ int bdrv_get_backing_file_depth(BlockDriverState *bs)
BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
QEMUIOVector *qiov, int nb_sectors, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque); trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
@ -4425,7 +4425,7 @@ BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
QEMUIOVector *qiov, int nb_sectors, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque); trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
@ -4435,7 +4435,7 @@ BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, BdrvRequestFlags flags, int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque); trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
@ -4450,7 +4450,7 @@ typedef struct MultiwriteCB {
int num_requests; int num_requests;
int num_callbacks; int num_callbacks;
struct { struct {
BlockDriverCompletionFunc *cb; BlockCompletionFunc *cb;
void *opaque; void *opaque;
QEMUIOVector *free_qiov; QEMUIOVector *free_qiov;
} callbacks[]; } callbacks[];
@ -4688,7 +4688,7 @@ static BlockAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
QEMUIOVector *qiov, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, void *opaque,
int is_write) int is_write)
@ -4717,14 +4717,14 @@ static BlockAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
} }
static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1); return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
} }
@ -4775,7 +4775,7 @@ static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
QEMUIOVector *qiov, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BdrvRequestFlags flags, BdrvRequestFlags flags,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, void *opaque,
bool is_write) bool is_write)
{ {
@ -4806,7 +4806,7 @@ static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
} }
BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs, BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
trace_bdrv_aio_flush(bs, opaque); trace_bdrv_aio_flush(bs, opaque);
@ -4833,7 +4833,7 @@ static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs, BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int64_t sector_num, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
Coroutine *co; Coroutine *co;
BlockAIOCBCoroutine *acb; BlockAIOCBCoroutine *acb;
@ -4861,7 +4861,7 @@ void bdrv_init_with_whitelist(void)
} }
void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BlockAIOCB *acb; BlockAIOCB *acb;
@ -5281,7 +5281,7 @@ int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
unsigned long int req, void *buf, unsigned long int req, void *buf,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BlockDriver *drv = bs->drv; BlockDriver *drv = bs->drv;

8
block/archipelago.c
View file

@ -860,7 +860,7 @@ static BlockAIOCB *qemu_archipelago_aio_rw(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
QEMUIOVector *qiov, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, void *opaque,
int op) int op)
{ {
@ -896,7 +896,7 @@ err_exit:
static BlockAIOCB *qemu_archipelago_aio_readv(BlockDriverState *bs, static BlockAIOCB *qemu_archipelago_aio_readv(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
return qemu_archipelago_aio_rw(bs, sector_num, qiov, nb_sectors, cb, return qemu_archipelago_aio_rw(bs, sector_num, qiov, nb_sectors, cb,
opaque, ARCHIP_OP_READ); opaque, ARCHIP_OP_READ);
@ -904,7 +904,7 @@ static BlockAIOCB *qemu_archipelago_aio_readv(BlockDriverState *bs,
static BlockAIOCB *qemu_archipelago_aio_writev(BlockDriverState *bs, static BlockAIOCB *qemu_archipelago_aio_writev(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
return qemu_archipelago_aio_rw(bs, sector_num, qiov, nb_sectors, cb, return qemu_archipelago_aio_rw(bs, sector_num, qiov, nb_sectors, cb,
opaque, ARCHIP_OP_WRITE); opaque, ARCHIP_OP_WRITE);
@ -1053,7 +1053,7 @@ static QemuOptsList qemu_archipelago_create_opts = {
}; };
static BlockAIOCB *qemu_archipelago_aio_flush(BlockDriverState *bs, static BlockAIOCB *qemu_archipelago_aio_flush(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
return qemu_archipelago_aio_rw(bs, 0, NULL, 0, cb, opaque, return qemu_archipelago_aio_rw(bs, 0, NULL, 0, cb, opaque,
ARCHIP_OP_FLUSH); ARCHIP_OP_FLUSH);

2
block/backup.c
View file

@ -353,7 +353,7 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
int64_t speed, MirrorSyncMode sync_mode, int64_t speed, MirrorSyncMode sync_mode,
BlockdevOnError on_source_error, BlockdevOnError on_source_error,
BlockdevOnError on_target_error, BlockdevOnError on_target_error,
BlockDriverCompletionFunc *cb, void *opaque, BlockCompletionFunc *cb, void *opaque,
Error **errp) Error **errp)
{ {
int64_t len; int64_t len;

8
block/blkdebug.c
View file

@ -464,7 +464,7 @@ static void error_callback_bh(void *opaque)
} }
static BlockAIOCB *inject_error(BlockDriverState *bs, static BlockAIOCB *inject_error(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque, BlkdebugRule *rule) BlockCompletionFunc *cb, void *opaque, BlkdebugRule *rule)
{ {
BDRVBlkdebugState *s = bs->opaque; BDRVBlkdebugState *s = bs->opaque;
int error = rule->options.inject.error; int error = rule->options.inject.error;
@ -491,7 +491,7 @@ static BlockAIOCB *inject_error(BlockDriverState *bs,
static BlockAIOCB *blkdebug_aio_readv(BlockDriverState *bs, static BlockAIOCB *blkdebug_aio_readv(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVBlkdebugState *s = bs->opaque; BDRVBlkdebugState *s = bs->opaque;
BlkdebugRule *rule = NULL; BlkdebugRule *rule = NULL;
@ -513,7 +513,7 @@ static BlockAIOCB *blkdebug_aio_readv(BlockDriverState *bs,
static BlockAIOCB *blkdebug_aio_writev(BlockDriverState *bs, static BlockAIOCB *blkdebug_aio_writev(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVBlkdebugState *s = bs->opaque; BDRVBlkdebugState *s = bs->opaque;
BlkdebugRule *rule = NULL; BlkdebugRule *rule = NULL;
@ -534,7 +534,7 @@ static BlockAIOCB *blkdebug_aio_writev(BlockDriverState *bs,
} }
static BlockAIOCB *blkdebug_aio_flush(BlockDriverState *bs, static BlockAIOCB *blkdebug_aio_flush(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVBlkdebugState *s = bs->opaque; BDRVBlkdebugState *s = bs->opaque;
BlkdebugRule *rule = NULL; BlkdebugRule *rule = NULL;

8
block/blkverify.c
View file

@ -165,7 +165,7 @@ static int64_t blkverify_getlength(BlockDriverState *bs)
static BlkverifyAIOCB *blkverify_aio_get(BlockDriverState *bs, bool is_write, static BlkverifyAIOCB *blkverify_aio_get(BlockDriverState *bs, bool is_write,
int64_t sector_num, QEMUIOVector *qiov, int64_t sector_num, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
BlkverifyAIOCB *acb = qemu_aio_get(&blkverify_aiocb_info, bs, cb, opaque); BlkverifyAIOCB *acb = qemu_aio_get(&blkverify_aiocb_info, bs, cb, opaque);
@ -231,7 +231,7 @@ static void blkverify_verify_readv(BlkverifyAIOCB *acb)
static BlockAIOCB *blkverify_aio_readv(BlockDriverState *bs, static BlockAIOCB *blkverify_aio_readv(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVBlkverifyState *s = bs->opaque; BDRVBlkverifyState *s = bs->opaque;
BlkverifyAIOCB *acb = blkverify_aio_get(bs, false, sector_num, qiov, BlkverifyAIOCB *acb = blkverify_aio_get(bs, false, sector_num, qiov,
@ -251,7 +251,7 @@ static BlockAIOCB *blkverify_aio_readv(BlockDriverState *bs,
static BlockAIOCB *blkverify_aio_writev(BlockDriverState *bs, static BlockAIOCB *blkverify_aio_writev(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVBlkverifyState *s = bs->opaque; BDRVBlkverifyState *s = bs->opaque;
BlkverifyAIOCB *acb = blkverify_aio_get(bs, true, sector_num, qiov, BlkverifyAIOCB *acb = blkverify_aio_get(bs, true, sector_num, qiov,
@ -265,7 +265,7 @@ static BlockAIOCB *blkverify_aio_writev(BlockDriverState *bs,
} }
static BlockAIOCB *blkverify_aio_flush(BlockDriverState *bs, static BlockAIOCB *blkverify_aio_flush(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
BDRVBlkverifyState *s = bs->opaque; BDRVBlkverifyState *s = bs->opaque;

2
block/commit.c
View file

@ -182,7 +182,7 @@ static const BlockJobDriver commit_job_driver = {
void commit_start(BlockDriverState *bs, BlockDriverState *base, void commit_start(BlockDriverState *bs, BlockDriverState *base,
BlockDriverState *top, int64_t speed, BlockDriverState *top, int64_t speed,
BlockdevOnError on_error, BlockDriverCompletionFunc *cb, BlockdevOnError on_error, BlockCompletionFunc *cb,
void *opaque, const char *backing_file_str, Error **errp) void *opaque, const char *backing_file_str, Error **errp)
{ {
CommitBlockJob *s; CommitBlockJob *s;

2
block/curl.c
View file

@ -682,7 +682,7 @@ static void curl_readv_bh_cb(void *p)
static BlockAIOCB *curl_aio_readv(BlockDriverState *bs, static BlockAIOCB *curl_aio_readv(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
CURLAIOCB *acb; CURLAIOCB *acb;

2
block/iscsi.c
View file

@ -665,7 +665,7 @@ iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status,
static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs, static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,
unsigned long int req, void *buf, unsigned long int req, void *buf,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
IscsiLun *iscsilun = bs->opaque; IscsiLun *iscsilun = bs->opaque;
struct iscsi_context *iscsi = iscsilun->iscsi; struct iscsi_context *iscsi = iscsilun->iscsi;

2
block/linux-aio.c
View file

@ -245,7 +245,7 @@ int laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug)
BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int type) BlockCompletionFunc *cb, void *opaque, int type)
{ {
struct qemu_laio_state *s = aio_ctx; struct qemu_laio_state *s = aio_ctx;
struct qemu_laiocb *laiocb; struct qemu_laiocb *laiocb;

6
block/mirror.c
View file

@ -613,7 +613,7 @@ static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target,
int64_t buf_size, int64_t buf_size,
BlockdevOnError on_source_error, BlockdevOnError on_source_error,
BlockdevOnError on_target_error, BlockdevOnError on_target_error,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, Error **errp, void *opaque, Error **errp,
const BlockJobDriver *driver, const BlockJobDriver *driver,
bool is_none_mode, BlockDriverState *base) bool is_none_mode, BlockDriverState *base)
@ -673,7 +673,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target,
int64_t speed, int64_t granularity, int64_t buf_size, int64_t speed, int64_t granularity, int64_t buf_size,
MirrorSyncMode mode, BlockdevOnError on_source_error, MirrorSyncMode mode, BlockdevOnError on_source_error,
BlockdevOnError on_target_error, BlockdevOnError on_target_error,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, Error **errp) void *opaque, Error **errp)
{ {
bool is_none_mode; bool is_none_mode;
@ -690,7 +690,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target,
void commit_active_start(BlockDriverState *bs, BlockDriverState *base, void commit_active_start(BlockDriverState *bs, BlockDriverState *base,
int64_t speed, int64_t speed,
BlockdevOnError on_error, BlockdevOnError on_error,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, Error **errp) void *opaque, Error **errp)
{ {
int64_t length, base_length; int64_t length, base_length;

8
block/null.c
View file

@ -95,7 +95,7 @@ static void null_bh_cb(void *opaque)
} }
static inline BlockAIOCB *null_aio_common(BlockDriverState *bs, static inline BlockAIOCB *null_aio_common(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
NullAIOCB *acb; NullAIOCB *acb;
@ -109,7 +109,7 @@ static inline BlockAIOCB *null_aio_common(BlockDriverState *bs,
static BlockAIOCB *null_aio_readv(BlockDriverState *bs, static BlockAIOCB *null_aio_readv(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int64_t sector_num, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
return null_aio_common(bs, cb, opaque); return null_aio_common(bs, cb, opaque);
@ -118,14 +118,14 @@ static BlockAIOCB *null_aio_readv(BlockDriverState *bs,
static BlockAIOCB *null_aio_writev(BlockDriverState *bs, static BlockAIOCB *null_aio_writev(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int64_t sector_num, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
return null_aio_common(bs, cb, opaque); return null_aio_common(bs, cb, opaque);
} }
static BlockAIOCB *null_aio_flush(BlockDriverState *bs, static BlockAIOCB *null_aio_flush(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
return null_aio_common(bs, cb, opaque); return null_aio_common(bs, cb, opaque);

4
block/qed-gencb.c
View file

@ -13,7 +13,7 @@
#include "qed.h" #include "qed.h"
void *gencb_alloc(size_t len, BlockDriverCompletionFunc *cb, void *opaque) void *gencb_alloc(size_t len, BlockCompletionFunc *cb, void *opaque)
{ {
GenericCB *gencb = g_malloc(len); GenericCB *gencb = g_malloc(len);
gencb->cb = cb; gencb->cb = cb;
@ -24,7 +24,7 @@ void *gencb_alloc(size_t len, BlockDriverCompletionFunc *cb, void *opaque)
void gencb_complete(void *opaque, int ret) void gencb_complete(void *opaque, int ret)
{ {
GenericCB *gencb = opaque; GenericCB *gencb = opaque;
BlockDriverCompletionFunc *cb = gencb->cb; BlockCompletionFunc *cb = gencb->cb;
void *user_opaque = gencb->opaque; void *user_opaque = gencb->opaque;
g_free(gencb); g_free(gencb);

10
block/qed-table.c
View file

@ -49,7 +49,7 @@ out:
} }
static void qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table, static void qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
QEDReadTableCB *read_table_cb = gencb_alloc(sizeof(*read_table_cb), QEDReadTableCB *read_table_cb = gencb_alloc(sizeof(*read_table_cb),
cb, opaque); cb, opaque);
@ -119,7 +119,7 @@ out:
*/ */
static void qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table, static void qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
unsigned int index, unsigned int n, bool flush, unsigned int index, unsigned int n, bool flush,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
QEDWriteTableCB *write_table_cb; QEDWriteTableCB *write_table_cb;
unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1; unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1;
@ -180,7 +180,7 @@ int qed_read_l1_table_sync(BDRVQEDState *s)
} }
void qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n, void qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BLKDBG_EVENT(s->bs->file, BLKDBG_L1_UPDATE); BLKDBG_EVENT(s->bs->file, BLKDBG_L1_UPDATE);
qed_write_table(s, s->header.l1_table_offset, qed_write_table(s, s->header.l1_table_offset,
@ -235,7 +235,7 @@ static void qed_read_l2_table_cb(void *opaque, int ret)
} }
void qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset, void qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
QEDReadL2TableCB *read_l2_table_cb; QEDReadL2TableCB *read_l2_table_cb;
@ -275,7 +275,7 @@ int qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, uint64_t offset
void qed_write_l2_table(BDRVQEDState *s, QEDRequest *request, void qed_write_l2_table(BDRVQEDState *s, QEDRequest *request,
unsigned int index, unsigned int n, bool flush, unsigned int index, unsigned int n, bool flush,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BLKDBG_EVENT(s->bs->file, BLKDBG_L2_UPDATE); BLKDBG_EVENT(s->bs->file, BLKDBG_L2_UPDATE);
qed_write_table(s, request->l2_table->offset, qed_write_table(s, request->l2_table->offset,

18
block/qed.c
View file

@ -130,7 +130,7 @@ static void qed_write_header_read_cb(void *opaque, int ret)
* This function only updates known header fields in-place and does not affect * This function only updates known header fields in-place and does not affect
* extra data after the QED header. * extra data after the QED header.
*/ */
static void qed_write_header(BDRVQEDState *s, BlockDriverCompletionFunc cb, static void qed_write_header(BDRVQEDState *s, BlockCompletionFunc cb,
void *opaque) void *opaque)
{ {
/* We must write full sectors for O_DIRECT but cannot necessarily generate /* We must write full sectors for O_DIRECT but cannot necessarily generate
@ -759,7 +759,7 @@ static BDRVQEDState *acb_to_s(QEDAIOCB *acb)
static void qed_read_backing_file(BDRVQEDState *s, uint64_t pos, static void qed_read_backing_file(BDRVQEDState *s, uint64_t pos,
QEMUIOVector *qiov, QEMUIOVector *qiov,
QEMUIOVector **backing_qiov, QEMUIOVector **backing_qiov,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
uint64_t backing_length = 0; uint64_t backing_length = 0;
size_t size; size_t size;
@ -851,7 +851,7 @@ static void qed_copy_from_backing_file_write(void *opaque, int ret)
*/ */
static void qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos, static void qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos,
uint64_t len, uint64_t offset, uint64_t len, uint64_t offset,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
CopyFromBackingFileCB *copy_cb; CopyFromBackingFileCB *copy_cb;
@ -902,7 +902,7 @@ static void qed_update_l2_table(BDRVQEDState *s, QEDTable *table, int index,
static void qed_aio_complete_bh(void *opaque) static void qed_aio_complete_bh(void *opaque)
{ {
QEDAIOCB *acb = opaque; QEDAIOCB *acb = opaque;
BlockDriverCompletionFunc *cb = acb->common.cb; BlockCompletionFunc *cb = acb->common.cb;
void *user_opaque = acb->common.opaque; void *user_opaque = acb->common.opaque;
int ret = acb->bh_ret; int ret = acb->bh_ret;
@ -1064,7 +1064,7 @@ static void qed_aio_write_main(void *opaque, int ret)
BDRVQEDState *s = acb_to_s(acb); BDRVQEDState *s = acb_to_s(acb);
uint64_t offset = acb->cur_cluster + uint64_t offset = acb->cur_cluster +
qed_offset_into_cluster(s, acb->cur_pos); qed_offset_into_cluster(s, acb->cur_pos);
BlockDriverCompletionFunc *next_fn; BlockCompletionFunc *next_fn;
trace_qed_aio_write_main(s, acb, ret, offset, acb->cur_qiov.size); trace_qed_aio_write_main(s, acb, ret, offset, acb->cur_qiov.size);
@ -1164,7 +1164,7 @@ static void qed_aio_write_zero_cluster(void *opaque, int ret)
static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len) static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len)
{ {
BDRVQEDState *s = acb_to_s(acb); BDRVQEDState *s = acb_to_s(acb);
BlockDriverCompletionFunc *cb; BlockCompletionFunc *cb;
/* Cancel timer when the first allocating request comes in */ /* Cancel timer when the first allocating request comes in */
if (QSIMPLEQ_EMPTY(&s->allocating_write_reqs)) { if (QSIMPLEQ_EMPTY(&s->allocating_write_reqs)) {
@ -1368,7 +1368,7 @@ static void qed_aio_next_io(void *opaque, int ret)
static BlockAIOCB *qed_aio_setup(BlockDriverState *bs, static BlockAIOCB *qed_aio_setup(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
QEMUIOVector *qiov, int nb_sectors, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, int flags) void *opaque, int flags)
{ {
QEDAIOCB *acb = qemu_aio_get(&qed_aiocb_info, bs, cb, opaque); QEDAIOCB *acb = qemu_aio_get(&qed_aiocb_info, bs, cb, opaque);
@ -1393,7 +1393,7 @@ static BlockAIOCB *qed_aio_setup(BlockDriverState *bs,
static BlockAIOCB *bdrv_qed_aio_readv(BlockDriverState *bs, static BlockAIOCB *bdrv_qed_aio_readv(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
QEMUIOVector *qiov, int nb_sectors, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
@ -1402,7 +1402,7 @@ static BlockAIOCB *bdrv_qed_aio_readv(BlockDriverState *bs,
static BlockAIOCB *bdrv_qed_aio_writev(BlockDriverState *bs, static BlockAIOCB *bdrv_qed_aio_writev(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
QEMUIOVector *qiov, int nb_sectors, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb,

10
block/qed.h
View file

@ -203,11 +203,11 @@ typedef void QEDFindClusterFunc(void *opaque, int ret, uint64_t offset, size_t l
* Generic callback for chaining async callbacks * Generic callback for chaining async callbacks
*/ */
typedef struct { typedef struct {
BlockDriverCompletionFunc *cb; BlockCompletionFunc *cb;
void *opaque; void *opaque;
} GenericCB; } GenericCB;
void *gencb_alloc(size_t len, BlockDriverCompletionFunc *cb, void *opaque); void *gencb_alloc(size_t len, BlockCompletionFunc *cb, void *opaque);
void gencb_complete(void *opaque, int ret); void gencb_complete(void *opaque, int ret);
/** /**
@ -230,16 +230,16 @@ void qed_commit_l2_cache_entry(L2TableCache *l2_cache, CachedL2Table *l2_table);
*/ */
int qed_read_l1_table_sync(BDRVQEDState *s); int qed_read_l1_table_sync(BDRVQEDState *s);
void qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n, void qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
int qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index, int qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index,
unsigned int n); unsigned int n);
int qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, int qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
uint64_t offset); uint64_t offset);
void qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset, void qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
void qed_write_l2_table(BDRVQEDState *s, QEDRequest *request, void qed_write_l2_table(BDRVQEDState *s, QEDRequest *request,
unsigned int index, unsigned int n, bool flush, unsigned int index, unsigned int n, bool flush,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
int qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request, int qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
unsigned int index, unsigned int n, bool flush); unsigned int index, unsigned int n, bool flush);

6
block/quorum.c
View file

@ -186,7 +186,7 @@ static QuorumAIOCB *quorum_aio_get(BDRVQuorumState *s,
QEMUIOVector *qiov, QEMUIOVector *qiov,
uint64_t sector_num, uint64_t sector_num,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
QuorumAIOCB *acb = qemu_aio_get(&quorum_aiocb_info, bs, cb, opaque); QuorumAIOCB *acb = qemu_aio_get(&quorum_aiocb_info, bs, cb, opaque);
@ -679,7 +679,7 @@ static BlockAIOCB *quorum_aio_readv(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
QEMUIOVector *qiov, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
BDRVQuorumState *s = bs->opaque; BDRVQuorumState *s = bs->opaque;
@ -700,7 +700,7 @@ static BlockAIOCB *quorum_aio_writev(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
QEMUIOVector *qiov, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
BDRVQuorumState *s = bs->opaque; BDRVQuorumState *s = bs->opaque;

4
block/raw-aio.h
View file

@ -37,7 +37,7 @@ void *laio_init(void);
void laio_cleanup(void *s); void laio_cleanup(void *s);
BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int type); BlockCompletionFunc *cb, void *opaque, int type);
void laio_detach_aio_context(void *s, AioContext *old_context); void laio_detach_aio_context(void *s, AioContext *old_context);
void laio_attach_aio_context(void *s, AioContext *new_context); void laio_attach_aio_context(void *s, AioContext *new_context);
void laio_io_plug(BlockDriverState *bs, void *aio_ctx); void laio_io_plug(BlockDriverState *bs, void *aio_ctx);
@ -52,7 +52,7 @@ int win32_aio_attach(QEMUWin32AIOState *aio, HANDLE hfile);
BlockAIOCB *win32_aio_submit(BlockDriverState *bs, BlockAIOCB *win32_aio_submit(BlockDriverState *bs,
QEMUWin32AIOState *aio, HANDLE hfile, QEMUWin32AIOState *aio, HANDLE hfile,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int type); BlockCompletionFunc *cb, void *opaque, int type);
void win32_aio_detach_aio_context(QEMUWin32AIOState *aio, void win32_aio_detach_aio_context(QEMUWin32AIOState *aio,
AioContext *old_context); AioContext *old_context);
void win32_aio_attach_aio_context(QEMUWin32AIOState *aio, void win32_aio_attach_aio_context(QEMUWin32AIOState *aio,

16
block/raw-posix.c
View file

@ -1043,7 +1043,7 @@ static int paio_submit_co(BlockDriverState *bs, int fd,
static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd, static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int type) BlockCompletionFunc *cb, void *opaque, int type)
{ {
RawPosixAIOData *acb = g_slice_new(RawPosixAIOData); RawPosixAIOData *acb = g_slice_new(RawPosixAIOData);
ThreadPool *pool; ThreadPool *pool;
@ -1068,7 +1068,7 @@ static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd,
static BlockAIOCB *raw_aio_submit(BlockDriverState *bs, static BlockAIOCB *raw_aio_submit(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int type) BlockCompletionFunc *cb, void *opaque, int type)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
@ -1127,7 +1127,7 @@ static void raw_aio_flush_io_queue(BlockDriverState *bs)
static BlockAIOCB *raw_aio_readv(BlockDriverState *bs, static BlockAIOCB *raw_aio_readv(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
return raw_aio_submit(bs, sector_num, qiov, nb_sectors, return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
cb, opaque, QEMU_AIO_READ); cb, opaque, QEMU_AIO_READ);
@ -1135,14 +1135,14 @@ static BlockAIOCB *raw_aio_readv(BlockDriverState *bs,
static BlockAIOCB *raw_aio_writev(BlockDriverState *bs, static BlockAIOCB *raw_aio_writev(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
return raw_aio_submit(bs, sector_num, qiov, nb_sectors, return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
cb, opaque, QEMU_AIO_WRITE); cb, opaque, QEMU_AIO_WRITE);
} }
static BlockAIOCB *raw_aio_flush(BlockDriverState *bs, static BlockAIOCB *raw_aio_flush(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
@ -1597,7 +1597,7 @@ static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
static coroutine_fn BlockAIOCB *raw_aio_discard(BlockDriverState *bs, static coroutine_fn BlockAIOCB *raw_aio_discard(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int64_t sector_num, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
@ -1937,7 +1937,7 @@ static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs, static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
unsigned long int req, void *buf, unsigned long int req, void *buf,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
RawPosixAIOData *acb; RawPosixAIOData *acb;
@ -1978,7 +1978,7 @@ static int fd_open(BlockDriverState *bs)
static coroutine_fn BlockAIOCB *hdev_aio_discard(BlockDriverState *bs, static coroutine_fn BlockAIOCB *hdev_aio_discard(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int64_t sector_num, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;

8
block/raw-win32.c
View file

@ -140,7 +140,7 @@ static int aio_worker(void *arg)
static BlockAIOCB *paio_submit(BlockDriverState *bs, HANDLE hfile, static BlockAIOCB *paio_submit(BlockDriverState *bs, HANDLE hfile,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int type) BlockCompletionFunc *cb, void *opaque, int type)
{ {
RawWin32AIOData *acb = g_slice_new(RawWin32AIOData); RawWin32AIOData *acb = g_slice_new(RawWin32AIOData);
ThreadPool *pool; ThreadPool *pool;
@ -371,7 +371,7 @@ fail:
static BlockAIOCB *raw_aio_readv(BlockDriverState *bs, static BlockAIOCB *raw_aio_readv(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
if (s->aio) { if (s->aio) {
@ -385,7 +385,7 @@ static BlockAIOCB *raw_aio_readv(BlockDriverState *bs,
static BlockAIOCB *raw_aio_writev(BlockDriverState *bs, static BlockAIOCB *raw_aio_writev(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
if (s->aio) { if (s->aio) {
@ -398,7 +398,7 @@ static BlockAIOCB *raw_aio_writev(BlockDriverState *bs,
} }
static BlockAIOCB *raw_aio_flush(BlockDriverState *bs, static BlockAIOCB *raw_aio_flush(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH); return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);

2
block/raw_bsd.c
View file

@ -131,7 +131,7 @@ static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
static BlockAIOCB *raw_aio_ioctl(BlockDriverState *bs, static BlockAIOCB *raw_aio_ioctl(BlockDriverState *bs,
unsigned long int req, void *buf, unsigned long int req, void *buf,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
return bdrv_aio_ioctl(bs->file, req, buf, cb, opaque); return bdrv_aio_ioctl(bs->file, req, buf, cb, opaque);

10
block/rbd.c
View file

@ -593,7 +593,7 @@ static BlockAIOCB *rbd_start_aio(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
QEMUIOVector *qiov, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, void *opaque,
RBDAIOCmd cmd) RBDAIOCmd cmd)
{ {
@ -679,7 +679,7 @@ static BlockAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
QEMUIOVector *qiov, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque, return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque,
@ -690,7 +690,7 @@ static BlockAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
QEMUIOVector *qiov, QEMUIOVector *qiov,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque, return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque,
@ -699,7 +699,7 @@ static BlockAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs,
#ifdef LIBRBD_SUPPORTS_AIO_FLUSH #ifdef LIBRBD_SUPPORTS_AIO_FLUSH
static BlockAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, static BlockAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH); return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH);
@ -879,7 +879,7 @@ static int qemu_rbd_snap_list(BlockDriverState *bs,
static BlockAIOCB* qemu_rbd_aio_discard(BlockDriverState *bs, static BlockAIOCB* qemu_rbd_aio_discard(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
int nb_sectors, int nb_sectors,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque) void *opaque)
{ {
return rbd_start_aio(bs, sector_num, NULL, nb_sectors, cb, opaque, return rbd_start_aio(bs, sector_num, NULL, nb_sectors, cb, opaque,

2
block/stream.c
View file

@ -220,7 +220,7 @@ static const BlockJobDriver stream_job_driver = {
void stream_start(BlockDriverState *bs, BlockDriverState *base, void stream_start(BlockDriverState *bs, BlockDriverState *base,
const char *backing_file_str, int64_t speed, const char *backing_file_str, int64_t speed,
BlockdevOnError on_error, BlockdevOnError on_error,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, Error **errp) void *opaque, Error **errp)
{ {
StreamBlockJob *s; StreamBlockJob *s;

2
block/win32-aio.c
View file

@ -113,7 +113,7 @@ static const AIOCBInfo win32_aiocb_info = {
BlockAIOCB *win32_aio_submit(BlockDriverState *bs, BlockAIOCB *win32_aio_submit(BlockDriverState *bs,
QEMUWin32AIOState *aio, HANDLE hfile, QEMUWin32AIOState *aio, HANDLE hfile,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int type) BlockCompletionFunc *cb, void *opaque, int type)
{ {
struct QEMUWin32AIOCB *waiocb; struct QEMUWin32AIOCB *waiocb;
uint64_t offset = sector_num * 512; uint64_t offset = sector_num * 512;

4
blockjob.c
View file

@ -36,7 +36,7 @@
#include "qapi-event.h" #include "qapi-event.h"
void *block_job_create(const BlockJobDriver *driver, BlockDriverState *bs, void *block_job_create(const BlockJobDriver *driver, BlockDriverState *bs,
int64_t speed, BlockDriverCompletionFunc *cb, int64_t speed, BlockCompletionFunc *cb,
void *opaque, Error **errp) void *opaque, Error **errp)
{ {
BlockJob *job; BlockJob *job;
@ -155,7 +155,7 @@ void block_job_iostatus_reset(BlockJob *job)
struct BlockCancelData { struct BlockCancelData {
BlockJob *job; BlockJob *job;
BlockDriverCompletionFunc *cb; BlockCompletionFunc *cb;
void *opaque; void *opaque;
bool cancelled; bool cancelled;
int ret; int ret;

2
dma-helpers.c
View file

@ -192,7 +192,7 @@ static const AIOCBInfo dma_aiocb_info = {
BlockAIOCB *dma_bdrv_io( BlockAIOCB *dma_bdrv_io(
BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num, BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num,
DMAIOFunc *io_func, BlockDriverCompletionFunc *cb, DMAIOFunc *io_func, BlockCompletionFunc *cb,
void *opaque, DMADirection dir) void *opaque, DMADirection dir)
{ {
DMAAIOCB *dbs = qemu_aio_get(&dma_aiocb_info, bs, cb, opaque); DMAAIOCB *dbs = qemu_aio_get(&dma_aiocb_info, bs, cb, opaque);

2
docs/blkdebug.txt
View file

@ -73,7 +73,7 @@ Rules support the following attributes:
immediately - (optional, default "off") return a NULL BlockAIOCB immediately - (optional, default "off") return a NULL BlockAIOCB
pointer and fail without an errno instead. This pointer and fail without an errno instead. This
exercises the code path where BlockAIOCB fails and the exercises the code path where BlockAIOCB fails and the
caller's BlockDriverCompletionFunc is not invoked. caller's BlockCompletionFunc is not invoked.
Events Events
------ ------

2
hw/ide/ahci.c
View file

@ -1122,7 +1122,7 @@ out:
} }
static void ahci_start_dma(IDEDMA *dma, IDEState *s, static void ahci_start_dma(IDEDMA *dma, IDEState *s,
BlockDriverCompletionFunc *dma_cb) BlockCompletionFunc *dma_cb)
{ {
#ifdef DEBUG_AHCI #ifdef DEBUG_AHCI
AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma); AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma);

4
hw/ide/core.c
View file

@ -440,7 +440,7 @@ static void ide_issue_trim_cb(void *opaque, int ret)
BlockAIOCB *ide_issue_trim(BlockDriverState *bs, BlockAIOCB *ide_issue_trim(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
TrimAIOCB *iocb; TrimAIOCB *iocb;
@ -789,7 +789,7 @@ static void ide_sector_start_dma(IDEState *s, enum ide_dma_cmd dma_cmd)
ide_start_dma(s, ide_dma_cb); ide_start_dma(s, ide_dma_cb);
} }
void ide_start_dma(IDEState *s, BlockDriverCompletionFunc *cb) void ide_start_dma(IDEState *s, BlockCompletionFunc *cb)
{ {
if (s->bus->dma->ops->start_dma) { if (s->bus->dma->ops->start_dma) {
s->bus->dma->ops->start_dma(s->bus->dma, s, cb); s->bus->dma->ops->start_dma(s->bus->dma, s, cb);

6
hw/ide/internal.h
View file

@ -319,7 +319,7 @@ typedef enum { IDE_HD, IDE_CD, IDE_CFATA } IDEDriveKind;
typedef void EndTransferFunc(IDEState *); typedef void EndTransferFunc(IDEState *);
typedef void DMAStartFunc(IDEDMA *, IDEState *, BlockDriverCompletionFunc *); typedef void DMAStartFunc(IDEDMA *, IDEState *, BlockCompletionFunc *);
typedef void DMAVoidFunc(IDEDMA *); typedef void DMAVoidFunc(IDEDMA *);
typedef int DMAIntFunc(IDEDMA *, int); typedef int DMAIntFunc(IDEDMA *, int);
typedef void DMAStopFunc(IDEDMA *, bool); typedef void DMAStopFunc(IDEDMA *, bool);
@ -521,7 +521,7 @@ void ide_bus_reset(IDEBus *bus);
int64_t ide_get_sector(IDEState *s); int64_t ide_get_sector(IDEState *s);
void ide_set_sector(IDEState *s, int64_t sector_num); void ide_set_sector(IDEState *s, int64_t sector_num);
void ide_start_dma(IDEState *s, BlockDriverCompletionFunc *cb); void ide_start_dma(IDEState *s, BlockCompletionFunc *cb);
void ide_dma_error(IDEState *s); void ide_dma_error(IDEState *s);
void ide_atapi_cmd_ok(IDEState *s); void ide_atapi_cmd_ok(IDEState *s);
@ -557,7 +557,7 @@ void ide_transfer_stop(IDEState *s);
void ide_set_inactive(IDEState *s, bool more); void ide_set_inactive(IDEState *s, bool more);
BlockAIOCB *ide_issue_trim(BlockDriverState *bs, BlockAIOCB *ide_issue_trim(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
/* hw/ide/atapi.c */ /* hw/ide/atapi.c */
void ide_atapi_cmd(IDEState *s); void ide_atapi_cmd(IDEState *s);

2
hw/ide/macio.c
View file

@ -558,7 +558,7 @@ static void ide_nop_restart(void *opaque, int x, RunState y)
} }
static void ide_dbdma_start(IDEDMA *dma, IDEState *s, static void ide_dbdma_start(IDEDMA *dma, IDEState *s,
BlockDriverCompletionFunc *cb) BlockCompletionFunc *cb)
{ {
MACIOIDEState *m = container_of(dma, MACIOIDEState, dma); MACIOIDEState *m = container_of(dma, MACIOIDEState, dma);

2
hw/ide/pci.c
View file

@ -38,7 +38,7 @@
IDE_RETRY_READ | IDE_RETRY_FLUSH) IDE_RETRY_READ | IDE_RETRY_FLUSH)
static void bmdma_start_dma(IDEDMA *dma, IDEState *s, static void bmdma_start_dma(IDEDMA *dma, IDEState *s,
BlockDriverCompletionFunc *dma_cb) BlockCompletionFunc *dma_cb)
{ {
BMDMAState *bm = DO_UPCAST(BMDMAState, dma, dma); BMDMAState *bm = DO_UPCAST(BMDMAState, dma, dma);

2
hw/ide/pci.h
View file

@ -23,7 +23,7 @@ typedef struct BMDMAState {
uint32_t cur_prd_addr; uint32_t cur_prd_addr;
uint32_t cur_prd_len; uint32_t cur_prd_len;
uint8_t unit; uint8_t unit;
BlockDriverCompletionFunc *dma_cb; BlockCompletionFunc *dma_cb;
int64_t sector_num; int64_t sector_num;
uint32_t nsector; uint32_t nsector;
MemoryRegion addr_ioport; MemoryRegion addr_ioport;

2
hw/scsi/scsi-generic.c
View file

@ -143,7 +143,7 @@ done:
static int execute_command(BlockDriverState *bdrv, static int execute_command(BlockDriverState *bdrv,
SCSIGenericReq *r, int direction, SCSIGenericReq *r, int direction,
BlockDriverCompletionFunc *complete) BlockCompletionFunc *complete)
{ {
r->io_header.interface_id = 'S'; r->io_header.interface_id = 'S';
r->io_header.dxfer_direction = direction; r->io_header.dxfer_direction = direction;

6
include/block/aio.h
View file

@ -23,7 +23,7 @@
#include "qemu/timer.h" #include "qemu/timer.h"
typedef struct BlockAIOCB BlockAIOCB; typedef struct BlockAIOCB BlockAIOCB;
typedef void BlockDriverCompletionFunc(void *opaque, int ret); typedef void BlockCompletionFunc(void *opaque, int ret);
typedef struct AIOCBInfo { typedef struct AIOCBInfo {
void (*cancel_async)(BlockAIOCB *acb); void (*cancel_async)(BlockAIOCB *acb);
@ -34,13 +34,13 @@ typedef struct AIOCBInfo {
struct BlockAIOCB { struct BlockAIOCB {
const AIOCBInfo *aiocb_info; const AIOCBInfo *aiocb_info;
BlockDriverState *bs; BlockDriverState *bs;
BlockDriverCompletionFunc *cb; BlockCompletionFunc *cb;
void *opaque; void *opaque;
int refcnt; int refcnt;
}; };
void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
void qemu_aio_unref(void *p); void qemu_aio_unref(void *p);
void qemu_aio_ref(void *p); void qemu_aio_ref(void *p);

14
include/block/block.h
View file

@ -250,7 +250,7 @@ int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, BdrvRequestFlags flags); int nb_sectors, BdrvRequestFlags flags);
BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num, BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, BdrvRequestFlags flags, int nb_sectors, BdrvRequestFlags flags,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags); int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags);
int bdrv_pread(BlockDriverState *bs, int64_t offset, int bdrv_pread(BlockDriverState *bs, int64_t offset,
void *buf, int count); void *buf, int count);
@ -328,15 +328,15 @@ typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
int sector_num); int sector_num);
BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
QEMUIOVector *iov, int nb_sectors, QEMUIOVector *iov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
QEMUIOVector *iov, int nb_sectors, QEMUIOVector *iov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs, BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs, BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int64_t sector_num, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
void bdrv_aio_cancel(BlockAIOCB *acb); void bdrv_aio_cancel(BlockAIOCB *acb);
void bdrv_aio_cancel_async(BlockAIOCB *acb); void bdrv_aio_cancel_async(BlockAIOCB *acb);
@ -346,7 +346,7 @@ typedef struct BlockRequest {
int nb_sectors; int nb_sectors;
int flags; int flags;
QEMUIOVector *qiov; QEMUIOVector *qiov;
BlockDriverCompletionFunc *cb; BlockCompletionFunc *cb;
void *opaque; void *opaque;
/* Filled by multiwrite implementation */ /* Filled by multiwrite implementation */
@ -360,7 +360,7 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf); int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
unsigned long int req, void *buf, unsigned long int req, void *buf,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
/* Invalidate any cached metadata used by image formats */ /* Invalidate any cached metadata used by image formats */
void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp); void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp);

20
include/block/block_int.h
View file

@ -130,15 +130,15 @@ struct BlockDriver {
/* aio */ /* aio */
BlockAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs, BlockAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
BlockAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs, BlockAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs, BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
BlockAIOCB *(*bdrv_aio_discard)(BlockDriverState *bs, BlockAIOCB *(*bdrv_aio_discard)(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int64_t sector_num, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs, int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, QEMUIOVector *qiov); int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
@ -220,7 +220,7 @@ struct BlockDriver {
int (*bdrv_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf); int (*bdrv_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf);
BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs, BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs,
unsigned long int req, void *buf, unsigned long int req, void *buf,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
/* List of options for creating images, terminated by name == NULL */ /* List of options for creating images, terminated by name == NULL */
QemuOptsList *create_opts; QemuOptsList *create_opts;
@ -501,7 +501,7 @@ int is_windows_drive(const char *filename);
*/ */
void stream_start(BlockDriverState *bs, BlockDriverState *base, void stream_start(BlockDriverState *bs, BlockDriverState *base,
const char *base_id, int64_t speed, BlockdevOnError on_error, const char *base_id, int64_t speed, BlockdevOnError on_error,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, Error **errp); void *opaque, Error **errp);
/** /**
@ -519,7 +519,7 @@ void stream_start(BlockDriverState *bs, BlockDriverState *base,
*/ */
void commit_start(BlockDriverState *bs, BlockDriverState *base, void commit_start(BlockDriverState *bs, BlockDriverState *base,
BlockDriverState *top, int64_t speed, BlockDriverState *top, int64_t speed,
BlockdevOnError on_error, BlockDriverCompletionFunc *cb, BlockdevOnError on_error, BlockCompletionFunc *cb,
void *opaque, const char *backing_file_str, Error **errp); void *opaque, const char *backing_file_str, Error **errp);
/** /**
* commit_active_start: * commit_active_start:
@ -535,7 +535,7 @@ void commit_start(BlockDriverState *bs, BlockDriverState *base,
void commit_active_start(BlockDriverState *bs, BlockDriverState *base, void commit_active_start(BlockDriverState *bs, BlockDriverState *base,
int64_t speed, int64_t speed,
BlockdevOnError on_error, BlockdevOnError on_error,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, Error **errp); void *opaque, Error **errp);
/* /*
* mirror_start: * mirror_start:
@ -563,7 +563,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target,
int64_t speed, int64_t granularity, int64_t buf_size, int64_t speed, int64_t granularity, int64_t buf_size,
MirrorSyncMode mode, BlockdevOnError on_source_error, MirrorSyncMode mode, BlockdevOnError on_source_error,
BlockdevOnError on_target_error, BlockdevOnError on_target_error,
BlockDriverCompletionFunc *cb, BlockCompletionFunc *cb,
void *opaque, Error **errp); void *opaque, Error **errp);
/* /*
@ -584,7 +584,7 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
int64_t speed, MirrorSyncMode sync_mode, int64_t speed, MirrorSyncMode sync_mode,
BlockdevOnError on_source_error, BlockdevOnError on_source_error,
BlockdevOnError on_target_error, BlockdevOnError on_target_error,
BlockDriverCompletionFunc *cb, void *opaque, BlockCompletionFunc *cb, void *opaque,
Error **errp); Error **errp);
#endif /* BLOCK_INT_H */ #endif /* BLOCK_INT_H */

4
include/block/blockjob.h
View file

@ -104,7 +104,7 @@ struct BlockJob {
int64_t speed; int64_t speed;
/** The completion function that will be called when the job completes. */ /** The completion function that will be called when the job completes. */
BlockDriverCompletionFunc *cb; BlockCompletionFunc *cb;
/** Block other operations when block job is running */ /** Block other operations when block job is running */
Error *blocker; Error *blocker;
@ -132,7 +132,7 @@ struct BlockJob {
* called from a wrapper that is specific to the job type. * called from a wrapper that is specific to the job type.
*/ */
void *block_job_create(const BlockJobDriver *driver, BlockDriverState *bs, void *block_job_create(const BlockJobDriver *driver, BlockDriverState *bs,
int64_t speed, BlockDriverCompletionFunc *cb, int64_t speed, BlockCompletionFunc *cb,
void *opaque, Error **errp); void *opaque, Error **errp);
/** /**

2
include/block/thread-pool.h
View file

@ -29,7 +29,7 @@ void thread_pool_free(ThreadPool *pool);
BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool, BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool,
ThreadPoolFunc *func, void *arg, ThreadPoolFunc *func, void *arg,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
int coroutine_fn thread_pool_submit_co(ThreadPool *pool, int coroutine_fn thread_pool_submit_co(ThreadPool *pool,
ThreadPoolFunc *func, void *arg); ThreadPoolFunc *func, void *arg);
void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg); void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg);

4
include/monitor/monitor.h
View file

@ -27,10 +27,10 @@ int monitor_suspend(Monitor *mon);
void monitor_resume(Monitor *mon); void monitor_resume(Monitor *mon);
int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs, int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
BlockDriverCompletionFunc *completion_cb, BlockCompletionFunc *completion_cb,
void *opaque); void *opaque);
int monitor_read_block_device_key(Monitor *mon, const char *device, int monitor_read_block_device_key(Monitor *mon, const char *device,
BlockDriverCompletionFunc *completion_cb, BlockCompletionFunc *completion_cb,
void *opaque); void *opaque);
int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp); int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp);

8
include/sysemu/dma.h
View file

@ -199,18 +199,18 @@ void qemu_sglist_destroy(QEMUSGList *qsg);
typedef BlockAIOCB *DMAIOFunc(BlockDriverState *bs, int64_t sector_num, typedef BlockAIOCB *DMAIOFunc(BlockDriverState *bs, int64_t sector_num,
QEMUIOVector *iov, int nb_sectors, QEMUIOVector *iov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
BlockAIOCB *dma_bdrv_io(BlockDriverState *bs, BlockAIOCB *dma_bdrv_io(BlockDriverState *bs,
QEMUSGList *sg, uint64_t sector_num, QEMUSGList *sg, uint64_t sector_num,
DMAIOFunc *io_func, BlockDriverCompletionFunc *cb, DMAIOFunc *io_func, BlockCompletionFunc *cb,
void *opaque, DMADirection dir); void *opaque, DMADirection dir);
BlockAIOCB *dma_bdrv_read(BlockDriverState *bs, BlockAIOCB *dma_bdrv_read(BlockDriverState *bs,
QEMUSGList *sg, uint64_t sector, QEMUSGList *sg, uint64_t sector,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
BlockAIOCB *dma_bdrv_write(BlockDriverState *bs, BlockAIOCB *dma_bdrv_write(BlockDriverState *bs,
QEMUSGList *sg, uint64_t sector, QEMUSGList *sg, uint64_t sector,
BlockDriverCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
uint64_t dma_buf_read(uint8_t *ptr, int32_t len, QEMUSGList *sg); uint64_t dma_buf_read(uint8_t *ptr, int32_t len, QEMUSGList *sg);
uint64_t dma_buf_write(uint8_t *ptr, int32_t len, QEMUSGList *sg); uint64_t dma_buf_write(uint8_t *ptr, int32_t len, QEMUSGList *sg);

6
monitor.c
View file

@ -206,7 +206,7 @@ struct Monitor {
ReadLineState *rs; ReadLineState *rs;
MonitorControl *mc; MonitorControl *mc;
CPUState *mon_cpu; CPUState *mon_cpu;
BlockDriverCompletionFunc *password_completion_cb; BlockCompletionFunc *password_completion_cb;
void *password_opaque; void *password_opaque;
mon_cmd_t *cmd_table; mon_cmd_t *cmd_table;
QError *error; QError *error;
@ -5374,7 +5374,7 @@ ReadLineState *monitor_get_rs(Monitor *mon)
} }
int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs, int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
BlockDriverCompletionFunc *completion_cb, BlockCompletionFunc *completion_cb,
void *opaque) void *opaque)
{ {
int err; int err;
@ -5406,7 +5406,7 @@ int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
} }
int monitor_read_block_device_key(Monitor *mon, const char *device, int monitor_read_block_device_key(Monitor *mon, const char *device,
BlockDriverCompletionFunc *completion_cb, BlockCompletionFunc *completion_cb,
void *opaque) void *opaque)
{ {
BlockDriverState *bs; BlockDriverState *bs;

2
thread-pool.c
View file

@ -235,7 +235,7 @@ static const AIOCBInfo thread_pool_aiocb_info = {
BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool, BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool,
ThreadPoolFunc *func, void *arg, ThreadPoolFunc *func, void *arg,
BlockDriverCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
ThreadPoolElement *req; ThreadPoolElement *req;