openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Block patches 

-----BEGIN PGP SIGNATURE-----
 Version: GnuPG v2.0.22 (GNU/Linux)
 
 iQIcBAABAgAGBQJURPo5AAoJEH8JsnLIjy/WK1gP/2PhKD4lsjQ0O9TYlwu2aWCc
 eej/z2wp47996KAkhRgS4mf/E0FnPSh80cHV1wobPJfRSTPPNuGgrmhX+HLcjlPz
 fWb3qN6Ikneou1TYCO/r1wMwhPpE1GKjZmuHQcH3B27GW5cqx/s1sPCxqwDJJnYq
 oBbbcIGZGNYLHlyJvl88gBTkIHBs5/nxhzVnPnpQi6JqtGz8CAbo6e36A5RQCqyV
 RoYEe5Lif81lZpaTpYFsoUhOcH9YtQnKoUSdAnqtXtLO9fOHsn7/75hnmT4bs5CR
 p6UAiutN+jiUcRrlF//TK5TNlS7KvOAf+LirEURAY0j5IJNXh30/5x8hXzHJxb60
 eY6ePrhnbkPeLfg1Qh/7LJyi/W0cl2YN6I2oslnMUfcumu9Ns1FfsFrFpKtgT/yM
 fkjQEo7w9khKT+iZaOm1XaNDliUKZiG2wLhni6KYAGM2edmE8W7VCkjSTFcz/4eQ
 vn7G3T1OnglW1cSt0onTAKNWn2swh0lXOXv7iBupmiNoy+hafNwTa1eHw+jjvXeF
 3WdfMxT6fRKAQUC/hwVlvyeJcZyBMG11BuovX9gNgdx5/UpWJFjxHsEmbiP9TtkO
 CJ5dGi+PgM/fxLJj4IW0zSVSL+mnhQmQdtzksU+l4GBHuErXdkt9W61sOHHQJGTf
 NGIkh6DwV4VfFZd6bzf0
 =8BaC
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging

Block patches

# gpg: Signature made Mon 20 Oct 2014 13:04:09 BST using RSA key ID C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>"

* remotes/kevin/tags/for-upstream: (28 commits)
  block: Make device model's references to BlockBackend strong
  block: Lift device model API into BlockBackend
  blockdev: Convert qmp_eject(), qmp_change_blockdev() to BlockBackend
  block/qapi: Convert qmp_query_block() to BlockBackend
  blockdev: Fix blockdev-add not to create DriveInfo
  blockdev: Drop superfluous DriveInfo member id
  pc87312: Drop unused members of PC87312State
  ide: Complete conversion from BlockDriverState to BlockBackend
  hw: Convert from BlockDriverState to BlockBackend, mostly
  virtio-blk: Rename VirtIOBlkConf variables to conf
  virtio-blk: Drop redundant VirtIOBlock member conf
  block: Rename BlockDriverCompletionFunc to BlockCompletionFunc
  block: Rename BlockDriverAIOCB* to BlockAIOCB*
  block: Eliminate DriveInfo member bdrv, use blk_by_legacy_dinfo()
  block: Merge BlockBackend and BlockDriverState name spaces
  block: Eliminate BlockDriverState member device_name[]
  block: Eliminate bdrv_iterate(), use bdrv_next()
  blockdev: Eliminate drive_del()
  block: Make BlockBackend own its BlockDriverState
  block: Code motion to get rid of stubs/blockdev.c
  ...

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2014-10-22 16:39:49 +01:00
parent 895b810c12 84ebe3755f
commit 8f4699d873
171 changed files with 2414 additions and 1737 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
block-migration.c
View File

@ -14,7 +14,9 @@
*/ */
#include "qemu-common.h" #include "qemu-common.h"
#include "block/block_int.h" #include "block/block.h"
#include "qemu/error-report.h"
#include "qemu/main-loop.h"
#include "hw/hw.h" #include "hw/hw.h"
#include "qemu/queue.h" #include "qemu/queue.h"
#include "qemu/timer.h" #include "qemu/timer.h"
@ -70,7 +72,7 @@ typedef struct BlkMigBlock {
int nr_sectors; int nr_sectors;
struct iovec iov; struct iovec iov;
QEMUIOVector qiov; QEMUIOVector qiov;
BlockDriverAIOCB *aiocb; BlockAIOCB *aiocb;
/* Protected by block migration lock. */ /* Protected by block migration lock. */
int ret; int ret;
@ -130,9 +132,9 @@ static void blk_send(QEMUFile *f, BlkMigBlock * blk)
| flags); | flags);
/* device name */ /* device name */
len = strlen(blk->bmds->bs->device_name); len = strlen(bdrv_get_device_name(blk->bmds->bs));
qemu_put_byte(f, len); qemu_put_byte(f, len);
qemu_put_buffer(f, (uint8_t *)blk->bmds->bs->device_name, len); qemu_put_buffer(f, (uint8_t *)bdrv_get_device_name(blk->bmds->bs), len);
/* if a block is zero we need to flush here since the network /* if a block is zero we need to flush here since the network
* bandwidth is now a lot higher than the storage device bandwidth. * bandwidth is now a lot higher than the storage device bandwidth.
@ -343,12 +345,25 @@ static void unset_dirty_tracking(void)
} }
} }
static void init_blk_migration_it(void *opaque, BlockDriverState *bs) static void init_blk_migration(QEMUFile *f)
{ {
BlockDriverState *bs;
BlkMigDevState *bmds; BlkMigDevState *bmds;
int64_t sectors; int64_t sectors;
if (!bdrv_is_read_only(bs)) { block_mig_state.submitted = 0;
block_mig_state.read_done = 0;
block_mig_state.transferred = 0;
block_mig_state.total_sector_sum = 0;
block_mig_state.prev_progress = -1;
block_mig_state.bulk_completed = 0;
block_mig_state.zero_blocks = migrate_zero_blocks();
for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) {
if (bdrv_is_read_only(bs)) {
continue;
}
sectors = bdrv_nb_sectors(bs); sectors = bdrv_nb_sectors(bs);
if (sectors <= 0) { if (sectors <= 0) {
return; return;
@ -369,28 +384,15 @@ static void init_blk_migration_it(void *opaque, BlockDriverState *bs)
if (bmds->shared_base) { if (bmds->shared_base) {
DPRINTF("Start migration for %s with shared base image\n", DPRINTF("Start migration for %s with shared base image\n",
bs->device_name); bdrv_get_device_name(bs));
} else { } else {
DPRINTF("Start full migration for %s\n", bs->device_name); DPRINTF("Start full migration for %s\n", bdrv_get_device_name(bs));
} }
QSIMPLEQ_INSERT_TAIL(&block_mig_state.bmds_list, bmds, entry); QSIMPLEQ_INSERT_TAIL(&block_mig_state.bmds_list, bmds, entry);
} }
} }
static void init_blk_migration(QEMUFile *f)
{
block_mig_state.submitted = 0;
block_mig_state.read_done = 0;
block_mig_state.transferred = 0;
block_mig_state.total_sector_sum = 0;
block_mig_state.prev_progress = -1;
block_mig_state.bulk_completed = 0;
block_mig_state.zero_blocks = migrate_zero_blocks();
bdrv_iterate(init_blk_migration_it, NULL);
}
/* Called with no lock taken. */ /* Called with no lock taken. */
static int blk_mig_save_bulked_block(QEMUFile *f) static int blk_mig_save_bulked_block(QEMUFile *f)

390
block.c
View File

@ -28,8 +28,8 @@
#include "block/blockjob.h" #include "block/blockjob.h"
#include "qemu/module.h" #include "qemu/module.h"
#include "qapi/qmp/qjson.h" #include "qapi/qmp/qjson.h"
#include "sysemu/block-backend.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "sysemu/blockdev.h" /* FIXME layering violation */
#include "qemu/notify.h" #include "qemu/notify.h"
#include "block/coroutine.h" #include "block/coroutine.h"
#include "block/qapi.h" #include "block/qapi.h"
@ -58,15 +58,12 @@ struct BdrvDirtyBitmap {
#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
#define COROUTINE_POOL_RESERVATION 64 /* number of coroutines to reserve */ static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
static BlockDriverAIOCB *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 BlockDriverAIOCB *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);
@ -79,14 +76,14 @@ static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
int64_t offset, unsigned int bytes, QEMUIOVector *qiov, int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
BdrvRequestFlags flags); BdrvRequestFlags flags);
static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
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);
static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, BdrvRequestFlags flags); 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); QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
} }
/* create a new block device (by default it is empty) */ BlockDriverState *bdrv_new_root(void)
BlockDriverState *bdrv_new(const char *device_name, Error **errp) {
BlockDriverState *bs = bdrv_new();
QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
return bs;
}
BlockDriverState *bdrv_new(void)
{ {
BlockDriverState *bs; BlockDriverState *bs;
int i; int i;
if (*device_name && !id_wellformed(device_name)) {
error_setg(errp, "Invalid device name");
return NULL;
}
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;
}
bs = g_new0(BlockDriverState, 1); bs = g_new0(BlockDriverState, 1);
QLIST_INIT(&bs->dirty_bitmaps); 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++) { for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
QLIST_INIT(&bs->op_blockers[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 */ /* 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", error_setg(errp, "node-name=%s is conflicting with a device id",
node_name); node_name);
return; return;
@ -1159,7 +1142,7 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
} else if (backing_hd) { } else if (backing_hd) {
error_setg(&bs->backing_blocker, error_setg(&bs->backing_blocker,
"device is used as backing hd of '%s'", "device is used as backing hd of '%s'",
bs->device_name); bdrv_get_device_name(bs));
} }
bs->backing_hd = backing_hd; bs->backing_hd = backing_hd;
@ -1224,7 +1207,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
goto free_exit; goto free_exit;
} }
backing_hd = bdrv_new("", errp); backing_hd = bdrv_new();
if (bs->backing_format[0] != '\0') { if (bs->backing_format[0] != '\0') {
back_drv = bdrv_find_format(bs->backing_format); 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", qdict_put(snapshot_options, "file.filename",
qstring_from_str(tmp_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, ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
flags, bdrv_qcow2, &local_err); flags, bdrv_qcow2, &local_err);
@ -1424,7 +1407,7 @@ int bdrv_open(BlockDriverState **pbs, const char *filename,
if (*pbs) { if (*pbs) {
bs = *pbs; bs = *pbs;
} else { } else {
bs = bdrv_new("", &error_abort); bs = bdrv_new();
} }
/* NULL means an empty set of options */ /* NULL means an empty set of options */
@ -1533,7 +1516,7 @@ int bdrv_open(BlockDriverState **pbs, const char *filename,
} else { } else {
error_setg(errp, "Block format '%s' used by device '%s' doesn't " error_setg(errp, "Block format '%s' used by device '%s' doesn't "
"support the option '%s'", drv->format_name, "support the option '%s'", drv->format_name,
bs->device_name, entry->key); bdrv_get_device_name(bs), entry->key);
} }
ret = -EINVAL; ret = -EINVAL;
@ -1541,7 +1524,9 @@ int bdrv_open(BlockDriverState **pbs, const char *filename,
} }
if (!bdrv_key_required(bs)) { 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) } else if (!runstate_check(RUN_STATE_PRELAUNCH)
&& !runstate_check(RUN_STATE_INMIGRATE) && !runstate_check(RUN_STATE_INMIGRATE)
&& !runstate_check(RUN_STATE_PAUSED)) { /* HACK */ && !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) && if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
reopen_state->flags & BDRV_O_RDWR) { reopen_state->flags & BDRV_O_RDWR) {
error_set(errp, QERR_DEVICE_IS_READ_ONLY, error_set(errp, QERR_DEVICE_IS_READ_ONLY,
reopen_state->bs->device_name); bdrv_get_device_name(reopen_state->bs));
goto error; 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() /* It is currently mandatory to have a bdrv_reopen_prepare()
* handler for each supported drv. */ * handler for each supported drv. */
error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, 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"); "reopening of file");
ret = -1; ret = -1;
goto error; 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*/ /*throttling disk I/O limits*/
if (bs->io_limits_enabled) { if (bs->io_limits_enabled) {
@ -1955,10 +1942,17 @@ void bdrv_drain_all(void)
Also, NULL terminate the device_name to prevent double remove */ Also, NULL terminate the device_name to prevent double remove */
void bdrv_make_anon(BlockDriverState *bs) 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); QTAILQ_REMOVE(&bdrv_states, bs, device_list);
bs->device_list.tqe_prev = NULL;
} }
bs->device_name[0] = '\0';
if (bs->node_name[0] != '\0') { if (bs->node_name[0] != '\0') {
QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list); 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 */ /* move some fields that need to stay attached to the device */
/* dev info */ /* 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->guest_block_size = bs_src->guest_block_size;
bs_dest->copy_on_read = bs_src->copy_on_read; 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; bs_dest->job = bs_src->job;
/* keep the same entry in bdrv_states */ /* 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->device_list = bs_src->device_list;
bs_dest->blk = bs_src->blk;
memcpy(bs_dest->op_blockers, bs_src->op_blockers, memcpy(bs_dest->op_blockers, bs_src->op_blockers,
sizeof(bs_dest->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 * This will modify the BlockDriverState fields, and swap contents
* between bs_new and bs_old. Both bs_new and bs_old are modified. * 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. * 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); QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
} }
/* bs_new must be anonymous and shouldn't have anything fancy enabled */ /* bs_new must be unattached and shouldn't have anything fancy enabled */
assert(bs_new->device_name[0] == '\0'); assert(!bs_new->blk);
assert(QLIST_EMPTY(&bs_new->dirty_bitmaps)); assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
assert(bs_new->job == NULL); assert(bs_new->job == NULL);
assert(bs_new->dev == NULL);
assert(bs_new->io_limits_enabled == false); assert(bs_new->io_limits_enabled == false);
assert(!throttle_have_timer(&bs_new->throttle_state)); 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_old, bs_new);
bdrv_move_feature_fields(bs_new, &tmp); bdrv_move_feature_fields(bs_new, &tmp);
/* bs_new shouldn't be in bdrv_states even after the swap! */ /* bs_new must remain unattached */
assert(bs_new->device_name[0] == '\0'); assert(!bs_new->blk);
/* Check a few fields that should remain attached to the device */ /* Check a few fields that should remain attached to the device */
assert(bs_new->dev == NULL);
assert(bs_new->job == NULL); assert(bs_new->job == NULL);
assert(bs_new->io_limits_enabled == false); assert(bs_new->io_limits_enabled == false);
assert(!throttle_have_timer(&bs_new->throttle_state)); 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 * This will modify the BlockDriverState fields, and swap contents
* between bs_new and bs_top. Both bs_new and bs_top are modified. * 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. * 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) static void bdrv_delete(BlockDriverState *bs)
{ {
assert(!bs->dev);
assert(!bs->job); assert(!bs->job);
assert(bdrv_op_blocker_is_empty(bs)); assert(bdrv_op_blocker_is_empty(bs));
assert(!bs->refcnt); assert(!bs->refcnt);
@ -2117,109 +2105,9 @@ static void bdrv_delete(BlockDriverState *bs)
/* remove from list, if necessary */ /* remove from list, if necessary */
bdrv_make_anon(bs); bdrv_make_anon(bs);
drive_info_del(drive_get_by_blockdev(bs));
g_free(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 * Run consistency checks on an image
* *
@ -3553,7 +3441,9 @@ int bdrv_truncate(BlockDriverState *bs, int64_t offset)
ret = drv->bdrv_truncate(bs, offset); ret = drv->bdrv_truncate(bs, offset);
if (ret == 0) { if (ret == 0) {
ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS); 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; return ret;
} }
@ -3754,8 +3644,10 @@ int bdrv_set_key(BlockDriverState *bs, const char *key)
bs->valid_key = 0; bs->valid_key = 0;
} else if (!bs->valid_key) { } else if (!bs->valid_key) {
bs->valid_key = 1; bs->valid_key = 1;
/* call the change callback now, we skipped it on open */ if (bs->blk) {
bdrv_dev_change_media_cb(bs, true); /* call the change callback now, we skipped it on open */
blk_dev_change_media_cb(bs->blk, true);
}
} }
return ret; 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 */ /* This function is to find block backend bs */
/* TODO convert callers to blk_by_name(), then remove */
BlockDriverState *bdrv_find(const char *name) BlockDriverState *bdrv_find(const char *name)
{ {
BlockDriverState *bs; BlockBackend *blk = blk_by_name(name);
QTAILQ_FOREACH(bs, &bdrv_states, device_list) { return blk ? blk_bs(blk) : NULL;
if (!strcmp(name, bs->device_name)) {
return bs;
}
}
return NULL;
} }
/* This function is to find a node in the bs graph */ /* 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, const char *node_name,
Error **errp) Error **errp)
{ {
BlockDriverState *bs = NULL; BlockBackend *blk;
BlockDriverState *bs;
if (device) { if (device) {
bs = bdrv_find(device); blk = blk_by_name(device);
if (bs) { if (blk) {
return bs; return blk_bs(blk);
} }
} }
@ -3894,18 +3783,10 @@ BlockDriverState *bdrv_next(BlockDriverState *bs)
return QTAILQ_NEXT(bs, device_list); 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; return bs->blk ? blk_name(bs->blk) : "";
QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
it(opaque, bs);
}
}
const char *bdrv_get_device_name(BlockDriverState *bs)
{
return bs->device_name;
} }
int bdrv_get_flags(BlockDriverState *bs) int bdrv_get_flags(BlockDriverState *bs)
@ -4432,9 +4313,9 @@ int bdrv_get_backing_file_depth(BlockDriverState *bs)
/**************************************************************/ /**************************************************************/
/* async I/Os */ /* async I/Os */
BlockDriverAIOCB *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);
@ -4442,9 +4323,9 @@ BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
cb, opaque, false); cb, opaque, false);
} }
BlockDriverAIOCB *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);
@ -4452,9 +4333,9 @@ BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
cb, opaque, true); 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, 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);
@ -4469,7 +4350,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[];
@ -4646,7 +4527,7 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
return 0; return 0;
} }
void bdrv_aio_cancel(BlockDriverAIOCB *acb) void bdrv_aio_cancel(BlockAIOCB *acb)
{ {
qemu_aio_ref(acb); qemu_aio_ref(acb);
bdrv_aio_cancel_async(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 /* 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. * cancel_async, otherwise we do nothing and let the request normally complete.
* In either case the completion callback must be called. */ * 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) { if (acb->aiocb_info->cancel_async) {
acb->aiocb_info->cancel_async(acb); acb->aiocb_info->cancel_async(acb);
@ -4675,23 +4556,23 @@ void bdrv_aio_cancel_async(BlockDriverAIOCB *acb)
/**************************************************************/ /**************************************************************/
/* async block device emulation */ /* async block device emulation */
typedef struct BlockDriverAIOCBSync { typedef struct BlockAIOCBSync {
BlockDriverAIOCB common; BlockAIOCB common;
QEMUBH *bh; QEMUBH *bh;
int ret; int ret;
/* vector translation state */ /* vector translation state */
QEMUIOVector *qiov; QEMUIOVector *qiov;
uint8_t *bounce; uint8_t *bounce;
int is_write; int is_write;
} BlockDriverAIOCBSync; } BlockAIOCBSync;
static const AIOCBInfo bdrv_em_aiocb_info = { static const AIOCBInfo bdrv_em_aiocb_info = {
.aiocb_size = sizeof(BlockDriverAIOCBSync), .aiocb_size = sizeof(BlockAIOCBSync),
}; };
static void bdrv_aio_bh_cb(void *opaque) static void bdrv_aio_bh_cb(void *opaque)
{ {
BlockDriverAIOCBSync *acb = opaque; BlockAIOCBSync *acb = opaque;
if (!acb->is_write && acb->ret >= 0) { if (!acb->is_write && acb->ret >= 0) {
qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); 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); qemu_aio_unref(acb);
} }
static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, 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)
{ {
BlockDriverAIOCBSync *acb; BlockAIOCBSync *acb;
acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque); acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
acb->is_write = is_write; acb->is_write = is_write;
@ -4734,36 +4615,36 @@ static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
return &acb->common; 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, 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 BlockDriverAIOCB *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);
} }
typedef struct BlockDriverAIOCBCoroutine { typedef struct BlockAIOCBCoroutine {
BlockDriverAIOCB common; BlockAIOCB common;
BlockRequest req; BlockRequest req;
bool is_write; bool is_write;
bool *done; bool *done;
QEMUBH* bh; QEMUBH* bh;
} BlockDriverAIOCBCoroutine; } BlockAIOCBCoroutine;
static const AIOCBInfo bdrv_em_co_aiocb_info = { static const AIOCBInfo bdrv_em_co_aiocb_info = {
.aiocb_size = sizeof(BlockDriverAIOCBCoroutine), .aiocb_size = sizeof(BlockAIOCBCoroutine),
}; };
static void bdrv_co_em_bh(void *opaque) static void bdrv_co_em_bh(void *opaque)
{ {
BlockDriverAIOCBCoroutine *acb = opaque; BlockAIOCBCoroutine *acb = opaque;
acb->common.cb(acb->common.opaque, acb->req.error); 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 */ /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
static void coroutine_fn bdrv_co_do_rw(void *opaque) static void coroutine_fn bdrv_co_do_rw(void *opaque)
{ {
BlockDriverAIOCBCoroutine *acb = opaque; BlockAIOCBCoroutine *acb = opaque;
BlockDriverState *bs = acb->common.bs; BlockDriverState *bs = acb->common.bs;
if (!acb->is_write) { if (!acb->is_write) {
@ -4789,17 +4670,17 @@ static void coroutine_fn bdrv_co_do_rw(void *opaque)
qemu_bh_schedule(acb->bh); qemu_bh_schedule(acb->bh);
} }
static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
int64_t sector_num, int64_t sector_num,
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)
{ {
Coroutine *co; Coroutine *co;
BlockDriverAIOCBCoroutine *acb; BlockAIOCBCoroutine *acb;
acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque); acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
acb->req.sector = sector_num; 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) static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
{ {
BlockDriverAIOCBCoroutine *acb = opaque; BlockAIOCBCoroutine *acb = opaque;
BlockDriverState *bs = acb->common.bs; BlockDriverState *bs = acb->common.bs;
acb->req.error = bdrv_co_flush(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); qemu_bh_schedule(acb->bh);
} }
BlockDriverAIOCB *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);
Coroutine *co; Coroutine *co;
BlockDriverAIOCBCoroutine *acb; BlockAIOCBCoroutine *acb;
acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque); 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) static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
{ {
BlockDriverAIOCBCoroutine *acb = opaque; BlockAIOCBCoroutine *acb = opaque;
BlockDriverState *bs = acb->common.bs; BlockDriverState *bs = acb->common.bs;
acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors); 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); qemu_bh_schedule(acb->bh);
} }
BlockDriverAIOCB *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;
BlockDriverAIOCBCoroutine *acb; BlockAIOCBCoroutine *acb;
trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque); 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, 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 = g_slice_alloc(aiocb_info->aiocb_size);
acb->aiocb_info = aiocb_info; 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) void qemu_aio_ref(void *p)
{ {
BlockDriverAIOCB *acb = p; BlockAIOCB *acb = p;
acb->refcnt++; acb->refcnt++;
} }
void qemu_aio_unref(void *p) void qemu_aio_unref(void *p)
{ {
BlockDriverAIOCB *acb = p; BlockAIOCB *acb = p;
assert(acb->refcnt > 0); assert(acb->refcnt > 0);
if (--acb->refcnt == 0) { if (--acb->refcnt == 0) {
g_slice_free1(acb->aiocb_info->aiocb_size, acb); 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 = { CoroutineIOCompletion co = {
.coroutine = qemu_coroutine_self(), .coroutine = qemu_coroutine_self(),
}; };
BlockDriverAIOCB *acb; BlockAIOCB *acb;
if (is_write) { if (is_write) {
acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors, 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) { if (bs->drv->bdrv_co_flush_to_disk) {
ret = bs->drv->bdrv_co_flush_to_disk(bs); ret = bs->drv->bdrv_co_flush_to_disk(bs);
} else if (bs->drv->bdrv_aio_flush) { } else if (bs->drv->bdrv_aio_flush) {
BlockDriverAIOCB *acb; BlockAIOCB *acb;
CoroutineIOCompletion co = { CoroutineIOCompletion co = {
.coroutine = qemu_coroutine_self(), .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) { if (bs->drv->bdrv_co_discard) {
ret = bs->drv->bdrv_co_discard(bs, sector_num, num); ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
} else { } else {
BlockDriverAIOCB *acb; BlockAIOCB *acb;
CoroutineIOCompletion co = { CoroutineIOCompletion co = {
.coroutine = qemu_coroutine_self(), .coroutine = qemu_coroutine_self(),
}; };
@ -5259,13 +5140,15 @@ int bdrv_media_changed(BlockDriverState *bs)
void bdrv_eject(BlockDriverState *bs, bool eject_flag) void bdrv_eject(BlockDriverState *bs, bool eject_flag)
{ {
BlockDriver *drv = bs->drv; BlockDriver *drv = bs->drv;
const char *device_name;
if (drv && drv->bdrv_eject) { if (drv && drv->bdrv_eject) {
drv->bdrv_eject(bs, eject_flag); drv->bdrv_eject(bs, eject_flag);
} }
if (bs->device_name[0] != '\0') { device_name = bdrv_get_device_name(bs);
qapi_event_send_device_tray_moved(bdrv_get_device_name(bs), if (device_name[0] != '\0') {
qapi_event_send_device_tray_moved(device_name,
eject_flag, &error_abort); eject_flag, &error_abort);
} }
} }
@ -5296,9 +5179,9 @@ int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
return -ENOTSUP; return -ENOTSUP;
} }
BlockDriverAIOCB *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;
@ -5475,7 +5358,8 @@ bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
blocker = QLIST_FIRST(&bs->op_blockers[op]); blocker = QLIST_FIRST(&bs->op_blockers[op]);
if (errp) { if (errp) {
error_setg(errp, "Device '%s' is busy: %s", 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; return true;
} }

2
block/Makefile.objs
View File

@ -5,7 +5,7 @@ block-obj-y += qed-check.o
block-obj-$(CONFIG_VHDX) += vhdx.o vhdx-endian.o vhdx-log.o block-obj-$(CONFIG_VHDX) += vhdx.o vhdx-endian.o vhdx-log.o
block-obj-$(CONFIG_QUORUM) += quorum.o block-obj-$(CONFIG_QUORUM) += quorum.o
block-obj-y += parallels.o blkdebug.o blkverify.o block-obj-y += parallels.o blkdebug.o blkverify.o
block-obj-y += snapshot.o qapi.o block-obj-y += block-backend.o snapshot.o qapi.o
block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o
block-obj-$(CONFIG_POSIX) += raw-posix.o block-obj-$(CONFIG_POSIX) += raw-posix.o
block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o

28
block/archipelago.c
View File

@ -86,7 +86,7 @@ typedef enum {
} ARCHIPCmd; } ARCHIPCmd;
typedef struct ArchipelagoAIOCB { typedef struct ArchipelagoAIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
QEMUBH *bh; QEMUBH *bh;
struct BDRVArchipelagoState *s; struct BDRVArchipelagoState *s;
QEMUIOVector *qiov; QEMUIOVector *qiov;
@ -856,13 +856,13 @@ err_exit:
return ret; return ret;
} }
static BlockDriverAIOCB *qemu_archipelago_aio_rw(BlockDriverState *bs, 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)
{ {
ArchipelagoAIOCB *aio_cb; ArchipelagoAIOCB *aio_cb;
BDRVArchipelagoState *s = bs->opaque; BDRVArchipelagoState *s = bs->opaque;
@ -894,17 +894,17 @@ err_exit:
return NULL; return NULL;
} }
static BlockDriverAIOCB *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);
} }
static BlockDriverAIOCB *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);
@ -1052,8 +1052,8 @@ static QemuOptsList qemu_archipelago_create_opts = {
} }
}; };
static BlockDriverAIOCB *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;

18
block/blkdebug.c
View File

@ -41,7 +41,7 @@ typedef struct BDRVBlkdebugState {
} BDRVBlkdebugState; } BDRVBlkdebugState;
typedef struct BlkdebugAIOCB { typedef struct BlkdebugAIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
QEMUBH *bh; QEMUBH *bh;
int ret; int ret;
} BlkdebugAIOCB; } BlkdebugAIOCB;
@ -463,8 +463,8 @@ static void error_callback_bh(void *opaque)
qemu_aio_unref(acb); qemu_aio_unref(acb);
} }
static BlockDriverAIOCB *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;
@ -489,9 +489,9 @@ static BlockDriverAIOCB *inject_error(BlockDriverState *bs,
return &acb->common; return &acb->common;
} }
static BlockDriverAIOCB *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;
@ -511,9 +511,9 @@ static BlockDriverAIOCB *blkdebug_aio_readv(BlockDriverState *bs,
return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, cb, opaque); return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, cb, opaque);
} }
static BlockDriverAIOCB *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;
@ -533,8 +533,8 @@ static BlockDriverAIOCB *blkdebug_aio_writev(BlockDriverState *bs,
return bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors, cb, opaque); return bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors, cb, opaque);
} }
static BlockDriverAIOCB *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;

18
block/blkverify.c
View File

@ -19,7 +19,7 @@ typedef struct {
typedef struct BlkverifyAIOCB BlkverifyAIOCB; typedef struct BlkverifyAIOCB BlkverifyAIOCB;
struct BlkverifyAIOCB { struct BlkverifyAIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
QEMUBH *bh; QEMUBH *bh;
/* Request metadata */ /* Request metadata */
@ -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);
@ -229,9 +229,9 @@ static void blkverify_verify_readv(BlkverifyAIOCB *acb)
} }
} }
static BlockDriverAIOCB *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,
@ -249,9 +249,9 @@ static BlockDriverAIOCB *blkverify_aio_readv(BlockDriverState *bs,
return &acb->common; return &acb->common;
} }
static BlockDriverAIOCB *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,
@ -264,9 +264,9 @@ static BlockDriverAIOCB *blkverify_aio_writev(BlockDriverState *bs,
return &acb->common; return &acb->common;
} }
static BlockDriverAIOCB *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;

631
block/block-backend.c Normal file
View File

@ -0,0 +1,631 @@
/*
* QEMU Block backends
*
* Copyright (C) 2014 Red Hat, Inc.
*
* Authors:
* Markus Armbruster <armbru@redhat.com>,
*
* This work is licensed under the terms of the GNU LGPL, version 2.1
* or later. See the COPYING.LIB file in the top-level directory.
*/
#include "sysemu/block-backend.h"
#include "block/block_int.h"
#include "sysemu/blockdev.h"
#include "qapi-event.h"
/* Number of coroutines to reserve per attached device model */
#define COROUTINE_POOL_RESERVATION 64
struct BlockBackend {
char *name;
int refcnt;
BlockDriverState *bs;
DriveInfo *legacy_dinfo; /* null unless created by drive_new() */
QTAILQ_ENTRY(BlockBackend) link; /* for blk_backends */
void *dev; /* attached device model, if any */
/* TODO change to DeviceState when all users are qdevified */
const BlockDevOps *dev_ops;
void *dev_opaque;
};
static void drive_info_del(DriveInfo *dinfo);
/* All the BlockBackends (except for hidden ones) */
static QTAILQ_HEAD(, BlockBackend) blk_backends =
QTAILQ_HEAD_INITIALIZER(blk_backends);
/*
* Create a new BlockBackend with @name, with a reference count of one.
* @name must not be null or empty.
* Fail if a BlockBackend with this name already exists.
* Store an error through @errp on failure, unless it's null.
* Return the new BlockBackend on success, null on failure.
*/
BlockBackend *blk_new(const char *name, Error **errp)
{
BlockBackend *blk;
assert(name && name[0]);
if (!id_wellformed(name)) {
error_setg(errp, "Invalid device name");
return NULL;
}
if (blk_by_name(name)) {
error_setg(errp, "Device with id '%s' already exists", name);
return NULL;
}
if (bdrv_find_node(name)) {
error_setg(errp,
"Device name '%s' conflicts with an existing node name",
name);
return NULL;
}
blk = g_new0(BlockBackend, 1);
blk->name = g_strdup(name);
blk->refcnt = 1;
QTAILQ_INSERT_TAIL(&blk_backends, blk, link);
return blk;
}
/*
* Create a new BlockBackend with a new BlockDriverState attached.
* Otherwise just like blk_new(), which see.
*/
BlockBackend *blk_new_with_bs(const char *name, Error **errp)
{
BlockBackend *blk;
BlockDriverState *bs;
blk = blk_new(name, errp);
if (!blk) {
return NULL;
}
bs = bdrv_new_root();
blk->bs = bs;
bs->blk = blk;
return blk;
}
static void blk_delete(BlockBackend *blk)
{
assert(!blk->refcnt);
assert(!blk->dev);
if (blk->bs) {
assert(blk->bs->blk == blk);
blk->bs->blk = NULL;
bdrv_unref(blk->bs);
blk->bs = NULL;
}
/* Avoid double-remove after blk_hide_on_behalf_of_do_drive_del() */
if (blk->name[0]) {
QTAILQ_REMOVE(&blk_backends, blk, link);
}
g_free(blk->name);
drive_info_del(blk->legacy_dinfo);
g_free(blk);
}
static void drive_info_del(DriveInfo *dinfo)
{
if (!dinfo) {
return;
}
qemu_opts_del(dinfo->opts);
g_free(dinfo->serial);
g_free(dinfo);
}
/*
* Increment @blk's reference count.
* @blk must not be null.
*/
void blk_ref(BlockBackend *blk)
{
blk->refcnt++;
}
/*
* Decrement @blk's reference count.
* If this drops it to zero, destroy @blk.
* For convenience, do nothing if @blk is null.
*/
void blk_unref(BlockBackend *blk)
{
if (blk) {
assert(blk->refcnt > 0);
if (!--blk->refcnt) {
blk_delete(blk);
}
}
}
/*
* Return the BlockBackend after @blk.
* If @blk is null, return the first one.
* Else, return @blk's next sibling, which may be null.
*
* To iterate over all BlockBackends, do
* for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
* ...
* }
*/
BlockBackend *blk_next(BlockBackend *blk)
{
return blk ? QTAILQ_NEXT(blk, link) : QTAILQ_FIRST(&blk_backends);
}
/*
* Return @blk's name, a non-null string.
* Wart: the name is empty iff @blk has been hidden with
* blk_hide_on_behalf_of_do_drive_del().
*/
const char *blk_name(BlockBackend *blk)
{
return blk->name;
}
/*
* Return the BlockBackend with name @name if it exists, else null.
* @name must not be null.
*/
BlockBackend *blk_by_name(const char *name)
{
BlockBackend *blk;
assert(name);
QTAILQ_FOREACH(blk, &blk_backends, link) {
if (!strcmp(name, blk->name)) {
return blk;
}
}
return NULL;
}
/*
* Return the BlockDriverState attached to @blk if any, else null.
*/
BlockDriverState *blk_bs(BlockBackend *blk)
{
return blk->bs;
}
/*
* Return @blk's DriveInfo if any, else null.
*/
DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
{
return blk->legacy_dinfo;
}
/*
* Set @blk's DriveInfo to @dinfo, and return it.
* @blk must not have a DriveInfo set already.
* No other BlockBackend may have the same DriveInfo set.
*/
DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
{
assert(!blk->legacy_dinfo);
return blk->legacy_dinfo = dinfo;
}
/*
* Return the BlockBackend with DriveInfo @dinfo.
* It must exist.
*/
BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
{
BlockBackend *blk;
QTAILQ_FOREACH(blk, &blk_backends, link) {
if (blk->legacy_dinfo == dinfo) {
return blk;
}
}
abort();
}
/*
* Hide @blk.
* @blk must not have been hidden already.
* Make attached BlockDriverState, if any, anonymous.
* Once hidden, @blk is invisible to all functions that don't receive
* it as argument. For example, blk_by_name() won't return it.
* Strictly for use by do_drive_del().
* TODO get rid of it!
*/
void blk_hide_on_behalf_of_do_drive_del(BlockBackend *blk)
{
QTAILQ_REMOVE(&blk_backends, blk, link);
blk->name[0] = 0;
if (blk->bs) {
bdrv_make_anon(blk->bs);
}
}
/*
* Attach device model @dev to @blk.
* Return 0 on success, -EBUSY when a device model is attached already.
*/
int blk_attach_dev(BlockBackend *blk, void *dev)
/* TODO change to DeviceState *dev when all users are qdevified */
{
if (blk->dev) {
return -EBUSY;
}
blk_ref(blk);
blk->dev = dev;
bdrv_iostatus_reset(blk->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;
}
/*
* Attach device model @dev to @blk.
* @blk must not have a device model attached already.
* TODO qdevified devices don't use this, remove when devices are qdevified
*/
void blk_attach_dev_nofail(BlockBackend *blk, void *dev)
{
if (blk_attach_dev(blk, dev) < 0) {
abort();
}
}
/*
* Detach device model @dev from @blk.
* @dev must be currently attached to @blk.
*/
void blk_detach_dev(BlockBackend *blk, void *dev)
/* TODO change to DeviceState *dev when all users are qdevified */
{
assert(blk->dev == dev);
blk->dev = NULL;
blk->dev_ops = NULL;
blk->dev_opaque = NULL;
bdrv_set_guest_block_size(blk->bs, 512);
qemu_coroutine_adjust_pool_size(-COROUTINE_POOL_RESERVATION);
blk_unref(blk);
}
/*
* Return the device model attached to @blk if any, else null.
*/
void *blk_get_attached_dev(BlockBackend *blk)
/* TODO change to return DeviceState * when all users are qdevified */
{
return blk->dev;
}
/*
* Set @blk's device model callbacks to @ops.
* @opaque is the opaque argument to pass to the callbacks.
* This is for use by device models.
*/
void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
void *opaque)
{
blk->dev_ops = ops;
blk->dev_opaque = opaque;
}
/*
* Notify @blk's attached device model of media change.
* If @load is true, notify of media load.
* Else, notify of media eject.
* Also send DEVICE_TRAY_MOVED events as appropriate.
*/
void blk_dev_change_media_cb(BlockBackend *blk, bool load)
{
if (blk->dev_ops && blk->dev_ops->change_media_cb) {
bool tray_was_closed = !blk_dev_is_tray_open(blk);
blk->dev_ops->change_media_cb(blk->dev_opaque, load);
if (tray_was_closed) {
/* tray open */
qapi_event_send_device_tray_moved(blk_name(blk),
true, &error_abort);
}
if (load) {
/* tray close */
qapi_event_send_device_tray_moved(blk_name(blk),
false, &error_abort);
}
}
}
/*
* Does @blk's attached device model have removable media?
* %true if no device model is attached.
*/
bool blk_dev_has_removable_media(BlockBackend *blk)
{
return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
}
/*
* Notify @blk's attached device model of a media eject request.
* If @force is true, the medium is about to be yanked out forcefully.
*/
void blk_dev_eject_request(BlockBackend *blk, bool force)
{
if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
}
}
/*
* Does @blk's attached device model have a tray, and is it open?
*/
bool blk_dev_is_tray_open(BlockBackend *blk)
{
if (blk->dev_ops && blk->dev_ops->is_tray_open) {
return blk->dev_ops->is_tray_open(blk->dev_opaque);
}
return false;
}
/*
* Does @blk's attached device model have the medium locked?
* %false if the device model has no such lock.
*/
bool blk_dev_is_medium_locked(BlockBackend *blk)
{
if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
return blk->dev_ops->is_medium_locked(blk->dev_opaque);
}
return false;
}
/*
* Notify @blk's attached device model of a backend size change.
*/
void blk_dev_resize_cb(BlockBackend *blk)
{
if (blk->dev_ops && blk->dev_ops->resize_cb) {
blk->dev_ops->resize_cb(blk->dev_opaque);
}
}
void blk_iostatus_enable(BlockBackend *blk)
{
bdrv_iostatus_enable(blk->bs);
}
int blk_read(BlockBackend *blk, int64_t sector_num, uint8_t *buf,
int nb_sectors)
{
return bdrv_read(blk->bs, sector_num, buf, nb_sectors);
}
int blk_read_unthrottled(BlockBackend *blk, int64_t sector_num, uint8_t *buf,
int nb_sectors)
{
return bdrv_read_unthrottled(blk->bs, sector_num, buf, nb_sectors);
}
int blk_write(BlockBackend *blk, int64_t sector_num, const uint8_t *buf,
int nb_sectors)
{
return bdrv_write(blk->bs, sector_num, buf, nb_sectors);
}
BlockAIOCB *blk_aio_write_zeroes(BlockBackend *blk, int64_t sector_num,
int nb_sectors, BdrvRequestFlags flags,
BlockCompletionFunc *cb, void *opaque)
{
return bdrv_aio_write_zeroes(blk->bs, sector_num, nb_sectors, flags,
cb, opaque);
}
int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count)
{
return bdrv_pread(blk->bs, offset, buf, count);
}
int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count)
{
return bdrv_pwrite(blk->bs, offset, buf, count);
}
int64_t blk_getlength(BlockBackend *blk)
{
return bdrv_getlength(blk->bs);
}
void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
{
bdrv_get_geometry(blk->bs, nb_sectors_ptr);
}
BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num,
QEMUIOVector *iov, int nb_sectors,
BlockCompletionFunc *cb, void *opaque)
{
return bdrv_aio_readv(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
}
BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num,
QEMUIOVector *iov, int nb_sectors,
BlockCompletionFunc *cb, void *opaque)
{
return bdrv_aio_writev(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
}
BlockAIOCB *blk_aio_flush(BlockBackend *blk,
BlockCompletionFunc *cb, void *opaque)
{
return bdrv_aio_flush(blk->bs, cb, opaque);
}
BlockAIOCB *blk_aio_discard(BlockBackend *blk,
int64_t sector_num, int nb_sectors,
BlockCompletionFunc *cb, void *opaque)
{
return bdrv_aio_discard(blk->bs, sector_num, nb_sectors, cb, opaque);
}
void blk_aio_cancel(BlockAIOCB *acb)
{
bdrv_aio_cancel(acb);
}
void blk_aio_cancel_async(BlockAIOCB *acb)
{
bdrv_aio_cancel_async(acb);
}
int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs)
{
return bdrv_aio_multiwrite(blk->bs, reqs, num_reqs);
}
int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
{
return bdrv_ioctl(blk->bs, req, buf);
}
BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
BlockCompletionFunc *cb, void *opaque)
{
return bdrv_aio_ioctl(blk->bs, req, buf, cb, opaque);
}
int blk_flush(BlockBackend *blk)
{
return bdrv_flush(blk->bs);
}
int blk_flush_all(void)
{
return bdrv_flush_all();
}
void blk_drain_all(void)
{
bdrv_drain_all();
}
BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
{
return bdrv_get_on_error(blk->bs, is_read);
}
BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
int error)
{
return bdrv_get_error_action(blk->bs, is_read, error);
}
void blk_error_action(BlockBackend *blk, BlockErrorAction action,
bool is_read, int error)
{
bdrv_error_action(blk->bs, action, is_read, error);
}
int blk_is_read_only(BlockBackend *blk)
{
return bdrv_is_read_only(blk->bs);
}
int blk_is_sg(BlockBackend *blk)
{
return bdrv_is_sg(blk->bs);
}
int blk_enable_write_cache(BlockBackend *blk)
{
return bdrv_enable_write_cache(blk->bs);
}
void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
{
bdrv_set_enable_write_cache(blk->bs, wce);
}
int blk_is_inserted(BlockBackend *blk)
{
return bdrv_is_inserted(blk->bs);
}
void blk_lock_medium(BlockBackend *blk, bool locked)
{
bdrv_lock_medium(blk->bs, locked);
}
void blk_eject(BlockBackend *blk, bool eject_flag)
{
bdrv_eject(blk->bs, eject_flag);
}
int blk_get_flags(BlockBackend *blk)
{
return bdrv_get_flags(blk->bs);
}
void blk_set_guest_block_size(BlockBackend *blk, int align)
{
bdrv_set_guest_block_size(blk->bs, align);
}
void *blk_blockalign(BlockBackend *blk, size_t size)
{
return qemu_blockalign(blk ? blk->bs : NULL, size);
}
bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
{
return bdrv_op_is_blocked(blk->bs, op, errp);
}
void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
{
bdrv_op_unblock(blk->bs, op, reason);
}
void blk_op_block_all(BlockBackend *blk, Error *reason)
{
bdrv_op_block_all(blk->bs, reason);
}
void blk_op_unblock_all(BlockBackend *blk, Error *reason)
{
bdrv_op_unblock_all(blk->bs, reason);
}
AioContext *blk_get_aio_context(BlockBackend *blk)
{
return bdrv_get_aio_context(blk->bs);
}
void blk_set_aio_context(BlockBackend *blk, AioContext *new_context)
{
bdrv_set_aio_context(blk->bs, new_context);
}
void blk_io_plug(BlockBackend *blk)
{
bdrv_io_plug(blk->bs);
}
void blk_io_unplug(BlockBackend *blk)
{
bdrv_io_unplug(blk->bs);
}
BlockAcctStats *blk_get_stats(BlockBackend *blk)
{
return bdrv_get_stats(blk->bs);
}
void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
BlockCompletionFunc *cb, void *opaque)
{
return qemu_aio_get(aiocb_info, blk_bs(blk), cb, 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;

6
block/curl.c
View File

@ -78,7 +78,7 @@ static CURLMcode __curl_multi_socket_action(CURLM *multi_handle,
struct BDRVCURLState; struct BDRVCURLState;
typedef struct CURLAIOCB { typedef struct CURLAIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
QEMUBH *bh; QEMUBH *bh;
QEMUIOVector *qiov; QEMUIOVector *qiov;
@ -680,9 +680,9 @@ static void curl_readv_bh_cb(void *p)
curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running); curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
} }
static BlockDriverAIOCB *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;

10
block/iscsi.c
View File

@ -80,7 +80,7 @@ typedef struct IscsiTask {
} IscsiTask; } IscsiTask;
typedef struct IscsiAIOCB { typedef struct IscsiAIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
QEMUIOVector *qiov; QEMUIOVector *qiov;
QEMUBH *bh; QEMUBH *bh;
IscsiLun *iscsilun; IscsiLun *iscsilun;
@ -227,7 +227,7 @@ iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data,
} }
static void static void
iscsi_aio_cancel(BlockDriverAIOCB *blockacb) iscsi_aio_cancel(BlockAIOCB *blockacb)
{ {
IscsiAIOCB *acb = (IscsiAIOCB *)blockacb; IscsiAIOCB *acb = (IscsiAIOCB *)blockacb;
IscsiLun *iscsilun = acb->iscsilun; IscsiLun *iscsilun = acb->iscsilun;
@ -663,9 +663,9 @@ iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status,
iscsi_schedule_bh(acb); iscsi_schedule_bh(acb);
} }
static BlockDriverAIOCB *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;
@ -1519,7 +1519,7 @@ static int iscsi_create(const char *filename, QemuOpts *opts, Error **errp)
IscsiLun *iscsilun = NULL; IscsiLun *iscsilun = NULL;
QDict *bs_options; QDict *bs_options;
bs = bdrv_new("", &error_abort); bs = bdrv_new();
/* Read out options */ /* Read out options */
total_size = DIV_ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), total_size = DIV_ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),

8
block/linux-aio.c
View File

@ -28,7 +28,7 @@
#define MAX_QUEUED_IO 128 #define MAX_QUEUED_IO 128
struct qemu_laiocb { struct qemu_laiocb {
BlockDriverAIOCB common; BlockAIOCB common;
struct qemu_laio_state *ctx; struct qemu_laio_state *ctx;
struct iocb iocb; struct iocb iocb;
ssize_t ret; ssize_t ret;
@ -146,7 +146,7 @@ static void qemu_laio_completion_cb(EventNotifier *e)
} }
} }
static void laio_cancel(BlockDriverAIOCB *blockacb) static void laio_cancel(BlockAIOCB *blockacb)
{ {
struct qemu_laiocb *laiocb = (struct qemu_laiocb *)blockacb; struct qemu_laiocb *laiocb = (struct qemu_laiocb *)blockacb;
struct io_event event; struct io_event event;
@ -243,9 +243,9 @@ int laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug)
return ret; return ret;
} }
BlockDriverAIOCB *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;

9
block/mirror.c
View File

@ -567,7 +567,8 @@ static void mirror_complete(BlockJob *job, Error **errp)
return; return;
} }
if (!s->synced) { if (!s->synced) {
error_set(errp, QERR_BLOCK_JOB_NOT_READY, job->bs->device_name); error_set(errp, QERR_BLOCK_JOB_NOT_READY,
bdrv_get_device_name(job->bs));
return; return;
} }
@ -612,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)
@ -672,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;
@ -689,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;

46
block/nbd.c
View File

@ -342,30 +342,44 @@ static void nbd_attach_aio_context(BlockDriverState *bs,
static void nbd_refresh_filename(BlockDriverState *bs) static void nbd_refresh_filename(BlockDriverState *bs)
{ {
BDRVNBDState *s = bs->opaque;
QDict *opts = qdict_new(); QDict *opts = qdict_new();
const char *path = qemu_opt_get(s->socket_opts, "path"); const char *path = qdict_get_try_str(bs->options, "path");
const char *host = qemu_opt_get(s->socket_opts, "host"); const char *host = qdict_get_try_str(bs->options, "host");
const char *port = qemu_opt_get(s->socket_opts, "port"); const char *port = qdict_get_try_str(bs->options, "port");
const char *export = qemu_opt_get(s->socket_opts, "export"); const char *export = qdict_get_try_str(bs->options, "export");
qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("nbd"))); qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("nbd")));
if (path && export) {
snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd+unix:///%s?socket=%s", export, path);
} else if (path && !export) {
snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd+unix://?socket=%s", path);
} else if (!path && export && port) {
snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd://%s:%s/%s", host, port, export);
} else if (!path && export && !port) {
snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd://%s/%s", host, export);
} else if (!path && !export && port) {
snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd://%s:%s", host, port);
} else if (!path && !export && !port) {
snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd://%s", host);
}
if (path) { if (path) {
snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd+unix:%s", path);
qdict_put_obj(opts, "path", QOBJECT(qstring_from_str(path))); qdict_put_obj(opts, "path", QOBJECT(qstring_from_str(path)));
} else if (export) { } else if (port) {
snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd:%s:%s/%s", host, port, export);
qdict_put_obj(opts, "host", QOBJECT(qstring_from_str(host)));
qdict_put_obj(opts, "port", QOBJECT(qstring_from_str(port)));
qdict_put_obj(opts, "export", QOBJECT(qstring_from_str(export)));
} else {
snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd:%s:%s", host, port);
qdict_put_obj(opts, "host", QOBJECT(qstring_from_str(host))); qdict_put_obj(opts, "host", QOBJECT(qstring_from_str(host)));
qdict_put_obj(opts, "port", QOBJECT(qstring_from_str(port))); qdict_put_obj(opts, "port", QOBJECT(qstring_from_str(port)));
} else {
qdict_put_obj(opts, "host", QOBJECT(qstring_from_str(host)));
}
if (export) {
qdict_put_obj(opts, "export", QOBJECT(qstring_from_str(export)));
} }
bs->full_open_options = opts; bs->full_open_options = opts;

34
block/null.c
View File

@ -78,7 +78,7 @@ static coroutine_fn int null_co_flush(BlockDriverState *bs)
} }
typedef struct { typedef struct {
BlockDriverAIOCB common; BlockAIOCB common;
QEMUBH *bh; QEMUBH *bh;
} NullAIOCB; } NullAIOCB;
@ -94,9 +94,9 @@ static void null_bh_cb(void *opaque)
qemu_aio_unref(acb); qemu_aio_unref(acb);
} }
static inline BlockDriverAIOCB *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;
@ -106,27 +106,27 @@ static inline BlockDriverAIOCB *null_aio_common(BlockDriverState *bs,
return &acb->common; return &acb->common;
} }
static BlockDriverAIOCB *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);
} }
static BlockDriverAIOCB *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 BlockDriverAIOCB *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);
} }

27
block/qapi.c
View File

@ -28,6 +28,7 @@
#include "qapi-visit.h" #include "qapi-visit.h"
#include "qapi/qmp-output-visitor.h" #include "qapi/qmp-output-visitor.h"
#include "qapi/qmp/types.h" #include "qapi/qmp/types.h"
#include "sysemu/block-backend.h"
#ifdef __linux__ #ifdef __linux__
#include <linux/fs.h> #include <linux/fs.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
@ -264,22 +265,22 @@ void bdrv_query_image_info(BlockDriverState *bs,
} }
/* @p_info will be set only on success. */ /* @p_info will be set only on success. */
void bdrv_query_info(BlockDriverState *bs, static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info,
BlockInfo **p_info, Error **errp)
Error **errp)
{ {
BlockInfo *info = g_malloc0(sizeof(*info)); BlockInfo *info = g_malloc0(sizeof(*info));
BlockDriverState *bs = blk_bs(blk);
BlockDriverState *bs0; BlockDriverState *bs0;
ImageInfo **p_image_info; ImageInfo **p_image_info;
Error *local_err = NULL; Error *local_err = NULL;
info->device = g_strdup(bs->device_name); info->device = g_strdup(blk_name(blk));
info->type = g_strdup("unknown"); info->type = g_strdup("unknown");
info->locked = bdrv_dev_is_medium_locked(bs); info->locked = blk_dev_is_medium_locked(blk);
info->removable = bdrv_dev_has_removable_media(bs); info->removable = blk_dev_has_removable_media(blk);
if (bdrv_dev_has_removable_media(bs)) { if (blk_dev_has_removable_media(blk)) {
info->has_tray_open = true; info->has_tray_open = true;
info->tray_open = bdrv_dev_is_tray_open(bs); info->tray_open = blk_dev_is_tray_open(blk);
} }
if (bdrv_iostatus_is_enabled(bs)) { if (bdrv_iostatus_is_enabled(bs)) {
@ -327,9 +328,9 @@ static BlockStats *bdrv_query_stats(const BlockDriverState *bs)
s = g_malloc0(sizeof(*s)); s = g_malloc0(sizeof(*s));
if (bs->device_name[0]) { if (bdrv_get_device_name(bs)[0]) {
s->has_device = true; s->has_device = true;
s->device = g_strdup(bs->device_name); s->device = g_strdup(bdrv_get_device_name(bs));
} }
s->stats = g_malloc0(sizeof(*s->stats)); s->stats = g_malloc0(sizeof(*s->stats));
@ -360,12 +361,12 @@ static BlockStats *bdrv_query_stats(const BlockDriverState *bs)
BlockInfoList *qmp_query_block(Error **errp) BlockInfoList *qmp_query_block(Error **errp)
{ {
BlockInfoList *head = NULL, **p_next = &head; BlockInfoList *head = NULL, **p_next = &head;
BlockDriverState *bs = NULL; BlockBackend *blk;
Error *local_err = NULL; Error *local_err = NULL;
while ((bs = bdrv_next(bs))) { for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
BlockInfoList *info = g_malloc0(sizeof(*info)); BlockInfoList *info = g_malloc0(sizeof(*info));
bdrv_query_info(bs, &info->value, &local_err); bdrv_query_info(blk, &info->value, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
goto err; goto err;

4
block/qcow.c
View File

@ -124,7 +124,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
snprintf(version, sizeof(version), "QCOW version %" PRIu32, snprintf(version, sizeof(version), "QCOW version %" PRIu32,
header.version); header.version);
error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
bs->device_name, "qcow", version); bdrv_get_device_name(bs), "qcow", version);
ret = -ENOTSUP; ret = -ENOTSUP;
goto fail; goto fail;
} }
@ -231,7 +231,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
/* Disable migration when qcow images are used */ /* Disable migration when qcow images are used */
error_set(&s->migration_blocker, error_set(&s->migration_blocker,
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
"qcow", bs->device_name, "live migration"); "qcow", bdrv_get_device_name(bs), "live migration");
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
qemu_co_mutex_init(&s->lock); qemu_co_mutex_init(&s->lock);

1
block/qcow2-refcount.c
View File

@ -524,6 +524,7 @@ found:
QTAILQ_REMOVE(&s->discards, p, next); QTAILQ_REMOVE(&s->discards, p, next);
d->offset = MIN(d->offset, p->offset); d->offset = MIN(d->offset, p->offset);
d->bytes += p->bytes; d->bytes += p->bytes;
g_free(p);
} }
} }

4
block/qcow2.c
View File

@ -206,8 +206,8 @@ static void GCC_FMT_ATTR(3, 4) report_unsupported(BlockDriverState *bs,
vsnprintf(msg, sizeof(msg), fmt, ap); vsnprintf(msg, sizeof(msg), fmt, ap);
va_end(ap); va_end(ap);
error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, bs->device_name, "qcow2", error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
msg); bdrv_get_device_name(bs), "qcow2", msg);
} }
static void report_unsupported_feature(BlockDriverState *bs, static void report_unsupported_feature(BlockDriverState *bs,

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,

46
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
@ -408,7 +408,7 @@ static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
snprintf(buf, sizeof(buf), "%" PRIx64, snprintf(buf, sizeof(buf), "%" PRIx64,
s->header.features & ~QED_FEATURE_MASK); s->header.features & ~QED_FEATURE_MASK);
error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
bs->device_name, "QED", buf); bdrv_get_device_name(bs), "QED", buf);
return -ENOTSUP; return -ENOTSUP;
} }
if (!qed_is_cluster_size_valid(s->header.cluster_size)) { if (!qed_is_cluster_size_valid(s->header.cluster_size)) {
@ -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)) {
@ -1365,11 +1365,11 @@ static void qed_aio_next_io(void *opaque, int ret)
io_fn, acb); io_fn, acb);
} }
static BlockDriverAIOCB *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);
@ -1390,20 +1390,20 @@ static BlockDriverAIOCB *qed_aio_setup(BlockDriverState *bs,
return &acb->common; return &acb->common;
} }
static BlockDriverAIOCB *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);
} }
static BlockDriverAIOCB *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,
opaque, QED_AIOCB_WRITE); opaque, QED_AIOCB_WRITE);
@ -1431,7 +1431,7 @@ static int coroutine_fn bdrv_qed_co_write_zeroes(BlockDriverState *bs,
int nb_sectors, int nb_sectors,
BdrvRequestFlags flags) BdrvRequestFlags flags)
{ {
BlockDriverAIOCB *blockacb; BlockAIOCB *blockacb;
BDRVQEDState *s = bs->opaque; BDRVQEDState *s = bs->opaque;
QEDWriteZeroesCB cb = { .done = false }; QEDWriteZeroesCB cb = { .done = false };
QEMUIOVector qiov; QEMUIOVector qiov;

12
block/qed.h
View File

@ -128,7 +128,7 @@ enum {
}; };
typedef struct QEDAIOCB { typedef struct QEDAIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
QEMUBH *bh; QEMUBH *bh;
int bh_ret; /* final return status for completion bh */ int bh_ret; /* final return status for completion bh */
QSIMPLEQ_ENTRY(QEDAIOCB) next; /* next request */ QSIMPLEQ_ENTRY(QEDAIOCB) next; /* next request */
@ -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);

42
block/quorum.c
View File

@ -92,7 +92,7 @@ typedef struct QuorumAIOCB QuorumAIOCB;
* $children_count QuorumChildRequest. * $children_count QuorumChildRequest.
*/ */
typedef struct QuorumChildRequest { typedef struct QuorumChildRequest {
BlockDriverAIOCB *aiocb; BlockAIOCB *aiocb;
QEMUIOVector qiov; QEMUIOVector qiov;
uint8_t *buf; uint8_t *buf;
int ret; int ret;
@ -105,7 +105,7 @@ typedef struct QuorumChildRequest {
* used to do operations on each children and track overall progress. * used to do operations on each children and track overall progress.
*/ */
struct QuorumAIOCB { struct QuorumAIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
/* Request metadata */ /* Request metadata */
uint64_t sector_num; uint64_t sector_num;
@ -130,7 +130,7 @@ struct QuorumAIOCB {
static bool quorum_vote(QuorumAIOCB *acb); static bool quorum_vote(QuorumAIOCB *acb);
static void quorum_aio_cancel(BlockDriverAIOCB *blockacb) static void quorum_aio_cancel(BlockAIOCB *blockacb)
{ {
QuorumAIOCB *acb = container_of(blockacb, QuorumAIOCB, common); QuorumAIOCB *acb = container_of(blockacb, QuorumAIOCB, common);
BDRVQuorumState *s = acb->common.bs->opaque; BDRVQuorumState *s = acb->common.bs->opaque;
@ -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);
@ -226,8 +226,8 @@ static void quorum_report_bad(QuorumAIOCB *acb, char *node_name, int ret)
static void quorum_report_failure(QuorumAIOCB *acb) static void quorum_report_failure(QuorumAIOCB *acb)
{ {
const char *reference = acb->common.bs->device_name[0] ? const char *reference = bdrv_get_device_name(acb->common.bs)[0] ?
acb->common.bs->device_name : bdrv_get_device_name(acb->common.bs) :
acb->common.bs->node_name; acb->common.bs->node_name;
qapi_event_send_quorum_failure(reference, acb->sector_num, qapi_event_send_quorum_failure(reference, acb->sector_num,
@ -264,7 +264,7 @@ static void quorum_rewrite_aio_cb(void *opaque, int ret)
quorum_aio_finalize(acb); quorum_aio_finalize(acb);
} }
static BlockDriverAIOCB *read_fifo_child(QuorumAIOCB *acb); static BlockAIOCB *read_fifo_child(QuorumAIOCB *acb);
static void quorum_copy_qiov(QEMUIOVector *dest, QEMUIOVector *source) static void quorum_copy_qiov(QEMUIOVector *dest, QEMUIOVector *source)
{ {
@ -640,7 +640,7 @@ free_exit:
return rewrite; return rewrite;
} }
static BlockDriverAIOCB *read_quorum_children(QuorumAIOCB *acb) static BlockAIOCB *read_quorum_children(QuorumAIOCB *acb)
{ {
BDRVQuorumState *s = acb->common.bs->opaque; BDRVQuorumState *s = acb->common.bs->opaque;
int i; int i;
@ -659,7 +659,7 @@ static BlockDriverAIOCB *read_quorum_children(QuorumAIOCB *acb)
return &acb->common; return &acb->common;
} }
static BlockDriverAIOCB *read_fifo_child(QuorumAIOCB *acb) static BlockAIOCB *read_fifo_child(QuorumAIOCB *acb)
{ {
BDRVQuorumState *s = acb->common.bs->opaque; BDRVQuorumState *s = acb->common.bs->opaque;
@ -675,12 +675,12 @@ static BlockDriverAIOCB *read_fifo_child(QuorumAIOCB *acb)
return &acb->common; return &acb->common;
} }
static BlockDriverAIOCB *quorum_aio_readv(BlockDriverState *bs, 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;
QuorumAIOCB *acb = quorum_aio_get(s, bs, qiov, sector_num, QuorumAIOCB *acb = quorum_aio_get(s, bs, qiov, sector_num,
@ -696,12 +696,12 @@ static BlockDriverAIOCB *quorum_aio_readv(BlockDriverState *bs,
return read_fifo_child(acb); return read_fifo_child(acb);
} }
static BlockDriverAIOCB *quorum_aio_writev(BlockDriverState *bs, 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;
QuorumAIOCB *acb = quorum_aio_get(s, bs, qiov, sector_num, nb_sectors, QuorumAIOCB *acb = quorum_aio_get(s, bs, qiov, sector_num, nb_sectors,

8
block/raw-aio.h
View File

@ -35,9 +35,9 @@
#ifdef CONFIG_LINUX_AIO #ifdef CONFIG_LINUX_AIO
void *laio_init(void); void *laio_init(void);
void laio_cleanup(void *s); void laio_cleanup(void *s);
BlockDriverAIOCB *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);
@ -49,10 +49,10 @@ typedef struct QEMUWin32AIOState QEMUWin32AIOState;
QEMUWin32AIOState *win32_aio_init(void); QEMUWin32AIOState *win32_aio_init(void);
void win32_aio_cleanup(QEMUWin32AIOState *aio); void win32_aio_cleanup(QEMUWin32AIOState *aio);
int win32_aio_attach(QEMUWin32AIOState *aio, HANDLE hfile); int win32_aio_attach(QEMUWin32AIOState *aio, HANDLE hfile);
BlockDriverAIOCB *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,

38
block/raw-posix.c
View File

@ -1041,9 +1041,9 @@ static int paio_submit_co(BlockDriverState *bs, int fd,
return thread_pool_submit_co(pool, aio_worker, acb); return thread_pool_submit_co(pool, aio_worker, acb);
} }
static BlockDriverAIOCB *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;
@ -1066,9 +1066,9 @@ static BlockDriverAIOCB *paio_submit(BlockDriverState *bs, int fd,
return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque); return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
} }
static BlockDriverAIOCB *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;
@ -1125,24 +1125,24 @@ static void raw_aio_flush_io_queue(BlockDriverState *bs)
#endif #endif
} }
static BlockDriverAIOCB *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);
} }
static BlockDriverAIOCB *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 BlockDriverAIOCB *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;
@ -1482,7 +1482,7 @@ static int64_t try_fiemap(BlockDriverState *bs, off_t start, off_t *data,
f.fm.fm_start = start; f.fm.fm_start = start;
f.fm.fm_length = (int64_t)nb_sectors * BDRV_SECTOR_SIZE; f.fm.fm_length = (int64_t)nb_sectors * BDRV_SECTOR_SIZE;
f.fm.fm_flags = 0; f.fm.fm_flags = FIEMAP_FLAG_SYNC;
f.fm.fm_extent_count = 1; f.fm.fm_extent_count = 1;
f.fm.fm_reserved = 0; f.fm.fm_reserved = 0;
if (ioctl(s->fd, FS_IOC_FIEMAP, &f) == -1) { if (ioctl(s->fd, FS_IOC_FIEMAP, &f) == -1) {
@ -1571,9 +1571,9 @@ static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
start = sector_num * BDRV_SECTOR_SIZE; start = sector_num * BDRV_SECTOR_SIZE;
ret = try_fiemap(bs, start, &data, &hole, nb_sectors, pnum); ret = try_seek_hole(bs, start, &data, &hole, pnum);
if (ret < 0) { if (ret < 0) {
ret = try_seek_hole(bs, start, &data, &hole, pnum); ret = try_fiemap(bs, start, &data, &hole, nb_sectors, pnum);
if (ret < 0) { if (ret < 0) {
/* Assume everything is allocated. */ /* Assume everything is allocated. */
data = 0; data = 0;
@ -1595,9 +1595,9 @@ static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
return ret; return ret;
} }
static coroutine_fn BlockDriverAIOCB *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;
@ -1935,9 +1935,9 @@ static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
return ioctl(s->fd, req, buf); return ioctl(s->fd, req, buf);
} }
static BlockDriverAIOCB *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;
@ -1976,9 +1976,9 @@ static int fd_open(BlockDriverState *bs)
#endif /* !linux && !FreeBSD */ #endif /* !linux && !FreeBSD */
static coroutine_fn BlockDriverAIOCB *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;

16
block/raw-win32.c
View File

@ -138,9 +138,9 @@ static int aio_worker(void *arg)
return ret; return ret;
} }
static BlockDriverAIOCB *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;
@ -369,9 +369,9 @@ fail:
return ret; return ret;
} }
static BlockDriverAIOCB *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) {
@ -383,9 +383,9 @@ static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs,
} }
} }
static BlockDriverAIOCB *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) {
@ -397,8 +397,8 @@ static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs,
} }
} }
static BlockDriverAIOCB *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);

8
block/raw_bsd.c
View File

@ -129,10 +129,10 @@ static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
return bdrv_ioctl(bs->file, req, buf); return bdrv_ioctl(bs->file, req, buf);
} }
static BlockDriverAIOCB *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);
} }

56
block/rbd.c
View File

@ -68,7 +68,7 @@ typedef enum {
} RBDAIOCmd; } RBDAIOCmd;
typedef struct RBDAIOCB { typedef struct RBDAIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
QEMUBH *bh; QEMUBH *bh;
int64_t ret; int64_t ret;
QEMUIOVector *qiov; QEMUIOVector *qiov;
@ -589,13 +589,13 @@ static int rbd_aio_flush_wrapper(rbd_image_t image,
#endif #endif
} }
static BlockDriverAIOCB *rbd_start_aio(BlockDriverState *bs, 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)
{ {
RBDAIOCB *acb; RBDAIOCB *acb;
RADOSCB *rcb = NULL; RADOSCB *rcb = NULL;
@ -675,32 +675,32 @@ failed:
return NULL; return NULL;
} }
static BlockDriverAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, 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,
RBD_AIO_READ); RBD_AIO_READ);
} }
static BlockDriverAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, 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,
RBD_AIO_WRITE); RBD_AIO_WRITE);
} }
#ifdef LIBRBD_SUPPORTS_AIO_FLUSH #ifdef LIBRBD_SUPPORTS_AIO_FLUSH
static BlockDriverAIOCB *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);
} }
@ -876,11 +876,11 @@ static int qemu_rbd_snap_list(BlockDriverState *bs,
} }
#ifdef LIBRBD_SUPPORTS_DISCARD #ifdef LIBRBD_SUPPORTS_DISCARD
static BlockDriverAIOCB* 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,
RBD_AIO_DISCARD); RBD_AIO_DISCARD);

4
block/sheepdog.c
View File

@ -301,7 +301,7 @@ enum AIOCBState {
}; };
struct SheepdogAIOCB { struct SheepdogAIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
QEMUIOVector *qiov; QEMUIOVector *qiov;
@ -473,7 +473,7 @@ static bool sd_acb_cancelable(const SheepdogAIOCB *acb)
return true; return true;
} }
static void sd_aio_cancel(BlockDriverAIOCB *blockacb) static void sd_aio_cancel(BlockAIOCB *blockacb)
{ {
SheepdogAIOCB *acb = (SheepdogAIOCB *)blockacb; SheepdogAIOCB *acb = (SheepdogAIOCB *)blockacb;
BDRVSheepdogState *s = acb->common.bs->opaque; BDRVSheepdogState *s = acb->common.bs->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/vdi.c
View File

@ -490,7 +490,7 @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
/* Disable migration when vdi images are used */ /* Disable migration when vdi images are used */
error_set(&s->migration_blocker, error_set(&s->migration_blocker,
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
"vdi", bs->device_name, "live migration"); "vdi", bdrv_get_device_name(bs), "live migration");
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
return 0; return 0;

2
block/vhdx.c
View File

@ -1004,7 +1004,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
/* Disable migration when VHDX images are used */ /* Disable migration when VHDX images are used */
error_set(&s->migration_blocker, error_set(&s->migration_blocker,
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
"vhdx", bs->device_name, "live migration"); "vhdx", bdrv_get_device_name(bs), "live migration");
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
return 0; return 0;

4
block/vmdk.c
View File

@ -657,7 +657,7 @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
snprintf(buf, sizeof(buf), "VMDK version %" PRId32, snprintf(buf, sizeof(buf), "VMDK version %" PRId32,
le32_to_cpu(header.version)); le32_to_cpu(header.version));
error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
bs->device_name, "vmdk", buf); bdrv_get_device_name(bs), "vmdk", buf);
return -ENOTSUP; return -ENOTSUP;
} else if (le32_to_cpu(header.version) == 3 && (flags & BDRV_O_RDWR)) { } else if (le32_to_cpu(header.version) == 3 && (flags & BDRV_O_RDWR)) {
/* VMware KB 2064959 explains that version 3 added support for /* VMware KB 2064959 explains that version 3 added support for
@ -939,7 +939,7 @@ static int vmdk_open(BlockDriverState *bs, QDict *options, int flags,
/* Disable migration when VMDK images are used */ /* Disable migration when VMDK images are used */
error_set(&s->migration_blocker, error_set(&s->migration_blocker,
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
"vmdk", bs->device_name, "live migration"); "vmdk", bdrv_get_device_name(bs), "live migration");
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
g_free(buf); g_free(buf);
return 0; return 0;

2
block/vpc.c
View File

@ -320,7 +320,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
/* Disable migration when VHD images are used */ /* Disable migration when VHD images are used */
error_set(&s->migration_blocker, error_set(&s->migration_blocker,
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
"vpc", bs->device_name, "live migration"); "vpc", bdrv_get_device_name(bs), "live migration");
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
return 0; return 0;

4
block/vvfat.c
View File

@ -1182,7 +1182,7 @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
if (s->qcow) { if (s->qcow) {
error_set(&s->migration_blocker, error_set(&s->migration_blocker,
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
"vvfat (rw)", bs->device_name, "live migration"); "vvfat (rw)", bdrv_get_device_name(bs), "live migration");
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
} }
@ -2939,7 +2939,7 @@ static int enable_write_target(BDRVVVFATState *s, Error **errp)
unlink(s->qcow_filename); unlink(s->qcow_filename);
#endif #endif
bdrv_set_backing_hd(s->bs, bdrv_new("", &error_abort)); bdrv_set_backing_hd(s->bs, bdrv_new());
s->bs->backing_hd->drv = &vvfat_write_target; s->bs->backing_hd->drv = &vvfat_write_target;
s->bs->backing_hd->opaque = g_new(void *, 1); s->bs->backing_hd->opaque = g_new(void *, 1);
*(void**)s->bs->backing_hd->opaque = s; *(void**)s->bs->backing_hd->opaque = s;

6
block/win32-aio.c
View File

@ -44,7 +44,7 @@ struct QEMUWin32AIOState {
}; };
typedef struct QEMUWin32AIOCB { typedef struct QEMUWin32AIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
struct QEMUWin32AIOState *ctx; struct QEMUWin32AIOState *ctx;
int nbytes; int nbytes;
OVERLAPPED ov; OVERLAPPED ov;
@ -110,10 +110,10 @@ static const AIOCBInfo win32_aiocb_info = {
.aiocb_size = sizeof(QEMUWin32AIOCB), .aiocb_size = sizeof(QEMUWin32AIOCB),
}; };
BlockDriverAIOCB *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;

201
blockdev.c
View File

@ -30,6 +30,7 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "hw/block/block.h" #include "hw/block/block.h"
#include "block/blockjob.h" #include "block/blockjob.h"
@ -46,8 +47,6 @@
#include "trace.h" #include "trace.h"
#include "sysemu/arch_init.h" #include "sysemu/arch_init.h"
static QTAILQ_HEAD(drivelist, DriveInfo) drives = QTAILQ_HEAD_INITIALIZER(drives);
static const char *const if_name[IF_COUNT] = { static const char *const if_name[IF_COUNT] = {
[IF_NONE] = "none", [IF_NONE] = "none",
[IF_IDE] = "ide", [IF_IDE] = "ide",
@ -85,13 +84,15 @@ static int if_max_devs[IF_COUNT] = {
*/ */
void override_max_devs(BlockInterfaceType type, int max_devs) void override_max_devs(BlockInterfaceType type, int max_devs)
{ {
BlockBackend *blk;
DriveInfo *dinfo; DriveInfo *dinfo;
if (max_devs <= 0) { if (max_devs <= 0) {
return; return;
} }
QTAILQ_FOREACH(dinfo, &drives, next) { for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
dinfo = blk_legacy_dinfo(blk);
if (dinfo->type == type) { if (dinfo->type == type) {
fprintf(stderr, "Cannot override units-per-bus property of" fprintf(stderr, "Cannot override units-per-bus property of"
" the %s interface, because a drive of that type has" " the %s interface, because a drive of that type has"
@ -110,28 +111,27 @@ void override_max_devs(BlockInterfaceType type, int max_devs)
* automatic deletion, and generic qdev code calls blockdev_auto_del() * automatic deletion, and generic qdev code calls blockdev_auto_del()
* when deletion is actually safe. * when deletion is actually safe.
*/ */
void blockdev_mark_auto_del(BlockDriverState *bs) void blockdev_mark_auto_del(BlockBackend *blk)
{ {
DriveInfo *dinfo = drive_get_by_blockdev(bs); DriveInfo *dinfo = blk_legacy_dinfo(blk);
BlockDriverState *bs = blk_bs(blk);
if (dinfo && !dinfo->enable_auto_del) { if (!dinfo) {
return; return;
} }
if (bs->job) { if (bs->job) {
block_job_cancel(bs->job); block_job_cancel(bs->job);
} }
if (dinfo) { dinfo->auto_del = 1;
dinfo->auto_del = 1;
}
} }
void blockdev_auto_del(BlockDriverState *bs) void blockdev_auto_del(BlockBackend *blk)
{ {
DriveInfo *dinfo = drive_get_by_blockdev(bs); DriveInfo *dinfo = blk_legacy_dinfo(blk);
if (dinfo && dinfo->auto_del) { if (dinfo && dinfo->auto_del) {
drive_del(dinfo); blk_unref(blk);
} }
} }
@ -193,15 +193,15 @@ QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit) DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
{ {
BlockBackend *blk;
DriveInfo *dinfo; DriveInfo *dinfo;
/* seek interface, bus and unit */ for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
dinfo = blk_legacy_dinfo(blk);
QTAILQ_FOREACH(dinfo, &drives, next) { if (dinfo && dinfo->type == type
if (dinfo->type == type && && dinfo->bus == bus && dinfo->unit == unit) {
dinfo->bus == bus &&
dinfo->unit == unit)
return dinfo; return dinfo;
}
} }
return NULL; return NULL;
@ -209,17 +209,19 @@ DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
bool drive_check_orphaned(void) bool drive_check_orphaned(void)
{ {
BlockBackend *blk;
DriveInfo *dinfo; DriveInfo *dinfo;
bool rs = false; bool rs = false;
QTAILQ_FOREACH(dinfo, &drives, next) { for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
dinfo = blk_legacy_dinfo(blk);
/* If dinfo->bdrv->dev is NULL, it has no device attached. */ /* If dinfo->bdrv->dev is NULL, it has no device attached. */
/* Unless this is a default drive, this may be an oversight. */ /* Unless this is a default drive, this may be an oversight. */
if (!dinfo->bdrv->dev && !dinfo->is_default && if (!blk_get_attached_dev(blk) && !dinfo->is_default &&
dinfo->type != IF_NONE) { dinfo->type != IF_NONE) {
fprintf(stderr, "Warning: Orphaned drive without device: " fprintf(stderr, "Warning: Orphaned drive without device: "
"id=%s,file=%s,if=%s,bus=%d,unit=%d\n", "id=%s,file=%s,if=%s,bus=%d,unit=%d\n",
dinfo->id, dinfo->bdrv->filename, if_name[dinfo->type], blk_name(blk), blk_bs(blk)->filename, if_name[dinfo->type],
dinfo->bus, dinfo->unit); dinfo->bus, dinfo->unit);
rs = true; rs = true;
} }
@ -238,13 +240,15 @@ DriveInfo *drive_get_by_index(BlockInterfaceType type, int index)
int drive_get_max_bus(BlockInterfaceType type) int drive_get_max_bus(BlockInterfaceType type)
{ {
int max_bus; int max_bus;
BlockBackend *blk;
DriveInfo *dinfo; DriveInfo *dinfo;
max_bus = -1; max_bus = -1;
QTAILQ_FOREACH(dinfo, &drives, next) { for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
if(dinfo->type == type && dinfo = blk_legacy_dinfo(blk);
dinfo->bus > max_bus) if (dinfo && dinfo->type == type && dinfo->bus > max_bus) {
max_bus = dinfo->bus; max_bus = dinfo->bus;
}
} }
return max_bus; return max_bus;
} }
@ -259,40 +263,11 @@ DriveInfo *drive_get_next(BlockInterfaceType type)
return drive_get(type, 0, next_block_unit[type]++); return drive_get(type, 0, next_block_unit[type]++);
} }
DriveInfo *drive_get_by_blockdev(BlockDriverState *bs)
{
DriveInfo *dinfo;
QTAILQ_FOREACH(dinfo, &drives, next) {
if (dinfo->bdrv == bs) {
return dinfo;
}
}
return NULL;
}
static void bdrv_format_print(void *opaque, const char *name) static void bdrv_format_print(void *opaque, const char *name)
{ {
error_printf(" %s", name); error_printf(" %s", name);
} }
void drive_del(DriveInfo *dinfo)
{
bdrv_unref(dinfo->bdrv);
}
void drive_info_del(DriveInfo *dinfo)
{
if (!dinfo) {
return;
}
qemu_opts_del(dinfo->opts);
g_free(dinfo->id);
QTAILQ_REMOVE(&drives, dinfo, next);
g_free(dinfo->serial);
g_free(dinfo);
}
typedef struct { typedef struct {
QEMUBH *bh; QEMUBH *bh;
BlockDriverState *bs; BlockDriverState *bs;
@ -360,15 +335,15 @@ static bool check_throttle_config(ThrottleConfig *cfg, Error **errp)
typedef enum { MEDIA_DISK, MEDIA_CDROM } DriveMediaType; typedef enum { MEDIA_DISK, MEDIA_CDROM } DriveMediaType;
/* Takes the ownership of bs_opts */ /* Takes the ownership of bs_opts */
static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
Error **errp) Error **errp)
{ {
const char *buf; const char *buf;
int ro = 0; int ro = 0;
int bdrv_flags = 0; int bdrv_flags = 0;
int on_read_error, on_write_error; int on_read_error, on_write_error;
BlockBackend *blk;
BlockDriverState *bs; BlockDriverState *bs;
DriveInfo *dinfo;
ThrottleConfig cfg; ThrottleConfig cfg;
int snapshot = 0; int snapshot = 0;
bool copy_on_read; bool copy_on_read;
@ -523,10 +498,11 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts,
} }
/* init */ /* init */
bs = bdrv_new(qemu_opts_id(opts), errp); blk = blk_new_with_bs(qemu_opts_id(opts), errp);
if (!bs) { if (!blk) {
goto early_err; goto early_err;
} }
bs = blk_bs(blk);
bs->open_flags = snapshot ? BDRV_O_SNAPSHOT : 0; bs->open_flags = snapshot ? BDRV_O_SNAPSHOT : 0;
bs->read_only = ro; bs->read_only = ro;
bs->detect_zeroes = detect_zeroes; bs->detect_zeroes = detect_zeroes;
@ -539,18 +515,13 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts,
bdrv_set_io_limits(bs, &cfg); bdrv_set_io_limits(bs, &cfg);
} }
dinfo = g_malloc0(sizeof(*dinfo));
dinfo->id = g_strdup(qemu_opts_id(opts));
dinfo->bdrv = bs;
QTAILQ_INSERT_TAIL(&drives, dinfo, next);
if (!file || !*file) { if (!file || !*file) {
if (has_driver_specific_opts) { if (has_driver_specific_opts) {
file = NULL; file = NULL;
} else { } else {
QDECREF(bs_opts); QDECREF(bs_opts);
qemu_opts_del(opts); qemu_opts_del(opts);
return dinfo; return blk;
} }
} }
if (snapshot) { if (snapshot) {
@ -571,11 +542,11 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts,
QINCREF(bs_opts); QINCREF(bs_opts);
ret = bdrv_open(&bs, file, NULL, bs_opts, bdrv_flags, drv, &error); ret = bdrv_open(&bs, file, NULL, bs_opts, bdrv_flags, drv, &error);
assert(bs == dinfo->bdrv); assert(bs == blk_bs(blk));
if (ret < 0) { if (ret < 0) {
error_setg(errp, "could not open disk image %s: %s", error_setg(errp, "could not open disk image %s: %s",
file ?: dinfo->id, error_get_pretty(error)); file ?: blk_name(blk), error_get_pretty(error));
error_free(error); error_free(error);
goto err; goto err;
} }
@ -587,10 +558,10 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts,
QDECREF(bs_opts); QDECREF(bs_opts);
qemu_opts_del(opts); qemu_opts_del(opts);
return dinfo; return blk;
err: err:
bdrv_unref(bs); blk_unref(blk);
early_err: early_err:
qemu_opts_del(opts); qemu_opts_del(opts);
err_no_opts: err_no_opts:
@ -703,6 +674,7 @@ QemuOptsList qemu_legacy_drive_opts = {
DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type) DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
{ {
const char *value; const char *value;
BlockBackend *blk;
DriveInfo *dinfo = NULL; DriveInfo *dinfo = NULL;
QDict *bs_opts; QDict *bs_opts;
QemuOpts *legacy_opts; QemuOpts *legacy_opts;
@ -1000,9 +972,9 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
} }
/* Actual block device init: Functionality shared with blockdev-add */ /* Actual block device init: Functionality shared with blockdev-add */
dinfo = blockdev_init(filename, bs_opts, &local_err); blk = blockdev_init(filename, bs_opts, &local_err);
bs_opts = NULL; bs_opts = NULL;
if (dinfo == NULL) { if (!blk) {
if (local_err) { if (local_err) {
error_report("%s", error_get_pretty(local_err)); error_report("%s", error_get_pretty(local_err));
error_free(local_err); error_free(local_err);
@ -1012,8 +984,8 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
assert(!local_err); assert(!local_err);
} }
/* Set legacy DriveInfo fields */ /* Create legacy DriveInfo */
dinfo->enable_auto_del = true; dinfo = g_malloc0(sizeof(*dinfo));
dinfo->opts = all_opts; dinfo->opts = all_opts;
dinfo->cyls = cyls; dinfo->cyls = cyls;
@ -1025,9 +997,10 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
dinfo->bus = bus_id; dinfo->bus = bus_id;
dinfo->unit = unit_id; dinfo->unit = unit_id;
dinfo->devaddr = devaddr; dinfo->devaddr = devaddr;
dinfo->serial = g_strdup(serial); dinfo->serial = g_strdup(serial);
blk_set_legacy_dinfo(blk, dinfo);
switch(type) { switch(type) {
case IF_IDE: case IF_IDE:
case IF_SCSI: case IF_SCSI:
@ -1620,19 +1593,21 @@ exit:
} }
static void eject_device(BlockDriverState *bs, int force, Error **errp) static void eject_device(BlockBackend *blk, int force, Error **errp)
{ {
BlockDriverState *bs = blk_bs(blk);
if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) { if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) {
return; return;
} }
if (!bdrv_dev_has_removable_media(bs)) { if (!blk_dev_has_removable_media(blk)) {
error_setg(errp, "Device '%s' is not removable", error_setg(errp, "Device '%s' is not removable",
bdrv_get_device_name(bs)); bdrv_get_device_name(bs));
return; return;
} }
if (bdrv_dev_is_medium_locked(bs) && !bdrv_dev_is_tray_open(bs)) { if (blk_dev_is_medium_locked(blk) && !blk_dev_is_tray_open(blk)) {
bdrv_dev_eject_request(bs, force); blk_dev_eject_request(blk, force);
if (!force) { if (!force) {
error_setg(errp, "Device '%s' is locked", error_setg(errp, "Device '%s' is locked",
bdrv_get_device_name(bs)); bdrv_get_device_name(bs));
@ -1645,15 +1620,15 @@ static void eject_device(BlockDriverState *bs, int force, Error **errp)
void qmp_eject(const char *device, bool has_force, bool force, Error **errp) void qmp_eject(const char *device, bool has_force, bool force, Error **errp)
{ {
BlockDriverState *bs; BlockBackend *blk;
bs = bdrv_find(device); blk = blk_by_name(device);
if (!bs) { if (!blk) {
error_set(errp, QERR_DEVICE_NOT_FOUND, device); error_set(errp, QERR_DEVICE_NOT_FOUND, device);
return; return;
} }
eject_device(bs, force, errp); eject_device(blk, force, errp);
} }
void qmp_block_passwd(bool has_device, const char *device, void qmp_block_passwd(bool has_device, const char *device,
@ -1712,16 +1687,18 @@ static void qmp_bdrv_open_encrypted(BlockDriverState *bs, const char *filename,
void qmp_change_blockdev(const char *device, const char *filename, void qmp_change_blockdev(const char *device, const char *filename,
const char *format, Error **errp) const char *format, Error **errp)
{ {
BlockBackend *blk;
BlockDriverState *bs; BlockDriverState *bs;
BlockDriver *drv = NULL; BlockDriver *drv = NULL;
int bdrv_flags; int bdrv_flags;
Error *err = NULL; Error *err = NULL;
bs = bdrv_find(device); blk = blk_by_name(device);
if (!bs) { if (!blk) {
error_set(errp, QERR_DEVICE_NOT_FOUND, device); error_set(errp, QERR_DEVICE_NOT_FOUND, device);
return; return;
} }
bs = blk_bs(blk);
if (format) { if (format) {
drv = bdrv_find_whitelisted_format(format, bs->read_only); drv = bdrv_find_whitelisted_format(format, bs->read_only);
@ -1731,7 +1708,7 @@ void qmp_change_blockdev(const char *device, const char *filename,
} }
} }
eject_device(bs, 0, &err); eject_device(blk, 0, &err);
if (err) { if (err) {
error_propagate(errp, err); error_propagate(errp, err);
return; return;
@ -1829,19 +1806,19 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,
int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data) int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
{ {
const char *id = qdict_get_str(qdict, "id"); const char *id = qdict_get_str(qdict, "id");
BlockBackend *blk;
BlockDriverState *bs; BlockDriverState *bs;
DriveInfo *dinfo;
AioContext *aio_context; AioContext *aio_context;
Error *local_err = NULL; Error *local_err = NULL;
bs = bdrv_find(id); blk = blk_by_name(id);
if (!bs) { if (!blk) {
error_report("Device '%s' not found", id); error_report("Device '%s' not found", id);
return -1; return -1;
} }
bs = blk_bs(blk);
dinfo = drive_get_by_blockdev(bs); if (!blk_legacy_dinfo(blk)) {
if (dinfo && !dinfo->enable_auto_del) {
error_report("Deleting device added with blockdev-add" error_report("Deleting device added with blockdev-add"
" is not supported"); " is not supported");
return -1; return -1;
@ -1867,14 +1844,13 @@ int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
* can be removed. If this is a drive with no device backing * can be removed. If this is a drive with no device backing
* then we can just get rid of the block driver state right here. * then we can just get rid of the block driver state right here.
*/ */
if (bdrv_get_attached_dev(bs)) { if (blk_get_attached_dev(blk)) {
bdrv_make_anon(bs); blk_hide_on_behalf_of_do_drive_del(blk);
/* Further I/O must not pause the guest */ /* Further I/O must not pause the guest */
bdrv_set_on_error(bs, BLOCKDEV_ON_ERROR_REPORT, bdrv_set_on_error(bs, BLOCKDEV_ON_ERROR_REPORT,
BLOCKDEV_ON_ERROR_REPORT); BLOCKDEV_ON_ERROR_REPORT);
} else { } else {
drive_del(dinfo); blk_unref(blk);
} }
aio_context_release(aio_context); aio_context_release(aio_context);
@ -2566,7 +2542,7 @@ void qmp_change_backing_file(const char *device,
void qmp_blockdev_add(BlockdevOptions *options, Error **errp) void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
{ {
QmpOutputVisitor *ov = qmp_output_visitor_new(); QmpOutputVisitor *ov = qmp_output_visitor_new();
DriveInfo *dinfo; BlockBackend *blk;
QObject *obj; QObject *obj;
QDict *qdict; QDict *qdict;
Error *local_err = NULL; Error *local_err = NULL;
@ -2604,14 +2580,14 @@ void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
qdict_flatten(qdict); qdict_flatten(qdict);
dinfo = blockdev_init(NULL, qdict, &local_err); blk = blockdev_init(NULL, qdict, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
goto fail; goto fail;
} }
if (bdrv_key_required(dinfo->bdrv)) { if (bdrv_key_required(blk_bs(blk))) {
drive_del(dinfo); blk_unref(blk);
error_setg(errp, "blockdev-add doesn't support encrypted devices"); error_setg(errp, "blockdev-add doesn't support encrypted devices");
goto fail; goto fail;
} }
@ -2620,26 +2596,21 @@ fail:
qmp_output_visitor_cleanup(ov); qmp_output_visitor_cleanup(ov);
} }
static void do_qmp_query_block_jobs_one(void *opaque, BlockDriverState *bs)
{
BlockJobInfoList **prev = opaque;
BlockJob *job = bs->job;
if (job) {
BlockJobInfoList *elem = g_new0(BlockJobInfoList, 1);
elem->value = block_job_query(bs->job);
(*prev)->next = elem;
*prev = elem;
}
}
BlockJobInfoList *qmp_query_block_jobs(Error **errp) BlockJobInfoList *qmp_query_block_jobs(Error **errp)
{ {
/* Dummy is a fake list element for holding the head pointer */ BlockJobInfoList *head = NULL, **p_next = &head;
BlockJobInfoList dummy = {}; BlockDriverState *bs;
BlockJobInfoList *prev = &dummy;
bdrv_iterate(do_qmp_query_block_jobs_one, &prev); for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) {
return dummy.next; if (bs->job) {
BlockJobInfoList *elem = g_new0(BlockJobInfoList, 1);
elem->value = block_job_query(bs->job);
*p_next = elem;
p_next = &elem->next;
}
}
return head;
} }
QemuOptsList qemu_common_drive_opts = { QemuOptsList qemu_common_drive_opts = {

7
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;
@ -107,7 +107,8 @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
void block_job_complete(BlockJob *job, Error **errp) void block_job_complete(BlockJob *job, Error **errp)
{ {
if (job->paused || job->cancelled || !job->driver->complete) { if (job->paused || job->cancelled || !job->driver->complete) {
error_set(errp, QERR_BLOCK_JOB_NOT_READY, job->bs->device_name); error_set(errp, QERR_BLOCK_JOB_NOT_READY,
bdrv_get_device_name(job->bs));
return; return;
} }
@ -154,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;

3
device-hotplug.c
View File

@ -24,6 +24,7 @@
#include "hw/hw.h" #include "hw/hw.h"
#include "hw/boards.h" #include "hw/boards.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "qemu/config-file.h" #include "qemu/config-file.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
@ -76,6 +77,6 @@ void drive_hot_add(Monitor *mon, const QDict *qdict)
err: err:
if (dinfo) { if (dinfo) {
drive_del(dinfo); blk_unref(blk_by_legacy_dinfo(dinfo));
} }
} }

67
dma-helpers.c
View File

@ -7,6 +7,7 @@
* (GNU GPL), version 2 or later. * (GNU GPL), version 2 or later.
*/ */
#include "sysemu/block-backend.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"
#include "trace.h" #include "trace.h"
#include "qemu/range.h" #include "qemu/range.h"
@ -67,9 +68,9 @@ void qemu_sglist_destroy(QEMUSGList *qsg)
} }
typedef struct { typedef struct {
BlockDriverAIOCB common; BlockAIOCB common;
BlockDriverState *bs; BlockBackend *blk;
BlockDriverAIOCB *acb; BlockAIOCB *acb;
QEMUSGList *sg; QEMUSGList *sg;
uint64_t sector_num; uint64_t sector_num;
DMADirection dir; DMADirection dir;
@ -80,7 +81,7 @@ typedef struct {
DMAIOFunc *io_func; DMAIOFunc *io_func;
} DMAAIOCB; } DMAAIOCB;
static void dma_bdrv_cb(void *opaque, int ret); static void dma_blk_cb(void *opaque, int ret);
static void reschedule_dma(void *opaque) static void reschedule_dma(void *opaque)
{ {
@ -88,7 +89,7 @@ static void reschedule_dma(void *opaque)
qemu_bh_delete(dbs->bh); qemu_bh_delete(dbs->bh);
dbs->bh = NULL; dbs->bh = NULL;
dma_bdrv_cb(dbs, 0); dma_blk_cb(dbs, 0);
} }
static void continue_after_map_failure(void *opaque) static void continue_after_map_failure(void *opaque)
@ -99,7 +100,7 @@ static void continue_after_map_failure(void *opaque)
qemu_bh_schedule(dbs->bh); qemu_bh_schedule(dbs->bh);
} }
static void dma_bdrv_unmap(DMAAIOCB *dbs) static void dma_blk_unmap(DMAAIOCB *dbs)
{ {
int i; int i;
@ -115,7 +116,7 @@ static void dma_complete(DMAAIOCB *dbs, int ret)
{ {
trace_dma_complete(dbs, ret, dbs->common.cb); trace_dma_complete(dbs, ret, dbs->common.cb);
dma_bdrv_unmap(dbs); dma_blk_unmap(dbs);
if (dbs->common.cb) { if (dbs->common.cb) {
dbs->common.cb(dbs->common.opaque, ret); dbs->common.cb(dbs->common.opaque, ret);
} }
@ -127,13 +128,13 @@ static void dma_complete(DMAAIOCB *dbs, int ret)
qemu_aio_unref(dbs); qemu_aio_unref(dbs);
} }
static void dma_bdrv_cb(void *opaque, int ret) static void dma_blk_cb(void *opaque, int ret)
{ {
DMAAIOCB *dbs = (DMAAIOCB *)opaque; DMAAIOCB *dbs = (DMAAIOCB *)opaque;
dma_addr_t cur_addr, cur_len; dma_addr_t cur_addr, cur_len;
void *mem; void *mem;
trace_dma_bdrv_cb(dbs, ret); trace_dma_blk_cb(dbs, ret);
dbs->acb = NULL; dbs->acb = NULL;
dbs->sector_num += dbs->iov.size / 512; dbs->sector_num += dbs->iov.size / 512;
@ -142,7 +143,7 @@ static void dma_bdrv_cb(void *opaque, int ret)
dma_complete(dbs, ret); dma_complete(dbs, ret);
return; return;
} }
dma_bdrv_unmap(dbs); dma_blk_unmap(dbs);
while (dbs->sg_cur_index < dbs->sg->nsg) { while (dbs->sg_cur_index < dbs->sg->nsg) {
cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte; cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte;
@ -168,19 +169,19 @@ static void dma_bdrv_cb(void *opaque, int ret)
qemu_iovec_discard_back(&dbs->iov, dbs->iov.size & ~BDRV_SECTOR_MASK); qemu_iovec_discard_back(&dbs->iov, dbs->iov.size & ~BDRV_SECTOR_MASK);
} }
dbs->acb = dbs->io_func(dbs->bs, dbs->sector_num, &dbs->iov, dbs->acb = dbs->io_func(dbs->blk, dbs->sector_num, &dbs->iov,
dbs->iov.size / 512, dma_bdrv_cb, dbs); dbs->iov.size / 512, dma_blk_cb, dbs);
assert(dbs->acb); assert(dbs->acb);
} }
static void dma_aio_cancel(BlockDriverAIOCB *acb) static void dma_aio_cancel(BlockAIOCB *acb)
{ {
DMAAIOCB *dbs = container_of(acb, DMAAIOCB, common); DMAAIOCB *dbs = container_of(acb, DMAAIOCB, common);
trace_dma_aio_cancel(dbs); trace_dma_aio_cancel(dbs);
if (dbs->acb) { if (dbs->acb) {
bdrv_aio_cancel_async(dbs->acb); blk_aio_cancel_async(dbs->acb);
} }
} }
@ -190,17 +191,17 @@ static const AIOCBInfo dma_aiocb_info = {
.cancel_async = dma_aio_cancel, .cancel_async = dma_aio_cancel,
}; };
BlockDriverAIOCB *dma_bdrv_io( BlockAIOCB *dma_blk_io(
BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num, BlockBackend *blk, 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 = blk_aio_get(&dma_aiocb_info, blk, cb, opaque);
trace_dma_bdrv_io(dbs, bs, sector_num, (dir == DMA_DIRECTION_TO_DEVICE)); trace_dma_blk_io(dbs, blk, sector_num, (dir == DMA_DIRECTION_TO_DEVICE));
dbs->acb = NULL; dbs->acb = NULL;
dbs->bs = bs; dbs->blk = blk;
dbs->sg = sg; dbs->sg = sg;
dbs->sector_num = sector_num; dbs->sector_num = sector_num;
dbs->sg_cur_index = 0; dbs->sg_cur_index = 0;
@ -209,25 +210,25 @@ BlockDriverAIOCB *dma_bdrv_io(
dbs->io_func = io_func; dbs->io_func = io_func;
dbs->bh = NULL; dbs->bh = NULL;
qemu_iovec_init(&dbs->iov, sg->nsg); qemu_iovec_init(&dbs->iov, sg->nsg);
dma_bdrv_cb(dbs, 0); dma_blk_cb(dbs, 0);
return &dbs->common; return &dbs->common;
} }
BlockDriverAIOCB *dma_bdrv_read(BlockDriverState *bs, BlockAIOCB *dma_blk_read(BlockBackend *blk,
QEMUSGList *sg, uint64_t sector, QEMUSGList *sg, uint64_t sector,
void (*cb)(void *opaque, int ret), void *opaque) void (*cb)(void *opaque, int ret), void *opaque)
{ {
return dma_bdrv_io(bs, sg, sector, bdrv_aio_readv, cb, opaque, return dma_blk_io(blk, sg, sector, blk_aio_readv, cb, opaque,
DMA_DIRECTION_FROM_DEVICE); DMA_DIRECTION_FROM_DEVICE);
} }
BlockDriverAIOCB *dma_bdrv_write(BlockDriverState *bs, BlockAIOCB *dma_blk_write(BlockBackend *blk,
QEMUSGList *sg, uint64_t sector, QEMUSGList *sg, uint64_t sector,
void (*cb)(void *opaque, int ret), void *opaque) void (*cb)(void *opaque, int ret), void *opaque)
{ {
return dma_bdrv_io(bs, sg, sector, bdrv_aio_writev, cb, opaque, return dma_blk_io(blk, sg, sector, blk_aio_writev, cb, opaque,
DMA_DIRECTION_TO_DEVICE); DMA_DIRECTION_TO_DEVICE);
} }
@ -262,8 +263,8 @@ uint64_t dma_buf_write(uint8_t *ptr, int32_t len, QEMUSGList *sg)
return dma_buf_rw(ptr, len, sg, DMA_DIRECTION_TO_DEVICE); return dma_buf_rw(ptr, len, sg, DMA_DIRECTION_TO_DEVICE);
} }
void dma_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, void dma_acct_start(BlockBackend *blk, BlockAcctCookie *cookie,
QEMUSGList *sg, enum BlockAcctType type) QEMUSGList *sg, enum BlockAcctType type)
{ {
block_acct_start(bdrv_get_stats(bs), cookie, sg->size, type); block_acct_start(blk_get_stats(blk), cookie, sg->size, type);
} }

8
docs/blkdebug.txt
View File

@ -70,10 +70,10 @@ Rules support the following attributes:
once - (optional, default "off") only execute this action on the first once - (optional, default "off") only execute this action on the first
matching request matching request
immediately - (optional, default "off") return a NULL BlockDriverAIOCB immediately - (optional, default "off") return a NULL BlockAIOCB
pointer and fail without an errno instead. This exercises the pointer and fail without an errno instead. This
code path where BlockDriverAIOCB fails and the caller's exercises the code path where BlockAIOCB fails and the
BlockDriverCompletionFunc is not invoked. caller's BlockCompletionFunc is not invoked.
Events Events
------ ------

10
hw/arm/collie.c
View File

@ -15,7 +15,7 @@
#include "strongarm.h" #include "strongarm.h"
#include "hw/arm/arm.h" #include "hw/arm/arm.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
static struct arm_boot_info collie_binfo = { static struct arm_boot_info collie_binfo = {
@ -41,13 +41,13 @@ static void collie_init(MachineState *machine)
dinfo = drive_get(IF_PFLASH, 0, 0); dinfo = drive_get(IF_PFLASH, 0, 0);
pflash_cfi01_register(SA_CS0, NULL, "collie.fl1", 0x02000000, pflash_cfi01_register(SA_CS0, NULL, "collie.fl1", 0x02000000,
dinfo ? dinfo->bdrv : NULL, (64 * 1024), dinfo ? blk_by_legacy_dinfo(dinfo) : NULL,
512, 4, 0x00, 0x00, 0x00, 0x00, 0); (64 * 1024), 512, 4, 0x00, 0x00, 0x00, 0x00, 0);
dinfo = drive_get(IF_PFLASH, 0, 1); dinfo = drive_get(IF_PFLASH, 0, 1);
pflash_cfi01_register(SA_CS1, NULL, "collie.fl2", 0x02000000, pflash_cfi01_register(SA_CS1, NULL, "collie.fl2", 0x02000000,
dinfo ? dinfo->bdrv : NULL, (64 * 1024), dinfo ? blk_by_legacy_dinfo(dinfo) : NULL,
512, 4, 0x00, 0x00, 0x00, 0x00, 0); (64 * 1024), 512, 4, 0x00, 0x00, 0x00, 0x00, 0);
sysbus_create_simple("scoop", 0x40800000, NULL); sysbus_create_simple("scoop", 0x40800000, NULL);

6
hw/arm/gumstix.c
View File

@ -40,7 +40,7 @@
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "hw/devices.h" #include "hw/devices.h"
#include "hw/boards.h" #include "hw/boards.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "sysemu/qtest.h" #include "sysemu/qtest.h"
@ -71,7 +71,7 @@ static void connex_init(MachineState *machine)
be = 0; be = 0;
#endif #endif
if (!pflash_cfi01_register(0x00000000, NULL, "connext.rom", connex_rom, if (!pflash_cfi01_register(0x00000000, NULL, "connext.rom", connex_rom,
dinfo ? dinfo->bdrv : NULL, dinfo ? blk_by_legacy_dinfo(dinfo) : NULL,
sector_len, connex_rom / sector_len, sector_len, connex_rom / sector_len,
2, 0, 0, 0, 0, be)) { 2, 0, 0, 0, 0, be)) {
fprintf(stderr, "qemu: Error registering flash memory.\n"); fprintf(stderr, "qemu: Error registering flash memory.\n");
@ -109,7 +109,7 @@ static void verdex_init(MachineState *machine)
be = 0; be = 0;
#endif #endif
if (!pflash_cfi01_register(0x00000000, NULL, "verdex.rom", verdex_rom, if (!pflash_cfi01_register(0x00000000, NULL, "verdex.rom", verdex_rom,
dinfo ? dinfo->bdrv : NULL, dinfo ? blk_by_legacy_dinfo(dinfo) : NULL,
sector_len, verdex_rom / sector_len, sector_len, verdex_rom / sector_len,
2, 0, 0, 0, 0, be)) { 2, 0, 0, 0, 0, be)) {
fprintf(stderr, "qemu: Error registering flash memory.\n"); fprintf(stderr, "qemu: Error registering flash memory.\n");

2
hw/arm/highbank.c
View File

@ -24,7 +24,7 @@
#include "net/net.h" #include "net/net.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "hw/boards.h" #include "hw/boards.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"

8
hw/arm/mainstone.c
View File

@ -18,7 +18,7 @@
#include "hw/devices.h" #include "hw/devices.h"
#include "hw/boards.h" #include "hw/boards.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "hw/sysbus.h" #include "hw/sysbus.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "sysemu/qtest.h" #include "sysemu/qtest.h"
@ -149,9 +149,9 @@ static void mainstone_common_init(MemoryRegion *address_space_mem,
if (!pflash_cfi01_register(mainstone_flash_base[i], NULL, if (!pflash_cfi01_register(mainstone_flash_base[i], NULL,
i ? "mainstone.flash1" : "mainstone.flash0", i ? "mainstone.flash1" : "mainstone.flash0",
MAINSTONE_FLASH, MAINSTONE_FLASH,
dinfo->bdrv, sector_len, blk_by_legacy_dinfo(dinfo),
MAINSTONE_FLASH / sector_len, 4, 0, 0, 0, 0, sector_len, MAINSTONE_FLASH / sector_len,
be)) { 4, 0, 0, 0, 0, be)) {
fprintf(stderr, "qemu: Error registering flash memory.\n"); fprintf(stderr, "qemu: Error registering flash memory.\n");
exit(1); exit(1);
} }

13
hw/arm/musicpal.c
View File

@ -18,11 +18,10 @@
#include "hw/char/serial.h" #include "hw/char/serial.h"
#include "qemu/timer.h" #include "qemu/timer.h"
#include "hw/ptimer.h" #include "hw/ptimer.h"
#include "block/block.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "ui/console.h" #include "ui/console.h"
#include "hw/i2c/i2c.h" #include "hw/i2c/i2c.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "ui/pixel_ops.h" #include "ui/pixel_ops.h"
@ -1632,7 +1631,9 @@ static void musicpal_init(MachineState *machine)
/* Register flash */ /* Register flash */
dinfo = drive_get(IF_PFLASH, 0, 0); dinfo = drive_get(IF_PFLASH, 0, 0);
if (dinfo) { if (dinfo) {
flash_size = bdrv_getlength(dinfo->bdrv); BlockBackend *blk = blk_by_legacy_dinfo(dinfo);
flash_size = blk_getlength(blk);
if (flash_size != 8*1024*1024 && flash_size != 16*1024*1024 && if (flash_size != 8*1024*1024 && flash_size != 16*1024*1024 &&
flash_size != 32*1024*1024) { flash_size != 32*1024*1024) {
fprintf(stderr, "Invalid flash image size\n"); fprintf(stderr, "Invalid flash image size\n");
@ -1647,16 +1648,14 @@ static void musicpal_init(MachineState *machine)
#ifdef TARGET_WORDS_BIGENDIAN #ifdef TARGET_WORDS_BIGENDIAN
pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL, pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL,
"musicpal.flash", flash_size, "musicpal.flash", flash_size,
dinfo->bdrv, 0x10000, blk, 0x10000, (flash_size + 0xffff) >> 16,
(flash_size + 0xffff) >> 16,
MP_FLASH_SIZE_MAX / flash_size, MP_FLASH_SIZE_MAX / flash_size,
2, 0x00BF, 0x236D, 0x0000, 0x0000, 2, 0x00BF, 0x236D, 0x0000, 0x0000,
0x5555, 0x2AAA, 1); 0x5555, 0x2AAA, 1);
#else #else
pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL, pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL,
"musicpal.flash", flash_size, "musicpal.flash", flash_size,
dinfo->bdrv, 0x10000, blk, 0x10000, (flash_size + 0xffff) >> 16,
(flash_size + 0xffff) >> 16,
MP_FLASH_SIZE_MAX / flash_size, MP_FLASH_SIZE_MAX / flash_size,
2, 0x00BF, 0x236D, 0x0000, 0x0000, 2, 0x00BF, 0x236D, 0x0000, 0x0000,
0x5555, 0x2AAA, 0); 0x5555, 0x2AAA, 0);

7
hw/arm/nseries.c
View File

@ -31,7 +31,7 @@
#include "hw/hw.h" #include "hw/hw.h"
#include "hw/bt.h" #include "hw/bt.h"
#include "hw/loader.h" #include "hw/loader.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "hw/sysbus.h" #include "hw/sysbus.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
@ -172,8 +172,9 @@ static void n8x0_nand_setup(struct n800_s *s)
qdev_prop_set_uint16(s->nand, "version_id", 0); qdev_prop_set_uint16(s->nand, "version_id", 0);
qdev_prop_set_int32(s->nand, "shift", 1); qdev_prop_set_int32(s->nand, "shift", 1);
dinfo = drive_get(IF_MTD, 0, 0); dinfo = drive_get(IF_MTD, 0, 0);
if (dinfo && dinfo->bdrv) { if (dinfo) {
qdev_prop_set_drive_nofail(s->nand, "drive", dinfo->bdrv); qdev_prop_set_drive_nofail(s->nand, "drive",
blk_by_legacy_dinfo(dinfo));
} }
qdev_init_nofail(s->nand); qdev_init_nofail(s->nand);
sysbus_connect_irq(SYS_BUS_DEVICE(s->nand), 0, sysbus_connect_irq(SYS_BUS_DEVICE(s->nand), 0,

4
hw/arm/omap1.c
View File

@ -21,6 +21,7 @@
#include "hw/arm/omap.h" #include "hw/arm/omap.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "hw/arm/soc_dma.h" #include "hw/arm/soc_dma.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "qemu/range.h" #include "qemu/range.h"
#include "hw/sysbus.h" #include "hw/sysbus.h"
@ -3978,7 +3979,8 @@ struct omap_mpu_state_s *omap310_mpu_init(MemoryRegion *system_memory,
fprintf(stderr, "qemu: missing SecureDigital device\n"); fprintf(stderr, "qemu: missing SecureDigital device\n");
exit(1); exit(1);
} }
s->mmc = omap_mmc_init(0xfffb7800, system_memory, dinfo->bdrv, s->mmc = omap_mmc_init(0xfffb7800, system_memory,
blk_by_legacy_dinfo(dinfo),
qdev_get_gpio_in(s->ih[1], OMAP_INT_OQN), qdev_get_gpio_in(s->ih[1], OMAP_INT_OQN),
&s->drq[OMAP_DMA_MMC_TX], &s->drq[OMAP_DMA_MMC_TX],
omap_findclk(s, "mmc_ck")); omap_findclk(s, "mmc_ck"));

4
hw/arm/omap2.c
View File

@ -18,6 +18,7 @@
* with this program; if not, see <http://www.gnu.org/licenses/>. * with this program; if not, see <http://www.gnu.org/licenses/>.
*/ */
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "hw/hw.h" #include "hw/hw.h"
#include "hw/arm/arm.h" #include "hw/arm/arm.h"
@ -2461,7 +2462,8 @@ struct omap_mpu_state_s *omap2420_mpu_init(MemoryRegion *sysmem,
fprintf(stderr, "qemu: missing SecureDigital device\n"); fprintf(stderr, "qemu: missing SecureDigital device\n");
exit(1); exit(1);
} }
s->mmc = omap2_mmc_init(omap_l4tao(s->l4, 9), dinfo->bdrv, s->mmc = omap2_mmc_init(omap_l4tao(s->l4, 9),
blk_by_legacy_dinfo(dinfo),
qdev_get_gpio_in(s->ih[0], OMAP_INT_24XX_MMC_IRQ), qdev_get_gpio_in(s->ih[0], OMAP_INT_24XX_MMC_IRQ),
&s->drq[OMAP24XX_DMA_MMC1_TX], &s->drq[OMAP24XX_DMA_MMC1_TX],
omap_findclk(s, "mmc_fclk"), omap_findclk(s, "mmc_iclk")); omap_findclk(s, "mmc_fclk"), omap_findclk(s, "mmc_iclk"));

10
hw/arm/omap_sx1.c
View File

@ -31,7 +31,7 @@
#include "hw/boards.h" #include "hw/boards.h"
#include "hw/arm/arm.h" #include "hw/arm/arm.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "sysemu/qtest.h" #include "sysemu/qtest.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
@ -154,8 +154,8 @@ static void sx1_init(MachineState *machine, const int version)
if ((dinfo = drive_get(IF_PFLASH, 0, fl_idx)) != NULL) { if ((dinfo = drive_get(IF_PFLASH, 0, fl_idx)) != NULL) {
if (!pflash_cfi01_register(OMAP_CS0_BASE, NULL, if (!pflash_cfi01_register(OMAP_CS0_BASE, NULL,
"omap_sx1.flash0-1", flash_size, "omap_sx1.flash0-1", flash_size,
dinfo->bdrv, sector_size, blk_by_legacy_dinfo(dinfo),
flash_size / sector_size, sector_size, flash_size / sector_size,
4, 0, 0, 0, 0, be)) { 4, 0, 0, 0, 0, be)) {
fprintf(stderr, "qemu: Error registering flash memory %d.\n", fprintf(stderr, "qemu: Error registering flash memory %d.\n",
fl_idx); fl_idx);
@ -178,8 +178,8 @@ static void sx1_init(MachineState *machine, const int version)
if (!pflash_cfi01_register(OMAP_CS1_BASE, NULL, if (!pflash_cfi01_register(OMAP_CS1_BASE, NULL,
"omap_sx1.flash1-1", flash1_size, "omap_sx1.flash1-1", flash1_size,
dinfo->bdrv, sector_size, blk_by_legacy_dinfo(dinfo),
flash1_size / sector_size, sector_size, flash1_size / sector_size,
4, 0, 0, 0, 0, be)) { 4, 0, 0, 0, 0, be)) {
fprintf(stderr, "qemu: Error registering flash memory %d.\n", fprintf(stderr, "qemu: Error registering flash memory %d.\n",
fl_idx); fl_idx);

7
hw/arm/pxa2xx.c
View File

@ -14,6 +14,7 @@
#include "hw/i2c/i2c.h" #include "hw/i2c/i2c.h"
#include "hw/ssi.h" #include "hw/ssi.h"
#include "sysemu/char.h" #include "sysemu/char.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
static struct { static struct {
@ -2085,7 +2086,8 @@ PXA2xxState *pxa270_init(MemoryRegion *address_space,
fprintf(stderr, "qemu: missing SecureDigital device\n"); fprintf(stderr, "qemu: missing SecureDigital device\n");
exit(1); exit(1);
} }
s->mmc = pxa2xx_mmci_init(address_space, 0x41100000, dinfo->bdrv, s->mmc = pxa2xx_mmci_init(address_space, 0x41100000,
blk_by_legacy_dinfo(dinfo),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC), qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI), qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI)); qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI));
@ -2217,7 +2219,8 @@ PXA2xxState *pxa255_init(MemoryRegion *address_space, unsigned int sdram_size)
fprintf(stderr, "qemu: missing SecureDigital device\n"); fprintf(stderr, "qemu: missing SecureDigital device\n");
exit(1); exit(1);
} }
s->mmc = pxa2xx_mmci_init(address_space, 0x41100000, dinfo->bdrv, s->mmc = pxa2xx_mmci_init(address_space, 0x41100000,
blk_by_legacy_dinfo(dinfo),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC), qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI), qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI)); qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI));

2
hw/arm/realview.c
View File

@ -16,7 +16,7 @@
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "hw/boards.h" #include "hw/boards.h"
#include "hw/i2c/i2c.h" #include "hw/i2c/i2c.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"

6
hw/arm/spitz.c
View File

@ -22,10 +22,9 @@
#include "hw/devices.h" #include "hw/devices.h"
#include "hw/arm/sharpsl.h" #include "hw/arm/sharpsl.h"
#include "ui/console.h" #include "ui/console.h"
#include "block/block.h"
#include "audio/audio.h" #include "audio/audio.h"
#include "hw/boards.h" #include "hw/boards.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "hw/sysbus.h" #include "hw/sysbus.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
@ -170,7 +169,8 @@ static int sl_nand_init(SysBusDevice *dev)
s->ctl = 0; s->ctl = 0;
nand = drive_get(IF_MTD, 0, 0); nand = drive_get(IF_MTD, 0, 0);
s->nand = nand_init(nand ? nand->bdrv : NULL, s->manf_id, s->chip_id); s->nand = nand_init(nand ? blk_by_legacy_dinfo(nand) : NULL,
s->manf_id, s->chip_id);
memory_region_init_io(&s->iomem, OBJECT(s), &sl_ops, s, "sl", 0x40); memory_region_init_io(&s->iomem, OBJECT(s), &sl_ops, s, "sl", 0x40);
sysbus_init_mmio(dev, &s->iomem); sysbus_init_mmio(dev, &s->iomem);

3
hw/arm/tosa.c
View File

@ -17,11 +17,10 @@
#include "hw/devices.h" #include "hw/devices.h"
#include "hw/arm/sharpsl.h" #include "hw/arm/sharpsl.h"
#include "hw/pcmcia.h" #include "hw/pcmcia.h"
#include "block/block.h"
#include "hw/boards.h" #include "hw/boards.h"
#include "hw/i2c/i2c.h" #include "hw/i2c/i2c.h"
#include "hw/ssi.h" #include "hw/ssi.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "hw/sysbus.h" #include "hw/sysbus.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"

5
hw/arm/versatilepb.c
View File

@ -15,7 +15,7 @@
#include "hw/pci/pci.h" #include "hw/pci/pci.h"
#include "hw/i2c/i2c.h" #include "hw/i2c/i2c.h"
#include "hw/boards.h" #include "hw/boards.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
@ -338,7 +338,8 @@ static void versatile_init(MachineState *machine, int board_id)
dinfo = drive_get(IF_PFLASH, 0, 0); dinfo = drive_get(IF_PFLASH, 0, 0);
if (!pflash_cfi01_register(VERSATILE_FLASH_ADDR, NULL, "versatile.flash", if (!pflash_cfi01_register(VERSATILE_FLASH_ADDR, NULL, "versatile.flash",
VERSATILE_FLASH_SIZE, dinfo ? dinfo->bdrv : NULL, VERSATILE_FLASH_SIZE,
dinfo ? blk_by_legacy_dinfo(dinfo) : NULL,
VERSATILE_FLASH_SECT_SIZE, VERSATILE_FLASH_SECT_SIZE,
VERSATILE_FLASH_SIZE / VERSATILE_FLASH_SECT_SIZE, VERSATILE_FLASH_SIZE / VERSATILE_FLASH_SECT_SIZE,
4, 0x0089, 0x0018, 0x0000, 0x0, 0)) { 4, 0x0089, 0x0018, 0x0000, 0x0, 0)) {

5
hw/arm/vexpress.c
View File

@ -30,7 +30,7 @@
#include "hw/boards.h" #include "hw/boards.h"
#include "hw/loader.h" #include "hw/loader.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "sysemu/device_tree.h" #include "sysemu/device_tree.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
@ -491,7 +491,8 @@ static pflash_t *ve_pflash_cfi01_register(hwaddr base, const char *name,
{ {
DeviceState *dev = qdev_create(NULL, "cfi.pflash01"); DeviceState *dev = qdev_create(NULL, "cfi.pflash01");
if (di && qdev_prop_set_drive(dev, "drive", di->bdrv)) { if (di && qdev_prop_set_drive(dev, "drive",
blk_by_legacy_dinfo(di))) {
abort(); abort();
} }

4
hw/arm/virt.c
View File

@ -33,6 +33,7 @@
#include "hw/arm/primecell.h" #include "hw/arm/primecell.h"
#include "hw/devices.h" #include "hw/devices.h"
#include "net/net.h" #include "net/net.h"
#include "sysemu/block-backend.h"
#include "sysemu/device_tree.h" #include "sysemu/device_tree.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "sysemu/kvm.h" #include "sysemu/kvm.h"
@ -450,7 +451,8 @@ static void create_one_flash(const char *name, hwaddr flashbase,
DeviceState *dev = qdev_create(NULL, "cfi.pflash01"); DeviceState *dev = qdev_create(NULL, "cfi.pflash01");
const uint64_t sectorlength = 256 * 1024; const uint64_t sectorlength = 256 * 1024;
if (dinfo && qdev_prop_set_drive(dev, "drive", dinfo->bdrv)) { if (dinfo && qdev_prop_set_drive(dev, "drive",
blk_by_legacy_dinfo(dinfo))) {
abort(); abort();
} }

5
hw/arm/xilinx_zynq.c
View File

@ -22,7 +22,7 @@
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "hw/boards.h" #include "hw/boards.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "hw/loader.h" #include "hw/loader.h"
#include "hw/ssi.h" #include "hw/ssi.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
@ -164,7 +164,8 @@ static void zynq_init(MachineState *machine)
/* AMD */ /* AMD */
pflash_cfi02_register(0xe2000000, NULL, "zynq.pflash", FLASH_SIZE, pflash_cfi02_register(0xe2000000, NULL, "zynq.pflash", FLASH_SIZE,
dinfo ? dinfo->bdrv : NULL, FLASH_SECTOR_SIZE, dinfo ? blk_by_legacy_dinfo(dinfo) : NULL,
FLASH_SECTOR_SIZE,
FLASH_SIZE/FLASH_SECTOR_SIZE, 1, FLASH_SIZE/FLASH_SECTOR_SIZE, 1,
1, 0x0066, 0x0022, 0x0000, 0x0000, 0x0555, 0x2aa, 1, 0x0066, 0x0022, 0x0000, 0x0000, 0x0555, 0x2aa,
0); 0);

8
hw/arm/z2.c
View File

@ -20,7 +20,7 @@
#include "hw/boards.h" #include "hw/boards.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "ui/console.h" #include "ui/console.h"
#include "audio/audio.h" #include "audio/audio.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
@ -336,9 +336,9 @@ static void z2_init(MachineState *machine)
if (!pflash_cfi01_register(Z2_FLASH_BASE, if (!pflash_cfi01_register(Z2_FLASH_BASE,
NULL, "z2.flash0", Z2_FLASH_SIZE, NULL, "z2.flash0", Z2_FLASH_SIZE,
dinfo ? dinfo->bdrv : NULL, sector_len, dinfo ? blk_by_legacy_dinfo(dinfo) : NULL,
Z2_FLASH_SIZE / sector_len, 4, 0, 0, 0, 0, sector_len, Z2_FLASH_SIZE / sector_len,
be)) { 4, 0, 0, 0, 0, be)) {
fprintf(stderr, "qemu: Error registering flash memory.\n"); fprintf(stderr, "qemu: Error registering flash memory.\n");
exit(1); exit(1);
} }

23
hw/block/block.c
View File

@ -8,6 +8,7 @@
*/ */
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "sysemu/block-backend.h"
#include "hw/block/block.h" #include "hw/block/block.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
@ -17,8 +18,10 @@ void blkconf_serial(BlockConf *conf, char **serial)
if (!*serial) { if (!*serial) {
/* try to fall back to value set with legacy -drive serial=... */ /* try to fall back to value set with legacy -drive serial=... */
dinfo = drive_get_by_blockdev(conf->bs); dinfo = blk_legacy_dinfo(conf->blk);
*serial = g_strdup(dinfo->serial); if (dinfo) {
*serial = g_strdup(dinfo->serial);
}
} }
} }
@ -30,16 +33,18 @@ void blkconf_geometry(BlockConf *conf, int *ptrans,
if (!conf->cyls && !conf->heads && !conf->secs) { if (!conf->cyls && !conf->heads && !conf->secs) {
/* try to fall back to value set with legacy -drive cyls=... */ /* try to fall back to value set with legacy -drive cyls=... */
dinfo = drive_get_by_blockdev(conf->bs); dinfo = blk_legacy_dinfo(conf->blk);
conf->cyls = dinfo->cyls; if (dinfo) {
conf->heads = dinfo->heads; conf->cyls = dinfo->cyls;
conf->secs = dinfo->secs; conf->heads = dinfo->heads;
if (ptrans) { conf->secs = dinfo->secs;
*ptrans = dinfo->trans; if (ptrans) {
*ptrans = dinfo->trans;
}
} }
} }
if (!conf->cyls && !conf->heads && !conf->secs) { if (!conf->cyls && !conf->heads && !conf->secs) {
hd_geometry_guess(conf->bs, hd_geometry_guess(conf->blk,
&conf->cyls, &conf->heads, &conf->secs, &conf->cyls, &conf->heads, &conf->secs,
ptrans); ptrans);
} else if (ptrans && *ptrans == BIOS_ATA_TRANSLATION_AUTO) { } else if (ptrans && *ptrans == BIOS_ATA_TRANSLATION_AUTO) {

35
hw/block/dataplane/virtio-blk.c
View File

@ -17,7 +17,7 @@
#include "qemu/thread.h" #include "qemu/thread.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
#include "hw/virtio/dataplane/vring.h" #include "hw/virtio/dataplane/vring.h"
#include "block/block.h" #include "sysemu/block-backend.h"
#include "hw/virtio/virtio-blk.h" #include "hw/virtio/virtio-blk.h"
#include "virtio-blk.h" #include "virtio-blk.h"
#include "block/aio.h" #include "block/aio.h"
@ -30,7 +30,7 @@ struct VirtIOBlockDataPlane {
bool stopping; bool stopping;
bool disabled; bool disabled;
VirtIOBlkConf *blk; VirtIOBlkConf *conf;
VirtIODevice *vdev; VirtIODevice *vdev;
Vring vring; /* virtqueue vring */ Vring vring; /* virtqueue vring */
@ -94,7 +94,7 @@ static void handle_notify(EventNotifier *e)
VirtIOBlock *vblk = VIRTIO_BLK(s->vdev); VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);
event_notifier_test_and_clear(&s->host_notifier); event_notifier_test_and_clear(&s->host_notifier);
bdrv_io_plug(s->blk->conf.bs); blk_io_plug(s->conf->conf.blk);
for (;;) { for (;;) {
MultiReqBuffer mrb = { MultiReqBuffer mrb = {
.num_writes = 0, .num_writes = 0,
@ -120,7 +120,7 @@ static void handle_notify(EventNotifier *e)
virtio_blk_handle_request(req, &mrb); virtio_blk_handle_request(req, &mrb);
} }
virtio_submit_multiwrite(s->blk->conf.bs, &mrb); virtio_submit_multiwrite(s->conf->conf.blk, &mrb);
if (likely(ret == -EAGAIN)) { /* vring emptied */ if (likely(ret == -EAGAIN)) { /* vring emptied */
/* Re-enable guest->host notifies and stop processing the vring. /* Re-enable guest->host notifies and stop processing the vring.
@ -133,11 +133,11 @@ static void handle_notify(EventNotifier *e)
break; break;
} }
} }
bdrv_io_unplug(s->blk->conf.bs); blk_io_unplug(s->conf->conf.blk);
} }
/* Context: QEMU global mutex held */ /* Context: QEMU global mutex held */
void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk, void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf,
VirtIOBlockDataPlane **dataplane, VirtIOBlockDataPlane **dataplane,
Error **errp) Error **errp)
{ {
@ -148,7 +148,7 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk,
*dataplane = NULL; *dataplane = NULL;
if (!blk->data_plane && !blk->iothread) { if (!conf->data_plane && !conf->iothread) {
return; return;
} }
@ -163,7 +163,8 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk,
/* If dataplane is (re-)enabled while the guest is running there could be /* If dataplane is (re-)enabled while the guest is running there could be
* block jobs that can conflict. * block jobs that can conflict.
*/ */
if (bdrv_op_is_blocked(blk->conf.bs, BLOCK_OP_TYPE_DATAPLANE, &local_err)) { if (blk_op_is_blocked(conf->conf.blk, BLOCK_OP_TYPE_DATAPLANE,
&local_err)) {
error_setg(errp, "cannot start dataplane thread: %s", error_setg(errp, "cannot start dataplane thread: %s",
error_get_pretty(local_err)); error_get_pretty(local_err));
error_free(local_err); error_free(local_err);
@ -172,10 +173,10 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk,
s = g_new0(VirtIOBlockDataPlane, 1); s = g_new0(VirtIOBlockDataPlane, 1);
s->vdev = vdev; s->vdev = vdev;
s->blk = blk; s->conf = conf;
if (blk->iothread) { if (conf->iothread) {
s->iothread = blk->iothread; s->iothread = conf->iothread;
object_ref(OBJECT(s->iothread)); object_ref(OBJECT(s->iothread));
} else { } else {
/* Create per-device IOThread if none specified. This is for /* Create per-device IOThread if none specified. This is for
@ -192,9 +193,9 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk,
s->bh = aio_bh_new(s->ctx, notify_guest_bh, s); s->bh = aio_bh_new(s->ctx, notify_guest_bh, s);
error_setg(&s->blocker, "block device is in use by data plane"); error_setg(&s->blocker, "block device is in use by data plane");
bdrv_op_block_all(blk->conf.bs, s->blocker); blk_op_block_all(conf->conf.blk, s->blocker);
bdrv_op_unblock(blk->conf.bs, BLOCK_OP_TYPE_RESIZE, s->blocker); blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_RESIZE, s->blocker);
bdrv_op_unblock(blk->conf.bs, BLOCK_OP_TYPE_DRIVE_DEL, s->blocker); blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_DRIVE_DEL, s->blocker);
*dataplane = s; *dataplane = s;
} }
@ -207,7 +208,7 @@ void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
} }
virtio_blk_data_plane_stop(s); virtio_blk_data_plane_stop(s);
bdrv_op_unblock_all(s->blk->conf.bs, s->blocker); blk_op_unblock_all(s->conf->conf.blk, s->blocker);
error_free(s->blocker); error_free(s->blocker);
object_unref(OBJECT(s->iothread)); object_unref(OBJECT(s->iothread));
qemu_bh_delete(s->bh); qemu_bh_delete(s->bh);
@ -262,7 +263,7 @@ void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s)
s->started = true; s->started = true;
trace_virtio_blk_data_plane_start(s); trace_virtio_blk_data_plane_start(s);
bdrv_set_aio_context(s->blk->conf.bs, s->ctx); blk_set_aio_context(s->conf->conf.blk, s->ctx);
/* Kick right away to begin processing requests already in vring */ /* Kick right away to begin processing requests already in vring */
event_notifier_set(virtio_queue_get_host_notifier(vq)); event_notifier_set(virtio_queue_get_host_notifier(vq));
@ -308,7 +309,7 @@ void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s)
aio_set_event_notifier(s->ctx, &s->host_notifier, NULL); aio_set_event_notifier(s->ctx, &s->host_notifier, NULL);
/* Drain and switch bs back to the QEMU main loop */ /* Drain and switch bs back to the QEMU main loop */
bdrv_set_aio_context(s->blk->conf.bs, qemu_get_aio_context()); blk_set_aio_context(s->conf->conf.blk, qemu_get_aio_context());
aio_context_release(s->ctx); aio_context_release(s->ctx);

2
hw/block/dataplane/virtio-blk.h
View File

@ -19,7 +19,7 @@
typedef struct VirtIOBlockDataPlane VirtIOBlockDataPlane; typedef struct VirtIOBlockDataPlane VirtIOBlockDataPlane;
void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk, void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf,
VirtIOBlockDataPlane **dataplane, VirtIOBlockDataPlane **dataplane,
Error **errp); Error **errp);
void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s); void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s);

74
hw/block/fdc.c
View File

@ -33,6 +33,7 @@
#include "qemu/timer.h" #include "qemu/timer.h"
#include "hw/isa/isa.h" #include "hw/isa/isa.h"
#include "hw/sysbus.h" #include "hw/sysbus.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "qemu/log.h" #include "qemu/log.h"
@ -113,7 +114,7 @@ static const FDFormat fd_formats[] = {
{ FDRIVE_DRV_NONE, -1, -1, 0, 0, }, { FDRIVE_DRV_NONE, -1, -1, 0, 0, },
}; };
static void pick_geometry(BlockDriverState *bs, int *nb_heads, static void pick_geometry(BlockBackend *blk, int *nb_heads,
int *max_track, int *last_sect, int *max_track, int *last_sect,
FDriveType drive_in, FDriveType *drive, FDriveType drive_in, FDriveType *drive,
FDriveRate *rate) FDriveRate *rate)
@ -122,7 +123,7 @@ static void pick_geometry(BlockDriverState *bs, int *nb_heads,
uint64_t nb_sectors, size; uint64_t nb_sectors, size;
int i, first_match, match; int i, first_match, match;
bdrv_get_geometry(bs, &nb_sectors); blk_get_geometry(blk, &nb_sectors);
match = -1; match = -1;
first_match = -1; first_match = -1;
for (i = 0; ; i++) { for (i = 0; ; i++) {
@ -175,7 +176,7 @@ typedef enum FDiskFlags {
typedef struct FDrive { typedef struct FDrive {
FDCtrl *fdctrl; FDCtrl *fdctrl;
BlockDriverState *bs; BlockBackend *blk;
/* Drive status */ /* Drive status */
FDriveType drive; FDriveType drive;
uint8_t perpendicular; /* 2.88 MB access mode */ uint8_t perpendicular; /* 2.88 MB access mode */
@ -260,7 +261,7 @@ static int fd_seek(FDrive *drv, uint8_t head, uint8_t track, uint8_t sect,
#endif #endif
drv->head = head; drv->head = head;
if (drv->track != track) { if (drv->track != track) {
if (drv->bs != NULL && bdrv_is_inserted(drv->bs)) { if (drv->blk != NULL && blk_is_inserted(drv->blk)) {
drv->media_changed = 0; drv->media_changed = 0;
} }
ret = 1; ret = 1;
@ -269,7 +270,7 @@ static int fd_seek(FDrive *drv, uint8_t head, uint8_t track, uint8_t sect,
drv->sect = sect; drv->sect = sect;
} }
if (drv->bs == NULL || !bdrv_is_inserted(drv->bs)) { if (drv->blk == NULL || !blk_is_inserted(drv->blk)) {
ret = 2; ret = 2;
} }
@ -291,11 +292,11 @@ static void fd_revalidate(FDrive *drv)
FDriveRate rate; FDriveRate rate;
FLOPPY_DPRINTF("revalidate\n"); FLOPPY_DPRINTF("revalidate\n");
if (drv->bs != NULL) { if (drv->blk != NULL) {
ro = bdrv_is_read_only(drv->bs); ro = blk_is_read_only(drv->blk);
pick_geometry(drv->bs, &nb_heads, &max_track, pick_geometry(drv->blk, &nb_heads, &max_track,
&last_sect, drv->drive, &drive, &rate); &last_sect, drv->drive, &drive, &rate);
if (!bdrv_is_inserted(drv->bs)) { if (!blk_is_inserted(drv->blk)) {
FLOPPY_DPRINTF("No disk in drive\n"); FLOPPY_DPRINTF("No disk in drive\n");
} else { } else {
FLOPPY_DPRINTF("Floppy disk (%d h %d t %d s) %s\n", nb_heads, FLOPPY_DPRINTF("Floppy disk (%d h %d t %d s) %s\n", nb_heads,
@ -665,7 +666,7 @@ static bool fdrive_media_changed_needed(void *opaque)
{ {
FDrive *drive = opaque; FDrive *drive = opaque;
return (drive->bs != NULL && drive->media_changed != 1); return (drive->blk != NULL && drive->media_changed != 1);
} }
static const VMStateDescription vmstate_fdrive_media_changed = { static const VMStateDescription vmstate_fdrive_media_changed = {
@ -910,8 +911,9 @@ static void fdctrl_reset(FDCtrl *fdctrl, int do_irq)
/* Initialise controller */ /* Initialise controller */
fdctrl->sra = 0; fdctrl->sra = 0;
fdctrl->srb = 0xc0; fdctrl->srb = 0xc0;
if (!fdctrl->drives[1].bs) if (!fdctrl->drives[1].blk) {
fdctrl->sra |= FD_SRA_nDRV2; fdctrl->sra |= FD_SRA_nDRV2;
}
fdctrl->cur_drv = 0; fdctrl->cur_drv = 0;
fdctrl->dor = FD_DOR_nRESET; fdctrl->dor = FD_DOR_nRESET;
fdctrl->dor |= (fdctrl->dma_chann != -1) ? FD_DOR_DMAEN : 0; fdctrl->dor |= (fdctrl->dma_chann != -1) ? FD_DOR_DMAEN : 0;
@ -1403,7 +1405,7 @@ static int fdctrl_transfer_handler (void *opaque, int nchan,
status2 = FD_SR2_SNS; status2 = FD_SR2_SNS;
if (dma_len > fdctrl->data_len) if (dma_len > fdctrl->data_len)
dma_len = fdctrl->data_len; dma_len = fdctrl->data_len;
if (cur_drv->bs == NULL) { if (cur_drv->blk == NULL) {
if (fdctrl->data_dir == FD_DIR_WRITE) if (fdctrl->data_dir == FD_DIR_WRITE)
fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00); fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00);
else else
@ -1424,8 +1426,8 @@ static int fdctrl_transfer_handler (void *opaque, int nchan,
if (fdctrl->data_dir != FD_DIR_WRITE || if (fdctrl->data_dir != FD_DIR_WRITE ||
len < FD_SECTOR_LEN || rel_pos != 0) { len < FD_SECTOR_LEN || rel_pos != 0) {
/* READ & SCAN commands and realign to a sector for WRITE */ /* READ & SCAN commands and realign to a sector for WRITE */
if (bdrv_read(cur_drv->bs, fd_sector(cur_drv), if (blk_read(cur_drv->blk, fd_sector(cur_drv),
fdctrl->fifo, 1) < 0) { fdctrl->fifo, 1) < 0) {
FLOPPY_DPRINTF("Floppy: error getting sector %d\n", FLOPPY_DPRINTF("Floppy: error getting sector %d\n",
fd_sector(cur_drv)); fd_sector(cur_drv));
/* Sure, image size is too small... */ /* Sure, image size is too small... */
@ -1452,8 +1454,8 @@ static int fdctrl_transfer_handler (void *opaque, int nchan,
DMA_read_memory (nchan, fdctrl->fifo + rel_pos, DMA_read_memory (nchan, fdctrl->fifo + rel_pos,
fdctrl->data_pos, len); fdctrl->data_pos, len);
if (bdrv_write(cur_drv->bs, fd_sector(cur_drv), if (blk_write(cur_drv->blk, fd_sector(cur_drv),
fdctrl->fifo, 1) < 0) { fdctrl->fifo, 1) < 0) {
FLOPPY_DPRINTF("error writing sector %d\n", FLOPPY_DPRINTF("error writing sector %d\n",
fd_sector(cur_drv)); fd_sector(cur_drv));
fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00); fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00);
@ -1528,7 +1530,8 @@ static uint32_t fdctrl_read_data(FDCtrl *fdctrl)
fd_sector(cur_drv)); fd_sector(cur_drv));
return 0; return 0;
} }
if (bdrv_read(cur_drv->bs, fd_sector(cur_drv), fdctrl->fifo, 1) < 0) { if (blk_read(cur_drv->blk, fd_sector(cur_drv), fdctrl->fifo, 1)
< 0) {
FLOPPY_DPRINTF("error getting sector %d\n", FLOPPY_DPRINTF("error getting sector %d\n",
fd_sector(cur_drv)); fd_sector(cur_drv));
/* Sure, image size is too small... */ /* Sure, image size is too small... */
@ -1597,8 +1600,8 @@ static void fdctrl_format_sector(FDCtrl *fdctrl)
break; break;
} }
memset(fdctrl->fifo, 0, FD_SECTOR_LEN); memset(fdctrl->fifo, 0, FD_SECTOR_LEN);
if (cur_drv->bs == NULL || if (cur_drv->blk == NULL ||
bdrv_write(cur_drv->bs, fd_sector(cur_drv), fdctrl->fifo, 1) < 0) { blk_write(cur_drv->blk, fd_sector(cur_drv), fdctrl->fifo, 1) < 0) {
FLOPPY_DPRINTF("error formatting sector %d\n", fd_sector(cur_drv)); FLOPPY_DPRINTF("error formatting sector %d\n", fd_sector(cur_drv));
fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00); fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00);
} else { } else {
@ -1988,7 +1991,8 @@ static void fdctrl_write_data(FDCtrl *fdctrl, uint32_t value)
if (pos == FD_SECTOR_LEN - 1 || if (pos == FD_SECTOR_LEN - 1 ||
fdctrl->data_pos == fdctrl->data_len) { fdctrl->data_pos == fdctrl->data_len) {
cur_drv = get_cur_drv(fdctrl); cur_drv = get_cur_drv(fdctrl);
if (bdrv_write(cur_drv->bs, fd_sector(cur_drv), fdctrl->fifo, 1) < 0) { if (blk_write(cur_drv->blk, fd_sector(cur_drv), fdctrl->fifo, 1)
< 0) {
FLOPPY_DPRINTF("error writing sector %d\n", FLOPPY_DPRINTF("error writing sector %d\n",
fd_sector(cur_drv)); fd_sector(cur_drv));
return; return;
@ -2076,12 +2080,12 @@ static void fdctrl_connect_drives(FDCtrl *fdctrl, Error **errp)
drive = &fdctrl->drives[i]; drive = &fdctrl->drives[i];
drive->fdctrl = fdctrl; drive->fdctrl = fdctrl;
if (drive->bs) { if (drive->blk) {
if (bdrv_get_on_error(drive->bs, 0) != BLOCKDEV_ON_ERROR_ENOSPC) { if (blk_get_on_error(drive->blk, 0) != BLOCKDEV_ON_ERROR_ENOSPC) {
error_setg(errp, "fdc doesn't support drive option werror"); error_setg(errp, "fdc doesn't support drive option werror");
return; return;
} }
if (bdrv_get_on_error(drive->bs, 1) != BLOCKDEV_ON_ERROR_REPORT) { if (blk_get_on_error(drive->blk, 1) != BLOCKDEV_ON_ERROR_REPORT) {
error_setg(errp, "fdc doesn't support drive option rerror"); error_setg(errp, "fdc doesn't support drive option rerror");
return; return;
} }
@ -2089,8 +2093,8 @@ static void fdctrl_connect_drives(FDCtrl *fdctrl, Error **errp)
fd_init(drive); fd_init(drive);
fdctrl_change_cb(drive, 0); fdctrl_change_cb(drive, 0);
if (drive->bs) { if (drive->blk) {
bdrv_set_dev_ops(drive->bs, &fdctrl_block_ops, drive); blk_set_dev_ops(drive->blk, &fdctrl_block_ops, drive);
} }
} }
} }
@ -2107,10 +2111,10 @@ ISADevice *fdctrl_init_isa(ISABus *bus, DriveInfo **fds)
dev = DEVICE(isadev); dev = DEVICE(isadev);
if (fds[0]) { if (fds[0]) {
qdev_prop_set_drive_nofail(dev, "driveA", fds[0]->bdrv); qdev_prop_set_drive_nofail(dev, "driveA", blk_by_legacy_dinfo(fds[0]));
} }
if (fds[1]) { if (fds[1]) {
qdev_prop_set_drive_nofail(dev, "driveB", fds[1]->bdrv); qdev_prop_set_drive_nofail(dev, "driveB", blk_by_legacy_dinfo(fds[1]));
} }
qdev_init_nofail(dev); qdev_init_nofail(dev);
@ -2130,10 +2134,10 @@ void fdctrl_init_sysbus(qemu_irq irq, int dma_chann,
fdctrl = &sys->state; fdctrl = &sys->state;
fdctrl->dma_chann = dma_chann; /* FIXME */ fdctrl->dma_chann = dma_chann; /* FIXME */
if (fds[0]) { if (fds[0]) {
qdev_prop_set_drive_nofail(dev, "driveA", fds[0]->bdrv); qdev_prop_set_drive_nofail(dev, "driveA", blk_by_legacy_dinfo(fds[0]));
} }
if (fds[1]) { if (fds[1]) {
qdev_prop_set_drive_nofail(dev, "driveB", fds[1]->bdrv); qdev_prop_set_drive_nofail(dev, "driveB", blk_by_legacy_dinfo(fds[1]));
} }
qdev_init_nofail(dev); qdev_init_nofail(dev);
sbd = SYS_BUS_DEVICE(dev); sbd = SYS_BUS_DEVICE(dev);
@ -2149,7 +2153,7 @@ void sun4m_fdctrl_init(qemu_irq irq, hwaddr io_base,
dev = qdev_create(NULL, "SUNW,fdtwo"); dev = qdev_create(NULL, "SUNW,fdtwo");
if (fds[0]) { if (fds[0]) {
qdev_prop_set_drive_nofail(dev, "drive", fds[0]->bdrv); qdev_prop_set_drive_nofail(dev, "drive", blk_by_legacy_dinfo(fds[0]));
} }
qdev_init_nofail(dev); qdev_init_nofail(dev);
sys = SYSBUS_FDC(dev); sys = SYSBUS_FDC(dev);
@ -2286,8 +2290,8 @@ static Property isa_fdc_properties[] = {
DEFINE_PROP_UINT32("iobase", FDCtrlISABus, iobase, 0x3f0), DEFINE_PROP_UINT32("iobase", FDCtrlISABus, iobase, 0x3f0),
DEFINE_PROP_UINT32("irq", FDCtrlISABus, irq, 6), DEFINE_PROP_UINT32("irq", FDCtrlISABus, irq, 6),
DEFINE_PROP_UINT32("dma", FDCtrlISABus, dma, 2), DEFINE_PROP_UINT32("dma", FDCtrlISABus, dma, 2),
DEFINE_PROP_DRIVE("driveA", FDCtrlISABus, state.drives[0].bs), DEFINE_PROP_DRIVE("driveA", FDCtrlISABus, state.drives[0].blk),
DEFINE_PROP_DRIVE("driveB", FDCtrlISABus, state.drives[1].bs), DEFINE_PROP_DRIVE("driveB", FDCtrlISABus, state.drives[1].blk),
DEFINE_PROP_BIT("check_media_rate", FDCtrlISABus, state.check_media_rate, DEFINE_PROP_BIT("check_media_rate", FDCtrlISABus, state.check_media_rate,
0, true), 0, true),
DEFINE_PROP_END_OF_LIST(), DEFINE_PROP_END_OF_LIST(),
@ -2336,8 +2340,8 @@ static const VMStateDescription vmstate_sysbus_fdc ={
}; };
static Property sysbus_fdc_properties[] = { static Property sysbus_fdc_properties[] = {
DEFINE_PROP_DRIVE("driveA", FDCtrlSysBus, state.drives[0].bs), DEFINE_PROP_DRIVE("driveA", FDCtrlSysBus, state.drives[0].blk),
DEFINE_PROP_DRIVE("driveB", FDCtrlSysBus, state.drives[1].bs), DEFINE_PROP_DRIVE("driveB", FDCtrlSysBus, state.drives[1].blk),
DEFINE_PROP_END_OF_LIST(), DEFINE_PROP_END_OF_LIST(),
}; };
@ -2357,7 +2361,7 @@ static const TypeInfo sysbus_fdc_info = {
}; };
static Property sun4m_fdc_properties[] = { static Property sun4m_fdc_properties[] = {
DEFINE_PROP_DRIVE("drive", FDCtrlSysBus, state.drives[0].bs), DEFINE_PROP_DRIVE("drive", FDCtrlSysBus, state.drives[0].blk),
DEFINE_PROP_END_OF_LIST(), DEFINE_PROP_END_OF_LIST(),
}; };

24
hw/block/hd-geometry.c
View File

@ -30,7 +30,7 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include "block/block.h" #include "sysemu/block-backend.h"
#include "hw/block/block.h" #include "hw/block/block.h"
#include "trace.h" #include "trace.h"
@ -49,7 +49,7 @@ struct partition {
/* try to guess the disk logical geometry from the MSDOS partition table. /* try to guess the disk logical geometry from the MSDOS partition table.
Return 0 if OK, -1 if could not guess */ Return 0 if OK, -1 if could not guess */
static int guess_disk_lchs(BlockDriverState *bs, static int guess_disk_lchs(BlockBackend *blk,
int *pcylinders, int *pheads, int *psectors) int *pcylinders, int *pheads, int *psectors)
{ {
uint8_t buf[BDRV_SECTOR_SIZE]; uint8_t buf[BDRV_SECTOR_SIZE];
@ -58,14 +58,14 @@ static int guess_disk_lchs(BlockDriverState *bs,
uint32_t nr_sects; uint32_t nr_sects;
uint64_t nb_sectors; uint64_t nb_sectors;
bdrv_get_geometry(bs, &nb_sectors); blk_get_geometry(blk, &nb_sectors);
/** /**
* The function will be invoked during startup not only in sync I/O mode, * The function will be invoked during startup not only in sync I/O mode,
* but also in async I/O mode. So the I/O throttling function has to * but also in async I/O mode. So the I/O throttling function has to
* be disabled temporarily here, not permanently. * be disabled temporarily here, not permanently.
*/ */
if (bdrv_read_unthrottled(bs, 0, buf, 1) < 0) { if (blk_read_unthrottled(blk, 0, buf, 1) < 0) {
return -1; return -1;
} }
/* test msdos magic */ /* test msdos magic */
@ -90,20 +90,20 @@ static int guess_disk_lchs(BlockDriverState *bs,
*pheads = heads; *pheads = heads;
*psectors = sectors; *psectors = sectors;
*pcylinders = cylinders; *pcylinders = cylinders;
trace_hd_geometry_lchs_guess(bs, cylinders, heads, sectors); trace_hd_geometry_lchs_guess(blk, cylinders, heads, sectors);
return 0; return 0;
} }
} }
return -1; return -1;
} }
static void guess_chs_for_size(BlockDriverState *bs, static void guess_chs_for_size(BlockBackend *blk,
uint32_t *pcyls, uint32_t *pheads, uint32_t *psecs) uint32_t *pcyls, uint32_t *pheads, uint32_t *psecs)
{ {
uint64_t nb_sectors; uint64_t nb_sectors;
int cylinders; int cylinders;
bdrv_get_geometry(bs, &nb_sectors); blk_get_geometry(blk, &nb_sectors);
cylinders = nb_sectors / (16 * 63); cylinders = nb_sectors / (16 * 63);
if (cylinders > 16383) { if (cylinders > 16383) {
@ -116,21 +116,21 @@ static void guess_chs_for_size(BlockDriverState *bs,
*psecs = 63; *psecs = 63;
} }
void hd_geometry_guess(BlockDriverState *bs, void hd_geometry_guess(BlockBackend *blk,
uint32_t *pcyls, uint32_t *pheads, uint32_t *psecs, uint32_t *pcyls, uint32_t *pheads, uint32_t *psecs,
int *ptrans) int *ptrans)
{ {
int cylinders, heads, secs, translation; int cylinders, heads, secs, translation;
if (guess_disk_lchs(bs, &cylinders, &heads, &secs) < 0) { if (guess_disk_lchs(blk, &cylinders, &heads, &secs) < 0) {
/* no LCHS guess: use a standard physical disk geometry */ /* no LCHS guess: use a standard physical disk geometry */
guess_chs_for_size(bs, pcyls, pheads, psecs); guess_chs_for_size(blk, pcyls, pheads, psecs);
translation = hd_bios_chs_auto_trans(*pcyls, *pheads, *psecs); translation = hd_bios_chs_auto_trans(*pcyls, *pheads, *psecs);
} else if (heads > 16) { } else if (heads > 16) {
/* LCHS guess with heads > 16 means that a BIOS LBA /* LCHS guess with heads > 16 means that a BIOS LBA
translation was active, so a standard physical disk translation was active, so a standard physical disk
geometry is OK */ geometry is OK */
guess_chs_for_size(bs, pcyls, pheads, psecs); guess_chs_for_size(blk, pcyls, pheads, psecs);
translation = *pcyls * *pheads <= 131072 translation = *pcyls * *pheads <= 131072
? BIOS_ATA_TRANSLATION_LARGE ? BIOS_ATA_TRANSLATION_LARGE
: BIOS_ATA_TRANSLATION_LBA; : BIOS_ATA_TRANSLATION_LBA;
@ -146,7 +146,7 @@ void hd_geometry_guess(BlockDriverState *bs,
if (ptrans) { if (ptrans) {
*ptrans = translation; *ptrans = translation;
} }
trace_hd_geometry_guess(bs, *pcyls, *pheads, *psecs, translation); trace_hd_geometry_guess(blk, *pcyls, *pheads, *psecs, translation);
} }
int hd_bios_chs_auto_trans(uint32_t cyls, uint32_t heads, uint32_t secs) int hd_bios_chs_auto_trans(uint32_t cyls, uint32_t heads, uint32_t secs)

31
hw/block/m25p80.c
View File

@ -22,6 +22,7 @@
*/ */
#include "hw/hw.h" #include "hw/hw.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "hw/ssi.h" #include "hw/ssi.h"
@ -245,7 +246,7 @@ typedef struct Flash {
uint32_t r; uint32_t r;
BlockDriverState *bdrv; BlockBackend *blk;
uint8_t *storage; uint8_t *storage;
uint32_t size; uint32_t size;
@ -279,7 +280,7 @@ typedef struct M25P80Class {
#define M25P80_GET_CLASS(obj) \ #define M25P80_GET_CLASS(obj) \
OBJECT_GET_CLASS(M25P80Class, (obj), TYPE_M25P80) OBJECT_GET_CLASS(M25P80Class, (obj), TYPE_M25P80)
static void bdrv_sync_complete(void *opaque, int ret) static void blk_sync_complete(void *opaque, int ret)
{ {
/* do nothing. Masters do not directly interact with the backing store, /* do nothing. Masters do not directly interact with the backing store,
* only the working copy so no mutexing required. * only the working copy so no mutexing required.
@ -288,20 +289,20 @@ static void bdrv_sync_complete(void *opaque, int ret)
static void flash_sync_page(Flash *s, int page) static void flash_sync_page(Flash *s, int page)
{ {
int bdrv_sector, nb_sectors; int blk_sector, nb_sectors;
QEMUIOVector iov; QEMUIOVector iov;
if (!s->bdrv || bdrv_is_read_only(s->bdrv)) { if (!s->blk || blk_is_read_only(s->blk)) {
return; return;
} }
bdrv_sector = (page * s->pi->page_size) / BDRV_SECTOR_SIZE; blk_sector = (page * s->pi->page_size) / BDRV_SECTOR_SIZE;
nb_sectors = DIV_ROUND_UP(s->pi->page_size, BDRV_SECTOR_SIZE); nb_sectors = DIV_ROUND_UP(s->pi->page_size, BDRV_SECTOR_SIZE);
qemu_iovec_init(&iov, 1); qemu_iovec_init(&iov, 1);
qemu_iovec_add(&iov, s->storage + bdrv_sector * BDRV_SECTOR_SIZE, qemu_iovec_add(&iov, s->storage + blk_sector * BDRV_SECTOR_SIZE,
nb_sectors * BDRV_SECTOR_SIZE); nb_sectors * BDRV_SECTOR_SIZE);
bdrv_aio_writev(s->bdrv, bdrv_sector, &iov, nb_sectors, bdrv_sync_complete, blk_aio_writev(s->blk, blk_sector, &iov, nb_sectors, blk_sync_complete,
NULL); NULL);
} }
static inline void flash_sync_area(Flash *s, int64_t off, int64_t len) static inline void flash_sync_area(Flash *s, int64_t off, int64_t len)
@ -309,7 +310,7 @@ static inline void flash_sync_area(Flash *s, int64_t off, int64_t len)
int64_t start, end, nb_sectors; int64_t start, end, nb_sectors;
QEMUIOVector iov; QEMUIOVector iov;
if (!s->bdrv || bdrv_is_read_only(s->bdrv)) { if (!s->blk || blk_is_read_only(s->blk)) {
return; return;
} }
@ -320,7 +321,7 @@ static inline void flash_sync_area(Flash *s, int64_t off, int64_t len)
qemu_iovec_init(&iov, 1); qemu_iovec_init(&iov, 1);
qemu_iovec_add(&iov, s->storage + (start * BDRV_SECTOR_SIZE), qemu_iovec_add(&iov, s->storage + (start * BDRV_SECTOR_SIZE),
nb_sectors * BDRV_SECTOR_SIZE); nb_sectors * BDRV_SECTOR_SIZE);
bdrv_aio_writev(s->bdrv, start, &iov, nb_sectors, bdrv_sync_complete, NULL); blk_aio_writev(s->blk, start, &iov, nb_sectors, blk_sync_complete, NULL);
} }
static void flash_erase(Flash *s, int offset, FlashCMD cmd) static void flash_erase(Flash *s, int offset, FlashCMD cmd)
@ -620,17 +621,17 @@ static int m25p80_init(SSISlave *ss)
s->size = s->pi->sector_size * s->pi->n_sectors; s->size = s->pi->sector_size * s->pi->n_sectors;
s->dirty_page = -1; s->dirty_page = -1;
s->storage = qemu_blockalign(s->bdrv, s->size); s->storage = blk_blockalign(s->blk, s->size);
dinfo = drive_get_next(IF_MTD); dinfo = drive_get_next(IF_MTD);
if (dinfo && dinfo->bdrv) { if (dinfo) {
DB_PRINT_L(0, "Binding to IF_MTD drive\n"); DB_PRINT_L(0, "Binding to IF_MTD drive\n");
s->bdrv = dinfo->bdrv; s->blk = blk_by_legacy_dinfo(dinfo);
/* FIXME: Move to late init */ /* FIXME: Move to late init */
if (bdrv_read(s->bdrv, 0, s->storage, DIV_ROUND_UP(s->size, if (blk_read(s->blk, 0, s->storage,
BDRV_SECTOR_SIZE))) { DIV_ROUND_UP(s->size, BDRV_SECTOR_SIZE))) {
fprintf(stderr, "Failed to initialize SPI flash!\n"); fprintf(stderr, "Failed to initialize SPI flash!\n");
return 1; return 1;
} }

50
hw/block/nand.c
View File

@ -20,7 +20,7 @@
# include "hw/hw.h" # include "hw/hw.h"
# include "hw/block/flash.h" # include "hw/block/flash.h"
# include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "hw/qdev.h" #include "hw/qdev.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
@ -61,7 +61,7 @@ struct NANDFlashState {
int size, pages; int size, pages;
int page_shift, oob_shift, erase_shift, addr_shift; int page_shift, oob_shift, erase_shift, addr_shift;
uint8_t *storage; uint8_t *storage;
BlockDriverState *bdrv; BlockBackend *blk;
int mem_oob; int mem_oob;
uint8_t cle, ale, ce, wp, gnd; uint8_t cle, ale, ce, wp, gnd;
@ -400,12 +400,12 @@ static void nand_realize(DeviceState *dev, Error **errp)
pagesize = 1 << s->oob_shift; pagesize = 1 << s->oob_shift;
s->mem_oob = 1; s->mem_oob = 1;
if (s->bdrv) { if (s->blk) {
if (bdrv_is_read_only(s->bdrv)) { if (blk_is_read_only(s->blk)) {
error_setg(errp, "Can't use a read-only drive"); error_setg(errp, "Can't use a read-only drive");
return; return;
} }
if (bdrv_getlength(s->bdrv) >= if (blk_getlength(s->blk) >=
(s->pages << s->page_shift) + (s->pages << s->oob_shift)) { (s->pages << s->page_shift) + (s->pages << s->oob_shift)) {
pagesize = 0; pagesize = 0;
s->mem_oob = 0; s->mem_oob = 0;
@ -424,7 +424,7 @@ static void nand_realize(DeviceState *dev, Error **errp)
static Property nand_properties[] = { static Property nand_properties[] = {
DEFINE_PROP_UINT8("manufacturer_id", NANDFlashState, manf_id, 0), DEFINE_PROP_UINT8("manufacturer_id", NANDFlashState, manf_id, 0),
DEFINE_PROP_UINT8("chip_id", NANDFlashState, chip_id, 0), DEFINE_PROP_UINT8("chip_id", NANDFlashState, chip_id, 0),
DEFINE_PROP_DRIVE("drive", NANDFlashState, bdrv), DEFINE_PROP_DRIVE("drive", NANDFlashState, blk),
DEFINE_PROP_END_OF_LIST(), DEFINE_PROP_END_OF_LIST(),
}; };
@ -624,7 +624,7 @@ uint32_t nand_getbuswidth(DeviceState *dev)
return s->buswidth << 3; return s->buswidth << 3;
} }
DeviceState *nand_init(BlockDriverState *bdrv, int manf_id, int chip_id) DeviceState *nand_init(BlockBackend *blk, int manf_id, int chip_id)
{ {
DeviceState *dev; DeviceState *dev;
@ -634,8 +634,8 @@ DeviceState *nand_init(BlockDriverState *bdrv, int manf_id, int chip_id)
dev = DEVICE(object_new(TYPE_NAND)); dev = DEVICE(object_new(TYPE_NAND));
qdev_prop_set_uint8(dev, "manufacturer_id", manf_id); qdev_prop_set_uint8(dev, "manufacturer_id", manf_id);
qdev_prop_set_uint8(dev, "chip_id", chip_id); qdev_prop_set_uint8(dev, "chip_id", chip_id);
if (bdrv) { if (blk) {
qdev_prop_set_drive_nofail(dev, "drive", bdrv); qdev_prop_set_drive_nofail(dev, "drive", blk);
} }
qdev_init_nofail(dev); qdev_init_nofail(dev);
@ -654,14 +654,14 @@ static void glue(nand_blk_write_, PAGE_SIZE)(NANDFlashState *s)
if (PAGE(s->addr) >= s->pages) if (PAGE(s->addr) >= s->pages)
return; return;
if (!s->bdrv) { if (!s->blk) {
mem_and(s->storage + PAGE_START(s->addr) + (s->addr & PAGE_MASK) + mem_and(s->storage + PAGE_START(s->addr) + (s->addr & PAGE_MASK) +
s->offset, s->io, s->iolen); s->offset, s->io, s->iolen);
} else if (s->mem_oob) { } else if (s->mem_oob) {
sector = SECTOR(s->addr); sector = SECTOR(s->addr);
off = (s->addr & PAGE_MASK) + s->offset; off = (s->addr & PAGE_MASK) + s->offset;
soff = SECTOR_OFFSET(s->addr); soff = SECTOR_OFFSET(s->addr);
if (bdrv_read(s->bdrv, sector, iobuf, PAGE_SECTORS) < 0) { if (blk_read(s->blk, sector, iobuf, PAGE_SECTORS) < 0) {
printf("%s: read error in sector %" PRIu64 "\n", __func__, sector); printf("%s: read error in sector %" PRIu64 "\n", __func__, sector);
return; return;
} }
@ -673,21 +673,21 @@ static void glue(nand_blk_write_, PAGE_SIZE)(NANDFlashState *s)
MIN(OOB_SIZE, off + s->iolen - PAGE_SIZE)); MIN(OOB_SIZE, off + s->iolen - PAGE_SIZE));
} }
if (bdrv_write(s->bdrv, sector, iobuf, PAGE_SECTORS) < 0) { if (blk_write(s->blk, sector, iobuf, PAGE_SECTORS) < 0) {
printf("%s: write error in sector %" PRIu64 "\n", __func__, sector); printf("%s: write error in sector %" PRIu64 "\n", __func__, sector);
} }
} else { } else {
off = PAGE_START(s->addr) + (s->addr & PAGE_MASK) + s->offset; off = PAGE_START(s->addr) + (s->addr & PAGE_MASK) + s->offset;
sector = off >> 9; sector = off >> 9;
soff = off & 0x1ff; soff = off & 0x1ff;
if (bdrv_read(s->bdrv, sector, iobuf, PAGE_SECTORS + 2) < 0) { if (blk_read(s->blk, sector, iobuf, PAGE_SECTORS + 2) < 0) {
printf("%s: read error in sector %" PRIu64 "\n", __func__, sector); printf("%s: read error in sector %" PRIu64 "\n", __func__, sector);
return; return;
} }
mem_and(iobuf + soff, s->io, s->iolen); mem_and(iobuf + soff, s->io, s->iolen);
if (bdrv_write(s->bdrv, sector, iobuf, PAGE_SECTORS + 2) < 0) { if (blk_write(s->blk, sector, iobuf, PAGE_SECTORS + 2) < 0) {
printf("%s: write error in sector %" PRIu64 "\n", __func__, sector); printf("%s: write error in sector %" PRIu64 "\n", __func__, sector);
} }
} }
@ -705,7 +705,7 @@ static void glue(nand_blk_erase_, PAGE_SIZE)(NANDFlashState *s)
return; return;
} }
if (!s->bdrv) { if (!s->blk) {
memset(s->storage + PAGE_START(addr), memset(s->storage + PAGE_START(addr),
0xff, (PAGE_SIZE + OOB_SIZE) << s->erase_shift); 0xff, (PAGE_SIZE + OOB_SIZE) << s->erase_shift);
} else if (s->mem_oob) { } else if (s->mem_oob) {
@ -714,17 +714,17 @@ static void glue(nand_blk_erase_, PAGE_SIZE)(NANDFlashState *s)
i = SECTOR(addr); i = SECTOR(addr);
page = SECTOR(addr + (ADDR_SHIFT + s->erase_shift)); page = SECTOR(addr + (ADDR_SHIFT + s->erase_shift));
for (; i < page; i ++) for (; i < page; i ++)
if (bdrv_write(s->bdrv, i, iobuf, 1) < 0) { if (blk_write(s->blk, i, iobuf, 1) < 0) {
printf("%s: write error in sector %" PRIu64 "\n", __func__, i); printf("%s: write error in sector %" PRIu64 "\n", __func__, i);
} }
} else { } else {
addr = PAGE_START(addr); addr = PAGE_START(addr);
page = addr >> 9; page = addr >> 9;
if (bdrv_read(s->bdrv, page, iobuf, 1) < 0) { if (blk_read(s->blk, page, iobuf, 1) < 0) {
printf("%s: read error in sector %" PRIu64 "\n", __func__, page); printf("%s: read error in sector %" PRIu64 "\n", __func__, page);
} }
memset(iobuf + (addr & 0x1ff), 0xff, (~addr & 0x1ff) + 1); memset(iobuf + (addr & 0x1ff), 0xff, (~addr & 0x1ff) + 1);
if (bdrv_write(s->bdrv, page, iobuf, 1) < 0) { if (blk_write(s->blk, page, iobuf, 1) < 0) {
printf("%s: write error in sector %" PRIu64 "\n", __func__, page); printf("%s: write error in sector %" PRIu64 "\n", __func__, page);
} }
@ -732,18 +732,18 @@ static void glue(nand_blk_erase_, PAGE_SIZE)(NANDFlashState *s)
i = (addr & ~0x1ff) + 0x200; i = (addr & ~0x1ff) + 0x200;
for (addr += ((PAGE_SIZE + OOB_SIZE) << s->erase_shift) - 0x200; for (addr += ((PAGE_SIZE + OOB_SIZE) << s->erase_shift) - 0x200;
i < addr; i += 0x200) { i < addr; i += 0x200) {
if (bdrv_write(s->bdrv, i >> 9, iobuf, 1) < 0) { if (blk_write(s->blk, i >> 9, iobuf, 1) < 0) {
printf("%s: write error in sector %" PRIu64 "\n", printf("%s: write error in sector %" PRIu64 "\n",
__func__, i >> 9); __func__, i >> 9);
} }
} }
page = i >> 9; page = i >> 9;
if (bdrv_read(s->bdrv, page, iobuf, 1) < 0) { if (blk_read(s->blk, page, iobuf, 1) < 0) {
printf("%s: read error in sector %" PRIu64 "\n", __func__, page); printf("%s: read error in sector %" PRIu64 "\n", __func__, page);
} }
memset(iobuf, 0xff, ((addr - 1) & 0x1ff) + 1); memset(iobuf, 0xff, ((addr - 1) & 0x1ff) + 1);
if (bdrv_write(s->bdrv, page, iobuf, 1) < 0) { if (blk_write(s->blk, page, iobuf, 1) < 0) {
printf("%s: write error in sector %" PRIu64 "\n", __func__, page); printf("%s: write error in sector %" PRIu64 "\n", __func__, page);
} }
} }
@ -756,9 +756,9 @@ static void glue(nand_blk_load_, PAGE_SIZE)(NANDFlashState *s,
return; return;
} }
if (s->bdrv) { if (s->blk) {
if (s->mem_oob) { if (s->mem_oob) {
if (bdrv_read(s->bdrv, SECTOR(addr), s->io, PAGE_SECTORS) < 0) { if (blk_read(s->blk, SECTOR(addr), s->io, PAGE_SECTORS) < 0) {
printf("%s: read error in sector %" PRIu64 "\n", printf("%s: read error in sector %" PRIu64 "\n",
__func__, SECTOR(addr)); __func__, SECTOR(addr));
} }
@ -767,8 +767,8 @@ static void glue(nand_blk_load_, PAGE_SIZE)(NANDFlashState *s,
OOB_SIZE); OOB_SIZE);
s->ioaddr = s->io + SECTOR_OFFSET(s->addr) + offset; s->ioaddr = s->io + SECTOR_OFFSET(s->addr) + offset;
} else { } else {
if (bdrv_read(s->bdrv, PAGE_START(addr) >> 9, if (blk_read(s->blk, PAGE_START(addr) >> 9,
s->io, (PAGE_SECTORS + 2)) < 0) { s->io, (PAGE_SECTORS + 2)) < 0) {
printf("%s: read error in sector %" PRIu64 "\n", printf("%s: read error in sector %" PRIu64 "\n",
__func__, PAGE_START(addr) >> 9); __func__, PAGE_START(addr) >> 9);
} }

19
hw/block/nvme.c
View File

@ -26,6 +26,7 @@
#include <hw/pci/pci.h> #include <hw/pci/pci.h>
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "qapi/visitor.h" #include "qapi/visitor.h"
#include "sysemu/block-backend.h"
#include "nvme.h" #include "nvme.h"
@ -199,7 +200,7 @@ static void nvme_rw_cb(void *opaque, int ret)
NvmeCtrl *n = sq->ctrl; NvmeCtrl *n = sq->ctrl;
NvmeCQueue *cq = n->cq[sq->cqid]; NvmeCQueue *cq = n->cq[sq->cqid];
block_acct_done(bdrv_get_stats(n->conf.bs), &req->acct); block_acct_done(blk_get_stats(n->conf.blk), &req->acct);
if (!ret) { if (!ret) {
req->status = NVME_SUCCESS; req->status = NVME_SUCCESS;
} else { } else {
@ -233,11 +234,11 @@ static uint16_t nvme_rw(NvmeCtrl *n, NvmeNamespace *ns, NvmeCmd *cmd,
} }
assert((nlb << data_shift) == req->qsg.size); assert((nlb << data_shift) == req->qsg.size);
dma_acct_start(n->conf.bs, &req->acct, &req->qsg, is_write ? dma_acct_start(n->conf.blk, &req->acct, &req->qsg,
BLOCK_ACCT_WRITE : BLOCK_ACCT_READ); is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ);
req->aiocb = is_write ? req->aiocb = is_write ?
dma_bdrv_write(n->conf.bs, &req->qsg, aio_slba, nvme_rw_cb, req) : dma_blk_write(n->conf.blk, &req->qsg, aio_slba, nvme_rw_cb, req) :
dma_bdrv_read(n->conf.bs, &req->qsg, aio_slba, nvme_rw_cb, req); dma_blk_read(n->conf.blk, &req->qsg, aio_slba, nvme_rw_cb, req);
return NVME_NO_COMPLETE; return NVME_NO_COMPLETE;
} }
@ -290,7 +291,7 @@ static uint16_t nvme_del_sq(NvmeCtrl *n, NvmeCmd *cmd)
while (!QTAILQ_EMPTY(&sq->out_req_list)) { while (!QTAILQ_EMPTY(&sq->out_req_list)) {
req = QTAILQ_FIRST(&sq->out_req_list); req = QTAILQ_FIRST(&sq->out_req_list);
assert(req->aiocb); assert(req->aiocb);
bdrv_aio_cancel(req->aiocb); blk_aio_cancel(req->aiocb);
} }
if (!nvme_check_cqid(n, sq->cqid)) { if (!nvme_check_cqid(n, sq->cqid)) {
cq = n->cq[sq->cqid]; cq = n->cq[sq->cqid];
@ -565,7 +566,7 @@ static void nvme_clear_ctrl(NvmeCtrl *n)
} }
} }
bdrv_flush(n->conf.bs); blk_flush(n->conf.blk);
n->bar.cc = 0; n->bar.cc = 0;
} }
@ -750,11 +751,11 @@ static int nvme_init(PCIDevice *pci_dev)
int64_t bs_size; int64_t bs_size;
uint8_t *pci_conf; uint8_t *pci_conf;
if (!(n->conf.bs)) { if (!n->conf.blk) {
return -1; return -1;
} }
bs_size = bdrv_getlength(n->conf.bs); bs_size = blk_getlength(n->conf.blk);
if (bs_size < 0) { if (bs_size < 0) {
return -1; return -1;
} }

2
hw/block/nvme.h
View File

@ -636,7 +636,7 @@ typedef struct NvmeAsyncEvent {
typedef struct NvmeRequest { typedef struct NvmeRequest {
struct NvmeSQueue *sq; struct NvmeSQueue *sq;
BlockDriverAIOCB *aiocb; BlockAIOCB *aiocb;
uint16_t status; uint16_t status;
NvmeCqe cqe; NvmeCqe cqe;
BlockAcctCookie acct; BlockAcctCookie acct;

67
hw/block/onenand.c
View File

@ -22,6 +22,7 @@
#include "hw/hw.h" #include "hw/hw.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "hw/irq.h" #include "hw/irq.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "exec/memory.h" #include "exec/memory.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
@ -49,8 +50,8 @@ typedef struct OneNANDState {
hwaddr base; hwaddr base;
qemu_irq intr; qemu_irq intr;
qemu_irq rdy; qemu_irq rdy;
BlockDriverState *bdrv; BlockBackend *blk;
BlockDriverState *bdrv_cur; BlockBackend *blk_cur;
uint8_t *image; uint8_t *image;
uint8_t *otp; uint8_t *otp;
uint8_t *current; uint8_t *current;
@ -213,7 +214,7 @@ static void onenand_reset(OneNANDState *s, int cold)
s->wpstatus = 0x0002; s->wpstatus = 0x0002;
s->cycle = 0; s->cycle = 0;
s->otpmode = 0; s->otpmode = 0;
s->bdrv_cur = s->bdrv; s->blk_cur = s->blk;
s->current = s->image; s->current = s->image;
s->secs_cur = s->secs; s->secs_cur = s->secs;
@ -221,7 +222,7 @@ static void onenand_reset(OneNANDState *s, int cold)
/* Lock the whole flash */ /* Lock the whole flash */
memset(s->blockwp, ONEN_LOCK_LOCKED, s->blocks); memset(s->blockwp, ONEN_LOCK_LOCKED, s->blocks);
if (s->bdrv_cur && bdrv_read(s->bdrv_cur, 0, s->boot[0], 8) < 0) { if (s->blk_cur && blk_read(s->blk_cur, 0, s->boot[0], 8) < 0) {
hw_error("%s: Loading the BootRAM failed.\n", __func__); hw_error("%s: Loading the BootRAM failed.\n", __func__);
} }
} }
@ -237,10 +238,11 @@ static void onenand_system_reset(DeviceState *dev)
static inline int onenand_load_main(OneNANDState *s, int sec, int secn, static inline int onenand_load_main(OneNANDState *s, int sec, int secn,
void *dest) void *dest)
{ {
if (s->bdrv_cur) if (s->blk_cur) {
return bdrv_read(s->bdrv_cur, sec, dest, secn) < 0; return blk_read(s->blk_cur, sec, dest, secn) < 0;
else if (sec + secn > s->secs_cur) } else if (sec + secn > s->secs_cur) {
return 1; return 1;
}
memcpy(dest, s->current + (sec << 9), secn << 9); memcpy(dest, s->current + (sec << 9), secn << 9);
@ -256,9 +258,9 @@ static inline int onenand_prog_main(OneNANDState *s, int sec, int secn,
uint32_t size = (uint32_t)secn * 512; uint32_t size = (uint32_t)secn * 512;
const uint8_t *sp = (const uint8_t *)src; const uint8_t *sp = (const uint8_t *)src;
uint8_t *dp = 0; uint8_t *dp = 0;
if (s->bdrv_cur) { if (s->blk_cur) {
dp = g_malloc(size); dp = g_malloc(size);
if (!dp || bdrv_read(s->bdrv_cur, sec, dp, secn) < 0) { if (!dp || blk_read(s->blk_cur, sec, dp, secn) < 0) {
result = 1; result = 1;
} }
} else { } else {
@ -273,11 +275,11 @@ static inline int onenand_prog_main(OneNANDState *s, int sec, int secn,
for (i = 0; i < size; i++) { for (i = 0; i < size; i++) {
dp[i] &= sp[i]; dp[i] &= sp[i];
} }
if (s->bdrv_cur) { if (s->blk_cur) {
result = bdrv_write(s->bdrv_cur, sec, dp, secn) < 0; result = blk_write(s->blk_cur, sec, dp, secn) < 0;
} }
} }
if (dp && s->bdrv_cur) { if (dp && s->blk_cur) {
g_free(dp); g_free(dp);
} }
} }
@ -290,14 +292,16 @@ static inline int onenand_load_spare(OneNANDState *s, int sec, int secn,
{ {
uint8_t buf[512]; uint8_t buf[512];
if (s->bdrv_cur) { if (s->blk_cur) {
if (bdrv_read(s->bdrv_cur, s->secs_cur + (sec >> 5), buf, 1) < 0) if (blk_read(s->blk_cur, s->secs_cur + (sec >> 5), buf, 1) < 0) {
return 1; return 1;
}
memcpy(dest, buf + ((sec & 31) << 4), secn << 4); memcpy(dest, buf + ((sec & 31) << 4), secn << 4);
} else if (sec + secn > s->secs_cur) } else if (sec + secn > s->secs_cur) {
return 1; return 1;
else } else {
memcpy(dest, s->current + (s->secs_cur << 9) + (sec << 4), secn << 4); memcpy(dest, s->current + (s->secs_cur << 9) + (sec << 4), secn << 4);
}
return 0; return 0;
} }
@ -309,11 +313,10 @@ static inline int onenand_prog_spare(OneNANDState *s, int sec, int secn,
if (secn > 0) { if (secn > 0) {
const uint8_t *sp = (const uint8_t *)src; const uint8_t *sp = (const uint8_t *)src;
uint8_t *dp = 0, *dpp = 0; uint8_t *dp = 0, *dpp = 0;
if (s->bdrv_cur) { if (s->blk_cur) {
dp = g_malloc(512); dp = g_malloc(512);
if (!dp || bdrv_read(s->bdrv_cur, if (!dp
s->secs_cur + (sec >> 5), || blk_read(s->blk_cur, s->secs_cur + (sec >> 5), dp, 1) < 0) {
dp, 1) < 0) {
result = 1; result = 1;
} else { } else {
dpp = dp + ((sec & 31) << 4); dpp = dp + ((sec & 31) << 4);
@ -330,9 +333,9 @@ static inline int onenand_prog_spare(OneNANDState *s, int sec, int secn,
for (i = 0; i < (secn << 4); i++) { for (i = 0; i < (secn << 4); i++) {
dpp[i] &= sp[i]; dpp[i] &= sp[i];
} }
if (s->bdrv_cur) { if (s->blk_cur) {
result = bdrv_write(s->bdrv_cur, s->secs_cur + (sec >> 5), result = blk_write(s->blk_cur, s->secs_cur + (sec >> 5),
dp, 1) < 0; dp, 1) < 0;
} }
} }
g_free(dp); g_free(dp);
@ -354,16 +357,16 @@ static inline int onenand_erase(OneNANDState *s, int sec, int num)
} }
memset(blankbuf, 0xff, 512); memset(blankbuf, 0xff, 512);
for (; num > 0; num--, sec++) { for (; num > 0; num--, sec++) {
if (s->bdrv_cur) { if (s->blk_cur) {
int erasesec = s->secs_cur + (sec >> 5); int erasesec = s->secs_cur + (sec >> 5);
if (bdrv_write(s->bdrv_cur, sec, blankbuf, 1) < 0) { if (blk_write(s->blk_cur, sec, blankbuf, 1) < 0) {
goto fail; goto fail;
} }
if (bdrv_read(s->bdrv_cur, erasesec, tmpbuf, 1) < 0) { if (blk_read(s->blk_cur, erasesec, tmpbuf, 1) < 0) {
goto fail; goto fail;
} }
memcpy(tmpbuf + ((sec & 31) << 4), blankbuf, 1 << 4); memcpy(tmpbuf + ((sec & 31) << 4), blankbuf, 1 << 4);
if (bdrv_write(s->bdrv_cur, erasesec, tmpbuf, 1) < 0) { if (blk_write(s->blk_cur, erasesec, tmpbuf, 1) < 0) {
goto fail; goto fail;
} }
} else { } else {
@ -576,7 +579,7 @@ static void onenand_command(OneNANDState *s)
case 0x65: /* OTP Access */ case 0x65: /* OTP Access */
s->intstatus |= ONEN_INT; s->intstatus |= ONEN_INT;
s->bdrv_cur = NULL; s->blk_cur = NULL;
s->current = s->otp; s->current = s->otp;
s->secs_cur = 1 << (BLOCK_SHIFT - 9); s->secs_cur = 1 << (BLOCK_SHIFT - 9);
s->addr[ONEN_BUF_BLOCK] = 0; s->addr[ONEN_BUF_BLOCK] = 0;
@ -776,15 +779,15 @@ static int onenand_initfn(SysBusDevice *sbd)
? (1 << (6 + ((s->id.dev >> 4) & 7))) : 0; ? (1 << (6 + ((s->id.dev >> 4) & 7))) : 0;
memory_region_init_io(&s->iomem, OBJECT(s), &onenand_ops, s, "onenand", memory_region_init_io(&s->iomem, OBJECT(s), &onenand_ops, s, "onenand",
0x10000 << s->shift); 0x10000 << s->shift);
if (!s->bdrv) { if (!s->blk) {
s->image = memset(g_malloc(size + (size >> 5)), s->image = memset(g_malloc(size + (size >> 5)),
0xff, size + (size >> 5)); 0xff, size + (size >> 5));
} else { } else {
if (bdrv_is_read_only(s->bdrv)) { if (blk_is_read_only(s->blk)) {
error_report("Can't use a read-only drive"); error_report("Can't use a read-only drive");
return -1; return -1;
} }
s->bdrv_cur = s->bdrv; s->blk_cur = s->blk;
} }
s->otp = memset(g_malloc((64 + 2) << PAGE_SHIFT), s->otp = memset(g_malloc((64 + 2) << PAGE_SHIFT),
0xff, (64 + 2) << PAGE_SHIFT); 0xff, (64 + 2) << PAGE_SHIFT);
@ -815,7 +818,7 @@ static Property onenand_properties[] = {
DEFINE_PROP_UINT16("device_id", OneNANDState, id.dev, 0), DEFINE_PROP_UINT16("device_id", OneNANDState, id.dev, 0),
DEFINE_PROP_UINT16("version_id", OneNANDState, id.ver, 0), DEFINE_PROP_UINT16("version_id", OneNANDState, id.ver, 0),
DEFINE_PROP_INT32("shift", OneNANDState, shift, 0), DEFINE_PROP_INT32("shift", OneNANDState, shift, 0),
DEFINE_PROP_DRIVE("drive", OneNANDState, bdrv), DEFINE_PROP_DRIVE("drive", OneNANDState, blk),
DEFINE_PROP_END_OF_LIST(), DEFINE_PROP_END_OF_LIST(),
}; };

24
hw/block/pflash_cfi01.c
View File

@ -38,7 +38,7 @@
#include "hw/hw.h" #include "hw/hw.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "block/block.h" #include "sysemu/block-backend.h"
#include "qemu/timer.h" #include "qemu/timer.h"
#include "qemu/bitops.h" #include "qemu/bitops.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
@ -69,7 +69,7 @@ struct pflash_t {
SysBusDevice parent_obj; SysBusDevice parent_obj;
/*< public >*/ /*< public >*/
BlockDriverState *bs; BlockBackend *blk;
uint32_t nb_blocs; uint32_t nb_blocs;
uint64_t sector_len; uint64_t sector_len;
uint8_t bank_width; uint8_t bank_width;
@ -395,13 +395,13 @@ static void pflash_update(pflash_t *pfl, int offset,
int size) int size)
{ {
int offset_end; int offset_end;
if (pfl->bs) { if (pfl->blk) {
offset_end = offset + size; offset_end = offset + size;
/* round to sectors */ /* round to sectors */
offset = offset >> 9; offset = offset >> 9;
offset_end = (offset_end + 511) >> 9; offset_end = (offset_end + 511) >> 9;
bdrv_write(pfl->bs, offset, pfl->storage + (offset << 9), blk_write(pfl->blk, offset, pfl->storage + (offset << 9),
offset_end - offset); offset_end - offset);
} }
} }
@ -784,9 +784,9 @@ static void pflash_cfi01_realize(DeviceState *dev, Error **errp)
pfl->storage = memory_region_get_ram_ptr(&pfl->mem); pfl->storage = memory_region_get_ram_ptr(&pfl->mem);
sysbus_init_mmio(SYS_BUS_DEVICE(dev), &pfl->mem); sysbus_init_mmio(SYS_BUS_DEVICE(dev), &pfl->mem);
if (pfl->bs) { if (pfl->blk) {
/* read the initial flash content */ /* read the initial flash content */
ret = bdrv_read(pfl->bs, 0, pfl->storage, total_len >> 9); ret = blk_read(pfl->blk, 0, pfl->storage, total_len >> 9);
if (ret < 0) { if (ret < 0) {
vmstate_unregister_ram(&pfl->mem, DEVICE(pfl)); vmstate_unregister_ram(&pfl->mem, DEVICE(pfl));
@ -795,8 +795,8 @@ static void pflash_cfi01_realize(DeviceState *dev, Error **errp)
} }
} }
if (pfl->bs) { if (pfl->blk) {
pfl->ro = bdrv_is_read_only(pfl->bs); pfl->ro = blk_is_read_only(pfl->blk);
} else { } else {
pfl->ro = 0; pfl->ro = 0;
} }
@ -898,7 +898,7 @@ static void pflash_cfi01_realize(DeviceState *dev, Error **errp)
} }
static Property pflash_cfi01_properties[] = { static Property pflash_cfi01_properties[] = {
DEFINE_PROP_DRIVE("drive", struct pflash_t, bs), DEFINE_PROP_DRIVE("drive", struct pflash_t, blk),
/* num-blocks is the number of blocks actually visible to the guest, /* num-blocks is the number of blocks actually visible to the guest,
* ie the total size of the device divided by the sector length. * ie the total size of the device divided by the sector length.
* If we're emulating flash devices wired in parallel the actual * If we're emulating flash devices wired in parallel the actual
@ -962,14 +962,14 @@ type_init(pflash_cfi01_register_types)
pflash_t *pflash_cfi01_register(hwaddr base, pflash_t *pflash_cfi01_register(hwaddr base,
DeviceState *qdev, const char *name, DeviceState *qdev, const char *name,
hwaddr size, hwaddr size,
BlockDriverState *bs, BlockBackend *blk,
uint32_t sector_len, int nb_blocs, uint32_t sector_len, int nb_blocs,
int bank_width, uint16_t id0, uint16_t id1, int bank_width, uint16_t id0, uint16_t id1,
uint16_t id2, uint16_t id3, int be) uint16_t id2, uint16_t id3, int be)
{ {
DeviceState *dev = qdev_create(NULL, TYPE_CFI_PFLASH01); DeviceState *dev = qdev_create(NULL, TYPE_CFI_PFLASH01);
if (bs && qdev_prop_set_drive(dev, "drive", bs)) { if (blk && qdev_prop_set_drive(dev, "drive", blk)) {
abort(); abort();
} }
qdev_prop_set_uint32(dev, "num-blocks", nb_blocs); qdev_prop_set_uint32(dev, "num-blocks", nb_blocs);

24
hw/block/pflash_cfi02.c
View File

@ -38,7 +38,7 @@
#include "hw/hw.h" #include "hw/hw.h"
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "qemu/timer.h" #include "qemu/timer.h"
#include "block/block.h" #include "sysemu/block-backend.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "qemu/host-utils.h" #include "qemu/host-utils.h"
#include "hw/sysbus.h" #include "hw/sysbus.h"
@ -63,7 +63,7 @@ struct pflash_t {
SysBusDevice parent_obj; SysBusDevice parent_obj;
/*< public >*/ /*< public >*/
BlockDriverState *bs; BlockBackend *blk;
uint32_t sector_len; uint32_t sector_len;
uint32_t nb_blocs; uint32_t nb_blocs;
uint32_t chip_len; uint32_t chip_len;
@ -249,13 +249,13 @@ static void pflash_update(pflash_t *pfl, int offset,
int size) int size)
{ {
int offset_end; int offset_end;
if (pfl->bs) { if (pfl->blk) {
offset_end = offset + size; offset_end = offset + size;
/* round to sectors */ /* round to sectors */
offset = offset >> 9; offset = offset >> 9;
offset_end = (offset_end + 511) >> 9; offset_end = (offset_end + 511) >> 9;
bdrv_write(pfl->bs, offset, pfl->storage + (offset << 9), blk_write(pfl->blk, offset, pfl->storage + (offset << 9),
offset_end - offset); offset_end - offset);
} }
} }
@ -618,9 +618,9 @@ static void pflash_cfi02_realize(DeviceState *dev, Error **errp)
vmstate_register_ram(&pfl->orig_mem, DEVICE(pfl)); vmstate_register_ram(&pfl->orig_mem, DEVICE(pfl));
pfl->storage = memory_region_get_ram_ptr(&pfl->orig_mem); pfl->storage = memory_region_get_ram_ptr(&pfl->orig_mem);
pfl->chip_len = chip_len; pfl->chip_len = chip_len;
if (pfl->bs) { if (pfl->blk) {
/* read the initial flash content */ /* read the initial flash content */
ret = bdrv_read(pfl->bs, 0, pfl->storage, chip_len >> 9); ret = blk_read(pfl->blk, 0, pfl->storage, chip_len >> 9);
if (ret < 0) { if (ret < 0) {
vmstate_unregister_ram(&pfl->orig_mem, DEVICE(pfl)); vmstate_unregister_ram(&pfl->orig_mem, DEVICE(pfl));
error_setg(errp, "failed to read the initial flash content"); error_setg(errp, "failed to read the initial flash content");
@ -632,8 +632,8 @@ static void pflash_cfi02_realize(DeviceState *dev, Error **errp)
pfl->rom_mode = 1; pfl->rom_mode = 1;
sysbus_init_mmio(SYS_BUS_DEVICE(dev), &pfl->mem); sysbus_init_mmio(SYS_BUS_DEVICE(dev), &pfl->mem);
if (pfl->bs) { if (pfl->blk) {
pfl->ro = bdrv_is_read_only(pfl->bs); pfl->ro = blk_is_read_only(pfl->blk);
} else { } else {
pfl->ro = 0; pfl->ro = 0;
} }
@ -722,7 +722,7 @@ static void pflash_cfi02_realize(DeviceState *dev, Error **errp)
} }
static Property pflash_cfi02_properties[] = { static Property pflash_cfi02_properties[] = {
DEFINE_PROP_DRIVE("drive", struct pflash_t, bs), DEFINE_PROP_DRIVE("drive", struct pflash_t, blk),
DEFINE_PROP_UINT32("num-blocks", struct pflash_t, nb_blocs, 0), DEFINE_PROP_UINT32("num-blocks", struct pflash_t, nb_blocs, 0),
DEFINE_PROP_UINT32("sector-length", struct pflash_t, sector_len, 0), DEFINE_PROP_UINT32("sector-length", struct pflash_t, sector_len, 0),
DEFINE_PROP_UINT8("width", struct pflash_t, width, 0), DEFINE_PROP_UINT8("width", struct pflash_t, width, 0),
@ -763,7 +763,7 @@ type_init(pflash_cfi02_register_types)
pflash_t *pflash_cfi02_register(hwaddr base, pflash_t *pflash_cfi02_register(hwaddr base,
DeviceState *qdev, const char *name, DeviceState *qdev, const char *name,
hwaddr size, hwaddr size,
BlockDriverState *bs, uint32_t sector_len, BlockBackend *blk, uint32_t sector_len,
int nb_blocs, int nb_mappings, int width, int nb_blocs, int nb_mappings, int width,
uint16_t id0, uint16_t id1, uint16_t id0, uint16_t id1,
uint16_t id2, uint16_t id3, uint16_t id2, uint16_t id3,
@ -772,7 +772,7 @@ pflash_t *pflash_cfi02_register(hwaddr base,
{ {
DeviceState *dev = qdev_create(NULL, TYPE_CFI_PFLASH02); DeviceState *dev = qdev_create(NULL, TYPE_CFI_PFLASH02);
if (bs && qdev_prop_set_drive(dev, "drive", bs)) { if (blk && qdev_prop_set_drive(dev, "drive", blk)) {
abort(); abort();
} }
qdev_prop_set_uint32(dev, "num-blocks", nb_blocs); qdev_prop_set_uint32(dev, "num-blocks", nb_blocs);

149
hw/block/virtio-blk.c
View File

@ -16,6 +16,7 @@
#include "qemu/error-report.h" #include "qemu/error-report.h"
#include "trace.h" #include "trace.h"
#include "hw/block/block.h" #include "hw/block/block.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "hw/virtio/virtio-blk.h" #include "hw/virtio/virtio-blk.h"
#include "dataplane/virtio-blk.h" #include "dataplane/virtio-blk.h"
@ -64,7 +65,8 @@ static void virtio_blk_req_complete(VirtIOBlockReq *req, unsigned char status)
static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error, static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
bool is_read) bool is_read)
{ {
BlockErrorAction action = bdrv_get_error_action(req->dev->bs, is_read, error); BlockErrorAction action = blk_get_error_action(req->dev->blk,
is_read, error);
VirtIOBlock *s = req->dev; VirtIOBlock *s = req->dev;
if (action == BLOCK_ERROR_ACTION_STOP) { if (action == BLOCK_ERROR_ACTION_STOP) {
@ -72,11 +74,11 @@ static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
s->rq = req; s->rq = req;
} else if (action == BLOCK_ERROR_ACTION_REPORT) { } else if (action == BLOCK_ERROR_ACTION_REPORT) {
virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR); virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
block_acct_done(bdrv_get_stats(s->bs), &req->acct); block_acct_done(blk_get_stats(s->blk), &req->acct);
virtio_blk_free_request(req); virtio_blk_free_request(req);
} }
bdrv_error_action(s->bs, action, is_read, error); blk_error_action(s->blk, action, is_read, error);
return action != BLOCK_ERROR_ACTION_IGNORE; return action != BLOCK_ERROR_ACTION_IGNORE;
} }
@ -94,7 +96,7 @@ static void virtio_blk_rw_complete(void *opaque, int ret)
} }
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
block_acct_done(bdrv_get_stats(req->dev->bs), &req->acct); block_acct_done(blk_get_stats(req->dev->blk), &req->acct);
virtio_blk_free_request(req); virtio_blk_free_request(req);
} }
@ -109,7 +111,7 @@ static void virtio_blk_flush_complete(void *opaque, int ret)
} }
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
block_acct_done(bdrv_get_stats(req->dev->bs), &req->acct); block_acct_done(blk_get_stats(req->dev->blk), &req->acct);
virtio_blk_free_request(req); virtio_blk_free_request(req);
} }
@ -155,7 +157,7 @@ int virtio_blk_handle_scsi_req(VirtIOBlock *blk,
*/ */
scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base; scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base;
if (!blk->blk.scsi) { if (!blk->conf.scsi) {
status = VIRTIO_BLK_S_UNSUPP; status = VIRTIO_BLK_S_UNSUPP;
goto fail; goto fail;
} }
@ -209,7 +211,7 @@ int virtio_blk_handle_scsi_req(VirtIOBlock *blk,
hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base; hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base;
hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len; hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len;
status = bdrv_ioctl(blk->bs, SG_IO, &hdr); status = blk_ioctl(blk->blk, SG_IO, &hdr);
if (status) { if (status) {
status = VIRTIO_BLK_S_UNSUPP; status = VIRTIO_BLK_S_UNSUPP;
goto fail; goto fail;
@ -255,7 +257,7 @@ static void virtio_blk_handle_scsi(VirtIOBlockReq *req)
virtio_blk_free_request(req); virtio_blk_free_request(req);
} }
void virtio_submit_multiwrite(BlockDriverState *bs, MultiReqBuffer *mrb) void virtio_submit_multiwrite(BlockBackend *blk, MultiReqBuffer *mrb)
{ {
int i, ret; int i, ret;
@ -263,7 +265,7 @@ void virtio_submit_multiwrite(BlockDriverState *bs, MultiReqBuffer *mrb)
return; return;
} }
ret = bdrv_aio_multiwrite(bs, mrb->blkreq, mrb->num_writes); ret = blk_aio_multiwrite(blk, mrb->blkreq, mrb->num_writes);
if (ret != 0) { if (ret != 0) {
for (i = 0; i < mrb->num_writes; i++) { for (i = 0; i < mrb->num_writes; i++) {
if (mrb->blkreq[i].error) { if (mrb->blkreq[i].error) {
@ -277,14 +279,14 @@ void virtio_submit_multiwrite(BlockDriverState *bs, MultiReqBuffer *mrb)
static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb) static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb)
{ {
block_acct_start(bdrv_get_stats(req->dev->bs), &req->acct, 0, block_acct_start(blk_get_stats(req->dev->blk), &req->acct, 0,
BLOCK_ACCT_FLUSH); BLOCK_ACCT_FLUSH);
/* /*
* Make sure all outstanding writes are posted to the backing device. * Make sure all outstanding writes are posted to the backing device.
*/ */
virtio_submit_multiwrite(req->dev->bs, mrb); virtio_submit_multiwrite(req->dev->blk, mrb);
bdrv_aio_flush(req->dev->bs, virtio_blk_flush_complete, req); blk_aio_flush(req->dev->blk, virtio_blk_flush_complete, req);
} }
static bool virtio_blk_sect_range_ok(VirtIOBlock *dev, static bool virtio_blk_sect_range_ok(VirtIOBlock *dev,
@ -296,10 +298,10 @@ static bool virtio_blk_sect_range_ok(VirtIOBlock *dev,
if (sector & dev->sector_mask) { if (sector & dev->sector_mask) {
return false; return false;
} }
if (size % dev->conf->logical_block_size) { if (size % dev->conf.conf.logical_block_size) {
return false; return false;
} }
bdrv_get_geometry(dev->bs, &total_sectors); blk_get_geometry(dev->blk, &total_sectors);
if (sector > total_sectors || nb_sectors > total_sectors - sector) { if (sector > total_sectors || nb_sectors > total_sectors - sector) {
return false; return false;
} }
@ -321,11 +323,11 @@ static void virtio_blk_handle_write(VirtIOBlockReq *req, MultiReqBuffer *mrb)
return; return;
} }
block_acct_start(bdrv_get_stats(req->dev->bs), &req->acct, req->qiov.size, block_acct_start(blk_get_stats(req->dev->blk), &req->acct, req->qiov.size,
BLOCK_ACCT_WRITE); BLOCK_ACCT_WRITE);
if (mrb->num_writes == 32) { if (mrb->num_writes == 32) {
virtio_submit_multiwrite(req->dev->bs, mrb); virtio_submit_multiwrite(req->dev->blk, mrb);
} }
blkreq = &mrb->blkreq[mrb->num_writes]; blkreq = &mrb->blkreq[mrb->num_writes];
@ -353,11 +355,11 @@ static void virtio_blk_handle_read(VirtIOBlockReq *req)
return; return;
} }
block_acct_start(bdrv_get_stats(req->dev->bs), &req->acct, req->qiov.size, block_acct_start(blk_get_stats(req->dev->blk), &req->acct, req->qiov.size,
BLOCK_ACCT_READ); BLOCK_ACCT_READ);
bdrv_aio_readv(req->dev->bs, sector, &req->qiov, blk_aio_readv(req->dev->blk, sector, &req->qiov,
req->qiov.size / BDRV_SECTOR_SIZE, req->qiov.size / BDRV_SECTOR_SIZE,
virtio_blk_rw_complete, req); virtio_blk_rw_complete, req);
} }
void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb) void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
@ -405,7 +407,7 @@ void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
* NB: per existing s/n string convention the string is * NB: per existing s/n string convention the string is
* terminated by '\0' only when shorter than buffer. * terminated by '\0' only when shorter than buffer.
*/ */
const char *serial = s->blk.serial ? s->blk.serial : ""; const char *serial = s->conf.serial ? s->conf.serial : "";
size_t size = MIN(strlen(serial) + 1, size_t size = MIN(strlen(serial) + 1,
MIN(iov_size(in_iov, in_num), MIN(iov_size(in_iov, in_num),
VIRTIO_BLK_ID_BYTES)); VIRTIO_BLK_ID_BYTES));
@ -445,7 +447,7 @@ static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
virtio_blk_handle_request(req, &mrb); virtio_blk_handle_request(req, &mrb);
} }
virtio_submit_multiwrite(s->bs, &mrb); virtio_submit_multiwrite(s->blk, &mrb);
/* /*
* FIXME: Want to check for completions before returning to guest mode, * FIXME: Want to check for completions before returning to guest mode,
@ -473,7 +475,7 @@ static void virtio_blk_dma_restart_bh(void *opaque)
req = next; req = next;
} }
virtio_submit_multiwrite(s->bs, &mrb); virtio_submit_multiwrite(s->blk, &mrb);
} }
static void virtio_blk_dma_restart_cb(void *opaque, int running, static void virtio_blk_dma_restart_cb(void *opaque, int running,
@ -486,7 +488,7 @@ static void virtio_blk_dma_restart_cb(void *opaque, int running,
} }
if (!s->bh) { if (!s->bh) {
s->bh = aio_bh_new(bdrv_get_aio_context(s->blk.conf.bs), s->bh = aio_bh_new(blk_get_aio_context(s->conf.conf.blk),
virtio_blk_dma_restart_bh, s); virtio_blk_dma_restart_bh, s);
qemu_bh_schedule(s->bh); qemu_bh_schedule(s->bh);
} }
@ -504,8 +506,8 @@ static void virtio_blk_reset(VirtIODevice *vdev)
* This should cancel pending requests, but can't do nicely until there * This should cancel pending requests, but can't do nicely until there
* are per-device request lists. * are per-device request lists.
*/ */
bdrv_drain_all(); blk_drain_all();
bdrv_set_enable_write_cache(s->bs, s->original_wce); blk_set_enable_write_cache(s->blk, s->original_wce);
} }
/* coalesce internal state, copy to pci i/o region 0 /* coalesce internal state, copy to pci i/o region 0
@ -513,19 +515,20 @@ static void virtio_blk_reset(VirtIODevice *vdev)
static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
{ {
VirtIOBlock *s = VIRTIO_BLK(vdev); VirtIOBlock *s = VIRTIO_BLK(vdev);
BlockConf *conf = &s->conf.conf;
struct virtio_blk_config blkcfg; struct virtio_blk_config blkcfg;
uint64_t capacity; uint64_t capacity;
int blk_size = s->conf->logical_block_size; int blk_size = conf->logical_block_size;
bdrv_get_geometry(s->bs, &capacity); blk_get_geometry(s->blk, &capacity);
memset(&blkcfg, 0, sizeof(blkcfg)); memset(&blkcfg, 0, sizeof(blkcfg));
virtio_stq_p(vdev, &blkcfg.capacity, capacity); virtio_stq_p(vdev, &blkcfg.capacity, capacity);
virtio_stl_p(vdev, &blkcfg.seg_max, 128 - 2); virtio_stl_p(vdev, &blkcfg.seg_max, 128 - 2);
virtio_stw_p(vdev, &blkcfg.cylinders, s->conf->cyls); virtio_stw_p(vdev, &blkcfg.cylinders, conf->cyls);
virtio_stl_p(vdev, &blkcfg.blk_size, blk_size); virtio_stl_p(vdev, &blkcfg.blk_size, blk_size);
virtio_stw_p(vdev, &blkcfg.min_io_size, s->conf->min_io_size / blk_size); virtio_stw_p(vdev, &blkcfg.min_io_size, conf->min_io_size / blk_size);
virtio_stw_p(vdev, &blkcfg.opt_io_size, s->conf->opt_io_size / blk_size); virtio_stw_p(vdev, &blkcfg.opt_io_size, conf->opt_io_size / blk_size);
blkcfg.heads = s->conf->heads; blkcfg.heads = conf->heads;
/* /*
* We must ensure that the block device capacity is a multiple of * We must ensure that the block device capacity is a multiple of
* the logical block size. If that is not the case, let's use * the logical block size. If that is not the case, let's use
@ -537,15 +540,15 @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
* divided by 512 - instead it is the amount of blk_size blocks * divided by 512 - instead it is the amount of blk_size blocks
* per track (cylinder). * per track (cylinder).
*/ */
if (bdrv_getlength(s->bs) / s->conf->heads / s->conf->secs % blk_size) { if (blk_getlength(s->blk) / conf->heads / conf->secs % blk_size) {
blkcfg.sectors = s->conf->secs & ~s->sector_mask; blkcfg.sectors = conf->secs & ~s->sector_mask;
} else { } else {
blkcfg.sectors = s->conf->secs; blkcfg.sectors = conf->secs;
} }
blkcfg.size_max = 0; blkcfg.size_max = 0;
blkcfg.physical_block_exp = get_physical_block_exp(s->conf); blkcfg.physical_block_exp = get_physical_block_exp(conf);
blkcfg.alignment_offset = 0; blkcfg.alignment_offset = 0;
blkcfg.wce = bdrv_enable_write_cache(s->bs); blkcfg.wce = blk_enable_write_cache(s->blk);
memcpy(config, &blkcfg, sizeof(struct virtio_blk_config)); memcpy(config, &blkcfg, sizeof(struct virtio_blk_config));
} }
@ -556,9 +559,9 @@ static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
memcpy(&blkcfg, config, sizeof(blkcfg)); memcpy(&blkcfg, config, sizeof(blkcfg));
aio_context_acquire(bdrv_get_aio_context(s->bs)); aio_context_acquire(blk_get_aio_context(s->blk));
bdrv_set_enable_write_cache(s->bs, blkcfg.wce != 0); blk_set_enable_write_cache(s->blk, blkcfg.wce != 0);
aio_context_release(bdrv_get_aio_context(s->bs)); aio_context_release(blk_get_aio_context(s->blk));
} }
static uint32_t virtio_blk_get_features(VirtIODevice *vdev, uint32_t features) static uint32_t virtio_blk_get_features(VirtIODevice *vdev, uint32_t features)
@ -571,14 +574,15 @@ static uint32_t virtio_blk_get_features(VirtIODevice *vdev, uint32_t features)
features |= (1 << VIRTIO_BLK_F_BLK_SIZE); features |= (1 << VIRTIO_BLK_F_BLK_SIZE);
features |= (1 << VIRTIO_BLK_F_SCSI); features |= (1 << VIRTIO_BLK_F_SCSI);
if (s->blk.config_wce) { if (s->conf.config_wce) {
features |= (1 << VIRTIO_BLK_F_CONFIG_WCE); features |= (1 << VIRTIO_BLK_F_CONFIG_WCE);
} }
if (bdrv_enable_write_cache(s->bs)) if (blk_enable_write_cache(s->blk)) {
features |= (1 << VIRTIO_BLK_F_WCE); features |= (1 << VIRTIO_BLK_F_WCE);
}
if (bdrv_is_read_only(s->bs)) if (blk_is_read_only(s->blk)) {
features |= 1 << VIRTIO_BLK_F_RO; features |= 1 << VIRTIO_BLK_F_RO;
}
return features; return features;
} }
@ -612,13 +616,13 @@ static void virtio_blk_set_status(VirtIODevice *vdev, uint8_t status)
* Guest writes 1 to the WCE configuration field (writeback mode) * Guest writes 1 to the WCE configuration field (writeback mode)
* Guest sets DRIVER_OK bit in status field * Guest sets DRIVER_OK bit in status field
* *
* s->bs would erroneously be placed in writethrough mode. * s->blk would erroneously be placed in writethrough mode.
*/ */
if (!(features & (1 << VIRTIO_BLK_F_CONFIG_WCE))) { if (!(features & (1 << VIRTIO_BLK_F_CONFIG_WCE))) {
aio_context_acquire(bdrv_get_aio_context(s->bs)); aio_context_acquire(blk_get_aio_context(s->blk));
bdrv_set_enable_write_cache(s->bs, blk_set_enable_write_cache(s->blk,
!!(features & (1 << VIRTIO_BLK_F_WCE))); !!(features & (1 << VIRTIO_BLK_F_WCE)));
aio_context_release(bdrv_get_aio_context(s->bs)); aio_context_release(blk_get_aio_context(s->blk));
} }
} }
@ -707,8 +711,8 @@ static void virtio_blk_migration_state_changed(Notifier *notifier, void *data)
if (s->dataplane) { if (s->dataplane) {
return; return;
} }
bdrv_drain_all(); /* complete in-flight non-dataplane requests */ blk_drain_all(); /* complete in-flight non-dataplane requests */
virtio_blk_data_plane_create(VIRTIO_DEVICE(s), &s->blk, virtio_blk_data_plane_create(VIRTIO_DEVICE(s), &s->conf,
&s->dataplane, &err); &s->dataplane, &err);
if (err != NULL) { if (err != NULL) {
error_report("%s", error_get_pretty(err)); error_report("%s", error_get_pretty(err));
@ -721,22 +725,22 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
{ {
VirtIODevice *vdev = VIRTIO_DEVICE(dev); VirtIODevice *vdev = VIRTIO_DEVICE(dev);
VirtIOBlock *s = VIRTIO_BLK(dev); VirtIOBlock *s = VIRTIO_BLK(dev);
VirtIOBlkConf *blk = &(s->blk); VirtIOBlkConf *conf = &s->conf;
Error *err = NULL; Error *err = NULL;
static int virtio_blk_id; static int virtio_blk_id;
if (!blk->conf.bs) { if (!conf->conf.blk) {
error_setg(errp, "drive property not set"); error_setg(errp, "drive property not set");
return; return;
} }
if (!bdrv_is_inserted(blk->conf.bs)) { if (!blk_is_inserted(conf->conf.blk)) {
error_setg(errp, "Device needs media, but drive is empty"); error_setg(errp, "Device needs media, but drive is empty");
return; return;
} }
blkconf_serial(&blk->conf, &blk->serial); blkconf_serial(&conf->conf, &conf->serial);
s->original_wce = bdrv_enable_write_cache(blk->conf.bs); s->original_wce = blk_enable_write_cache(conf->conf.blk);
blkconf_geometry(&blk->conf, NULL, 65535, 255, 255, &err); blkconf_geometry(&conf->conf, NULL, 65535, 255, 255, &err);
if (err) { if (err) {
error_propagate(errp, err); error_propagate(errp, err);
return; return;
@ -745,14 +749,13 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK,
sizeof(struct virtio_blk_config)); sizeof(struct virtio_blk_config));
s->bs = blk->conf.bs; s->blk = conf->conf.blk;
s->conf = &blk->conf;
s->rq = NULL; s->rq = NULL;
s->sector_mask = (s->conf->logical_block_size / BDRV_SECTOR_SIZE) - 1; s->sector_mask = (s->conf.conf.logical_block_size / BDRV_SECTOR_SIZE) - 1;
s->vq = virtio_add_queue(vdev, 128, virtio_blk_handle_output); s->vq = virtio_add_queue(vdev, 128, virtio_blk_handle_output);
s->complete_request = virtio_blk_complete_request; s->complete_request = virtio_blk_complete_request;
virtio_blk_data_plane_create(vdev, blk, &s->dataplane, &err); virtio_blk_data_plane_create(vdev, conf, &s->dataplane, &err);
if (err != NULL) { if (err != NULL) {
error_propagate(errp, err); error_propagate(errp, err);
virtio_cleanup(vdev); virtio_cleanup(vdev);
@ -764,10 +767,10 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
s->change = qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s); s->change = qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s);
register_savevm(dev, "virtio-blk", virtio_blk_id++, 2, register_savevm(dev, "virtio-blk", virtio_blk_id++, 2,
virtio_blk_save, virtio_blk_load, s); virtio_blk_save, virtio_blk_load, s);
bdrv_set_dev_ops(s->bs, &virtio_block_ops, s); blk_set_dev_ops(s->blk, &virtio_block_ops, s);
bdrv_set_guest_block_size(s->bs, s->conf->logical_block_size); blk_set_guest_block_size(s->blk, s->conf.conf.logical_block_size);
bdrv_iostatus_enable(s->bs); blk_iostatus_enable(s->blk);
} }
static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp) static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp)
@ -780,7 +783,7 @@ static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp)
s->dataplane = NULL; s->dataplane = NULL;
qemu_del_vm_change_state_handler(s->change); qemu_del_vm_change_state_handler(s->change);
unregister_savevm(dev, "virtio-blk", s); unregister_savevm(dev, "virtio-blk", s);
blockdev_mark_auto_del(s->bs); blockdev_mark_auto_del(s->blk);
virtio_cleanup(vdev); virtio_cleanup(vdev);
} }
@ -789,23 +792,23 @@ static void virtio_blk_instance_init(Object *obj)
VirtIOBlock *s = VIRTIO_BLK(obj); VirtIOBlock *s = VIRTIO_BLK(obj);
object_property_add_link(obj, "iothread", TYPE_IOTHREAD, object_property_add_link(obj, "iothread", TYPE_IOTHREAD,
(Object **)&s->blk.iothread, (Object **)&s->conf.iothread,
qdev_prop_allow_set_link_before_realize, qdev_prop_allow_set_link_before_realize,
OBJ_PROP_LINK_UNREF_ON_RELEASE, NULL); OBJ_PROP_LINK_UNREF_ON_RELEASE, NULL);
device_add_bootindex_property(obj, &s->blk.conf.bootindex, device_add_bootindex_property(obj, &s->conf.conf.bootindex,
"bootindex", "/disk@0,0", "bootindex", "/disk@0,0",
DEVICE(obj), NULL); DEVICE(obj), NULL);
} }
static Property virtio_blk_properties[] = { static Property virtio_blk_properties[] = {
DEFINE_BLOCK_PROPERTIES(VirtIOBlock, blk.conf), DEFINE_BLOCK_PROPERTIES(VirtIOBlock, conf.conf),
DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock, blk.conf), DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock, conf.conf),
DEFINE_PROP_STRING("serial", VirtIOBlock, blk.serial), DEFINE_PROP_STRING("serial", VirtIOBlock, conf.serial),
DEFINE_PROP_BIT("config-wce", VirtIOBlock, blk.config_wce, 0, true), DEFINE_PROP_BIT("config-wce", VirtIOBlock, conf.config_wce, 0, true),
#ifdef __linux__ #ifdef __linux__
DEFINE_PROP_BIT("scsi", VirtIOBlock, blk.scsi, 0, true), DEFINE_PROP_BIT("scsi", VirtIOBlock, conf.scsi, 0, true),
#endif #endif
DEFINE_PROP_BIT("x-data-plane", VirtIOBlock, blk.data_plane, 0, false), DEFINE_PROP_BIT("x-data-plane", VirtIOBlock, conf.data_plane, 0, false),
DEFINE_PROP_END_OF_LIST(), DEFINE_PROP_END_OF_LIST(),
}; };

72
hw/block/xen_disk.c
View File

@ -39,6 +39,7 @@
#include "hw/xen/xen_backend.h" #include "hw/xen/xen_backend.h"
#include "xen_blkif.h" #include "xen_blkif.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "sysemu/block-backend.h"
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -122,7 +123,7 @@ struct XenBlkDev {
/* qemu block driver */ /* qemu block driver */
DriveInfo *dinfo; DriveInfo *dinfo;
BlockDriverState *bs; BlockBackend *blk;
QEMUBH *bh; QEMUBH *bh;
}; };
@ -479,7 +480,7 @@ static void qemu_aio_complete(void *opaque, int ret)
if (ioreq->postsync) { if (ioreq->postsync) {
ioreq->postsync = 0; ioreq->postsync = 0;
ioreq->aio_inflight++; ioreq->aio_inflight++;
bdrv_aio_flush(ioreq->blkdev->bs, qemu_aio_complete, ioreq); blk_aio_flush(ioreq->blkdev->blk, qemu_aio_complete, ioreq);
return; return;
} }
@ -493,7 +494,7 @@ static void qemu_aio_complete(void *opaque, int ret)
break; break;
} }
case BLKIF_OP_READ: case BLKIF_OP_READ:
block_acct_done(bdrv_get_stats(ioreq->blkdev->bs), &ioreq->acct); block_acct_done(blk_get_stats(ioreq->blkdev->blk), &ioreq->acct);
break; break;
case BLKIF_OP_DISCARD: case BLKIF_OP_DISCARD:
default: default:
@ -512,18 +513,18 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq)
ioreq->aio_inflight++; ioreq->aio_inflight++;
if (ioreq->presync) { if (ioreq->presync) {
bdrv_aio_flush(ioreq->blkdev->bs, qemu_aio_complete, ioreq); blk_aio_flush(ioreq->blkdev->blk, qemu_aio_complete, ioreq);
return 0; return 0;
} }
switch (ioreq->req.operation) { switch (ioreq->req.operation) {
case BLKIF_OP_READ: case BLKIF_OP_READ:
block_acct_start(bdrv_get_stats(blkdev->bs), &ioreq->acct, block_acct_start(blk_get_stats(blkdev->blk), &ioreq->acct,
ioreq->v.size, BLOCK_ACCT_READ); ioreq->v.size, BLOCK_ACCT_READ);
ioreq->aio_inflight++; ioreq->aio_inflight++;
bdrv_aio_readv(blkdev->bs, ioreq->start / BLOCK_SIZE, blk_aio_readv(blkdev->blk, ioreq->start / BLOCK_SIZE,
&ioreq->v, ioreq->v.size / BLOCK_SIZE, &ioreq->v, ioreq->v.size / BLOCK_SIZE,
qemu_aio_complete, ioreq); qemu_aio_complete, ioreq);
break; break;
case BLKIF_OP_WRITE: case BLKIF_OP_WRITE:
case BLKIF_OP_FLUSH_DISKCACHE: case BLKIF_OP_FLUSH_DISKCACHE:
@ -531,18 +532,18 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq)
break; break;
} }
block_acct_start(bdrv_get_stats(blkdev->bs), &ioreq->acct, block_acct_start(blk_get_stats(blkdev->blk), &ioreq->acct,
ioreq->v.size, BLOCK_ACCT_WRITE); ioreq->v.size, BLOCK_ACCT_WRITE);
ioreq->aio_inflight++; ioreq->aio_inflight++;
bdrv_aio_writev(blkdev->bs, ioreq->start / BLOCK_SIZE, blk_aio_writev(blkdev->blk, ioreq->start / BLOCK_SIZE,
&ioreq->v, ioreq->v.size / BLOCK_SIZE, &ioreq->v, ioreq->v.size / BLOCK_SIZE,
qemu_aio_complete, ioreq); qemu_aio_complete, ioreq);
break; break;
case BLKIF_OP_DISCARD: case BLKIF_OP_DISCARD:
{ {
struct blkif_request_discard *discard_req = (void *)&ioreq->req; struct blkif_request_discard *discard_req = (void *)&ioreq->req;
ioreq->aio_inflight++; ioreq->aio_inflight++;
bdrv_aio_discard(blkdev->bs, blk_aio_discard(blkdev->blk,
discard_req->sector_number, discard_req->nr_sectors, discard_req->sector_number, discard_req->nr_sectors,
qemu_aio_complete, ioreq); qemu_aio_complete, ioreq);
break; break;
@ -854,44 +855,49 @@ static int blk_connect(struct XenDevice *xendev)
blkdev->dinfo = drive_get(IF_XEN, 0, index); blkdev->dinfo = drive_get(IF_XEN, 0, index);
if (!blkdev->dinfo) { if (!blkdev->dinfo) {
Error *local_err = NULL; Error *local_err = NULL;
BlockBackend *blk;
BlockDriver *drv; BlockDriver *drv;
BlockDriverState *bs;
/* setup via xenbus -> create new block driver instance */ /* setup via xenbus -> create new block driver instance */
xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n"); xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n");
blkdev->bs = bdrv_new(blkdev->dev, NULL); blk = blk_new_with_bs(blkdev->dev, NULL);
if (!blkdev->bs) { if (!blk) {
return -1; return -1;
} }
blkdev->blk = blk;
bs = blk_bs(blk);
drv = bdrv_find_whitelisted_format(blkdev->fileproto, readonly); drv = bdrv_find_whitelisted_format(blkdev->fileproto, readonly);
if (bdrv_open(&blkdev->bs, blkdev->filename, NULL, NULL, qflags, if (bdrv_open(&bs, blkdev->filename, NULL, NULL, qflags,
drv, &local_err) != 0) { drv, &local_err) != 0) {
xen_be_printf(&blkdev->xendev, 0, "error: %s\n", xen_be_printf(&blkdev->xendev, 0, "error: %s\n",
error_get_pretty(local_err)); error_get_pretty(local_err));
error_free(local_err); error_free(local_err);
bdrv_unref(blkdev->bs); blk_unref(blk);
blkdev->bs = NULL; blkdev->blk = NULL;
return -1; return -1;
} }
assert(bs == blk_bs(blk));
} else { } else {
/* setup via qemu cmdline -> already setup for us */ /* setup via qemu cmdline -> already setup for us */
xen_be_printf(&blkdev->xendev, 2, "get configured bdrv (cmdline setup)\n"); xen_be_printf(&blkdev->xendev, 2, "get configured bdrv (cmdline setup)\n");
blkdev->bs = blkdev->dinfo->bdrv; blkdev->blk = blk_by_legacy_dinfo(blkdev->dinfo);
if (bdrv_is_read_only(blkdev->bs) && !readonly) { if (blk_is_read_only(blkdev->blk) && !readonly) {
xen_be_printf(&blkdev->xendev, 0, "Unexpected read-only drive"); xen_be_printf(&blkdev->xendev, 0, "Unexpected read-only drive");
blkdev->bs = NULL; blkdev->blk = NULL;
return -1; return -1;
} }
/* blkdev->bs is not create by us, we get a reference /* blkdev->blk is not create by us, we get a reference
* so we can bdrv_unref() unconditionally */ * so we can blk_unref() unconditionally */
bdrv_ref(blkdev->bs); blk_ref(blkdev->blk);
} }
bdrv_attach_dev_nofail(blkdev->bs, blkdev); blk_attach_dev_nofail(blkdev->blk, blkdev);
blkdev->file_size = bdrv_getlength(blkdev->bs); blkdev->file_size = blk_getlength(blkdev->blk);
if (blkdev->file_size < 0) { if (blkdev->file_size < 0) {
xen_be_printf(&blkdev->xendev, 1, "bdrv_getlength: %d (%s) | drv %s\n", xen_be_printf(&blkdev->xendev, 1, "blk_getlength: %d (%s) | drv %s\n",
(int)blkdev->file_size, strerror(-blkdev->file_size), (int)blkdev->file_size, strerror(-blkdev->file_size),
bdrv_get_format_name(blkdev->bs) ?: "-"); bdrv_get_format_name(blk_bs(blkdev->blk)) ?: "-");
blkdev->file_size = 0; blkdev->file_size = 0;
} }
@ -982,10 +988,10 @@ static void blk_disconnect(struct XenDevice *xendev)
{ {
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
if (blkdev->bs) { if (blkdev->blk) {
bdrv_detach_dev(blkdev->bs, blkdev); blk_detach_dev(blkdev->blk, blkdev);
bdrv_unref(blkdev->bs); blk_unref(blkdev->blk);
blkdev->bs = NULL; blkdev->blk = NULL;
} }
xen_be_unbind_evtchn(&blkdev->xendev); xen_be_unbind_evtchn(&blkdev->xendev);
@ -1001,7 +1007,7 @@ static int blk_free(struct XenDevice *xendev)
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
struct ioreq *ioreq; struct ioreq *ioreq;
if (blkdev->bs || blkdev->sring) { if (blkdev->blk || blkdev->sring) {
blk_disconnect(xendev); blk_disconnect(xendev);
} }

26
hw/core/qdev-properties-system.c
View File

@ -13,6 +13,7 @@
#include "net/net.h" #include "net/net.h"
#include "hw/qdev.h" #include "hw/qdev.h"
#include "qapi/qmp/qerror.h" #include "qapi/qmp/qerror.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "hw/block/block.h" #include "hw/block/block.h"
#include "net/hub.h" #include "net/hub.h"
@ -68,16 +69,16 @@ static void set_pointer(Object *obj, Visitor *v, Property *prop,
static int parse_drive(DeviceState *dev, const char *str, void **ptr) static int parse_drive(DeviceState *dev, const char *str, void **ptr)
{ {
BlockDriverState *bs; BlockBackend *blk;
bs = bdrv_find(str); blk = blk_by_name(str);
if (bs == NULL) { if (!blk) {
return -ENOENT; return -ENOENT;
} }
if (bdrv_attach_dev(bs, dev) < 0) { if (blk_attach_dev(blk, dev) < 0) {
return -EEXIST; return -EEXIST;
} }
*ptr = bs; *ptr = blk;
return 0; return 0;
} }
@ -85,17 +86,17 @@ static void release_drive(Object *obj, const char *name, void *opaque)
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque; Property *prop = opaque;
BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop); BlockBackend **ptr = qdev_get_prop_ptr(dev, prop);
if (*ptr) { if (*ptr) {
bdrv_detach_dev(*ptr, dev); blk_detach_dev(*ptr, dev);
blockdev_auto_del(*ptr); blockdev_auto_del(*ptr);
} }
} }
static char *print_drive(void *ptr) static char *print_drive(void *ptr)
{ {
return g_strdup(bdrv_get_device_name(ptr)); return g_strdup(blk_name(ptr));
} }
static void get_drive(Object *obj, Visitor *v, void *opaque, static void get_drive(Object *obj, Visitor *v, void *opaque,
@ -335,12 +336,11 @@ PropertyInfo qdev_prop_vlan = {
}; };
int qdev_prop_set_drive(DeviceState *dev, const char *name, int qdev_prop_set_drive(DeviceState *dev, const char *name,
BlockDriverState *value) BlockBackend *value)
{ {
Error *err = NULL; Error *err = NULL;
const char *bdrv_name = value ? bdrv_get_device_name(value) : ""; object_property_set_str(OBJECT(dev),
object_property_set_str(OBJECT(dev), bdrv_name, value ? blk_name(value) : "", name, &err);
name, &err);
if (err) { if (err) {
qerror_report_err(err); qerror_report_err(err);
error_free(err); error_free(err);
@ -350,7 +350,7 @@ int qdev_prop_set_drive(DeviceState *dev, const char *name,
} }
void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name,
BlockDriverState *value) BlockBackend *value)
{ {
if (qdev_prop_set_drive(dev, name, value) < 0) { if (qdev_prop_set_drive(dev, name, value) < 0) {
exit(1); exit(1);

2
hw/core/qdev-properties.c
View File

@ -1,7 +1,7 @@
#include "net/net.h" #include "net/net.h"
#include "hw/qdev.h" #include "hw/qdev.h"
#include "qapi/qmp/qerror.h" #include "qapi/qmp/qerror.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "hw/block/block.h" #include "hw/block/block.h"
#include "net/hub.h" #include "net/hub.h"
#include "qapi/visitor.h" #include "qapi/visitor.h"

4
hw/cris/axis_dev88.c
View File

@ -30,7 +30,7 @@
#include "hw/loader.h" #include "hw/loader.h"
#include "elf.h" #include "elf.h"
#include "boot.h" #include "boot.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "sysemu/qtest.h" #include "sysemu/qtest.h"
@ -284,7 +284,7 @@ void axisdev88_init(MachineState *machine)
/* Attach a NAND flash to CS1. */ /* Attach a NAND flash to CS1. */
nand = drive_get(IF_MTD, 0, 0); nand = drive_get(IF_MTD, 0, 0);
nand_state.nand = nand_init(nand ? nand->bdrv : NULL, nand_state.nand = nand_init(nand ? blk_by_legacy_dinfo(nand) : NULL,
NAND_MFR_STMICRO, 0x39); NAND_MFR_STMICRO, 0x39);
memory_region_init_io(&nand_state.iomem, NULL, &nand_ops, &nand_state, memory_region_init_io(&nand_state.iomem, NULL, &nand_ops, &nand_state,
"nand", 0x05000000); "nand", 0x05000000);

4
hw/display/tc6393xb.c
View File

@ -15,6 +15,7 @@
#include "hw/block/flash.h" #include "hw/block/flash.h"
#include "ui/console.h" #include "ui/console.h"
#include "ui/pixel_ops.h" #include "ui/pixel_ops.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#define IRQ_TC6393_NAND 0 #define IRQ_TC6393_NAND 0
@ -576,7 +577,8 @@ TC6393xbState *tc6393xb_init(MemoryRegion *sysmem, uint32_t base, qemu_irq irq)
s->sub_irqs = qemu_allocate_irqs(tc6393xb_sub_irq, s, TC6393XB_NR_IRQS); s->sub_irqs = qemu_allocate_irqs(tc6393xb_sub_irq, s, TC6393XB_NR_IRQS);
nand = drive_get(IF_MTD, 0, 0); nand = drive_get(IF_MTD, 0, 0);
s->flash = nand_init(nand ? nand->bdrv : NULL, NAND_MFR_TOSHIBA, 0x76); s->flash = nand_init(nand ? blk_by_legacy_dinfo(nand) : NULL,
NAND_MFR_TOSHIBA, 0x76);
memory_region_init_io(&s->iomem, NULL, &tc6393xb_ops, s, "tc6393xb", 0x10000); memory_region_init_io(&s->iomem, NULL, &tc6393xb_ops, s, "tc6393xb", 0x10000);
memory_region_add_subregion(sysmem, base, &s->iomem); memory_region_add_subregion(sysmem, base, &s->iomem);

2
hw/i386/pc.c
View File

@ -44,7 +44,7 @@
#include "sysemu/kvm.h" #include "sysemu/kvm.h"
#include "kvm_i386.h" #include "kvm_i386.h"
#include "hw/xen/xen.h" #include "hw/xen/xen.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "hw/block/block.h" #include "hw/block/block.h"
#include "ui/qemu-spice.h" #include "ui/qemu-spice.h"
#include "exec/memory.h" #include "exec/memory.h"

2
hw/i386/pc_piix.c
View File

@ -41,7 +41,7 @@
#include "hw/sysbus.h" #include "hw/sysbus.h"
#include "hw/cpu/icc_bus.h" #include "hw/cpu/icc_bus.h"
#include "sysemu/arch_init.h" #include "sysemu/arch_init.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "hw/i2c/smbus.h" #include "hw/i2c/smbus.h"
#include "hw/xen/xen.h" #include "hw/xen/xen.h"
#include "exec/memory.h" #include "exec/memory.h"

10
hw/i386/pc_sysfw.c
View File

@ -23,7 +23,7 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
#include "hw/sysbus.h" #include "hw/sysbus.h"
#include "hw/hw.h" #include "hw/hw.h"
@ -103,7 +103,7 @@ static void pc_system_flash_init(MemoryRegion *rom_memory)
{ {
int unit; int unit;
DriveInfo *pflash_drv; DriveInfo *pflash_drv;
BlockDriverState *bdrv; BlockBackend *blk;
int64_t size; int64_t size;
char *fatal_errmsg = NULL; char *fatal_errmsg = NULL;
hwaddr phys_addr = 0x100000000ULL; hwaddr phys_addr = 0x100000000ULL;
@ -119,8 +119,8 @@ static void pc_system_flash_init(MemoryRegion *rom_memory)
(unit < FLASH_MAP_UNIT_MAX && (unit < FLASH_MAP_UNIT_MAX &&
(pflash_drv = drive_get(IF_PFLASH, 0, unit)) != NULL); (pflash_drv = drive_get(IF_PFLASH, 0, unit)) != NULL);
++unit) { ++unit) {
bdrv = pflash_drv->bdrv; blk = blk_by_legacy_dinfo(pflash_drv);
size = bdrv_getlength(bdrv); size = blk_getlength(blk);
if (size < 0) { if (size < 0) {
fatal_errmsg = g_strdup_printf("failed to get backing file size"); fatal_errmsg = g_strdup_printf("failed to get backing file size");
} else if (size == 0) { } else if (size == 0) {
@ -156,7 +156,7 @@ static void pc_system_flash_init(MemoryRegion *rom_memory)
/* pflash_cfi01_register() creates a deep copy of the name */ /* pflash_cfi01_register() creates a deep copy of the name */
snprintf(name, sizeof name, "system.flash%d", unit); snprintf(name, sizeof name, "system.flash%d", unit);
system_flash = pflash_cfi01_register(phys_addr, NULL /* qdev */, name, system_flash = pflash_cfi01_register(phys_addr, NULL /* qdev */, name,
size, bdrv, sector_size, size, blk, sector_size,
size >> sector_bits, size >> sector_bits,
1 /* width */, 1 /* width */,
0x0000 /* id0 */, 0x0000 /* id0 */,

5
hw/i386/xen/xen_platform.c
View File

@ -34,6 +34,7 @@
#include "hw/xen/xen_backend.h" #include "hw/xen/xen_backend.h"
#include "trace.h" #include "trace.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "sysemu/block-backend.h"
#include <xenguest.h> #include <xenguest.h>
@ -132,8 +133,8 @@ static void platform_fixed_ioport_writew(void *opaque, uint32_t addr, uint32_t v
devices, and bit 2 the non-primary-master IDE devices. */ devices, and bit 2 the non-primary-master IDE devices. */
if (val & UNPLUG_ALL_IDE_DISKS) { if (val & UNPLUG_ALL_IDE_DISKS) {
DPRINTF("unplug disks\n"); DPRINTF("unplug disks\n");
bdrv_drain_all(); blk_drain_all();
bdrv_flush_all(); blk_flush_all();
pci_unplug_disks(pci_dev->bus); pci_unplug_disks(pci_dev->bus);
} }
if (val & UNPLUG_ALL_NICS) { if (val & UNPLUG_ALL_NICS) {

33
hw/ide/ahci.c
View File

@ -28,6 +28,7 @@
#include <hw/sysbus.h> #include <hw/sysbus.h>
#include "monitor/monitor.h" #include "monitor/monitor.h"
#include "sysemu/block-backend.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"
#include "internal.h" #include "internal.h"
#include <hw/ide/pci.h> #include <hw/ide/pci.h>
@ -84,7 +85,7 @@ static uint32_t ahci_port_read(AHCIState *s, int port, int offset)
val = pr->sig; val = pr->sig;
break; break;
case PORT_SCR_STAT: case PORT_SCR_STAT:
if (s->dev[port].port.ifs[0].bs) { if (s->dev[port].port.ifs[0].blk) {
val = SATA_SCR_SSTATUS_DET_DEV_PRESENT_PHY_UP | val = SATA_SCR_SSTATUS_DET_DEV_PRESENT_PHY_UP |
SATA_SCR_SSTATUS_SPD_GEN1 | SATA_SCR_SSTATUS_IPM_ACTIVE; SATA_SCR_SSTATUS_SPD_GEN1 | SATA_SCR_SSTATUS_IPM_ACTIVE;
} else { } else {
@ -501,7 +502,7 @@ static void ahci_reset_port(AHCIState *s, int port)
d->init_d2h_sent = false; d->init_d2h_sent = false;
ide_state = &s->dev[port].port.ifs[0]; ide_state = &s->dev[port].port.ifs[0];
if (!ide_state->bs) { if (!ide_state->blk) {
return; return;
} }
@ -513,11 +514,11 @@ static void ahci_reset_port(AHCIState *s, int port)
} }
if (ncq_tfs->aiocb) { if (ncq_tfs->aiocb) {
bdrv_aio_cancel(ncq_tfs->aiocb); blk_aio_cancel(ncq_tfs->aiocb);
ncq_tfs->aiocb = NULL; ncq_tfs->aiocb = NULL;
} }
/* Maybe we just finished the request thanks to bdrv_aio_cancel() */ /* Maybe we just finished the request thanks to blk_aio_cancel() */
if (!ncq_tfs->used) { if (!ncq_tfs->used) {
continue; continue;
} }
@ -527,7 +528,7 @@ static void ahci_reset_port(AHCIState *s, int port)
} }
s->dev[port].port_state = STATE_RUN; s->dev[port].port_state = STATE_RUN;
if (!ide_state->bs) { if (!ide_state->blk) {
pr->sig = 0; pr->sig = 0;
ide_state->status = SEEK_STAT | WRERR_STAT; ide_state->status = SEEK_STAT | WRERR_STAT;
} else if (ide_state->drive_kind == IDE_CD) { } else if (ide_state->drive_kind == IDE_CD) {
@ -826,7 +827,7 @@ static void ncq_cb(void *opaque, int ret)
DPRINTF(ncq_tfs->drive->port_no, "NCQ transfer tag %d finished\n", DPRINTF(ncq_tfs->drive->port_no, "NCQ transfer tag %d finished\n",
ncq_tfs->tag); ncq_tfs->tag);
block_acct_done(bdrv_get_stats(ncq_tfs->drive->port.ifs[0].bs), block_acct_done(blk_get_stats(ncq_tfs->drive->port.ifs[0].blk),
&ncq_tfs->acct); &ncq_tfs->acct);
qemu_sglist_destroy(&ncq_tfs->sglist); qemu_sglist_destroy(&ncq_tfs->sglist);
ncq_tfs->used = 0; ncq_tfs->used = 0;
@ -877,11 +878,11 @@ static void process_ncq_command(AHCIState *s, int port, uint8_t *cmd_fis,
DPRINTF(port, "tag %d aio read %"PRId64"\n", DPRINTF(port, "tag %d aio read %"PRId64"\n",
ncq_tfs->tag, ncq_tfs->lba); ncq_tfs->tag, ncq_tfs->lba);
dma_acct_start(ncq_tfs->drive->port.ifs[0].bs, &ncq_tfs->acct, dma_acct_start(ncq_tfs->drive->port.ifs[0].blk, &ncq_tfs->acct,
&ncq_tfs->sglist, BLOCK_ACCT_READ); &ncq_tfs->sglist, BLOCK_ACCT_READ);
ncq_tfs->aiocb = dma_bdrv_read(ncq_tfs->drive->port.ifs[0].bs, ncq_tfs->aiocb = dma_blk_read(ncq_tfs->drive->port.ifs[0].blk,
&ncq_tfs->sglist, ncq_tfs->lba, &ncq_tfs->sglist, ncq_tfs->lba,
ncq_cb, ncq_tfs); ncq_cb, ncq_tfs);
break; break;
case WRITE_FPDMA_QUEUED: case WRITE_FPDMA_QUEUED:
DPRINTF(port, "NCQ writing %d sectors to LBA %"PRId64", tag %d\n", DPRINTF(port, "NCQ writing %d sectors to LBA %"PRId64", tag %d\n",
@ -890,11 +891,11 @@ static void process_ncq_command(AHCIState *s, int port, uint8_t *cmd_fis,
DPRINTF(port, "tag %d aio write %"PRId64"\n", DPRINTF(port, "tag %d aio write %"PRId64"\n",
ncq_tfs->tag, ncq_tfs->lba); ncq_tfs->tag, ncq_tfs->lba);
dma_acct_start(ncq_tfs->drive->port.ifs[0].bs, &ncq_tfs->acct, dma_acct_start(ncq_tfs->drive->port.ifs[0].blk, &ncq_tfs->acct,
&ncq_tfs->sglist, BLOCK_ACCT_WRITE); &ncq_tfs->sglist, BLOCK_ACCT_WRITE);
ncq_tfs->aiocb = dma_bdrv_write(ncq_tfs->drive->port.ifs[0].bs, ncq_tfs->aiocb = dma_blk_write(ncq_tfs->drive->port.ifs[0].blk,
&ncq_tfs->sglist, ncq_tfs->lba, &ncq_tfs->sglist, ncq_tfs->lba,
ncq_cb, ncq_tfs); ncq_cb, ncq_tfs);
break; break;
default: default:
DPRINTF(port, "error: tried to process non-NCQ command as NCQ\n"); DPRINTF(port, "error: tried to process non-NCQ command as NCQ\n");
@ -943,7 +944,7 @@ static int handle_cmd(AHCIState *s, int port, int slot)
/* The device we are working for */ /* The device we are working for */
ide_state = &s->dev[port].port.ifs[0]; ide_state = &s->dev[port].port.ifs[0];
if (!ide_state->bs) { if (!ide_state->blk) {
DPRINTF(port, "error: guest accessed unused port"); DPRINTF(port, "error: guest accessed unused port");
goto out; goto out;
} }
@ -1122,7 +1123,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);

2
hw/ide/ahci.h
View File

@ -241,7 +241,7 @@ typedef struct AHCIDevice AHCIDevice;
typedef struct NCQTransferState { typedef struct NCQTransferState {
AHCIDevice *drive; AHCIDevice *drive;
BlockDriverAIOCB *aiocb; BlockAIOCB *aiocb;
QEMUSGList sglist; QEMUSGList sglist;
BlockAcctCookie acct; BlockAcctCookie acct;
uint16_t sector_count; uint16_t sector_count;

33
hw/ide/atapi.c
View File

@ -25,6 +25,7 @@
#include "hw/ide/internal.h" #include "hw/ide/internal.h"
#include "hw/scsi/scsi.h" #include "hw/scsi/scsi.h"
#include "sysemu/block-backend.h"
static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret); static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret);
@ -110,16 +111,16 @@ static int cd_read_sector(IDEState *s, int lba, uint8_t *buf, int sector_size)
switch(sector_size) { switch(sector_size) {
case 2048: case 2048:
block_acct_start(bdrv_get_stats(s->bs), &s->acct, block_acct_start(blk_get_stats(s->blk), &s->acct,
4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); 4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
ret = bdrv_read(s->bs, (int64_t)lba << 2, buf, 4); ret = blk_read(s->blk, (int64_t)lba << 2, buf, 4);
block_acct_done(bdrv_get_stats(s->bs), &s->acct); block_acct_done(blk_get_stats(s->blk), &s->acct);
break; break;
case 2352: case 2352:
block_acct_start(bdrv_get_stats(s->bs), &s->acct, block_acct_start(blk_get_stats(s->blk), &s->acct,
4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); 4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
ret = bdrv_read(s->bs, (int64_t)lba << 2, buf + 16, 4); ret = blk_read(s->blk, (int64_t)lba << 2, buf + 16, 4);
block_acct_done(bdrv_get_stats(s->bs), &s->acct); block_acct_done(blk_get_stats(s->blk), &s->acct);
if (ret < 0) if (ret < 0)
return ret; return ret;
cd_data_to_raw(buf, lba); cd_data_to_raw(buf, lba);
@ -254,7 +255,7 @@ static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size)
s->io_buffer_index = 0; s->io_buffer_index = 0;
if (s->atapi_dma) { if (s->atapi_dma) {
block_acct_start(bdrv_get_stats(s->bs), &s->acct, size, block_acct_start(blk_get_stats(s->blk), &s->acct, size,
BLOCK_ACCT_READ); BLOCK_ACCT_READ);
s->status = READY_STAT | SEEK_STAT | DRQ_STAT; s->status = READY_STAT | SEEK_STAT | DRQ_STAT;
ide_start_dma(s, ide_atapi_cmd_read_dma_cb); ide_start_dma(s, ide_atapi_cmd_read_dma_cb);
@ -350,13 +351,13 @@ static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
s->bus->dma->iov.iov_len = n * 4 * 512; s->bus->dma->iov.iov_len = n * 4 * 512;
qemu_iovec_init_external(&s->bus->dma->qiov, &s->bus->dma->iov, 1); qemu_iovec_init_external(&s->bus->dma->qiov, &s->bus->dma->iov, 1);
s->bus->dma->aiocb = bdrv_aio_readv(s->bs, (int64_t)s->lba << 2, s->bus->dma->aiocb = blk_aio_readv(s->blk, (int64_t)s->lba << 2,
&s->bus->dma->qiov, n * 4, &s->bus->dma->qiov, n * 4,
ide_atapi_cmd_read_dma_cb, s); ide_atapi_cmd_read_dma_cb, s);
return; return;
eot: eot:
block_acct_done(bdrv_get_stats(s->bs), &s->acct); block_acct_done(blk_get_stats(s->blk), &s->acct);
ide_set_inactive(s, false); ide_set_inactive(s, false);
} }
@ -371,7 +372,7 @@ static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors,
s->io_buffer_size = 0; s->io_buffer_size = 0;
s->cd_sector_size = sector_size; s->cd_sector_size = sector_size;
block_acct_start(bdrv_get_stats(s->bs), &s->acct, s->packet_transfer_size, block_acct_start(blk_get_stats(s->blk), &s->acct, s->packet_transfer_size,
BLOCK_ACCT_READ); BLOCK_ACCT_READ);
/* XXX: check if BUSY_STAT should be set */ /* XXX: check if BUSY_STAT should be set */
@ -504,7 +505,7 @@ static unsigned int event_status_media(IDEState *s,
media_status = 0; media_status = 0;
if (s->tray_open) { if (s->tray_open) {
media_status = MS_TRAY_OPEN; media_status = MS_TRAY_OPEN;
} else if (bdrv_is_inserted(s->bs)) { } else if (blk_is_inserted(s->blk)) {
media_status = MS_MEDIA_PRESENT; media_status = MS_MEDIA_PRESENT;
} }
@ -800,7 +801,7 @@ static void cmd_test_unit_ready(IDEState *s, uint8_t *buf)
static void cmd_prevent_allow_medium_removal(IDEState *s, uint8_t* buf) static void cmd_prevent_allow_medium_removal(IDEState *s, uint8_t* buf)
{ {
s->tray_locked = buf[4] & 1; s->tray_locked = buf[4] & 1;
bdrv_lock_medium(s->bs, buf[4] & 1); blk_lock_medium(s->blk, buf[4] & 1);
ide_atapi_cmd_ok(s); ide_atapi_cmd_ok(s);
} }
@ -884,14 +885,14 @@ static void cmd_start_stop_unit(IDEState *s, uint8_t* buf)
if (loej) { if (loej) {
if (!start && !s->tray_open && s->tray_locked) { if (!start && !s->tray_open && s->tray_locked) {
sense = bdrv_is_inserted(s->bs) sense = blk_is_inserted(s->blk)
? NOT_READY : ILLEGAL_REQUEST; ? NOT_READY : ILLEGAL_REQUEST;
ide_atapi_cmd_error(s, sense, ASC_MEDIA_REMOVAL_PREVENTED); ide_atapi_cmd_error(s, sense, ASC_MEDIA_REMOVAL_PREVENTED);
return; return;
} }
if (s->tray_open != !start) { if (s->tray_open != !start) {
bdrv_eject(s->bs, !start); blk_eject(s->blk, !start);
s->tray_open = !start; s->tray_open = !start;
} }
} }
@ -1125,7 +1126,7 @@ void ide_atapi_cmd(IDEState *s)
* states rely on this behavior. * states rely on this behavior.
*/ */
if (!(atapi_cmd_table[s->io_buffer[0]].flags & ALLOW_UA) && if (!(atapi_cmd_table[s->io_buffer[0]].flags & ALLOW_UA) &&
!s->tray_open && bdrv_is_inserted(s->bs) && s->cdrom_changed) { !s->tray_open && blk_is_inserted(s->blk) && s->cdrom_changed) {
if (s->cdrom_changed == 1) { if (s->cdrom_changed == 1) {
ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT); ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT);
@ -1140,7 +1141,7 @@ void ide_atapi_cmd(IDEState *s)
/* Report a Not Ready condition if appropriate for the command */ /* Report a Not Ready condition if appropriate for the command */
if ((atapi_cmd_table[s->io_buffer[0]].flags & CHECK_READY) && if ((atapi_cmd_table[s->io_buffer[0]].flags & CHECK_READY) &&
(!media_present(s) || !bdrv_is_inserted(s->bs))) (!media_present(s) || !blk_is_inserted(s->blk)))
{ {
ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT); ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT);
return; return;

2
hw/ide/cmd646.c
View File

@ -26,7 +26,7 @@
#include <hw/i386/pc.h> #include <hw/i386/pc.h>
#include <hw/pci/pci.h> #include <hw/pci/pci.h>
#include <hw/isa/isa.h> #include <hw/isa/isa.h>
#include "block/block.h" #include "sysemu/block-backend.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"

198
hw/ide/core.c
View File

@ -31,7 +31,7 @@
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"
#include "hw/block/block.h" #include "hw/block/block.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include <hw/ide/internal.h> #include <hw/ide/internal.h>
@ -158,10 +158,11 @@ static void ide_identify(IDEState *s)
put_le16(p + 84, (1 << 14) | 0); put_le16(p + 84, (1 << 14) | 0);
} }
/* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */ /* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */
if (bdrv_enable_write_cache(s->bs)) if (blk_enable_write_cache(s->blk)) {
put_le16(p + 85, (1 << 14) | (1 << 5) | 1); put_le16(p + 85, (1 << 14) | (1 << 5) | 1);
else } else {
put_le16(p + 85, (1 << 14) | 1); put_le16(p + 85, (1 << 14) | 1);
}
/* 13=flush_cache_ext,12=flush_cache,10=lba48 */ /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
put_le16(p + 86, (1 << 13) | (1 <<12) | (1 << 10)); put_le16(p + 86, (1 << 13) | (1 <<12) | (1 << 10));
/* 14=set to 1, 8=has WWN, 1=SMART self test, 0=SMART error logging */ /* 14=set to 1, 8=has WWN, 1=SMART self test, 0=SMART error logging */
@ -350,7 +351,7 @@ static void ide_set_signature(IDEState *s)
if (s->drive_kind == IDE_CD) { if (s->drive_kind == IDE_CD) {
s->lcyl = 0x14; s->lcyl = 0x14;
s->hcyl = 0xeb; s->hcyl = 0xeb;
} else if (s->bs) { } else if (s->blk) {
s->lcyl = 0; s->lcyl = 0;
s->hcyl = 0; s->hcyl = 0;
} else { } else {
@ -360,15 +361,16 @@ static void ide_set_signature(IDEState *s)
} }
typedef struct TrimAIOCB { typedef struct TrimAIOCB {
BlockDriverAIOCB common; BlockAIOCB common;
BlockBackend *blk;
QEMUBH *bh; QEMUBH *bh;
int ret; int ret;
QEMUIOVector *qiov; QEMUIOVector *qiov;
BlockDriverAIOCB *aiocb; BlockAIOCB *aiocb;
int i, j; int i, j;
} TrimAIOCB; } TrimAIOCB;
static void trim_aio_cancel(BlockDriverAIOCB *acb) static void trim_aio_cancel(BlockAIOCB *acb)
{ {
TrimAIOCB *iocb = container_of(acb, TrimAIOCB, common); TrimAIOCB *iocb = container_of(acb, TrimAIOCB, common);
@ -379,7 +381,7 @@ static void trim_aio_cancel(BlockDriverAIOCB *acb)
iocb->ret = -ECANCELED; iocb->ret = -ECANCELED;
if (iocb->aiocb) { if (iocb->aiocb) {
bdrv_aio_cancel_async(iocb->aiocb); blk_aio_cancel_async(iocb->aiocb);
iocb->aiocb = NULL; iocb->aiocb = NULL;
} }
} }
@ -420,8 +422,8 @@ static void ide_issue_trim_cb(void *opaque, int ret)
} }
/* Got an entry! Submit and exit. */ /* Got an entry! Submit and exit. */
iocb->aiocb = bdrv_aio_discard(iocb->common.bs, sector, count, iocb->aiocb = blk_aio_discard(iocb->blk, sector, count,
ide_issue_trim_cb, opaque); ide_issue_trim_cb, opaque);
return; return;
} }
@ -438,13 +440,14 @@ static void ide_issue_trim_cb(void *opaque, int ret)
} }
} }
BlockDriverAIOCB *ide_issue_trim(BlockDriverState *bs, BlockAIOCB *ide_issue_trim(BlockBackend *blk,
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;
iocb = qemu_aio_get(&trim_aiocb_info, bs, cb, opaque); iocb = blk_aio_get(&trim_aiocb_info, blk, cb, opaque);
iocb->blk = blk;
iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb); iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb);
iocb->ret = 0; iocb->ret = 0;
iocb->qiov = qiov; iocb->qiov = qiov;
@ -551,7 +554,7 @@ static bool ide_sect_range_ok(IDEState *s,
{ {
uint64_t total_sectors; uint64_t total_sectors;
bdrv_get_geometry(s->bs, &total_sectors); blk_get_geometry(s->blk, &total_sectors);
if (sector > total_sectors || nb_sectors > total_sectors - sector) { if (sector > total_sectors || nb_sectors > total_sectors - sector) {
return false; return false;
} }
@ -569,7 +572,7 @@ static void ide_sector_read_cb(void *opaque, int ret)
if (ret == -ECANCELED) { if (ret == -ECANCELED) {
return; return;
} }
block_acct_done(bdrv_get_stats(s->bs), &s->acct); block_acct_done(blk_get_stats(s->blk), &s->acct);
if (ret != 0) { if (ret != 0) {
if (ide_handle_rw_error(s, -ret, IDE_RETRY_PIO | if (ide_handle_rw_error(s, -ret, IDE_RETRY_PIO |
IDE_RETRY_READ)) { IDE_RETRY_READ)) {
@ -625,10 +628,10 @@ void ide_sector_read(IDEState *s)
s->iov.iov_len = n * BDRV_SECTOR_SIZE; s->iov.iov_len = n * BDRV_SECTOR_SIZE;
qemu_iovec_init_external(&s->qiov, &s->iov, 1); qemu_iovec_init_external(&s->qiov, &s->iov, 1);
block_acct_start(bdrv_get_stats(s->bs), &s->acct, block_acct_start(blk_get_stats(s->blk), &s->acct,
n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
s->pio_aiocb = bdrv_aio_readv(s->bs, sector_num, &s->qiov, n, s->pio_aiocb = blk_aio_readv(s->blk, sector_num, &s->qiov, n,
ide_sector_read_cb, s); ide_sector_read_cb, s);
} }
static void dma_buf_commit(IDEState *s) static void dma_buf_commit(IDEState *s)
@ -655,7 +658,7 @@ void ide_dma_error(IDEState *s)
static int ide_handle_rw_error(IDEState *s, int error, int op) static int ide_handle_rw_error(IDEState *s, int error, int op)
{ {
bool is_read = (op & IDE_RETRY_READ) != 0; bool is_read = (op & IDE_RETRY_READ) != 0;
BlockErrorAction action = bdrv_get_error_action(s->bs, is_read, error); BlockErrorAction action = blk_get_error_action(s->blk, is_read, error);
if (action == BLOCK_ERROR_ACTION_STOP) { if (action == BLOCK_ERROR_ACTION_STOP) {
s->bus->dma->ops->set_unit(s->bus->dma, s->unit); s->bus->dma->ops->set_unit(s->bus->dma, s->unit);
@ -668,7 +671,7 @@ static int ide_handle_rw_error(IDEState *s, int error, int op)
ide_rw_error(s); ide_rw_error(s);
} }
} }
bdrv_error_action(s->bs, action, is_read, error); blk_error_action(s->blk, action, is_read, error);
return action != BLOCK_ERROR_ACTION_IGNORE; return action != BLOCK_ERROR_ACTION_IGNORE;
} }
@ -744,24 +747,24 @@ void ide_dma_cb(void *opaque, int ret)
switch (s->dma_cmd) { switch (s->dma_cmd) {
case IDE_DMA_READ: case IDE_DMA_READ:
s->bus->dma->aiocb = dma_bdrv_read(s->bs, &s->sg, sector_num, s->bus->dma->aiocb = dma_blk_read(s->blk, &s->sg, sector_num,
ide_dma_cb, s); ide_dma_cb, s);
break; break;
case IDE_DMA_WRITE: case IDE_DMA_WRITE:
s->bus->dma->aiocb = dma_bdrv_write(s->bs, &s->sg, sector_num, s->bus->dma->aiocb = dma_blk_write(s->blk, &s->sg, sector_num,
ide_dma_cb, s); ide_dma_cb, s);
break; break;
case IDE_DMA_TRIM: case IDE_DMA_TRIM:
s->bus->dma->aiocb = dma_bdrv_io(s->bs, &s->sg, sector_num, s->bus->dma->aiocb = dma_blk_io(s->blk, &s->sg, sector_num,
ide_issue_trim, ide_dma_cb, s, ide_issue_trim, ide_dma_cb, s,
DMA_DIRECTION_TO_DEVICE); DMA_DIRECTION_TO_DEVICE);
break; break;
} }
return; return;
eot: eot:
if (s->dma_cmd == IDE_DMA_READ || s->dma_cmd == IDE_DMA_WRITE) { if (s->dma_cmd == IDE_DMA_READ || s->dma_cmd == IDE_DMA_WRITE) {
block_acct_done(bdrv_get_stats(s->bs), &s->acct); block_acct_done(blk_get_stats(s->blk), &s->acct);
} }
ide_set_inactive(s, stay_active); ide_set_inactive(s, stay_active);
} }
@ -775,11 +778,11 @@ static void ide_sector_start_dma(IDEState *s, enum ide_dma_cmd dma_cmd)
switch (dma_cmd) { switch (dma_cmd) {
case IDE_DMA_READ: case IDE_DMA_READ:
block_acct_start(bdrv_get_stats(s->bs), &s->acct, block_acct_start(blk_get_stats(s->blk), &s->acct,
s->nsector * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); s->nsector * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
break; break;
case IDE_DMA_WRITE: case IDE_DMA_WRITE:
block_acct_start(bdrv_get_stats(s->bs), &s->acct, block_acct_start(blk_get_stats(s->blk), &s->acct,
s->nsector * BDRV_SECTOR_SIZE, BLOCK_ACCT_WRITE); s->nsector * BDRV_SECTOR_SIZE, BLOCK_ACCT_WRITE);
break; break;
default: default:
@ -789,7 +792,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);
@ -810,7 +813,7 @@ static void ide_sector_write_cb(void *opaque, int ret)
if (ret == -ECANCELED) { if (ret == -ECANCELED) {
return; return;
} }
block_acct_done(bdrv_get_stats(s->bs), &s->acct); block_acct_done(blk_get_stats(s->blk), &s->acct);
s->pio_aiocb = NULL; s->pio_aiocb = NULL;
s->status &= ~BUSY_STAT; s->status &= ~BUSY_STAT;
@ -877,10 +880,10 @@ void ide_sector_write(IDEState *s)
s->iov.iov_len = n * BDRV_SECTOR_SIZE; s->iov.iov_len = n * BDRV_SECTOR_SIZE;
qemu_iovec_init_external(&s->qiov, &s->iov, 1); qemu_iovec_init_external(&s->qiov, &s->iov, 1);
block_acct_start(bdrv_get_stats(s->bs), &s->acct, block_acct_start(blk_get_stats(s->blk), &s->acct,
n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
s->pio_aiocb = bdrv_aio_writev(s->bs, sector_num, &s->qiov, n, s->pio_aiocb = blk_aio_writev(s->blk, sector_num, &s->qiov, n,
ide_sector_write_cb, s); ide_sector_write_cb, s);
} }
static void ide_flush_cb(void *opaque, int ret) static void ide_flush_cb(void *opaque, int ret)
@ -899,8 +902,8 @@ static void ide_flush_cb(void *opaque, int ret)
} }
} }
if (s->bs) { if (s->blk) {
block_acct_done(bdrv_get_stats(s->bs), &s->acct); block_acct_done(blk_get_stats(s->blk), &s->acct);
} }
s->status = READY_STAT | SEEK_STAT; s->status = READY_STAT | SEEK_STAT;
ide_cmd_done(s); ide_cmd_done(s);
@ -909,14 +912,14 @@ static void ide_flush_cb(void *opaque, int ret)
void ide_flush_cache(IDEState *s) void ide_flush_cache(IDEState *s)
{ {
if (s->bs == NULL) { if (s->blk == NULL) {
ide_flush_cb(s, 0); ide_flush_cb(s, 0);
return; return;
} }
s->status |= BUSY_STAT; s->status |= BUSY_STAT;
block_acct_start(bdrv_get_stats(s->bs), &s->acct, 0, BLOCK_ACCT_FLUSH); block_acct_start(blk_get_stats(s->blk), &s->acct, 0, BLOCK_ACCT_FLUSH);
s->pio_aiocb = bdrv_aio_flush(s->bs, ide_flush_cb, s); s->pio_aiocb = blk_aio_flush(s->blk, ide_flush_cb, s);
} }
static void ide_cfata_metadata_inquiry(IDEState *s) static void ide_cfata_metadata_inquiry(IDEState *s)
@ -979,7 +982,7 @@ static void ide_cd_change_cb(void *opaque, bool load)
uint64_t nb_sectors; uint64_t nb_sectors;
s->tray_open = !load; s->tray_open = !load;
bdrv_get_geometry(s->bs, &nb_sectors); blk_get_geometry(s->blk, &nb_sectors);
s->nb_sectors = nb_sectors; s->nb_sectors = nb_sectors;
/* /*
@ -1113,7 +1116,7 @@ static bool cmd_data_set_management(IDEState *s, uint8_t cmd)
{ {
switch (s->feature) { switch (s->feature) {
case DSM_TRIM: case DSM_TRIM:
if (s->bs) { if (s->blk) {
ide_sector_start_dma(s, IDE_DMA_TRIM); ide_sector_start_dma(s, IDE_DMA_TRIM);
return false; return false;
} }
@ -1126,7 +1129,7 @@ static bool cmd_data_set_management(IDEState *s, uint8_t cmd)
static bool cmd_identify(IDEState *s, uint8_t cmd) static bool cmd_identify(IDEState *s, uint8_t cmd)
{ {
if (s->bs && s->drive_kind != IDE_CD) { if (s->blk && s->drive_kind != IDE_CD) {
if (s->drive_kind != IDE_CFATA) { if (s->drive_kind != IDE_CFATA) {
ide_identify(s); ide_identify(s);
} else { } else {
@ -1176,7 +1179,7 @@ static bool cmd_read_multiple(IDEState *s, uint8_t cmd)
{ {
bool lba48 = (cmd == WIN_MULTREAD_EXT); bool lba48 = (cmd == WIN_MULTREAD_EXT);
if (!s->bs || !s->mult_sectors) { if (!s->blk || !s->mult_sectors) {
ide_abort_command(s); ide_abort_command(s);
return true; return true;
} }
@ -1192,7 +1195,7 @@ static bool cmd_write_multiple(IDEState *s, uint8_t cmd)
bool lba48 = (cmd == WIN_MULTWRITE_EXT); bool lba48 = (cmd == WIN_MULTWRITE_EXT);
int n; int n;
if (!s->bs || !s->mult_sectors) { if (!s->blk || !s->mult_sectors) {
ide_abort_command(s); ide_abort_command(s);
return true; return true;
} }
@ -1220,7 +1223,7 @@ static bool cmd_read_pio(IDEState *s, uint8_t cmd)
return true; return true;
} }
if (!s->bs) { if (!s->blk) {
ide_abort_command(s); ide_abort_command(s);
return true; return true;
} }
@ -1236,7 +1239,7 @@ static bool cmd_write_pio(IDEState *s, uint8_t cmd)
{ {
bool lba48 = (cmd == WIN_WRITE_EXT); bool lba48 = (cmd == WIN_WRITE_EXT);
if (!s->bs) { if (!s->blk) {
ide_abort_command(s); ide_abort_command(s);
return true; return true;
} }
@ -1256,7 +1259,7 @@ static bool cmd_read_dma(IDEState *s, uint8_t cmd)
{ {
bool lba48 = (cmd == WIN_READDMA_EXT); bool lba48 = (cmd == WIN_READDMA_EXT);
if (!s->bs) { if (!s->blk) {
ide_abort_command(s); ide_abort_command(s);
return true; return true;
} }
@ -1271,7 +1274,7 @@ static bool cmd_write_dma(IDEState *s, uint8_t cmd)
{ {
bool lba48 = (cmd == WIN_WRITEDMA_EXT); bool lba48 = (cmd == WIN_WRITEDMA_EXT);
if (!s->bs) { if (!s->blk) {
ide_abort_command(s); ide_abort_command(s);
return true; return true;
} }
@ -1322,7 +1325,7 @@ static bool cmd_set_features(IDEState *s, uint8_t cmd)
{ {
uint16_t *identify_data; uint16_t *identify_data;
if (!s->bs) { if (!s->blk) {
ide_abort_command(s); ide_abort_command(s);
return true; return true;
} }
@ -1330,12 +1333,12 @@ static bool cmd_set_features(IDEState *s, uint8_t cmd)
/* XXX: valid for CDROM ? */ /* XXX: valid for CDROM ? */
switch (s->feature) { switch (s->feature) {
case 0x02: /* write cache enable */ case 0x02: /* write cache enable */
bdrv_set_enable_write_cache(s->bs, true); blk_set_enable_write_cache(s->blk, true);
identify_data = (uint16_t *)s->identify_data; identify_data = (uint16_t *)s->identify_data;
put_le16(identify_data + 85, (1 << 14) | (1 << 5) | 1); put_le16(identify_data + 85, (1 << 14) | (1 << 5) | 1);
return true; return true;
case 0x82: /* write cache disable */ case 0x82: /* write cache disable */
bdrv_set_enable_write_cache(s->bs, false); blk_set_enable_write_cache(s->blk, false);
identify_data = (uint16_t *)s->identify_data; identify_data = (uint16_t *)s->identify_data;
put_le16(identify_data + 85, (1 << 14) | 1); put_le16(identify_data + 85, (1 << 14) | 1);
ide_flush_cache(s); ide_flush_cache(s);
@ -1802,8 +1805,9 @@ void ide_exec_cmd(IDEBus *bus, uint32_t val)
#endif #endif
s = idebus_active_if(bus); s = idebus_active_if(bus);
/* ignore commands to non existent slave */ /* ignore commands to non existent slave */
if (s != bus->ifs && !s->bs) if (s != bus->ifs && !s->blk) {
return; return;
}
/* Only DEVICE RESET is allowed while BSY or/and DRQ are set */ /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
if ((s->status & (BUSY_STAT|DRQ_STAT)) && val != WIN_DEVICE_RESET) if ((s->status & (BUSY_STAT|DRQ_STAT)) && val != WIN_DEVICE_RESET)
@ -1848,59 +1852,66 @@ uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
ret = 0xff; ret = 0xff;
break; break;
case 1: case 1:
if ((!bus->ifs[0].bs && !bus->ifs[1].bs) || if ((!bus->ifs[0].blk && !bus->ifs[1].blk) ||
(s != bus->ifs && !s->bs)) (s != bus->ifs && !s->blk)) {
ret = 0; ret = 0;
else if (!hob) } else if (!hob) {
ret = s->error; ret = s->error;
else } else {
ret = s->hob_feature; ret = s->hob_feature;
}
break; break;
case 2: case 2:
if (!bus->ifs[0].bs && !bus->ifs[1].bs) if (!bus->ifs[0].blk && !bus->ifs[1].blk) {
ret = 0; ret = 0;
else if (!hob) } else if (!hob) {
ret = s->nsector & 0xff; ret = s->nsector & 0xff;
else } else {
ret = s->hob_nsector; ret = s->hob_nsector;
}
break; break;
case 3: case 3:
if (!bus->ifs[0].bs && !bus->ifs[1].bs) if (!bus->ifs[0].blk && !bus->ifs[1].blk) {
ret = 0; ret = 0;
else if (!hob) } else if (!hob) {
ret = s->sector; ret = s->sector;
else } else {
ret = s->hob_sector; ret = s->hob_sector;
}
break; break;
case 4: case 4:
if (!bus->ifs[0].bs && !bus->ifs[1].bs) if (!bus->ifs[0].blk && !bus->ifs[1].blk) {
ret = 0; ret = 0;
else if (!hob) } else if (!hob) {
ret = s->lcyl; ret = s->lcyl;
else } else {
ret = s->hob_lcyl; ret = s->hob_lcyl;
}
break; break;
case 5: case 5:
if (!bus->ifs[0].bs && !bus->ifs[1].bs) if (!bus->ifs[0].blk && !bus->ifs[1].blk) {
ret = 0; ret = 0;
else if (!hob) } else if (!hob) {
ret = s->hcyl; ret = s->hcyl;
else } else {
ret = s->hob_hcyl; ret = s->hob_hcyl;
}
break; break;
case 6: case 6:
if (!bus->ifs[0].bs && !bus->ifs[1].bs) if (!bus->ifs[0].blk && !bus->ifs[1].blk) {
ret = 0; ret = 0;
else } else {
ret = s->select; ret = s->select;
}
break; break;
default: default:
case 7: case 7:
if ((!bus->ifs[0].bs && !bus->ifs[1].bs) || if ((!bus->ifs[0].blk && !bus->ifs[1].blk) ||
(s != bus->ifs && !s->bs)) (s != bus->ifs && !s->blk)) {
ret = 0; ret = 0;
else } else {
ret = s->status; ret = s->status;
}
qemu_irq_lower(bus->irq); qemu_irq_lower(bus->irq);
break; break;
} }
@ -1916,11 +1927,12 @@ uint32_t ide_status_read(void *opaque, uint32_t addr)
IDEState *s = idebus_active_if(bus); IDEState *s = idebus_active_if(bus);
int ret; int ret;
if ((!bus->ifs[0].bs && !bus->ifs[1].bs) || if ((!bus->ifs[0].blk && !bus->ifs[1].blk) ||
(s != bus->ifs && !s->bs)) (s != bus->ifs && !s->blk)) {
ret = 0; ret = 0;
else } else {
ret = s->status; ret = s->status;
}
#ifdef DEBUG_IDE #ifdef DEBUG_IDE
printf("ide: read status addr=0x%x val=%02x\n", addr, ret); printf("ide: read status addr=0x%x val=%02x\n", addr, ret);
#endif #endif
@ -2081,7 +2093,7 @@ static void ide_reset(IDEState *s)
#endif #endif
if (s->pio_aiocb) { if (s->pio_aiocb) {
bdrv_aio_cancel(s->pio_aiocb); blk_aio_cancel(s->pio_aiocb);
s->pio_aiocb = NULL; s->pio_aiocb = NULL;
} }
@ -2145,7 +2157,7 @@ void ide_bus_reset(IDEBus *bus)
#ifdef DEBUG_AIO #ifdef DEBUG_AIO
printf("aio_cancel\n"); printf("aio_cancel\n");
#endif #endif
bdrv_aio_cancel(bus->dma->aiocb); blk_aio_cancel(bus->dma->aiocb);
bus->dma->aiocb = NULL; bus->dma->aiocb = NULL;
} }
@ -2174,7 +2186,7 @@ static void ide_resize_cb(void *opaque)
return; return;
} }
bdrv_get_geometry(s->bs, &nb_sectors); blk_get_geometry(s->blk, &nb_sectors);
s->nb_sectors = nb_sectors; s->nb_sectors = nb_sectors;
/* Update the identify data buffer. */ /* Update the identify data buffer. */
@ -2198,7 +2210,7 @@ static const BlockDevOps ide_hd_block_ops = {
.resize_cb = ide_resize_cb, .resize_cb = ide_resize_cb,
}; };
int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind, int ide_init_drive(IDEState *s, BlockBackend *blk, IDEDriveKind kind,
const char *version, const char *serial, const char *model, const char *version, const char *serial, const char *model,
uint64_t wwn, uint64_t wwn,
uint32_t cylinders, uint32_t heads, uint32_t secs, uint32_t cylinders, uint32_t heads, uint32_t secs,
@ -2206,10 +2218,10 @@ int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind,
{ {
uint64_t nb_sectors; uint64_t nb_sectors;
s->bs = bs; s->blk = blk;
s->drive_kind = kind; s->drive_kind = kind;
bdrv_get_geometry(bs, &nb_sectors); blk_get_geometry(blk, &nb_sectors);
s->cylinders = cylinders; s->cylinders = cylinders;
s->heads = heads; s->heads = heads;
s->sectors = secs; s->sectors = secs;
@ -2223,18 +2235,18 @@ int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind,
s->smart_errors = 0; s->smart_errors = 0;
s->smart_selftest_count = 0; s->smart_selftest_count = 0;
if (kind == IDE_CD) { if (kind == IDE_CD) {
bdrv_set_dev_ops(bs, &ide_cd_block_ops, s); blk_set_dev_ops(blk, &ide_cd_block_ops, s);
bdrv_set_guest_block_size(bs, 2048); blk_set_guest_block_size(blk, 2048);
} else { } else {
if (!bdrv_is_inserted(s->bs)) { if (!blk_is_inserted(s->blk)) {
error_report("Device needs media, but drive is empty"); error_report("Device needs media, but drive is empty");
return -1; return -1;
} }
if (bdrv_is_read_only(bs)) { if (blk_is_read_only(blk)) {
error_report("Can't use a read-only drive"); error_report("Can't use a read-only drive");
return -1; return -1;
} }
bdrv_set_dev_ops(bs, &ide_hd_block_ops, s); blk_set_dev_ops(blk, &ide_hd_block_ops, s);
} }
if (serial) { if (serial) {
pstrcpy(s->drive_serial_str, sizeof(s->drive_serial_str), serial); pstrcpy(s->drive_serial_str, sizeof(s->drive_serial_str), serial);
@ -2265,7 +2277,7 @@ int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind,
} }
ide_reset(s); ide_reset(s);
bdrv_iostatus_enable(bs); blk_iostatus_enable(blk);
return 0; return 0;
} }
@ -2282,7 +2294,7 @@ static void ide_init1(IDEBus *bus, int unit)
s->io_buffer = qemu_memalign(2048, s->io_buffer_total_len); s->io_buffer = qemu_memalign(2048, s->io_buffer_total_len);
memset(s->io_buffer, 0, s->io_buffer_total_len); memset(s->io_buffer, 0, s->io_buffer_total_len);
s->smart_selftest_data = qemu_blockalign(s->bs, 512); s->smart_selftest_data = blk_blockalign(s->blk, 512);
memset(s->smart_selftest_data, 0, 512); memset(s->smart_selftest_data, 0, 512);
s->sector_write_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, s->sector_write_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
@ -2377,7 +2389,7 @@ static int ide_drive_post_load(void *opaque, int version_id)
IDEState *s = opaque; IDEState *s = opaque;
if (s->identify_set) { if (s->identify_set) {
bdrv_set_enable_write_cache(s->bs, !!(s->identify_data[85] & (1 << 5))); blk_set_enable_write_cache(s->blk, !!(s->identify_data[85] & (1 << 5)));
} }
return 0; return 0;
} }

2
hw/ide/ich.c
View File

@ -65,7 +65,7 @@
#include <hw/i386/pc.h> #include <hw/i386/pc.h>
#include <hw/pci/pci.h> #include <hw/pci/pci.h>
#include <hw/isa/isa.h> #include <hw/isa/isa.h>
#include "block/block.h" #include "sysemu/block-backend.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"
#include <hw/ide/pci.h> #include <hw/ide/pci.h>

16
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);
@ -373,7 +373,7 @@ struct IDEState {
/* set for lba48 access */ /* set for lba48 access */
uint8_t lba48; uint8_t lba48;
BlockDriverState *bs; BlockBackend *blk;
char version[9]; char version[9];
/* ATAPI specific */ /* ATAPI specific */
struct unreported_events events; struct unreported_events events;
@ -389,7 +389,7 @@ struct IDEState {
int cd_sector_size; int cd_sector_size;
int atapi_dma; /* true if dma is requested for the packet cmd */ int atapi_dma; /* true if dma is requested for the packet cmd */
BlockAcctCookie acct; BlockAcctCookie acct;
BlockDriverAIOCB *pio_aiocb; BlockAIOCB *pio_aiocb;
struct iovec iov; struct iovec iov;
QEMUIOVector qiov; QEMUIOVector qiov;
/* ATA DMA state */ /* ATA DMA state */
@ -442,7 +442,7 @@ struct IDEDMA {
const struct IDEDMAOps *ops; const struct IDEDMAOps *ops;
struct iovec iov; struct iovec iov;
QEMUIOVector qiov; QEMUIOVector qiov;
BlockDriverAIOCB *aiocb; BlockAIOCB *aiocb;
}; };
struct IDEBus { struct IDEBus {
@ -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);
@ -537,7 +537,7 @@ uint32_t ide_data_readw(void *opaque, uint32_t addr);
void ide_data_writel(void *opaque, uint32_t addr, uint32_t val); void ide_data_writel(void *opaque, uint32_t addr, uint32_t val);
uint32_t ide_data_readl(void *opaque, uint32_t addr); uint32_t ide_data_readl(void *opaque, uint32_t addr);
int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind, int ide_init_drive(IDEState *s, BlockBackend *blk, IDEDriveKind kind,
const char *version, const char *serial, const char *model, const char *version, const char *serial, const char *model,
uint64_t wwn, uint64_t wwn,
uint32_t cylinders, uint32_t heads, uint32_t secs, uint32_t cylinders, uint32_t heads, uint32_t secs,
@ -555,9 +555,9 @@ void ide_transfer_start(IDEState *s, uint8_t *buf, int size,
EndTransferFunc *end_transfer_func); EndTransferFunc *end_transfer_func);
void ide_transfer_stop(IDEState *s); void ide_transfer_stop(IDEState *s);
void ide_set_inactive(IDEState *s, bool more); void ide_set_inactive(IDEState *s, bool more);
BlockDriverAIOCB *ide_issue_trim(BlockDriverState *bs, BlockAIOCB *ide_issue_trim(BlockBackend *blk,
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/isa.c
View File

@ -25,7 +25,7 @@
#include <hw/hw.h> #include <hw/hw.h>
#include <hw/i386/pc.h> #include <hw/i386/pc.h>
#include <hw/isa/isa.h> #include <hw/isa/isa.h>
#include "block/block.h" #include "sysemu/block-backend.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"
#include <hw/ide/internal.h> #include <hw/ide/internal.h>

50
hw/ide/macio.c
View File

@ -25,7 +25,7 @@
#include "hw/hw.h" #include "hw/hw.h"
#include "hw/ppc/mac.h" #include "hw/ppc/mac.h"
#include "hw/ppc/mac_dbdma.h" #include "hw/ppc/mac_dbdma.h"
#include "block/block.h" #include "sysemu/block-backend.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"
#include <hw/ide/internal.h> #include <hw/ide/internal.h>
@ -134,7 +134,7 @@ static void pmac_ide_atapi_transfer_cb(void *opaque, int ret)
MACIO_DPRINTF("precopying unaligned %d bytes to %#" HWADDR_PRIx "\n", MACIO_DPRINTF("precopying unaligned %d bytes to %#" HWADDR_PRIx "\n",
unaligned, io->addr + io->len - unaligned); unaligned, io->addr + io->len - unaligned);
bdrv_read(s->bs, sector_num + nsector, io->remainder, 1); blk_read(s->blk, sector_num + nsector, io->remainder, 1);
cpu_physical_memory_write(io->addr + io->len - unaligned, cpu_physical_memory_write(io->addr + io->len - unaligned,
io->remainder, unaligned); io->remainder, unaligned);
@ -164,14 +164,14 @@ static void pmac_ide_atapi_transfer_cb(void *opaque, int ret)
(s->lba << 2) + (s->io_buffer_index >> 9), (s->lba << 2) + (s->io_buffer_index >> 9),
s->packet_transfer_size, s->dma_cmd); s->packet_transfer_size, s->dma_cmd);
m->aiocb = dma_bdrv_read(s->bs, &s->sg, m->aiocb = dma_blk_read(s->blk, &s->sg,
(int64_t)(s->lba << 2) + (s->io_buffer_index >> 9), (int64_t)(s->lba << 2) + (s->io_buffer_index >> 9),
pmac_ide_atapi_transfer_cb, io); pmac_ide_atapi_transfer_cb, io);
return; return;
done: done:
MACIO_DPRINTF("done DMA\n"); MACIO_DPRINTF("done DMA\n");
block_acct_done(bdrv_get_stats(s->bs), &s->acct); block_acct_done(blk_get_stats(s->blk), &s->acct);
io->dma_end(opaque); io->dma_end(opaque);
} }
@ -254,8 +254,8 @@ static void pmac_ide_transfer_cb(void *opaque, int ret)
qemu_iovec_reset(&io->iov); qemu_iovec_reset(&io->iov);
qemu_iovec_add(&io->iov, io->remainder, 0x200); qemu_iovec_add(&io->iov, io->remainder, 0x200);
m->aiocb = bdrv_aio_writev(s->bs, sector_num - 1, &io->iov, 1, m->aiocb = blk_aio_writev(s->blk, sector_num - 1, &io->iov, 1,
pmac_ide_transfer_cb, io); pmac_ide_transfer_cb, io);
} }
} }
@ -294,8 +294,8 @@ static void pmac_ide_transfer_cb(void *opaque, int ret)
qemu_iovec_reset(&io->iov); qemu_iovec_reset(&io->iov);
qemu_iovec_add(&io->iov, io->remainder, 0x200); qemu_iovec_add(&io->iov, io->remainder, 0x200);
m->aiocb = bdrv_aio_readv(s->bs, sector_num + nsector, &io->iov, 1, m->aiocb = blk_aio_readv(s->blk, sector_num + nsector, &io->iov, 1,
pmac_ide_transfer_cb, io); pmac_ide_transfer_cb, io);
break; break;
case IDE_DMA_WRITE: case IDE_DMA_WRITE:
/* cache the contents in our io struct */ /* cache the contents in our io struct */
@ -333,17 +333,17 @@ static void pmac_ide_transfer_cb(void *opaque, int ret)
switch (s->dma_cmd) { switch (s->dma_cmd) {
case IDE_DMA_READ: case IDE_DMA_READ:
m->aiocb = dma_bdrv_read(s->bs, &s->sg, sector_num, m->aiocb = dma_blk_read(s->blk, &s->sg, sector_num,
pmac_ide_transfer_cb, io); pmac_ide_transfer_cb, io);
break; break;
case IDE_DMA_WRITE: case IDE_DMA_WRITE:
m->aiocb = dma_bdrv_write(s->bs, &s->sg, sector_num, m->aiocb = dma_blk_write(s->blk, &s->sg, sector_num,
pmac_ide_transfer_cb, io); pmac_ide_transfer_cb, io);
break; break;
case IDE_DMA_TRIM: case IDE_DMA_TRIM:
m->aiocb = dma_bdrv_io(s->bs, &s->sg, sector_num, m->aiocb = dma_blk_io(s->blk, &s->sg, sector_num,
ide_issue_trim, pmac_ide_transfer_cb, io, ide_issue_trim, pmac_ide_transfer_cb, io,
DMA_DIRECTION_TO_DEVICE); DMA_DIRECTION_TO_DEVICE);
break; break;
} }
@ -352,7 +352,7 @@ static void pmac_ide_transfer_cb(void *opaque, int ret)
done: done:
if (s->dma_cmd == IDE_DMA_READ || s->dma_cmd == IDE_DMA_WRITE) { if (s->dma_cmd == IDE_DMA_READ || s->dma_cmd == IDE_DMA_WRITE) {
block_acct_done(bdrv_get_stats(s->bs), &s->acct); block_acct_done(blk_get_stats(s->blk), &s->acct);
} }
io->dma_end(io); io->dma_end(io);
} }
@ -370,7 +370,7 @@ static void pmac_ide_transfer(DBDMA_io *io)
/* Handle non-block ATAPI DMA transfers */ /* Handle non-block ATAPI DMA transfers */
if (s->lba == -1) { if (s->lba == -1) {
s->io_buffer_size = MIN(io->len, s->packet_transfer_size); s->io_buffer_size = MIN(io->len, s->packet_transfer_size);
block_acct_start(bdrv_get_stats(s->bs), &s->acct, s->io_buffer_size, block_acct_start(blk_get_stats(s->blk), &s->acct, s->io_buffer_size,
BLOCK_ACCT_READ); BLOCK_ACCT_READ);
MACIO_DPRINTF("non-block ATAPI DMA transfer size: %d\n", MACIO_DPRINTF("non-block ATAPI DMA transfer size: %d\n",
s->io_buffer_size); s->io_buffer_size);
@ -382,12 +382,12 @@ static void pmac_ide_transfer(DBDMA_io *io)
m->dma_active = false; m->dma_active = false;
MACIO_DPRINTF("end of non-block ATAPI DMA transfer\n"); MACIO_DPRINTF("end of non-block ATAPI DMA transfer\n");
block_acct_done(bdrv_get_stats(s->bs), &s->acct); block_acct_done(blk_get_stats(s->blk), &s->acct);
io->dma_end(io); io->dma_end(io);
return; return;
} }
block_acct_start(bdrv_get_stats(s->bs), &s->acct, io->len, block_acct_start(blk_get_stats(s->blk), &s->acct, io->len,
BLOCK_ACCT_READ); BLOCK_ACCT_READ);
pmac_ide_atapi_transfer_cb(io, 0); pmac_ide_atapi_transfer_cb(io, 0);
return; return;
@ -395,11 +395,11 @@ static void pmac_ide_transfer(DBDMA_io *io)
switch (s->dma_cmd) { switch (s->dma_cmd) {
case IDE_DMA_READ: case IDE_DMA_READ:
block_acct_start(bdrv_get_stats(s->bs), &s->acct, io->len, block_acct_start(blk_get_stats(s->blk), &s->acct, io->len,
BLOCK_ACCT_READ); BLOCK_ACCT_READ);
break; break;
case IDE_DMA_WRITE: case IDE_DMA_WRITE:
block_acct_start(bdrv_get_stats(s->bs), &s->acct, io->len, block_acct_start(blk_get_stats(s->blk), &s->acct, io->len,
BLOCK_ACCT_WRITE); BLOCK_ACCT_WRITE);
break; break;
default: default:
@ -415,7 +415,7 @@ static void pmac_ide_flush(DBDMA_io *io)
MACIOIDEState *m = io->opaque; MACIOIDEState *m = io->opaque;
if (m->aiocb) { if (m->aiocb) {
bdrv_drain_all(); blk_drain_all();
} }
} }
@ -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);

4
hw/ide/microdrive.c
View File

@ -25,7 +25,7 @@
#include <hw/hw.h> #include <hw/hw.h>
#include <hw/i386/pc.h> #include <hw/i386/pc.h>
#include <hw/pcmcia.h> #include <hw/pcmcia.h>
#include "block/block.h" #include "sysemu/block-backend.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"
#include <hw/ide/internal.h> #include <hw/ide/internal.h>
@ -247,7 +247,7 @@ static uint16_t md_common_read(PCMCIACardState *card, uint32_t at)
return ide_ioport_read(&s->bus, 0x1); return ide_ioport_read(&s->bus, 0x1);
case 0xe: /* Alternate Status */ case 0xe: /* Alternate Status */
ifs = idebus_active_if(&s->bus); ifs = idebus_active_if(&s->bus);
if (ifs->bs) { if (ifs->blk) {
return ifs->status; return ifs->status;
} else { } else {
return 0; return 0;

2
hw/ide/mmio.c
View File

@ -24,7 +24,7 @@
*/ */
#include "hw/hw.h" #include "hw/hw.h"
#include "hw/sysbus.h" #include "hw/sysbus.h"
#include "block/block.h" #include "sysemu/block-backend.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"
#include <hw/ide/internal.h> #include <hw/ide/internal.h>

6
hw/ide/pci.c
View File

@ -26,7 +26,7 @@
#include <hw/i386/pc.h> #include <hw/i386/pc.h>
#include <hw/pci/pci.h> #include <hw/pci/pci.h>
#include <hw/isa/isa.h> #include <hw/isa/isa.h>
#include "block/block.h" #include "sysemu/block-backend.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"
#include <hw/ide/pci.h> #include <hw/ide/pci.h>
@ -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);
@ -302,7 +302,7 @@ void bmdma_cmd_writeb(BMDMAState *bm, uint32_t val)
* aio operation with preadv/pwritev. * aio operation with preadv/pwritev.
*/ */
if (bm->bus->dma->aiocb) { if (bm->bus->dma->aiocb) {
bdrv_drain_all(); blk_drain_all();
assert(bm->bus->dma->aiocb == NULL); assert(bm->bus->dma->aiocb == NULL);
} }
bm->status &= ~BM_STATUS_DMAING; bm->status &= ~BM_STATUS_DMAING;

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;

11
hw/ide/piix.c
View File

@ -27,7 +27,7 @@
#include <hw/i386/pc.h> #include <hw/i386/pc.h>
#include <hw/pci/pci.h> #include <hw/pci/pci.h>
#include <hw/isa/isa.h> #include <hw/isa/isa.h>
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"
@ -178,12 +178,13 @@ int pci_piix3_xen_ide_unplug(DeviceState *dev)
for (; i < 3; i++) { for (; i < 3; i++) {
di = drive_get_by_index(IF_IDE, i); di = drive_get_by_index(IF_IDE, i);
if (di != NULL && !di->media_cd) { if (di != NULL && !di->media_cd) {
DeviceState *ds = bdrv_get_attached_dev(di->bdrv); BlockBackend *blk = blk_by_legacy_dinfo(di);
DeviceState *ds = blk_get_attached_dev(blk);
if (ds) { if (ds) {
bdrv_detach_dev(di->bdrv, ds); blk_detach_dev(blk, ds);
} }
pci_ide->bus[di->bus].ifs[di->unit].bs = NULL; pci_ide->bus[di->bus].ifs[di->unit].blk = NULL;
drive_del(di); blk_unref(blk);
} }
} }
qdev_reset_all(DEVICE(dev)); qdev_reset_all(DEVICE(dev));

13
hw/ide/qdev.c
View File

@ -20,6 +20,7 @@
#include "sysemu/dma.h" #include "sysemu/dma.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
#include <hw/ide/internal.h> #include <hw/ide/internal.h>
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "hw/block/block.h" #include "hw/block/block.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
@ -72,7 +73,7 @@ static int ide_qdev_init(DeviceState *qdev)
IDEDeviceClass *dc = IDE_DEVICE_GET_CLASS(dev); IDEDeviceClass *dc = IDE_DEVICE_GET_CLASS(dev);
IDEBus *bus = DO_UPCAST(IDEBus, qbus, qdev->parent_bus); IDEBus *bus = DO_UPCAST(IDEBus, qbus, qdev->parent_bus);
if (!dev->conf.bs) { if (!dev->conf.blk) {
error_report("No drive specified"); error_report("No drive specified");
goto err; goto err;
} }
@ -117,7 +118,7 @@ IDEDevice *ide_create_drive(IDEBus *bus, int unit, DriveInfo *drive)
dev = qdev_create(&bus->qbus, drive->media_cd ? "ide-cd" : "ide-hd"); dev = qdev_create(&bus->qbus, drive->media_cd ? "ide-cd" : "ide-hd");
qdev_prop_set_uint32(dev, "unit", unit); qdev_prop_set_uint32(dev, "unit", unit);
qdev_prop_set_drive_nofail(dev, "drive", drive->bdrv); qdev_prop_set_drive_nofail(dev, "drive", blk_by_legacy_dinfo(drive));
qdev_init_nofail(dev); qdev_init_nofail(dev);
return DO_UPCAST(IDEDevice, qdev, dev); return DO_UPCAST(IDEDevice, qdev, dev);
} }
@ -127,7 +128,7 @@ int ide_get_geometry(BusState *bus, int unit,
{ {
IDEState *s = &DO_UPCAST(IDEBus, qbus, bus)->ifs[unit]; IDEState *s = &DO_UPCAST(IDEBus, qbus, bus)->ifs[unit];
if (s->drive_kind != IDE_HD || !s->bs) { if (s->drive_kind != IDE_HD || !s->blk) {
return -1; return -1;
} }
@ -172,7 +173,7 @@ static int ide_dev_initfn(IDEDevice *dev, IDEDriveKind kind)
} }
} }
if (ide_init_drive(s, dev->conf.bs, kind, if (ide_init_drive(s, dev->conf.blk, kind,
dev->version, dev->serial, dev->model, dev->wwn, dev->version, dev->serial, dev->model, dev->wwn,
dev->conf.cyls, dev->conf.heads, dev->conf.secs, dev->conf.cyls, dev->conf.heads, dev->conf.secs,
dev->chs_trans) < 0) { dev->chs_trans) < 0) {
@ -249,9 +250,9 @@ static int ide_cd_initfn(IDEDevice *dev)
static int ide_drive_initfn(IDEDevice *dev) static int ide_drive_initfn(IDEDevice *dev)
{ {
DriveInfo *dinfo = drive_get_by_blockdev(dev->conf.bs); DriveInfo *dinfo = blk_legacy_dinfo(dev->conf.blk);
return ide_dev_initfn(dev, dinfo->media_cd ? IDE_CD : IDE_HD); return ide_dev_initfn(dev, dinfo && dinfo->media_cd ? IDE_CD : IDE_HD);
} }
#define DEFINE_IDE_DEV_PROPERTIES() \ #define DEFINE_IDE_DEV_PROPERTIES() \

2
hw/ide/via.c
View File

@ -27,7 +27,7 @@
#include <hw/i386/pc.h> #include <hw/i386/pc.h>
#include <hw/pci/pci.h> #include <hw/pci/pci.h>
#include <hw/isa/isa.h> #include <hw/isa/isa.h>
#include "block/block.h" #include "sysemu/block-backend.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "sysemu/dma.h" #include "sysemu/dma.h"

7
hw/isa/pc87312.c
View File

@ -25,6 +25,7 @@
#include "hw/isa/pc87312.h" #include "hw/isa/pc87312.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "sysemu/char.h" #include "sysemu/char.h"
@ -320,11 +321,13 @@ static void pc87312_realize(DeviceState *dev, Error **errp)
qdev_prop_set_uint32(d, "irq", 6); qdev_prop_set_uint32(d, "irq", 6);
drive = drive_get(IF_FLOPPY, 0, 0); drive = drive_get(IF_FLOPPY, 0, 0);
if (drive != NULL) { if (drive != NULL) {
qdev_prop_set_drive_nofail(d, "driveA", drive->bdrv); qdev_prop_set_drive_nofail(d, "driveA",
blk_by_legacy_dinfo(drive));
} }
drive = drive_get(IF_FLOPPY, 0, 1); drive = drive_get(IF_FLOPPY, 0, 1);
if (drive != NULL) { if (drive != NULL) {
qdev_prop_set_drive_nofail(d, "driveB", drive->bdrv); qdev_prop_set_drive_nofail(d, "driveB",
blk_by_legacy_dinfo(drive));
} }
qdev_init_nofail(d); qdev_init_nofail(d);
s->fdc.dev = isa; s->fdc.dev = isa;

14
hw/lm32/lm32_boards.c
View File

@ -23,7 +23,7 @@
#include "hw/devices.h" #include "hw/devices.h"
#include "hw/boards.h" #include "hw/boards.h"
#include "hw/loader.h" #include "hw/loader.h"
#include "sysemu/blockdev.h" #include "sysemu/block-backend.h"
#include "elf.h" #include "elf.h"
#include "lm32_hwsetup.h" #include "lm32_hwsetup.h"
#include "lm32.h" #include "lm32.h"
@ -119,9 +119,9 @@ static void lm32_evr_init(MachineState *machine)
dinfo = drive_get(IF_PFLASH, 0, 0); dinfo = drive_get(IF_PFLASH, 0, 0);
/* Spansion S29NS128P */ /* Spansion S29NS128P */
pflash_cfi02_register(flash_base, NULL, "lm32_evr.flash", flash_size, pflash_cfi02_register(flash_base, NULL, "lm32_evr.flash", flash_size,
dinfo ? dinfo->bdrv : NULL, flash_sector_size, dinfo ? blk_by_legacy_dinfo(dinfo) : NULL,
flash_size / flash_sector_size, 1, 2, flash_sector_size, flash_size / flash_sector_size,
0x01, 0x7e, 0x43, 0x00, 0x555, 0x2aa, 1); 1, 2, 0x01, 0x7e, 0x43, 0x00, 0x555, 0x2aa, 1);
/* create irq lines */ /* create irq lines */
cpu_irq = qemu_allocate_irqs(cpu_irq_handler, cpu, 1); cpu_irq = qemu_allocate_irqs(cpu_irq_handler, cpu, 1);
@ -222,9 +222,9 @@ static void lm32_uclinux_init(MachineState *machine)
dinfo = drive_get(IF_PFLASH, 0, 0); dinfo = drive_get(IF_PFLASH, 0, 0);
/* Spansion S29NS128P */ /* Spansion S29NS128P */
pflash_cfi02_register(flash_base, NULL, "lm32_uclinux.flash", flash_size, pflash_cfi02_register(flash_base, NULL, "lm32_uclinux.flash", flash_size,
dinfo ? dinfo->bdrv : NULL, flash_sector_size, dinfo ? blk_by_legacy_dinfo(dinfo) : NULL,
flash_size / flash_sector_size, 1, 2, flash_sector_size, flash_size / flash_sector_size,
0x01, 0x7e, 0x43, 0x00, 0x555, 0x2aa, 1); 1, 2, 0x01, 0x7e, 0x43, 0x00, 0x555, 0x2aa, 1);
/* create irq lines */ /* create irq lines */
cpu_irq = qemu_allocate_irqs(cpu_irq_handler, env, 1); cpu_irq = qemu_allocate_irqs(cpu_irq_handler, env, 1);

Some files were not shown because too many files have changed in this diff Show More