5bb0474778
bs->file and bs->backing are a kind of duplication of part of bs->children. But very useful diplication, so let's not drop them at all:) We should manage bs->file and bs->backing in same place, where we manage bs->children, to keep them in sync. Moreover, generic io paths are unprepared to BdrvChild without a bs, so it's double good to clear bs->file / bs->backing when we detach the child. Detach is simple: if we detach bs->file or bs->backing child, just set corresponding field to NULL. Attach is a bit more complicated. But we still can precisely detect should we set one of bs->file / bs->backing or not: - if role is BDRV_CHILD_COW, we definitely deal with bs->backing - else, if role is BDRV_CHILD_FILTERED (it must be also BDRV_CHILD_PRIMARY), it's a filtered child. Use bs->drv->filtered_child_is_backing to chose the pointer field to modify. - else, if role is BDRV_CHILD_PRIMARY, we deal with bs->file - in all other cases, it's neither bs->backing nor bs->file. It's some other child and we shouldn't care OK. This change brings one more good thing: we can (and should) get rid of all indirect pointers in the block-graph-change transactions: bdrv_attach_child_common() stores BdrvChild** into transaction to clear it on abort. bdrv_attach_child_common() has two callers: bdrv_attach_child_noperm() just pass-through this feature, bdrv_root_attach_child() doesn't need the feature. Look at bdrv_attach_child_noperm() callers: - bdrv_attach_child() doesn't need the feature - bdrv_set_file_or_backing_noperm() uses the feature to manage bs->file and bs->backing, we don't want it anymore - bdrv_append() uses the feature to manage bs->backing, again we don't want it anymore So, we should drop this stuff! Great! We could probably keep BdrvChild** argument to keep the int return value, but it seems not worth the complexity. Finally, we now set .file / .backing automatically in generic code and want to restring setting them by hand outside of .attach/.detach. So, this patch cleanups all remaining places where they were set. To find such places I use: git grep '\->file =' git grep '\->backing =' git grep '&.*\<backing\>' git grep '&.*\<file\>' Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru> Reviewed-by: Hanna Reitz <hreitz@redhat.com> Message-Id: <20220726201134.924743-14-vsementsov@yandex-team.ru> Signed-off-by: Kevin Wolf <kwolf@redhat.com>
646 lines
20 KiB
C
646 lines
20 KiB
C
/* BlockDriver implementation for "raw" format driver
|
|
*
|
|
* Copyright (C) 2010-2016 Red Hat, Inc.
|
|
* Copyright (C) 2010, Blue Swirl <blauwirbel@gmail.com>
|
|
* Copyright (C) 2009, Anthony Liguori <aliguori@us.ibm.com>
|
|
*
|
|
* Author:
|
|
* Laszlo Ersek <lersek@redhat.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to
|
|
* deal in the Software without restriction, including without limitation the
|
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
* sell copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "block/block_int.h"
|
|
#include "qapi/error.h"
|
|
#include "qemu/module.h"
|
|
#include "qemu/option.h"
|
|
#include "qemu/memalign.h"
|
|
|
|
typedef struct BDRVRawState {
|
|
uint64_t offset;
|
|
uint64_t size;
|
|
bool has_size;
|
|
} BDRVRawState;
|
|
|
|
static const char *const mutable_opts[] = { "offset", "size", NULL };
|
|
|
|
static QemuOptsList raw_runtime_opts = {
|
|
.name = "raw",
|
|
.head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
|
|
.desc = {
|
|
{
|
|
.name = "offset",
|
|
.type = QEMU_OPT_SIZE,
|
|
.help = "offset in the disk where the image starts",
|
|
},
|
|
{
|
|
.name = "size",
|
|
.type = QEMU_OPT_SIZE,
|
|
.help = "virtual disk size",
|
|
},
|
|
{ /* end of list */ }
|
|
},
|
|
};
|
|
|
|
static QemuOptsList raw_create_opts = {
|
|
.name = "raw-create-opts",
|
|
.head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
|
|
.desc = {
|
|
{
|
|
.name = BLOCK_OPT_SIZE,
|
|
.type = QEMU_OPT_SIZE,
|
|
.help = "Virtual disk size"
|
|
},
|
|
{ /* end of list */ }
|
|
}
|
|
};
|
|
|
|
static int raw_read_options(QDict *options, uint64_t *offset, bool *has_size,
|
|
uint64_t *size, Error **errp)
|
|
{
|
|
QemuOpts *opts = NULL;
|
|
int ret;
|
|
|
|
opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
|
|
if (!qemu_opts_absorb_qdict(opts, options, errp)) {
|
|
ret = -EINVAL;
|
|
goto end;
|
|
}
|
|
|
|
*offset = qemu_opt_get_size(opts, "offset", 0);
|
|
*has_size = qemu_opt_find(opts, "size");
|
|
*size = qemu_opt_get_size(opts, "size", 0);
|
|
|
|
ret = 0;
|
|
end:
|
|
qemu_opts_del(opts);
|
|
return ret;
|
|
}
|
|
|
|
static int raw_apply_options(BlockDriverState *bs, BDRVRawState *s,
|
|
uint64_t offset, bool has_size, uint64_t size,
|
|
Error **errp)
|
|
{
|
|
int64_t real_size = 0;
|
|
|
|
real_size = bdrv_getlength(bs->file->bs);
|
|
if (real_size < 0) {
|
|
error_setg_errno(errp, -real_size, "Could not get image size");
|
|
return real_size;
|
|
}
|
|
|
|
/* Check size and offset */
|
|
if (offset > real_size) {
|
|
error_setg(errp, "Offset (%" PRIu64 ") cannot be greater than "
|
|
"size of the containing file (%" PRId64 ")",
|
|
s->offset, real_size);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (has_size && (real_size - offset) < size) {
|
|
error_setg(errp, "The sum of offset (%" PRIu64 ") and size "
|
|
"(%" PRIu64 ") has to be smaller or equal to the "
|
|
" actual size of the containing file (%" PRId64 ")",
|
|
s->offset, s->size, real_size);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Make sure size is multiple of BDRV_SECTOR_SIZE to prevent rounding
|
|
* up and leaking out of the specified area. */
|
|
if (has_size && !QEMU_IS_ALIGNED(size, BDRV_SECTOR_SIZE)) {
|
|
error_setg(errp, "Specified size is not multiple of %llu",
|
|
BDRV_SECTOR_SIZE);
|
|
return -EINVAL;
|
|
}
|
|
|
|
s->offset = offset;
|
|
s->has_size = has_size;
|
|
s->size = has_size ? size : real_size - offset;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int raw_reopen_prepare(BDRVReopenState *reopen_state,
|
|
BlockReopenQueue *queue, Error **errp)
|
|
{
|
|
bool has_size;
|
|
uint64_t offset, size;
|
|
int ret;
|
|
|
|
assert(reopen_state != NULL);
|
|
assert(reopen_state->bs != NULL);
|
|
|
|
reopen_state->opaque = g_new0(BDRVRawState, 1);
|
|
|
|
ret = raw_read_options(reopen_state->options, &offset, &has_size, &size,
|
|
errp);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
|
|
ret = raw_apply_options(reopen_state->bs, reopen_state->opaque,
|
|
offset, has_size, size, errp);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void raw_reopen_commit(BDRVReopenState *state)
|
|
{
|
|
BDRVRawState *new_s = state->opaque;
|
|
BDRVRawState *s = state->bs->opaque;
|
|
|
|
memcpy(s, new_s, sizeof(BDRVRawState));
|
|
|
|
g_free(state->opaque);
|
|
state->opaque = NULL;
|
|
}
|
|
|
|
static void raw_reopen_abort(BDRVReopenState *state)
|
|
{
|
|
g_free(state->opaque);
|
|
state->opaque = NULL;
|
|
}
|
|
|
|
/* Check and adjust the offset, against 'offset' and 'size' options. */
|
|
static inline int raw_adjust_offset(BlockDriverState *bs, int64_t *offset,
|
|
int64_t bytes, bool is_write)
|
|
{
|
|
BDRVRawState *s = bs->opaque;
|
|
|
|
if (s->has_size && (*offset > s->size || bytes > (s->size - *offset))) {
|
|
/* There's not enough space for the write, or the read request is
|
|
* out-of-range. Don't read/write anything to prevent leaking out of
|
|
* the size specified in options. */
|
|
return is_write ? -ENOSPC : -EINVAL;
|
|
}
|
|
|
|
if (*offset > INT64_MAX - s->offset) {
|
|
return -EINVAL;
|
|
}
|
|
*offset += s->offset;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
|
|
int64_t bytes, QEMUIOVector *qiov,
|
|
BdrvRequestFlags flags)
|
|
{
|
|
int ret;
|
|
|
|
ret = raw_adjust_offset(bs, &offset, bytes, false);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
|
|
BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
|
|
return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
|
|
}
|
|
|
|
static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset,
|
|
int64_t bytes, QEMUIOVector *qiov,
|
|
BdrvRequestFlags flags)
|
|
{
|
|
void *buf = NULL;
|
|
BlockDriver *drv;
|
|
QEMUIOVector local_qiov;
|
|
int ret;
|
|
|
|
if (bs->probed && offset < BLOCK_PROBE_BUF_SIZE && bytes) {
|
|
/* Handling partial writes would be a pain - so we just
|
|
* require that guests have 512-byte request alignment if
|
|
* probing occurred */
|
|
QEMU_BUILD_BUG_ON(BLOCK_PROBE_BUF_SIZE != 512);
|
|
QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != 512);
|
|
assert(offset == 0 && bytes >= BLOCK_PROBE_BUF_SIZE);
|
|
|
|
buf = qemu_try_blockalign(bs->file->bs, 512);
|
|
if (!buf) {
|
|
ret = -ENOMEM;
|
|
goto fail;
|
|
}
|
|
|
|
ret = qemu_iovec_to_buf(qiov, 0, buf, 512);
|
|
if (ret != 512) {
|
|
ret = -EINVAL;
|
|
goto fail;
|
|
}
|
|
|
|
drv = bdrv_probe_all(buf, 512, NULL);
|
|
if (drv != bs->drv) {
|
|
ret = -EPERM;
|
|
goto fail;
|
|
}
|
|
|
|
/* Use the checked buffer, a malicious guest might be overwriting its
|
|
* original buffer in the background. */
|
|
qemu_iovec_init(&local_qiov, qiov->niov + 1);
|
|
qemu_iovec_add(&local_qiov, buf, 512);
|
|
qemu_iovec_concat(&local_qiov, qiov, 512, qiov->size - 512);
|
|
qiov = &local_qiov;
|
|
}
|
|
|
|
ret = raw_adjust_offset(bs, &offset, bytes, true);
|
|
if (ret) {
|
|
goto fail;
|
|
}
|
|
|
|
BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
|
|
ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
|
|
|
|
fail:
|
|
if (qiov == &local_qiov) {
|
|
qemu_iovec_destroy(&local_qiov);
|
|
}
|
|
qemu_vfree(buf);
|
|
return ret;
|
|
}
|
|
|
|
static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
|
|
bool want_zero, int64_t offset,
|
|
int64_t bytes, int64_t *pnum,
|
|
int64_t *map,
|
|
BlockDriverState **file)
|
|
{
|
|
BDRVRawState *s = bs->opaque;
|
|
*pnum = bytes;
|
|
*file = bs->file->bs;
|
|
*map = offset + s->offset;
|
|
return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID;
|
|
}
|
|
|
|
static int coroutine_fn raw_co_pwrite_zeroes(BlockDriverState *bs,
|
|
int64_t offset, int64_t bytes,
|
|
BdrvRequestFlags flags)
|
|
{
|
|
int ret;
|
|
|
|
ret = raw_adjust_offset(bs, &offset, bytes, true);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
|
|
}
|
|
|
|
static int coroutine_fn raw_co_pdiscard(BlockDriverState *bs,
|
|
int64_t offset, int64_t bytes)
|
|
{
|
|
int ret;
|
|
|
|
ret = raw_adjust_offset(bs, &offset, bytes, true);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
return bdrv_co_pdiscard(bs->file, offset, bytes);
|
|
}
|
|
|
|
static int64_t raw_getlength(BlockDriverState *bs)
|
|
{
|
|
int64_t len;
|
|
BDRVRawState *s = bs->opaque;
|
|
|
|
/* Update size. It should not change unless the file was externally
|
|
* modified. */
|
|
len = bdrv_getlength(bs->file->bs);
|
|
if (len < 0) {
|
|
return len;
|
|
}
|
|
|
|
if (len < s->offset) {
|
|
s->size = 0;
|
|
} else {
|
|
if (s->has_size) {
|
|
/* Try to honour the size */
|
|
s->size = MIN(s->size, len - s->offset);
|
|
} else {
|
|
s->size = len - s->offset;
|
|
}
|
|
}
|
|
|
|
return s->size;
|
|
}
|
|
|
|
static BlockMeasureInfo *raw_measure(QemuOpts *opts, BlockDriverState *in_bs,
|
|
Error **errp)
|
|
{
|
|
BlockMeasureInfo *info;
|
|
int64_t required;
|
|
|
|
if (in_bs) {
|
|
required = bdrv_getlength(in_bs);
|
|
if (required < 0) {
|
|
error_setg_errno(errp, -required, "Unable to get image size");
|
|
return NULL;
|
|
}
|
|
} else {
|
|
required = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
|
|
BDRV_SECTOR_SIZE);
|
|
}
|
|
|
|
info = g_new0(BlockMeasureInfo, 1);
|
|
info->required = required;
|
|
|
|
/* Unallocated sectors count towards the file size in raw images */
|
|
info->fully_allocated = info->required;
|
|
return info;
|
|
}
|
|
|
|
static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
|
|
{
|
|
return bdrv_get_info(bs->file->bs, bdi);
|
|
}
|
|
|
|
static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
|
|
{
|
|
if (bs->probed) {
|
|
/* To make it easier to protect the first sector, any probed
|
|
* image is restricted to read-modify-write on sub-sector
|
|
* operations. */
|
|
bs->bl.request_alignment = BDRV_SECTOR_SIZE;
|
|
}
|
|
}
|
|
|
|
static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
|
|
bool exact, PreallocMode prealloc,
|
|
BdrvRequestFlags flags, Error **errp)
|
|
{
|
|
BDRVRawState *s = bs->opaque;
|
|
|
|
if (s->has_size) {
|
|
error_setg(errp, "Cannot resize fixed-size raw disks");
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
if (INT64_MAX - offset < s->offset) {
|
|
error_setg(errp, "Disk size too large for the chosen offset");
|
|
return -EINVAL;
|
|
}
|
|
|
|
s->size = offset;
|
|
offset += s->offset;
|
|
return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
|
|
}
|
|
|
|
static void raw_eject(BlockDriverState *bs, bool eject_flag)
|
|
{
|
|
bdrv_eject(bs->file->bs, eject_flag);
|
|
}
|
|
|
|
static void raw_lock_medium(BlockDriverState *bs, bool locked)
|
|
{
|
|
bdrv_lock_medium(bs->file->bs, locked);
|
|
}
|
|
|
|
static int coroutine_fn raw_co_ioctl(BlockDriverState *bs,
|
|
unsigned long int req, void *buf)
|
|
{
|
|
BDRVRawState *s = bs->opaque;
|
|
if (s->offset || s->has_size) {
|
|
return -ENOTSUP;
|
|
}
|
|
return bdrv_co_ioctl(bs->file->bs, req, buf);
|
|
}
|
|
|
|
static int raw_has_zero_init(BlockDriverState *bs)
|
|
{
|
|
return bdrv_has_zero_init(bs->file->bs);
|
|
}
|
|
|
|
static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
|
|
const char *filename,
|
|
QemuOpts *opts,
|
|
Error **errp)
|
|
{
|
|
return bdrv_create_file(filename, opts, errp);
|
|
}
|
|
|
|
static int raw_open(BlockDriverState *bs, QDict *options, int flags,
|
|
Error **errp)
|
|
{
|
|
BDRVRawState *s = bs->opaque;
|
|
bool has_size;
|
|
uint64_t offset, size;
|
|
BdrvChildRole file_role;
|
|
int ret;
|
|
|
|
ret = raw_read_options(options, &offset, &has_size, &size, errp);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Without offset and a size limit, this driver behaves very much
|
|
* like a filter. With any such limit, it does not.
|
|
*/
|
|
if (offset || has_size) {
|
|
file_role = BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY;
|
|
} else {
|
|
file_role = BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
|
|
}
|
|
|
|
bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
|
|
file_role, false, errp);
|
|
if (!bs->file) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
bs->sg = bdrv_is_sg(bs->file->bs);
|
|
bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
|
|
(BDRV_REQ_FUA & bs->file->bs->supported_write_flags);
|
|
bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
|
|
((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
|
|
bs->file->bs->supported_zero_flags);
|
|
bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags &
|
|
BDRV_REQ_ZERO_WRITE;
|
|
|
|
if (bs->probed && !bdrv_is_read_only(bs)) {
|
|
bdrv_refresh_filename(bs->file->bs);
|
|
fprintf(stderr,
|
|
"WARNING: Image format was not specified for '%s' and probing "
|
|
"guessed raw.\n"
|
|
" Automatically detecting the format is dangerous for "
|
|
"raw images, write operations on block 0 will be restricted.\n"
|
|
" Specify the 'raw' format explicitly to remove the "
|
|
"restrictions.\n",
|
|
bs->file->bs->filename);
|
|
}
|
|
|
|
ret = raw_apply_options(bs, s, offset, has_size, size, errp);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
|
|
if (bdrv_is_sg(bs) && (s->offset || s->has_size)) {
|
|
error_setg(errp, "Cannot use offset/size with SCSI generic devices");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int raw_probe(const uint8_t *buf, int buf_size, const char *filename)
|
|
{
|
|
/* smallest possible positive score so that raw is used if and only if no
|
|
* other block driver works
|
|
*/
|
|
return 1;
|
|
}
|
|
|
|
static int raw_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
|
|
{
|
|
BDRVRawState *s = bs->opaque;
|
|
int ret;
|
|
|
|
ret = bdrv_probe_blocksizes(bs->file->bs, bsz);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
|
|
if (!QEMU_IS_ALIGNED(s->offset, MAX(bsz->log, bsz->phys))) {
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
|
|
{
|
|
BDRVRawState *s = bs->opaque;
|
|
if (s->offset || s->has_size) {
|
|
return -ENOTSUP;
|
|
}
|
|
return bdrv_probe_geometry(bs->file->bs, geo);
|
|
}
|
|
|
|
static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs,
|
|
BdrvChild *src,
|
|
int64_t src_offset,
|
|
BdrvChild *dst,
|
|
int64_t dst_offset,
|
|
int64_t bytes,
|
|
BdrvRequestFlags read_flags,
|
|
BdrvRequestFlags write_flags)
|
|
{
|
|
int ret;
|
|
|
|
ret = raw_adjust_offset(bs, &src_offset, bytes, false);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
return bdrv_co_copy_range_from(bs->file, src_offset, dst, dst_offset,
|
|
bytes, read_flags, write_flags);
|
|
}
|
|
|
|
static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
|
|
BdrvChild *src,
|
|
int64_t src_offset,
|
|
BdrvChild *dst,
|
|
int64_t dst_offset,
|
|
int64_t bytes,
|
|
BdrvRequestFlags read_flags,
|
|
BdrvRequestFlags write_flags)
|
|
{
|
|
int ret;
|
|
|
|
ret = raw_adjust_offset(bs, &dst_offset, bytes, true);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
return bdrv_co_copy_range_to(src, src_offset, bs->file, dst_offset, bytes,
|
|
read_flags, write_flags);
|
|
}
|
|
|
|
static const char *const raw_strong_runtime_opts[] = {
|
|
"offset",
|
|
"size",
|
|
|
|
NULL
|
|
};
|
|
|
|
static void raw_cancel_in_flight(BlockDriverState *bs)
|
|
{
|
|
bdrv_cancel_in_flight(bs->file->bs);
|
|
}
|
|
|
|
static void raw_child_perm(BlockDriverState *bs, BdrvChild *c,
|
|
BdrvChildRole role,
|
|
BlockReopenQueue *reopen_queue,
|
|
uint64_t parent_perm, uint64_t parent_shared,
|
|
uint64_t *nperm, uint64_t *nshared)
|
|
{
|
|
bdrv_default_perms(bs, c, role, reopen_queue, parent_perm,
|
|
parent_shared, nperm, nshared);
|
|
|
|
/*
|
|
* bdrv_default_perms() may add WRITE and/or RESIZE (see comment in
|
|
* bdrv_default_perms_for_storage() for an explanation) but we only need
|
|
* them if they are in parent_perm. Drop WRITE and RESIZE whenever possible
|
|
* to avoid permission conflicts.
|
|
*/
|
|
*nperm &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
|
|
*nperm |= parent_perm & (BLK_PERM_WRITE | BLK_PERM_RESIZE);
|
|
}
|
|
|
|
BlockDriver bdrv_raw = {
|
|
.format_name = "raw",
|
|
.instance_size = sizeof(BDRVRawState),
|
|
.bdrv_probe = &raw_probe,
|
|
.bdrv_reopen_prepare = &raw_reopen_prepare,
|
|
.bdrv_reopen_commit = &raw_reopen_commit,
|
|
.bdrv_reopen_abort = &raw_reopen_abort,
|
|
.bdrv_open = &raw_open,
|
|
.bdrv_child_perm = raw_child_perm,
|
|
.bdrv_co_create_opts = &raw_co_create_opts,
|
|
.bdrv_co_preadv = &raw_co_preadv,
|
|
.bdrv_co_pwritev = &raw_co_pwritev,
|
|
.bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes,
|
|
.bdrv_co_pdiscard = &raw_co_pdiscard,
|
|
.bdrv_co_block_status = &raw_co_block_status,
|
|
.bdrv_co_copy_range_from = &raw_co_copy_range_from,
|
|
.bdrv_co_copy_range_to = &raw_co_copy_range_to,
|
|
.bdrv_co_truncate = &raw_co_truncate,
|
|
.bdrv_getlength = &raw_getlength,
|
|
.is_format = true,
|
|
.has_variable_length = true,
|
|
.bdrv_measure = &raw_measure,
|
|
.bdrv_get_info = &raw_get_info,
|
|
.bdrv_refresh_limits = &raw_refresh_limits,
|
|
.bdrv_probe_blocksizes = &raw_probe_blocksizes,
|
|
.bdrv_probe_geometry = &raw_probe_geometry,
|
|
.bdrv_eject = &raw_eject,
|
|
.bdrv_lock_medium = &raw_lock_medium,
|
|
.bdrv_co_ioctl = &raw_co_ioctl,
|
|
.create_opts = &raw_create_opts,
|
|
.bdrv_has_zero_init = &raw_has_zero_init,
|
|
.strong_runtime_opts = raw_strong_runtime_opts,
|
|
.mutable_opts = mutable_opts,
|
|
.bdrv_cancel_in_flight = raw_cancel_in_flight,
|
|
};
|
|
|
|
static void bdrv_raw_init(void)
|
|
{
|
|
bdrv_register(&bdrv_raw);
|
|
}
|
|
|
|
block_init(bdrv_raw_init);
|