diff options
Diffstat (limited to 'block.c')
| -rw-r--r-- | block.c | 390 |
1 files changed, 137 insertions, 253 deletions
diff --git a/block.c b/block.c index 27533f3a81..773e87ef08 100644 --- a/block.c +++ b/block.c @@ -28,8 +28,8 @@ #include "block/blockjob.h" #include "qemu/module.h" #include "qapi/qmp/qjson.h" +#include "sysemu/block-backend.h" #include "sysemu/sysemu.h" -#include "sysemu/blockdev.h" /* FIXME layering violation */ #include "qemu/notify.h" #include "block/coroutine.h" #include "block/qapi.h" @@ -58,15 +58,12 @@ struct BdrvDirtyBitmap { #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ -#define COROUTINE_POOL_RESERVATION 64 /* number of coroutines to reserve */ - -static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load); -static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, +static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); -static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, + BlockCompletionFunc *cb, void *opaque); +static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, 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, int64_t sector_num, int nb_sectors, QEMUIOVector *iov); @@ -79,14 +76,14 @@ static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs, static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, int64_t offset, unsigned int bytes, QEMUIOVector *qiov, BdrvRequestFlags flags); -static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BdrvRequestFlags flags, - BlockDriverCompletionFunc *cb, - void *opaque, - bool is_write); +static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BdrvRequestFlags flags, + BlockCompletionFunc *cb, + void *opaque, + bool is_write); static void coroutine_fn bdrv_co_do_rw(void *opaque); static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BdrvRequestFlags flags); @@ -335,35 +332,21 @@ void bdrv_register(BlockDriver *bdrv) QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list); } -/* create a new block device (by default it is empty) */ -BlockDriverState *bdrv_new(const char *device_name, Error **errp) +BlockDriverState *bdrv_new_root(void) { - BlockDriverState *bs; - int i; + BlockDriverState *bs = bdrv_new(); - if (*device_name && !id_wellformed(device_name)) { - error_setg(errp, "Invalid device name"); - return NULL; - } + QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list); + return bs; +} - if (bdrv_find(device_name)) { - error_setg(errp, "Device with id '%s' already exists", - device_name); - return NULL; - } - if (bdrv_find_node(device_name)) { - error_setg(errp, - "Device name '%s' conflicts with an existing node name", - device_name); - return NULL; - } +BlockDriverState *bdrv_new(void) +{ + BlockDriverState *bs; + int i; bs = g_new0(BlockDriverState, 1); QLIST_INIT(&bs->dirty_bitmaps); - pstrcpy(bs->device_name, sizeof(bs->device_name), device_name); - if (device_name[0] != '\0') { - QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list); - } for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { QLIST_INIT(&bs->op_blockers[i]); } @@ -875,7 +858,7 @@ static void bdrv_assign_node_name(BlockDriverState *bs, } /* takes care of avoiding namespaces collisions */ - if (bdrv_find(node_name)) { + if (blk_by_name(node_name)) { error_setg(errp, "node-name=%s is conflicting with a device id", node_name); return; @@ -1159,7 +1142,7 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd) } else if (backing_hd) { error_setg(&bs->backing_blocker, "device is used as backing hd of '%s'", - bs->device_name); + bdrv_get_device_name(bs)); } bs->backing_hd = backing_hd; @@ -1224,7 +1207,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp) goto free_exit; } - backing_hd = bdrv_new("", errp); + backing_hd = bdrv_new(); if (bs->backing_format[0] != '\0') { back_drv = bdrv_find_format(bs->backing_format); @@ -1353,7 +1336,7 @@ int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp) qdict_put(snapshot_options, "file.filename", qstring_from_str(tmp_filename)); - bs_snapshot = bdrv_new("", &error_abort); + bs_snapshot = bdrv_new(); ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options, flags, bdrv_qcow2, &local_err); @@ -1424,7 +1407,7 @@ int bdrv_open(BlockDriverState **pbs, const char *filename, if (*pbs) { bs = *pbs; } else { - bs = bdrv_new("", &error_abort); + bs = bdrv_new(); } /* NULL means an empty set of options */ @@ -1533,7 +1516,7 @@ int bdrv_open(BlockDriverState **pbs, const char *filename, } else { error_setg(errp, "Block format '%s' used by device '%s' doesn't " "support the option '%s'", drv->format_name, - bs->device_name, entry->key); + bdrv_get_device_name(bs), entry->key); } ret = -EINVAL; @@ -1541,7 +1524,9 @@ int bdrv_open(BlockDriverState **pbs, const char *filename, } if (!bdrv_key_required(bs)) { - bdrv_dev_change_media_cb(bs, true); + if (bs->blk) { + blk_dev_change_media_cb(bs->blk, true); + } } else if (!runstate_check(RUN_STATE_PRELAUNCH) && !runstate_check(RUN_STATE_INMIGRATE) && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */ @@ -1740,7 +1725,7 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue, if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) && reopen_state->flags & BDRV_O_RDWR) { error_set(errp, QERR_DEVICE_IS_READ_ONLY, - reopen_state->bs->device_name); + bdrv_get_device_name(reopen_state->bs)); goto error; } @@ -1767,7 +1752,7 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue, /* It is currently mandatory to have a bdrv_reopen_prepare() * handler for each supported drv. */ error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, - drv->format_name, reopen_state->bs->device_name, + drv->format_name, bdrv_get_device_name(reopen_state->bs), "reopening of file"); ret = -1; goto error; @@ -1866,7 +1851,9 @@ void bdrv_close(BlockDriverState *bs) } } - bdrv_dev_change_media_cb(bs, false); + if (bs->blk) { + blk_dev_change_media_cb(bs->blk, false); + } /*throttling disk I/O limits*/ if (bs->io_limits_enabled) { @@ -1955,10 +1942,17 @@ void bdrv_drain_all(void) Also, NULL terminate the device_name to prevent double remove */ void bdrv_make_anon(BlockDriverState *bs) { - if (bs->device_name[0] != '\0') { + /* + * Take care to remove bs from bdrv_states only when it's actually + * in it. Note that bs->device_list.tqe_prev is initially null, + * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish + * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by + * resetting it to null on remove. + */ + if (bs->device_list.tqe_prev) { QTAILQ_REMOVE(&bdrv_states, bs, device_list); + bs->device_list.tqe_prev = NULL; } - bs->device_name[0] = '\0'; if (bs->node_name[0] != '\0') { QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list); } @@ -1978,9 +1972,6 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, /* move some fields that need to stay attached to the device */ /* dev info */ - bs_dest->dev_ops = bs_src->dev_ops; - bs_dest->dev_opaque = bs_src->dev_opaque; - bs_dest->dev = bs_src->dev; bs_dest->guest_block_size = bs_src->guest_block_size; bs_dest->copy_on_read = bs_src->copy_on_read; @@ -2012,9 +2003,9 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, bs_dest->job = bs_src->job; /* keep the same entry in bdrv_states */ - pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name), - bs_src->device_name); bs_dest->device_list = bs_src->device_list; + bs_dest->blk = bs_src->blk; + memcpy(bs_dest->op_blockers, bs_src->op_blockers, sizeof(bs_dest->op_blockers)); } @@ -2027,7 +2018,7 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, * This will modify the BlockDriverState fields, and swap contents * between bs_new and bs_old. Both bs_new and bs_old are modified. * - * bs_new is required to be anonymous. + * bs_new must not be attached to a BlockBackend. * * This function does not create any image files. */ @@ -2046,11 +2037,10 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list); } - /* bs_new must be anonymous and shouldn't have anything fancy enabled */ - assert(bs_new->device_name[0] == '\0'); + /* bs_new must be unattached and shouldn't have anything fancy enabled */ + assert(!bs_new->blk); assert(QLIST_EMPTY(&bs_new->dirty_bitmaps)); assert(bs_new->job == NULL); - assert(bs_new->dev == NULL); assert(bs_new->io_limits_enabled == false); assert(!throttle_have_timer(&bs_new->throttle_state)); @@ -2063,11 +2053,10 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) bdrv_move_feature_fields(bs_old, bs_new); bdrv_move_feature_fields(bs_new, &tmp); - /* bs_new shouldn't be in bdrv_states even after the swap! */ - assert(bs_new->device_name[0] == '\0'); + /* bs_new must remain unattached */ + assert(!bs_new->blk); /* Check a few fields that should remain attached to the device */ - assert(bs_new->dev == NULL); assert(bs_new->job == NULL); assert(bs_new->io_limits_enabled == false); assert(!throttle_have_timer(&bs_new->throttle_state)); @@ -2091,7 +2080,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) * This will modify the BlockDriverState fields, and swap contents * between bs_new and bs_top. Both bs_new and bs_top are modified. * - * bs_new is required to be anonymous. + * bs_new must not be attached to a BlockBackend. * * This function does not create any image files. */ @@ -2106,7 +2095,6 @@ void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top) static void bdrv_delete(BlockDriverState *bs) { - assert(!bs->dev); assert(!bs->job); assert(bdrv_op_blocker_is_empty(bs)); assert(!bs->refcnt); @@ -2117,109 +2105,9 @@ static void bdrv_delete(BlockDriverState *bs) /* remove from list, if necessary */ bdrv_make_anon(bs); - drive_info_del(drive_get_by_blockdev(bs)); g_free(bs); } -int bdrv_attach_dev(BlockDriverState *bs, void *dev) -/* TODO change to DeviceState *dev when all users are qdevified */ -{ - if (bs->dev) { - return -EBUSY; - } - bs->dev = dev; - bdrv_iostatus_reset(bs); - - /* We're expecting I/O from the device so bump up coroutine pool size */ - qemu_coroutine_adjust_pool_size(COROUTINE_POOL_RESERVATION); - return 0; -} - -/* TODO qdevified devices don't use this, remove when devices are qdevified */ -void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev) -{ - if (bdrv_attach_dev(bs, dev) < 0) { - abort(); - } -} - -void bdrv_detach_dev(BlockDriverState *bs, void *dev) -/* TODO change to DeviceState *dev when all users are qdevified */ -{ - assert(bs->dev == dev); - bs->dev = NULL; - bs->dev_ops = NULL; - bs->dev_opaque = NULL; - bs->guest_block_size = 512; - qemu_coroutine_adjust_pool_size(-COROUTINE_POOL_RESERVATION); -} - -/* TODO change to return DeviceState * when all users are qdevified */ -void *bdrv_get_attached_dev(BlockDriverState *bs) -{ - return bs->dev; -} - -void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops, - void *opaque) -{ - bs->dev_ops = ops; - bs->dev_opaque = opaque; -} - -static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load) -{ - if (bs->dev_ops && bs->dev_ops->change_media_cb) { - bool tray_was_closed = !bdrv_dev_is_tray_open(bs); - bs->dev_ops->change_media_cb(bs->dev_opaque, load); - if (tray_was_closed) { - /* tray open */ - qapi_event_send_device_tray_moved(bdrv_get_device_name(bs), - true, &error_abort); - } - if (load) { - /* tray close */ - qapi_event_send_device_tray_moved(bdrv_get_device_name(bs), - false, &error_abort); - } - } -} - -bool bdrv_dev_has_removable_media(BlockDriverState *bs) -{ - return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb); -} - -void bdrv_dev_eject_request(BlockDriverState *bs, bool force) -{ - if (bs->dev_ops && bs->dev_ops->eject_request_cb) { - bs->dev_ops->eject_request_cb(bs->dev_opaque, force); - } -} - -bool bdrv_dev_is_tray_open(BlockDriverState *bs) -{ - if (bs->dev_ops && bs->dev_ops->is_tray_open) { - return bs->dev_ops->is_tray_open(bs->dev_opaque); - } - return false; -} - -static void bdrv_dev_resize_cb(BlockDriverState *bs) -{ - if (bs->dev_ops && bs->dev_ops->resize_cb) { - bs->dev_ops->resize_cb(bs->dev_opaque); - } -} - -bool bdrv_dev_is_medium_locked(BlockDriverState *bs) -{ - if (bs->dev_ops && bs->dev_ops->is_medium_locked) { - return bs->dev_ops->is_medium_locked(bs->dev_opaque); - } - return false; -} - /* * Run consistency checks on an image * @@ -3553,7 +3441,9 @@ int bdrv_truncate(BlockDriverState *bs, int64_t offset) ret = drv->bdrv_truncate(bs, offset); if (ret == 0) { ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS); - bdrv_dev_resize_cb(bs); + if (bs->blk) { + blk_dev_resize_cb(bs->blk); + } } return ret; } @@ -3754,8 +3644,10 @@ int bdrv_set_key(BlockDriverState *bs, const char *key) bs->valid_key = 0; } else if (!bs->valid_key) { bs->valid_key = 1; - /* call the change callback now, we skipped it on open */ - bdrv_dev_change_media_cb(bs, true); + if (bs->blk) { + /* call the change callback now, we skipped it on open */ + blk_dev_change_media_cb(bs->blk, true); + } } return ret; } @@ -3803,16 +3695,12 @@ void bdrv_iterate_format(void (*it)(void *opaque, const char *name), } /* This function is to find block backend bs */ +/* TODO convert callers to blk_by_name(), then remove */ BlockDriverState *bdrv_find(const char *name) { - BlockDriverState *bs; + BlockBackend *blk = blk_by_name(name); - QTAILQ_FOREACH(bs, &bdrv_states, device_list) { - if (!strcmp(name, bs->device_name)) { - return bs; - } - } - return NULL; + return blk ? blk_bs(blk) : NULL; } /* This function is to find a node in the bs graph */ @@ -3851,13 +3739,14 @@ BlockDriverState *bdrv_lookup_bs(const char *device, const char *node_name, Error **errp) { - BlockDriverState *bs = NULL; + BlockBackend *blk; + BlockDriverState *bs; if (device) { - bs = bdrv_find(device); + blk = blk_by_name(device); - if (bs) { - return bs; + if (blk) { + return blk_bs(blk); } } @@ -3894,18 +3783,10 @@ BlockDriverState *bdrv_next(BlockDriverState *bs) return QTAILQ_NEXT(bs, device_list); } -void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque) +/* TODO check what callers really want: bs->node_name or blk_name() */ +const char *bdrv_get_device_name(const BlockDriverState *bs) { - BlockDriverState *bs; - - QTAILQ_FOREACH(bs, &bdrv_states, device_list) { - it(opaque, bs); - } -} - -const char *bdrv_get_device_name(BlockDriverState *bs) -{ - return bs->device_name; + return bs->blk ? blk_name(bs->blk) : ""; } int bdrv_get_flags(BlockDriverState *bs) @@ -4432,9 +4313,9 @@ int bdrv_get_backing_file_depth(BlockDriverState *bs) /**************************************************************/ /* async I/Os */ -BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, - QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) +BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, + QEMUIOVector *qiov, int nb_sectors, + BlockCompletionFunc *cb, void *opaque) { trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque); @@ -4442,9 +4323,9 @@ BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, cb, opaque, false); } -BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, - QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) +BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, + QEMUIOVector *qiov, int nb_sectors, + BlockCompletionFunc *cb, void *opaque) { trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque); @@ -4452,9 +4333,9 @@ BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, cb, opaque, true); } -BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, +BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, 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); @@ -4469,7 +4350,7 @@ typedef struct MultiwriteCB { int num_requests; int num_callbacks; struct { - BlockDriverCompletionFunc *cb; + BlockCompletionFunc *cb; void *opaque; QEMUIOVector *free_qiov; } callbacks[]; @@ -4646,7 +4527,7 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs) return 0; } -void bdrv_aio_cancel(BlockDriverAIOCB *acb) +void bdrv_aio_cancel(BlockAIOCB *acb) { qemu_aio_ref(acb); bdrv_aio_cancel_async(acb); @@ -4665,7 +4546,7 @@ void bdrv_aio_cancel(BlockDriverAIOCB *acb) /* Async version of aio cancel. The caller is not blocked if the acb implements * cancel_async, otherwise we do nothing and let the request normally complete. * In either case the completion callback must be called. */ -void bdrv_aio_cancel_async(BlockDriverAIOCB *acb) +void bdrv_aio_cancel_async(BlockAIOCB *acb) { if (acb->aiocb_info->cancel_async) { acb->aiocb_info->cancel_async(acb); @@ -4675,23 +4556,23 @@ void bdrv_aio_cancel_async(BlockDriverAIOCB *acb) /**************************************************************/ /* async block device emulation */ -typedef struct BlockDriverAIOCBSync { - BlockDriverAIOCB common; +typedef struct BlockAIOCBSync { + BlockAIOCB common; QEMUBH *bh; int ret; /* vector translation state */ QEMUIOVector *qiov; uint8_t *bounce; int is_write; -} BlockDriverAIOCBSync; +} BlockAIOCBSync; static const AIOCBInfo bdrv_em_aiocb_info = { - .aiocb_size = sizeof(BlockDriverAIOCBSync), + .aiocb_size = sizeof(BlockAIOCBSync), }; static void bdrv_aio_bh_cb(void *opaque) { - BlockDriverAIOCBSync *acb = opaque; + BlockAIOCBSync *acb = opaque; if (!acb->is_write && acb->ret >= 0) { qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); @@ -4703,16 +4584,16 @@ static void bdrv_aio_bh_cb(void *opaque) qemu_aio_unref(acb); } -static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque, - int is_write) +static BlockAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BlockCompletionFunc *cb, + void *opaque, + int is_write) { - BlockDriverAIOCBSync *acb; + BlockAIOCBSync *acb; acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque); acb->is_write = is_write; @@ -4734,36 +4615,36 @@ static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, return &acb->common; } -static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, +static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, 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); } -static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, +static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, 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); } -typedef struct BlockDriverAIOCBCoroutine { - BlockDriverAIOCB common; +typedef struct BlockAIOCBCoroutine { + BlockAIOCB common; BlockRequest req; bool is_write; bool *done; QEMUBH* bh; -} BlockDriverAIOCBCoroutine; +} BlockAIOCBCoroutine; static const AIOCBInfo bdrv_em_co_aiocb_info = { - .aiocb_size = sizeof(BlockDriverAIOCBCoroutine), + .aiocb_size = sizeof(BlockAIOCBCoroutine), }; static void bdrv_co_em_bh(void *opaque) { - BlockDriverAIOCBCoroutine *acb = opaque; + BlockAIOCBCoroutine *acb = opaque; acb->common.cb(acb->common.opaque, acb->req.error); @@ -4774,7 +4655,7 @@ static void bdrv_co_em_bh(void *opaque) /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */ static void coroutine_fn bdrv_co_do_rw(void *opaque) { - BlockDriverAIOCBCoroutine *acb = opaque; + BlockAIOCBCoroutine *acb = opaque; BlockDriverState *bs = acb->common.bs; if (!acb->is_write) { @@ -4789,17 +4670,17 @@ static void coroutine_fn bdrv_co_do_rw(void *opaque) qemu_bh_schedule(acb->bh); } -static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BdrvRequestFlags flags, - BlockDriverCompletionFunc *cb, - void *opaque, - bool is_write) +static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BdrvRequestFlags flags, + BlockCompletionFunc *cb, + void *opaque, + bool is_write) { Coroutine *co; - BlockDriverAIOCBCoroutine *acb; + BlockAIOCBCoroutine *acb; acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque); acb->req.sector = sector_num; @@ -4816,7 +4697,7 @@ static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque) { - BlockDriverAIOCBCoroutine *acb = opaque; + BlockAIOCBCoroutine *acb = opaque; BlockDriverState *bs = acb->common.bs; acb->req.error = bdrv_co_flush(bs); @@ -4824,13 +4705,13 @@ static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque) qemu_bh_schedule(acb->bh); } -BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque) +BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs, + BlockCompletionFunc *cb, void *opaque) { trace_bdrv_aio_flush(bs, opaque); Coroutine *co; - BlockDriverAIOCBCoroutine *acb; + BlockAIOCBCoroutine *acb; acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque); @@ -4842,7 +4723,7 @@ BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque) { - BlockDriverAIOCBCoroutine *acb = opaque; + BlockAIOCBCoroutine *acb = opaque; BlockDriverState *bs = acb->common.bs; acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors); @@ -4850,12 +4731,12 @@ static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque) qemu_bh_schedule(acb->bh); } -BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs, +BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { Coroutine *co; - BlockDriverAIOCBCoroutine *acb; + BlockAIOCBCoroutine *acb; trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque); @@ -4880,9 +4761,9 @@ void bdrv_init_with_whitelist(void) } void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { - BlockDriverAIOCB *acb; + BlockAIOCB *acb; acb = g_slice_alloc(aiocb_info->aiocb_size); acb->aiocb_info = aiocb_info; @@ -4895,13 +4776,13 @@ void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, void qemu_aio_ref(void *p) { - BlockDriverAIOCB *acb = p; + BlockAIOCB *acb = p; acb->refcnt++; } void qemu_aio_unref(void *p) { - BlockDriverAIOCB *acb = p; + BlockAIOCB *acb = p; assert(acb->refcnt > 0); if (--acb->refcnt == 0) { g_slice_free1(acb->aiocb_info->aiocb_size, acb); @@ -4931,7 +4812,7 @@ static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num, CoroutineIOCompletion co = { .coroutine = qemu_coroutine_self(), }; - BlockDriverAIOCB *acb; + BlockAIOCB *acb; if (is_write) { acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors, @@ -4997,7 +4878,7 @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs) if (bs->drv->bdrv_co_flush_to_disk) { ret = bs->drv->bdrv_co_flush_to_disk(bs); } else if (bs->drv->bdrv_aio_flush) { - BlockDriverAIOCB *acb; + BlockAIOCB *acb; CoroutineIOCompletion co = { .coroutine = qemu_coroutine_self(), }; @@ -5172,7 +5053,7 @@ int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, if (bs->drv->bdrv_co_discard) { ret = bs->drv->bdrv_co_discard(bs, sector_num, num); } else { - BlockDriverAIOCB *acb; + BlockAIOCB *acb; CoroutineIOCompletion co = { .coroutine = qemu_coroutine_self(), }; @@ -5259,13 +5140,15 @@ int bdrv_media_changed(BlockDriverState *bs) void bdrv_eject(BlockDriverState *bs, bool eject_flag) { BlockDriver *drv = bs->drv; + const char *device_name; if (drv && drv->bdrv_eject) { drv->bdrv_eject(bs, eject_flag); } - if (bs->device_name[0] != '\0') { - qapi_event_send_device_tray_moved(bdrv_get_device_name(bs), + device_name = bdrv_get_device_name(bs); + if (device_name[0] != '\0') { + qapi_event_send_device_tray_moved(device_name, eject_flag, &error_abort); } } @@ -5296,9 +5179,9 @@ int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) return -ENOTSUP; } -BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, +BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BlockDriver *drv = bs->drv; @@ -5475,7 +5358,8 @@ bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp) blocker = QLIST_FIRST(&bs->op_blockers[op]); if (errp) { error_setg(errp, "Device '%s' is busy: %s", - bs->device_name, error_get_pretty(blocker->reason)); + bdrv_get_device_name(bs), + error_get_pretty(blocker->reason)); } return true; } |