2007-07-31 23:28:53 +00:00
|
|
|
/*
|
|
|
|
* Block driver for Parallels disk image format
|
|
|
|
*
|
|
|
|
* Copyright (c) 2007 Alex Beregszaszi
|
2015-04-28 07:46:46 +00:00
|
|
|
* Copyright (c) 2015 Denis V. Lunev <den@openvz.org>
|
2007-07-31 23:28:53 +00:00
|
|
|
*
|
2015-04-28 07:46:46 +00:00
|
|
|
* This code was originally based on comparing different disk images created
|
|
|
|
* by Parallels. Currently it is based on opened OpenVZ sources
|
|
|
|
* available at
|
|
|
|
* http://git.openvz.org/?p=ploop;a=summary
|
2007-07-31 23:28:53 +00:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2018-02-01 11:18:46 +00:00
|
|
|
|
2016-01-18 18:01:42 +00:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 08:01:28 +00:00
|
|
|
#include "qapi/error.h"
|
2012-12-17 17:19:44 +00:00
|
|
|
#include "block/block_int.h"
|
2018-06-14 19:14:28 +00:00
|
|
|
#include "block/qdict.h"
|
2016-03-08 14:57:05 +00:00
|
|
|
#include "sysemu/block-backend.h"
|
2012-12-17 17:20:00 +00:00
|
|
|
#include "qemu/module.h"
|
2018-02-01 11:18:46 +00:00
|
|
|
#include "qemu/option.h"
|
2018-03-06 11:13:58 +00:00
|
|
|
#include "qapi/qmp/qdict.h"
|
|
|
|
#include "qapi/qobject-input-visitor.h"
|
|
|
|
#include "qapi/qapi-visit-block-core.h"
|
2016-03-15 16:22:36 +00:00
|
|
|
#include "qemu/bswap.h"
|
2015-04-28 07:46:57 +00:00
|
|
|
#include "qemu/bitmap.h"
|
2017-11-07 13:10:35 +00:00
|
|
|
#include "migration/blocker.h"
|
2018-01-12 09:01:20 +00:00
|
|
|
#include "parallels.h"
|
2007-07-31 23:28:53 +00:00
|
|
|
|
|
|
|
/**************************************************************/
|
|
|
|
|
|
|
|
#define HEADER_MAGIC "WithoutFreeSpace"
|
2014-07-28 16:23:55 +00:00
|
|
|
#define HEADER_MAGIC2 "WithouFreSpacExt"
|
2007-07-31 23:28:53 +00:00
|
|
|
#define HEADER_VERSION 2
|
2015-04-28 07:46:53 +00:00
|
|
|
#define HEADER_INUSE_MAGIC (0x746F6E59)
|
2016-07-27 17:08:20 +00:00
|
|
|
#define MAX_PARALLELS_IMAGE_FACTOR (1ull << 32)
|
2007-07-31 23:28:53 +00:00
|
|
|
|
2017-08-24 08:46:10 +00:00
|
|
|
static QEnumLookup prealloc_mode_lookup = {
|
|
|
|
.array = (const char *const[]) {
|
|
|
|
"falloc",
|
|
|
|
"truncate",
|
|
|
|
},
|
|
|
|
.size = PRL_PREALLOC_MODE__MAX
|
2015-04-28 07:46:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define PARALLELS_OPT_PREALLOC_MODE "prealloc-mode"
|
|
|
|
#define PARALLELS_OPT_PREALLOC_SIZE "prealloc-size"
|
|
|
|
|
|
|
|
static QemuOptsList parallels_runtime_opts = {
|
|
|
|
.name = "parallels",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(parallels_runtime_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
|
|
|
.name = PARALLELS_OPT_PREALLOC_SIZE,
|
|
|
|
.type = QEMU_OPT_SIZE,
|
|
|
|
.help = "Preallocation size on image expansion",
|
2017-03-20 09:27:02 +00:00
|
|
|
.def_value_str = "128M",
|
2015-04-28 07:46:58 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = PARALLELS_OPT_PREALLOC_MODE,
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "Preallocation mode on image expansion "
|
|
|
|
"(allowed values: falloc, truncate)",
|
|
|
|
.def_value_str = "falloc",
|
|
|
|
},
|
|
|
|
{ /* end of list */ },
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2018-03-06 11:13:58 +00:00
|
|
|
static QemuOptsList parallels_create_opts = {
|
|
|
|
.name = "parallels-create-opts",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(parallels_create_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_SIZE,
|
|
|
|
.type = QEMU_OPT_SIZE,
|
|
|
|
.help = "Virtual disk size",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_CLUSTER_SIZE,
|
|
|
|
.type = QEMU_OPT_SIZE,
|
|
|
|
.help = "Parallels image cluster size",
|
|
|
|
.def_value_str = stringify(DEFAULT_CLUSTER_SIZE),
|
|
|
|
},
|
|
|
|
{ /* end of list */ }
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-04-28 07:46:58 +00:00
|
|
|
|
2015-04-28 07:46:48 +00:00
|
|
|
static int64_t bat2sect(BDRVParallelsState *s, uint32_t idx)
|
|
|
|
{
|
2015-04-28 07:46:49 +00:00
|
|
|
return (uint64_t)le32_to_cpu(s->bat_bitmap[idx]) * s->off_multiplier;
|
2015-04-28 07:46:48 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:56 +00:00
|
|
|
static uint32_t bat_entry_off(uint32_t idx)
|
|
|
|
{
|
|
|
|
return sizeof(ParallelsHeader) + sizeof(uint32_t) * idx;
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:36 +00:00
|
|
|
static int64_t seek_to_sector(BDRVParallelsState *s, int64_t sector_num)
|
2007-07-31 23:28:53 +00:00
|
|
|
{
|
2009-11-07 14:10:01 +00:00
|
|
|
uint32_t index, offset;
|
2007-07-31 23:28:53 +00:00
|
|
|
|
|
|
|
index = sector_num / s->tracks;
|
|
|
|
offset = sector_num % s->tracks;
|
|
|
|
|
2010-05-06 20:04:34 +00:00
|
|
|
/* not allocated */
|
2015-04-28 07:46:47 +00:00
|
|
|
if ((index >= s->bat_size) || (s->bat_bitmap[index] == 0)) {
|
2014-07-28 16:23:53 +00:00
|
|
|
return -1;
|
2015-04-28 07:46:47 +00:00
|
|
|
}
|
2015-04-28 07:46:48 +00:00
|
|
|
return bat2sect(s, index) + offset;
|
2007-07-31 23:28:53 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:37 +00:00
|
|
|
static int cluster_remainder(BDRVParallelsState *s, int64_t sector_num,
|
|
|
|
int nb_sectors)
|
|
|
|
{
|
|
|
|
int ret = s->tracks - sector_num % s->tracks;
|
|
|
|
return MIN(nb_sectors, ret);
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:55 +00:00
|
|
|
static int64_t block_status(BDRVParallelsState *s, int64_t sector_num,
|
|
|
|
int nb_sectors, int *pnum)
|
|
|
|
{
|
|
|
|
int64_t start_off = -2, prev_end_off = -2;
|
|
|
|
|
|
|
|
*pnum = 0;
|
|
|
|
while (nb_sectors > 0 || start_off == -2) {
|
|
|
|
int64_t offset = seek_to_sector(s, sector_num);
|
|
|
|
int to_end;
|
|
|
|
|
|
|
|
if (start_off == -2) {
|
|
|
|
start_off = offset;
|
|
|
|
prev_end_off = offset;
|
|
|
|
} else if (offset != prev_end_off) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
to_end = cluster_remainder(s, sector_num, nb_sectors);
|
|
|
|
nb_sectors -= to_end;
|
|
|
|
sector_num += to_end;
|
|
|
|
*pnum += to_end;
|
|
|
|
|
|
|
|
if (offset > 0) {
|
|
|
|
prev_end_off += to_end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return start_off;
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:47:00 +00:00
|
|
|
static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
int nb_sectors, int *pnum)
|
2015-04-28 07:46:42 +00:00
|
|
|
{
|
2018-01-12 09:01:22 +00:00
|
|
|
int ret;
|
2015-04-28 07:46:42 +00:00
|
|
|
BDRVParallelsState *s = bs->opaque;
|
2017-08-04 15:10:12 +00:00
|
|
|
int64_t pos, space, idx, to_allocate, i, len;
|
2015-04-28 07:46:42 +00:00
|
|
|
|
2015-04-28 07:47:00 +00:00
|
|
|
pos = block_status(s, sector_num, nb_sectors, pnum);
|
|
|
|
if (pos > 0) {
|
|
|
|
return pos;
|
|
|
|
}
|
2015-04-28 07:46:42 +00:00
|
|
|
|
2015-04-28 07:47:00 +00:00
|
|
|
idx = sector_num / s->tracks;
|
2016-05-31 16:35:51 +00:00
|
|
|
to_allocate = DIV_ROUND_UP(sector_num + *pnum, s->tracks) - idx;
|
2017-03-31 17:05:12 +00:00
|
|
|
|
|
|
|
/* This function is called only by parallels_co_writev(), which will never
|
|
|
|
* pass a sector_num at or beyond the end of the image (because the block
|
|
|
|
* layer never passes such a sector_num to that function). Therefore, idx
|
|
|
|
* is always below s->bat_size.
|
|
|
|
* block_status() will limit *pnum so that sector_num + *pnum will not
|
|
|
|
* exceed the image end. Therefore, idx + to_allocate cannot exceed
|
|
|
|
* s->bat_size.
|
|
|
|
* Note that s->bat_size is an unsigned int, therefore idx + to_allocate
|
|
|
|
* will always fit into a uint32_t. */
|
|
|
|
assert(idx < s->bat_size && idx + to_allocate <= s->bat_size);
|
|
|
|
|
2015-04-28 07:47:00 +00:00
|
|
|
space = to_allocate * s->tracks;
|
2017-08-04 15:10:12 +00:00
|
|
|
len = bdrv_getlength(bs->file->bs);
|
|
|
|
if (len < 0) {
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
if (s->data_end + space > (len >> BDRV_SECTOR_BITS)) {
|
2015-04-28 07:47:00 +00:00
|
|
|
space += s->prealloc_size;
|
2015-04-28 07:46:59 +00:00
|
|
|
if (s->prealloc_mode == PRL_PREALLOC_MODE_FALLOCATE) {
|
2016-06-16 13:13:15 +00:00
|
|
|
ret = bdrv_pwrite_zeroes(bs->file,
|
2016-06-01 21:10:04 +00:00
|
|
|
s->data_end << BDRV_SECTOR_BITS,
|
|
|
|
space << BDRV_SECTOR_BITS, 0);
|
2015-04-28 07:46:59 +00:00
|
|
|
} else {
|
2017-02-16 17:39:03 +00:00
|
|
|
ret = bdrv_truncate(bs->file,
|
2017-03-28 20:51:27 +00:00
|
|
|
(s->data_end + space) << BDRV_SECTOR_BITS,
|
2017-06-13 20:20:53 +00:00
|
|
|
PREALLOC_MODE_OFF, NULL);
|
2015-04-28 07:46:59 +00:00
|
|
|
}
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
2015-04-28 07:46:42 +00:00
|
|
|
}
|
|
|
|
|
2018-01-12 09:01:22 +00:00
|
|
|
/* Try to read from backing to fill empty clusters
|
|
|
|
* FIXME: 1. previous write_zeroes may be redundant
|
|
|
|
* 2. most of data we read from backing will be rewritten by
|
|
|
|
* parallels_co_writev. On aligned-to-cluster write we do not need
|
|
|
|
* this read at all.
|
|
|
|
* 3. it would be good to combine write of data from backing and new
|
|
|
|
* data into one write call */
|
|
|
|
if (bs->backing) {
|
|
|
|
int64_t nb_cow_sectors = to_allocate * s->tracks;
|
|
|
|
int64_t nb_cow_bytes = nb_cow_sectors << BDRV_SECTOR_BITS;
|
|
|
|
QEMUIOVector qiov;
|
|
|
|
struct iovec iov = {
|
|
|
|
.iov_len = nb_cow_bytes,
|
|
|
|
.iov_base = qemu_blockalign(bs, nb_cow_bytes)
|
|
|
|
};
|
|
|
|
qemu_iovec_init_external(&qiov, &iov, 1);
|
|
|
|
|
|
|
|
ret = bdrv_co_readv(bs->backing, idx * s->tracks, nb_cow_sectors,
|
|
|
|
&qiov);
|
|
|
|
if (ret < 0) {
|
|
|
|
qemu_vfree(iov.iov_base);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = bdrv_co_writev(bs->file, s->data_end, nb_cow_sectors, &qiov);
|
|
|
|
qemu_vfree(iov.iov_base);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:47:00 +00:00
|
|
|
for (i = 0; i < to_allocate; i++) {
|
|
|
|
s->bat_bitmap[idx + i] = cpu_to_le32(s->data_end / s->off_multiplier);
|
|
|
|
s->data_end += s->tracks;
|
|
|
|
bitmap_set(s->bat_dirty_bmap,
|
2015-11-17 17:02:58 +00:00
|
|
|
bat_entry_off(idx + i) / s->bat_dirty_block, 1);
|
2015-04-28 07:47:00 +00:00
|
|
|
}
|
2015-04-28 07:46:57 +00:00
|
|
|
|
2015-04-28 07:47:00 +00:00
|
|
|
return bat2sect(s, idx) + sector_num % s->tracks;
|
2015-04-28 07:46:42 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:57 +00:00
|
|
|
|
|
|
|
static coroutine_fn int parallels_co_flush_to_os(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVParallelsState *s = bs->opaque;
|
|
|
|
unsigned long size = DIV_ROUND_UP(s->header_size, s->bat_dirty_block);
|
|
|
|
unsigned long bit;
|
|
|
|
|
|
|
|
qemu_co_mutex_lock(&s->lock);
|
|
|
|
|
|
|
|
bit = find_first_bit(s->bat_dirty_bmap, size);
|
|
|
|
while (bit < size) {
|
|
|
|
uint32_t off = bit * s->bat_dirty_block;
|
|
|
|
uint32_t to_write = s->bat_dirty_block;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (off + to_write > s->header_size) {
|
|
|
|
to_write = s->header_size - off;
|
|
|
|
}
|
2016-06-20 18:09:15 +00:00
|
|
|
ret = bdrv_pwrite(bs->file, off, (uint8_t *)s->header + off,
|
2015-06-16 12:19:22 +00:00
|
|
|
to_write);
|
2015-04-28 07:46:57 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
bit = find_next_bit(s->bat_dirty_bmap, size, bit + 1);
|
|
|
|
}
|
|
|
|
bitmap_zero(s->bat_dirty_bmap, size);
|
|
|
|
|
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-13 20:26:50 +00:00
|
|
|
static int coroutine_fn parallels_co_block_status(BlockDriverState *bs,
|
|
|
|
bool want_zero,
|
|
|
|
int64_t offset,
|
|
|
|
int64_t bytes,
|
|
|
|
int64_t *pnum,
|
|
|
|
int64_t *map,
|
|
|
|
BlockDriverState **file)
|
2015-04-28 07:46:38 +00:00
|
|
|
{
|
|
|
|
BDRVParallelsState *s = bs->opaque;
|
2018-02-13 20:26:50 +00:00
|
|
|
int count;
|
2015-04-28 07:46:38 +00:00
|
|
|
|
2018-02-13 20:26:50 +00:00
|
|
|
assert(QEMU_IS_ALIGNED(offset | bytes, BDRV_SECTOR_SIZE));
|
2015-04-28 07:46:38 +00:00
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2018-02-13 20:26:50 +00:00
|
|
|
offset = block_status(s, offset >> BDRV_SECTOR_BITS,
|
|
|
|
bytes >> BDRV_SECTOR_BITS, &count);
|
2015-04-28 07:46:38 +00:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
|
2018-02-13 20:26:50 +00:00
|
|
|
*pnum = count * BDRV_SECTOR_SIZE;
|
2015-04-28 07:46:38 +00:00
|
|
|
if (offset < 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-02-13 20:26:50 +00:00
|
|
|
*map = offset * BDRV_SECTOR_SIZE;
|
2016-01-26 03:58:53 +00:00
|
|
|
*file = bs->file->bs;
|
2018-02-13 20:26:50 +00:00
|
|
|
return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
|
2015-04-28 07:46:38 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:42 +00:00
|
|
|
static coroutine_fn int parallels_co_writev(BlockDriverState *bs,
|
2018-04-24 22:01:57 +00:00
|
|
|
int64_t sector_num, int nb_sectors,
|
|
|
|
QEMUIOVector *qiov, int flags)
|
2015-04-28 07:46:42 +00:00
|
|
|
{
|
|
|
|
BDRVParallelsState *s = bs->opaque;
|
|
|
|
uint64_t bytes_done = 0;
|
|
|
|
QEMUIOVector hd_qiov;
|
|
|
|
int ret = 0;
|
|
|
|
|
2018-04-24 22:01:57 +00:00
|
|
|
assert(!flags);
|
2015-04-28 07:46:42 +00:00
|
|
|
qemu_iovec_init(&hd_qiov, qiov->niov);
|
|
|
|
|
|
|
|
while (nb_sectors > 0) {
|
|
|
|
int64_t position;
|
|
|
|
int n, nbytes;
|
|
|
|
|
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2015-04-28 07:47:00 +00:00
|
|
|
position = allocate_clusters(bs, sector_num, nb_sectors, &n);
|
2015-04-28 07:46:42 +00:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
if (position < 0) {
|
|
|
|
ret = (int)position;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
nbytes = n << BDRV_SECTOR_BITS;
|
|
|
|
|
|
|
|
qemu_iovec_reset(&hd_qiov);
|
|
|
|
qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes);
|
|
|
|
|
2016-05-24 15:21:22 +00:00
|
|
|
ret = bdrv_co_writev(bs->file, position, n, &hd_qiov);
|
2015-04-28 07:46:42 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
nb_sectors -= n;
|
|
|
|
sector_num += n;
|
|
|
|
bytes_done += nbytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_iovec_destroy(&hd_qiov);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:39 +00:00
|
|
|
static coroutine_fn int parallels_co_readv(BlockDriverState *bs,
|
|
|
|
int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
|
2007-07-31 23:28:53 +00:00
|
|
|
{
|
2015-04-28 07:46:36 +00:00
|
|
|
BDRVParallelsState *s = bs->opaque;
|
2015-04-28 07:46:39 +00:00
|
|
|
uint64_t bytes_done = 0;
|
|
|
|
QEMUIOVector hd_qiov;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
qemu_iovec_init(&hd_qiov, qiov->niov);
|
2015-04-28 07:46:36 +00:00
|
|
|
|
2007-07-31 23:28:53 +00:00
|
|
|
while (nb_sectors > 0) {
|
2015-04-28 07:46:39 +00:00
|
|
|
int64_t position;
|
|
|
|
int n, nbytes;
|
|
|
|
|
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2015-04-28 07:46:55 +00:00
|
|
|
position = block_status(s, sector_num, nb_sectors, &n);
|
2015-04-28 07:46:39 +00:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
|
|
|
|
nbytes = n << BDRV_SECTOR_BITS;
|
|
|
|
|
2018-01-12 09:01:22 +00:00
|
|
|
qemu_iovec_reset(&hd_qiov);
|
|
|
|
qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes);
|
|
|
|
|
2015-04-28 07:46:39 +00:00
|
|
|
if (position < 0) {
|
2018-01-12 09:01:22 +00:00
|
|
|
if (bs->backing) {
|
|
|
|
ret = bdrv_co_readv(bs->backing, sector_num, n, &hd_qiov);
|
|
|
|
if (ret < 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
qemu_iovec_memset(&hd_qiov, 0, 0, nbytes);
|
|
|
|
}
|
2015-04-28 07:46:39 +00:00
|
|
|
} else {
|
2016-05-24 15:21:22 +00:00
|
|
|
ret = bdrv_co_readv(bs->file, position, n, &hd_qiov);
|
2015-04-28 07:46:36 +00:00
|
|
|
if (ret < 0) {
|
2015-04-28 07:46:39 +00:00
|
|
|
break;
|
2015-04-28 07:46:36 +00:00
|
|
|
}
|
2010-05-06 20:04:34 +00:00
|
|
|
}
|
2015-04-28 07:46:39 +00:00
|
|
|
|
2015-04-28 07:46:37 +00:00
|
|
|
nb_sectors -= n;
|
|
|
|
sector_num += n;
|
2015-04-28 07:46:39 +00:00
|
|
|
bytes_done += nbytes;
|
2007-07-31 23:28:53 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:39 +00:00
|
|
|
qemu_iovec_destroy(&hd_qiov);
|
2011-10-20 11:16:22 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:52 +00:00
|
|
|
|
2018-03-01 16:36:19 +00:00
|
|
|
static int coroutine_fn parallels_co_check(BlockDriverState *bs,
|
|
|
|
BdrvCheckResult *res,
|
|
|
|
BdrvCheckMode fix)
|
2015-04-28 07:46:52 +00:00
|
|
|
{
|
|
|
|
BDRVParallelsState *s = bs->opaque;
|
|
|
|
int64_t size, prev_off, high_off;
|
|
|
|
int ret;
|
|
|
|
uint32_t i;
|
|
|
|
bool flush_bat = false;
|
|
|
|
int cluster_size = s->tracks << BDRV_SECTOR_BITS;
|
|
|
|
|
2015-06-16 12:19:22 +00:00
|
|
|
size = bdrv_getlength(bs->file->bs);
|
2015-04-28 07:46:52 +00:00
|
|
|
if (size < 0) {
|
|
|
|
res->check_errors++;
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2018-03-01 16:36:19 +00:00
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2015-04-28 07:46:53 +00:00
|
|
|
if (s->header_unclean) {
|
|
|
|
fprintf(stderr, "%s image was not closed correctly\n",
|
|
|
|
fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR");
|
|
|
|
res->corruptions++;
|
|
|
|
if (fix & BDRV_FIX_ERRORS) {
|
|
|
|
/* parallels_close will do the job right */
|
|
|
|
res->corruptions_fixed++;
|
|
|
|
s->header_unclean = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:52 +00:00
|
|
|
res->bfi.total_clusters = s->bat_size;
|
|
|
|
res->bfi.compressed_clusters = 0; /* compression is not supported */
|
|
|
|
|
|
|
|
high_off = 0;
|
|
|
|
prev_off = 0;
|
|
|
|
for (i = 0; i < s->bat_size; i++) {
|
|
|
|
int64_t off = bat2sect(s, i) << BDRV_SECTOR_BITS;
|
|
|
|
if (off == 0) {
|
|
|
|
prev_off = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* cluster outside the image */
|
|
|
|
if (off > size) {
|
|
|
|
fprintf(stderr, "%s cluster %u is outside image\n",
|
|
|
|
fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR", i);
|
|
|
|
res->corruptions++;
|
|
|
|
if (fix & BDRV_FIX_ERRORS) {
|
|
|
|
prev_off = 0;
|
|
|
|
s->bat_bitmap[i] = 0;
|
|
|
|
res->corruptions_fixed++;
|
|
|
|
flush_bat = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
res->bfi.allocated_clusters++;
|
|
|
|
if (off > high_off) {
|
|
|
|
high_off = off;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prev_off != 0 && (prev_off + cluster_size) != off) {
|
|
|
|
res->bfi.fragmented_clusters++;
|
|
|
|
}
|
|
|
|
prev_off = off;
|
|
|
|
}
|
|
|
|
|
2018-03-01 16:36:19 +00:00
|
|
|
ret = 0;
|
2015-04-28 07:46:52 +00:00
|
|
|
if (flush_bat) {
|
2016-06-20 18:09:15 +00:00
|
|
|
ret = bdrv_pwrite_sync(bs->file, 0, s->header, s->header_size);
|
2015-04-28 07:46:52 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
res->check_errors++;
|
2018-03-01 16:36:19 +00:00
|
|
|
goto out;
|
2015-04-28 07:46:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
res->image_end_offset = high_off + cluster_size;
|
|
|
|
if (size > res->image_end_offset) {
|
|
|
|
int64_t count;
|
|
|
|
count = DIV_ROUND_UP(size - res->image_end_offset, cluster_size);
|
|
|
|
fprintf(stderr, "%s space leaked at the end of the image %" PRId64 "\n",
|
|
|
|
fix & BDRV_FIX_LEAKS ? "Repairing" : "ERROR",
|
|
|
|
size - res->image_end_offset);
|
|
|
|
res->leaks += count;
|
|
|
|
if (fix & BDRV_FIX_LEAKS) {
|
2017-03-28 20:51:27 +00:00
|
|
|
Error *local_err = NULL;
|
2017-06-13 20:20:53 +00:00
|
|
|
ret = bdrv_truncate(bs->file, res->image_end_offset,
|
|
|
|
PREALLOC_MODE_OFF, &local_err);
|
2015-04-28 07:46:52 +00:00
|
|
|
if (ret < 0) {
|
2017-03-28 20:51:27 +00:00
|
|
|
error_report_err(local_err);
|
2015-04-28 07:46:52 +00:00
|
|
|
res->check_errors++;
|
2018-03-01 16:36:19 +00:00
|
|
|
goto out;
|
2015-04-28 07:46:52 +00:00
|
|
|
}
|
|
|
|
res->leaks_fixed += count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-01 16:36:19 +00:00
|
|
|
out:
|
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
return ret;
|
2015-04-28 07:46:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-03-06 11:13:58 +00:00
|
|
|
static int coroutine_fn parallels_co_create(BlockdevCreateOptions* opts,
|
|
|
|
Error **errp)
|
2015-04-28 07:46:44 +00:00
|
|
|
{
|
2018-03-06 11:13:58 +00:00
|
|
|
BlockdevCreateOptionsParallels *parallels_opts;
|
|
|
|
BlockDriverState *bs;
|
|
|
|
BlockBackend *blk;
|
2015-04-28 07:46:44 +00:00
|
|
|
int64_t total_size, cl_size;
|
2015-04-28 07:46:47 +00:00
|
|
|
uint32_t bat_entries, bat_sectors;
|
2015-04-28 07:46:44 +00:00
|
|
|
ParallelsHeader header;
|
2018-03-06 11:13:58 +00:00
|
|
|
uint8_t tmp[BDRV_SECTOR_SIZE];
|
2015-04-28 07:46:44 +00:00
|
|
|
int ret;
|
|
|
|
|
2018-03-06 11:13:58 +00:00
|
|
|
assert(opts->driver == BLOCKDEV_DRIVER_PARALLELS);
|
|
|
|
parallels_opts = &opts->u.parallels;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
|
|
|
total_size = parallels_opts->size;
|
|
|
|
|
|
|
|
if (parallels_opts->has_cluster_size) {
|
|
|
|
cl_size = parallels_opts->cluster_size;
|
|
|
|
} else {
|
|
|
|
cl_size = DEFAULT_CLUSTER_SIZE;
|
|
|
|
}
|
|
|
|
|
2018-03-20 16:07:58 +00:00
|
|
|
/* XXX What is the real limit here? This is an insanely large maximum. */
|
|
|
|
if (cl_size >= INT64_MAX / MAX_PARALLELS_IMAGE_FACTOR) {
|
|
|
|
error_setg(errp, "Cluster size is too large");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2016-07-27 17:08:20 +00:00
|
|
|
if (total_size >= MAX_PARALLELS_IMAGE_FACTOR * cl_size) {
|
2018-03-06 11:13:58 +00:00
|
|
|
error_setg(errp, "Image size is too large for this cluster size");
|
2016-07-27 17:08:20 +00:00
|
|
|
return -E2BIG;
|
|
|
|
}
|
2015-04-28 07:46:44 +00:00
|
|
|
|
2018-03-06 11:13:58 +00:00
|
|
|
if (!QEMU_IS_ALIGNED(total_size, BDRV_SECTOR_SIZE)) {
|
|
|
|
error_setg(errp, "Image size must be a multiple of 512 bytes");
|
|
|
|
return -EINVAL;
|
2015-04-28 07:46:44 +00:00
|
|
|
}
|
|
|
|
|
2018-03-06 11:13:58 +00:00
|
|
|
if (!QEMU_IS_ALIGNED(cl_size, BDRV_SECTOR_SIZE)) {
|
|
|
|
error_setg(errp, "Cluster size must be a multiple of 512 bytes");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create BlockBackend to write to the image */
|
|
|
|
bs = bdrv_open_blockdev_ref(parallels_opts->file, errp);
|
|
|
|
if (bs == NULL) {
|
2016-03-08 14:57:05 +00:00
|
|
|
return -EIO;
|
2015-04-28 07:46:44 +00:00
|
|
|
}
|
2016-03-08 14:57:05 +00:00
|
|
|
|
2018-03-06 11:13:58 +00:00
|
|
|
blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
|
|
|
|
ret = blk_insert_bs(blk, bs, errp);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
blk_set_allow_write_beyond_eof(blk, true);
|
2016-03-08 14:57:05 +00:00
|
|
|
|
2018-03-06 11:13:58 +00:00
|
|
|
/* Create image format */
|
|
|
|
ret = blk_truncate(blk, 0, PREALLOC_MODE_OFF, errp);
|
2015-04-28 07:46:44 +00:00
|
|
|
if (ret < 0) {
|
2018-03-06 11:13:58 +00:00
|
|
|
goto out;
|
2015-04-28 07:46:44 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:47 +00:00
|
|
|
bat_entries = DIV_ROUND_UP(total_size, cl_size);
|
2015-04-28 07:46:56 +00:00
|
|
|
bat_sectors = DIV_ROUND_UP(bat_entry_off(bat_entries), cl_size);
|
2015-04-28 07:46:47 +00:00
|
|
|
bat_sectors = (bat_sectors * cl_size) >> BDRV_SECTOR_BITS;
|
2015-04-28 07:46:44 +00:00
|
|
|
|
|
|
|
memset(&header, 0, sizeof(header));
|
|
|
|
memcpy(header.magic, HEADER_MAGIC2, sizeof(header.magic));
|
|
|
|
header.version = cpu_to_le32(HEADER_VERSION);
|
|
|
|
/* don't care much about geometry, it is not used on image level */
|
2018-01-12 09:01:21 +00:00
|
|
|
header.heads = cpu_to_le32(HEADS_NUMBER);
|
|
|
|
header.cylinders = cpu_to_le32(total_size / BDRV_SECTOR_SIZE
|
|
|
|
/ HEADS_NUMBER / SEC_IN_CYL);
|
2015-04-28 07:46:44 +00:00
|
|
|
header.tracks = cpu_to_le32(cl_size >> BDRV_SECTOR_BITS);
|
2015-04-28 07:46:47 +00:00
|
|
|
header.bat_entries = cpu_to_le32(bat_entries);
|
2015-04-28 07:46:44 +00:00
|
|
|
header.nb_sectors = cpu_to_le64(DIV_ROUND_UP(total_size, BDRV_SECTOR_SIZE));
|
2015-04-28 07:46:47 +00:00
|
|
|
header.data_off = cpu_to_le32(bat_sectors);
|
2015-04-28 07:46:44 +00:00
|
|
|
|
|
|
|
/* write all the data */
|
|
|
|
memset(tmp, 0, sizeof(tmp));
|
|
|
|
memcpy(tmp, &header, sizeof(header));
|
|
|
|
|
2018-03-06 11:13:58 +00:00
|
|
|
ret = blk_pwrite(blk, 0, tmp, BDRV_SECTOR_SIZE, 0);
|
2015-04-28 07:46:44 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
goto exit;
|
|
|
|
}
|
2018-03-06 11:13:58 +00:00
|
|
|
ret = blk_pwrite_zeroes(blk, BDRV_SECTOR_SIZE,
|
2016-05-24 22:25:20 +00:00
|
|
|
(bat_sectors - 1) << BDRV_SECTOR_BITS, 0);
|
2015-04-28 07:46:44 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2018-03-06 11:13:58 +00:00
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
blk_unref(blk);
|
|
|
|
bdrv_unref(bs);
|
2015-04-28 07:46:44 +00:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
exit:
|
|
|
|
error_setg_errno(errp, -ret, "Failed to create Parallels image");
|
2018-03-06 11:13:58 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coroutine_fn parallels_co_create_opts(const char *filename,
|
|
|
|
QemuOpts *opts,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
BlockdevCreateOptions *create_options = NULL;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
BlockDriverState *bs = NULL;
|
2018-06-14 19:14:32 +00:00
|
|
|
QDict *qdict;
|
2018-03-06 11:13:58 +00:00
|
|
|
QObject *qobj;
|
|
|
|
Visitor *v;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
static const QDictRenames opt_renames[] = {
|
|
|
|
{ BLOCK_OPT_CLUSTER_SIZE, "cluster-size" },
|
|
|
|
{ NULL, NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Parse options and convert legacy syntax */
|
|
|
|
qdict = qemu_opts_to_qdict_filtered(opts, NULL, ¶llels_create_opts,
|
|
|
|
true);
|
|
|
|
|
|
|
|
if (!qdict_rename_keys(qdict, opt_renames, errp)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create and open the file (protocol layer) */
|
|
|
|
ret = bdrv_create_file(filename, opts, &local_err);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
bs = bdrv_open(filename, NULL, NULL,
|
|
|
|
BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
|
|
|
|
if (bs == NULL) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now get the QAPI type BlockdevCreateOptions */
|
|
|
|
qdict_put_str(qdict, "driver", "parallels");
|
|
|
|
qdict_put_str(qdict, "file", bs->node_name);
|
|
|
|
|
block: Fix -blockdev for certain non-string scalars
Configuration flows through the block subsystem in a rather peculiar
way. Configuration made with -drive enters it as QemuOpts.
Configuration made with -blockdev / blockdev-add enters it as QAPI
type BlockdevOptions. The block subsystem uses QDict, QemuOpts and
QAPI types internally. The precise flow is next to impossible to
explain (I tried for this commit message, but gave up after wasting
several hours). What I can explain is a flaw in the BlockDriver
interface that leads to this bug:
$ qemu-system-x86_64 -blockdev node-name=n1,driver=nfs,server.type=inet,server.host=localhost,path=/foo/bar,user=1234
qemu-system-x86_64: -blockdev node-name=n1,driver=nfs,server.type=inet,server.host=localhost,path=/foo/bar,user=1234: Internal error: parameter user invalid
QMP blockdev-add is broken the same way.
Here's what happens. The block layer passes configuration represented
as flat QDict (with dotted keys) to BlockDriver methods
.bdrv_file_open(). The QDict's members are typed according to the
QAPI schema.
nfs_file_open() converts it to QAPI type BlockdevOptionsNfs, with
qdict_crumple() and a qobject input visitor.
This visitor comes in two flavors. The plain flavor requires scalars
to be typed according to the QAPI schema. That's the case here. The
keyval flavor requires string scalars. That's not the case here.
nfs_file_open() uses the latter, and promptly falls apart for members
@user, @group, @tcp-syn-count, @readahead-size, @page-cache-size,
@debug.
Switching to the plain flavor would fix -blockdev, but break -drive,
because there the scalars arrive in nfs_file_open() as strings.
The proper fix would be to replace the QDict by QAPI type
BlockdevOptions in the BlockDriver interface. Sadly, that's beyond my
reach right now.
Next best would be to fix the block layer to always pass correctly
typed QDicts to the BlockDriver methods. Also beyond my reach.
What I can do is throw another hack onto the pile: have
nfs_file_open() convert all members to string, so use of the keyval
flavor actually works, by replacing qdict_crumple() by new function
qdict_crumple_for_keyval_qiv().
The pattern "pass result of qdict_crumple() to
qobject_input_visitor_new_keyval()" occurs several times more:
* qemu_rbd_open()
Same issue as nfs_file_open(), but since BlockdevOptionsRbd has only
string members, its only a latent bug. Fix it anyway.
* parallels_co_create_opts(), qcow_co_create_opts(),
qcow2_co_create_opts(), bdrv_qed_co_create_opts(),
sd_co_create_opts(), vhdx_co_create_opts(), vpc_co_create_opts()
These work, because they create the QDict with
qemu_opts_to_qdict_filtered(), which creates only string scalars.
The function sports a TODO comment asking for better typing; that's
going to be fun. Use qdict_crumple_for_keyval_qiv() to be safe.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-06-14 19:14:30 +00:00
|
|
|
qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
|
2018-06-14 19:14:32 +00:00
|
|
|
if (!qobj) {
|
2018-03-06 11:13:58 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2018-06-14 19:14:32 +00:00
|
|
|
v = qobject_input_visitor_new_keyval(qobj);
|
|
|
|
qobject_unref(qobj);
|
2018-03-06 11:13:58 +00:00
|
|
|
visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
|
|
|
|
visit_free(v);
|
|
|
|
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Silently round up sizes */
|
|
|
|
create_options->u.parallels.size =
|
|
|
|
ROUND_UP(create_options->u.parallels.size, BDRV_SECTOR_SIZE);
|
|
|
|
create_options->u.parallels.cluster_size =
|
|
|
|
ROUND_UP(create_options->u.parallels.cluster_size, BDRV_SECTOR_SIZE);
|
|
|
|
|
|
|
|
/* Create the Parallels image (format layer) */
|
|
|
|
ret = parallels_co_create(create_options, errp);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
done:
|
2018-04-19 15:01:43 +00:00
|
|
|
qobject_unref(qdict);
|
2018-03-06 11:13:58 +00:00
|
|
|
bdrv_unref(bs);
|
|
|
|
qapi_free_BlockdevCreateOptions(create_options);
|
|
|
|
return ret;
|
2015-04-28 07:46:44 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:51 +00:00
|
|
|
|
|
|
|
static int parallels_probe(const uint8_t *buf, int buf_size,
|
|
|
|
const char *filename)
|
|
|
|
{
|
|
|
|
const ParallelsHeader *ph = (const void *)buf;
|
|
|
|
|
|
|
|
if (buf_size < sizeof(ParallelsHeader)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((!memcmp(ph->magic, HEADER_MAGIC, 16) ||
|
|
|
|
!memcmp(ph->magic, HEADER_MAGIC2, 16)) &&
|
|
|
|
(le32_to_cpu(ph->version) == HEADER_VERSION)) {
|
|
|
|
return 100;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:53 +00:00
|
|
|
static int parallels_update_header(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVParallelsState *s = bs->opaque;
|
2015-06-16 12:19:22 +00:00
|
|
|
unsigned size = MAX(bdrv_opt_mem_align(bs->file->bs),
|
|
|
|
sizeof(ParallelsHeader));
|
2015-04-28 07:46:53 +00:00
|
|
|
|
|
|
|
if (size > s->header_size) {
|
|
|
|
size = s->header_size;
|
|
|
|
}
|
2016-06-20 18:09:15 +00:00
|
|
|
return bdrv_pwrite_sync(bs->file, 0, s->header, size);
|
2015-04-28 07:46:53 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:51 +00:00
|
|
|
static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
BDRVParallelsState *s = bs->opaque;
|
|
|
|
ParallelsHeader ph;
|
2015-04-28 07:46:59 +00:00
|
|
|
int ret, size, i;
|
2015-04-28 07:46:58 +00:00
|
|
|
QemuOpts *opts = NULL;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
char *buf;
|
2015-04-28 07:46:51 +00:00
|
|
|
|
2016-12-16 17:52:37 +00:00
|
|
|
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
|
|
|
|
false, errp);
|
|
|
|
if (!bs->file) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-06-20 16:24:02 +00:00
|
|
|
ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph));
|
2015-04-28 07:46:51 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
bs->total_sectors = le64_to_cpu(ph.nb_sectors);
|
|
|
|
|
|
|
|
if (le32_to_cpu(ph.version) != HEADER_VERSION) {
|
|
|
|
goto fail_format;
|
|
|
|
}
|
|
|
|
if (!memcmp(ph.magic, HEADER_MAGIC, 16)) {
|
|
|
|
s->off_multiplier = 1;
|
|
|
|
bs->total_sectors = 0xffffffff & bs->total_sectors;
|
|
|
|
} else if (!memcmp(ph.magic, HEADER_MAGIC2, 16)) {
|
|
|
|
s->off_multiplier = le32_to_cpu(ph.tracks);
|
|
|
|
} else {
|
|
|
|
goto fail_format;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->tracks = le32_to_cpu(ph.tracks);
|
|
|
|
if (s->tracks == 0) {
|
|
|
|
error_setg(errp, "Invalid image: Zero sectors per track");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (s->tracks > INT32_MAX/513) {
|
|
|
|
error_setg(errp, "Invalid image: Too big cluster");
|
|
|
|
ret = -EFBIG;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->bat_size = le32_to_cpu(ph.bat_entries);
|
|
|
|
if (s->bat_size > INT_MAX / sizeof(uint32_t)) {
|
|
|
|
error_setg(errp, "Catalog too large");
|
|
|
|
ret = -EFBIG;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:56 +00:00
|
|
|
size = bat_entry_off(s->bat_size);
|
2015-06-16 12:19:22 +00:00
|
|
|
s->header_size = ROUND_UP(size, bdrv_opt_mem_align(bs->file->bs));
|
|
|
|
s->header = qemu_try_blockalign(bs->file->bs, s->header_size);
|
2015-04-28 07:46:51 +00:00
|
|
|
if (s->header == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
2015-04-28 07:46:59 +00:00
|
|
|
s->data_end = le32_to_cpu(ph.data_off);
|
|
|
|
if (s->data_end == 0) {
|
|
|
|
s->data_end = ROUND_UP(bat_entry_off(s->bat_size), BDRV_SECTOR_SIZE);
|
|
|
|
}
|
|
|
|
if (s->data_end < s->header_size) {
|
2015-04-28 07:46:51 +00:00
|
|
|
/* there is not enough unused space to fit to block align between BAT
|
|
|
|
and actual data. We can't avoid read-modify-write... */
|
|
|
|
s->header_size = size;
|
|
|
|
}
|
|
|
|
|
2016-06-20 16:24:02 +00:00
|
|
|
ret = bdrv_pread(bs->file, 0, s->header, s->header_size);
|
2015-04-28 07:46:51 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
s->bat_bitmap = (uint32_t *)(s->header + 1);
|
|
|
|
|
2015-04-28 07:46:59 +00:00
|
|
|
for (i = 0; i < s->bat_size; i++) {
|
|
|
|
int64_t off = bat2sect(s, i);
|
|
|
|
if (off >= s->data_end) {
|
|
|
|
s->data_end = off + s->tracks;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:53 +00:00
|
|
|
if (le32_to_cpu(ph.inuse) == HEADER_INUSE_MAGIC) {
|
|
|
|
/* Image was not closed correctly. The check is mandatory */
|
|
|
|
s->header_unclean = true;
|
|
|
|
if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
|
|
|
|
error_setg(errp, "parallels: Image was not closed correctly; "
|
|
|
|
"cannot be opened read/write");
|
|
|
|
ret = -EACCES;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:58 +00:00
|
|
|
opts = qemu_opts_create(¶llels_runtime_opts, NULL, 0, &local_err);
|
|
|
|
if (local_err != NULL) {
|
|
|
|
goto fail_options;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_opts_absorb_qdict(opts, options, &local_err);
|
|
|
|
if (local_err != NULL) {
|
|
|
|
goto fail_options;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->prealloc_size =
|
|
|
|
qemu_opt_get_size_del(opts, PARALLELS_OPT_PREALLOC_SIZE, 0);
|
|
|
|
s->prealloc_size = MAX(s->tracks, s->prealloc_size >> BDRV_SECTOR_BITS);
|
|
|
|
buf = qemu_opt_get_del(opts, PARALLELS_OPT_PREALLOC_MODE);
|
2017-08-24 08:46:10 +00:00
|
|
|
s->prealloc_mode = qapi_enum_parse(&prealloc_mode_lookup, buf,
|
2017-08-24 08:45:57 +00:00
|
|
|
PRL_PREALLOC_MODE_FALLOCATE,
|
|
|
|
&local_err);
|
2015-04-28 07:46:58 +00:00
|
|
|
g_free(buf);
|
|
|
|
if (local_err != NULL) {
|
|
|
|
goto fail_options;
|
|
|
|
}
|
2017-03-27 14:38:08 +00:00
|
|
|
|
2017-08-04 15:10:13 +00:00
|
|
|
if (!bdrv_has_zero_init(bs->file->bs)) {
|
2015-04-28 07:46:58 +00:00
|
|
|
s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
|
|
|
|
}
|
|
|
|
|
2017-11-07 13:10:34 +00:00
|
|
|
if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_INACTIVE)) {
|
2015-04-28 07:46:53 +00:00
|
|
|
s->header->inuse = cpu_to_le32(HEADER_INUSE_MAGIC);
|
|
|
|
ret = parallels_update_header(bs);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:57 +00:00
|
|
|
s->bat_dirty_block = 4 * getpagesize();
|
|
|
|
s->bat_dirty_bmap =
|
|
|
|
bitmap_new(DIV_ROUND_UP(s->header_size, s->bat_dirty_block));
|
|
|
|
|
2017-11-07 13:10:35 +00:00
|
|
|
/* Disable migration until bdrv_invalidate_cache method is added */
|
|
|
|
error_setg(&s->migration_blocker, "The Parallels format used by node '%s' "
|
|
|
|
"does not support live migration",
|
|
|
|
bdrv_get_device_or_node_name(bs));
|
|
|
|
ret = migrate_add_blocker(s->migration_blocker, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
error_free(s->migration_blocker);
|
|
|
|
goto fail;
|
|
|
|
}
|
2015-04-28 07:46:51 +00:00
|
|
|
qemu_co_mutex_init(&s->lock);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail_format:
|
|
|
|
error_setg(errp, "Image not in Parallels format");
|
|
|
|
ret = -EINVAL;
|
|
|
|
fail:
|
|
|
|
qemu_vfree(s->header);
|
|
|
|
return ret;
|
2015-04-28 07:46:58 +00:00
|
|
|
|
|
|
|
fail_options:
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
2015-04-28 07:46:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-07-31 23:28:53 +00:00
|
|
|
static void parallels_close(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVParallelsState *s = bs->opaque;
|
2015-04-28 07:46:53 +00:00
|
|
|
|
2017-11-07 13:10:34 +00:00
|
|
|
if ((bs->open_flags & BDRV_O_RDWR) && !(bs->open_flags & BDRV_O_INACTIVE)) {
|
2015-04-28 07:46:53 +00:00
|
|
|
s->header->inuse = 0;
|
|
|
|
parallels_update_header(bs);
|
2017-06-13 20:20:53 +00:00
|
|
|
bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS,
|
|
|
|
PREALLOC_MODE_OFF, NULL);
|
2015-04-28 07:46:59 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 07:46:57 +00:00
|
|
|
g_free(s->bat_dirty_bmap);
|
2015-04-28 07:46:50 +00:00
|
|
|
qemu_vfree(s->header);
|
2017-11-07 13:10:35 +00:00
|
|
|
|
|
|
|
migrate_del_blocker(s->migration_blocker);
|
|
|
|
error_free(s->migration_blocker);
|
2007-07-31 23:28:53 +00:00
|
|
|
}
|
|
|
|
|
2009-05-09 22:03:42 +00:00
|
|
|
static BlockDriver bdrv_parallels = {
|
2009-03-07 22:00:29 +00:00
|
|
|
.format_name = "parallels",
|
|
|
|
.instance_size = sizeof(BDRVParallelsState),
|
|
|
|
.bdrv_probe = parallels_probe,
|
2010-05-06 20:04:50 +00:00
|
|
|
.bdrv_open = parallels_open,
|
2009-03-07 22:00:29 +00:00
|
|
|
.bdrv_close = parallels_close,
|
2016-12-19 15:36:02 +00:00
|
|
|
.bdrv_child_perm = bdrv_format_default_perms,
|
2018-02-13 20:26:50 +00:00
|
|
|
.bdrv_co_block_status = parallels_co_block_status,
|
2015-04-28 07:46:41 +00:00
|
|
|
.bdrv_has_zero_init = bdrv_has_zero_init_1,
|
2015-04-28 07:46:57 +00:00
|
|
|
.bdrv_co_flush_to_os = parallels_co_flush_to_os,
|
2015-04-28 07:46:39 +00:00
|
|
|
.bdrv_co_readv = parallels_co_readv,
|
2015-04-28 07:46:42 +00:00
|
|
|
.bdrv_co_writev = parallels_co_writev,
|
2018-01-12 09:01:22 +00:00
|
|
|
.supports_backing = true,
|
2018-03-06 11:13:58 +00:00
|
|
|
.bdrv_co_create = parallels_co_create,
|
2018-01-18 12:43:45 +00:00
|
|
|
.bdrv_co_create_opts = parallels_co_create_opts,
|
2018-03-01 16:36:19 +00:00
|
|
|
.bdrv_co_check = parallels_co_check,
|
2015-04-28 07:46:44 +00:00
|
|
|
.create_opts = ¶llels_create_opts,
|
2007-07-31 23:28:53 +00:00
|
|
|
};
|
2009-05-09 22:03:42 +00:00
|
|
|
|
|
|
|
static void bdrv_parallels_init(void)
|
|
|
|
{
|
|
|
|
bdrv_register(&bdrv_parallels);
|
|
|
|
}
|
|
|
|
|
|
|
|
block_init(bdrv_parallels_init);
|