falso
/
qemu-irix
mirror of https://github.com/n64decomp/qemu-irix.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

vmdk: convert error code to use errp 

Convert "fprintf(stderr,..." and standardize error messages:

Remove a few local_error's and use errp.

Remove "VMDK:" or "Vmdk:" prefixes in error message and fix to upper
case.

Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Fam Zheng 2013-10-11 15:43:22 +08:00 committed by Kevin Wolf
parent 2cdfb12332
commit 4823970bcb
2 changed files with 63 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
block/vmdk.c
View File

@ -331,8 +331,7 @@ static int vmdk_reopen_prepare(BDRVReopenState *state,
assert(state->bs != NULL); assert(state->bs != NULL);
if (queue == NULL) { if (queue == NULL) {
error_set(errp, ERROR_CLASS_GENERIC_ERROR, error_setg(errp, "No reopen queue for VMDK extents");
"No reopen queue for VMDK extents");
goto exit; goto exit;
} }
@ -391,22 +390,23 @@ static int vmdk_add_extent(BlockDriverState *bs,
int64_t l1_offset, int64_t l1_backup_offset, int64_t l1_offset, int64_t l1_backup_offset,
uint32_t l1_size, uint32_t l1_size,
int l2_size, uint64_t cluster_sectors, int l2_size, uint64_t cluster_sectors,
VmdkExtent **new_extent) VmdkExtent **new_extent,
Error **errp)
{ {
VmdkExtent *extent; VmdkExtent *extent;
BDRVVmdkState *s = bs->opaque; BDRVVmdkState *s = bs->opaque;
if (cluster_sectors > 0x200000) { if (cluster_sectors > 0x200000) {
/* 0x200000 * 512Bytes = 1GB for one cluster is unrealistic */ /* 0x200000 * 512Bytes = 1GB for one cluster is unrealistic */
error_report("invalid granularity, image may be corrupt"); error_setg(errp, "Invalid granularity, image may be corrupt");
return -EINVAL; return -EFBIG;
} }
if (l1_size > 512 * 1024 * 1024) { if (l1_size > 512 * 1024 * 1024) {
/* Although with big capacity and small l1_entry_sectors, we can get a /* Although with big capacity and small l1_entry_sectors, we can get a
* big l1_size, we don't want unbounded value to allocate the table. * big l1_size, we don't want unbounded value to allocate the table.
* Limit it to 512M, which is 16PB for default cluster and L2 table * Limit it to 512M, which is 16PB for default cluster and L2 table
* size */ * size */
error_report("L1 size too big"); error_setg(errp, "L1 size too big");
return -EFBIG; return -EFBIG;
} }
@ -438,7 +438,8 @@ static int vmdk_add_extent(BlockDriverState *bs,
return 0; return 0;
} }
static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent) static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent,
Error **errp)
{ {
int ret; int ret;
int l1_size, i; int l1_size, i;
@ -451,6 +452,9 @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent)
extent->l1_table, extent->l1_table,
l1_size); l1_size);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret,
"Could not read l1 table from extent '%s'",
extent->file->filename);
goto fail_l1; goto fail_l1;
} }
for (i = 0; i < extent->l1_size; i++) { for (i = 0; i < extent->l1_size; i++) {
@ -464,6 +468,9 @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent)
extent->l1_backup_table, extent->l1_backup_table,
l1_size); l1_size);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret,
"Could not read l1 backup table from extent '%s'",
extent->file->filename);
goto fail_l1b; goto fail_l1b;
} }
for (i = 0; i < extent->l1_size; i++) { for (i = 0; i < extent->l1_size; i++) {
@ -483,7 +490,7 @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent)
static int vmdk_open_vmfs_sparse(BlockDriverState *bs, static int vmdk_open_vmfs_sparse(BlockDriverState *bs,
BlockDriverState *file, BlockDriverState *file,
int flags) int flags, Error **errp)
{ {
int ret; int ret;
uint32_t magic; uint32_t magic;
@ -492,6 +499,9 @@ static int vmdk_open_vmfs_sparse(BlockDriverState *bs,
ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header)); ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret,
"Could not read header from file '%s'",
file->filename);
return ret; return ret;
} }
ret = vmdk_add_extent(bs, file, false, ret = vmdk_add_extent(bs, file, false,
@ -501,11 +511,12 @@ static int vmdk_open_vmfs_sparse(BlockDriverState *bs,
le32_to_cpu(header.l1dir_size), le32_to_cpu(header.l1dir_size),
4096, 4096,
le32_to_cpu(header.granularity), le32_to_cpu(header.granularity),
&extent); &extent,
errp);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = vmdk_init_tables(bs, extent); ret = vmdk_init_tables(bs, extent, errp);
if (ret) { if (ret) {
/* free extent allocated by vmdk_add_extent */ /* free extent allocated by vmdk_add_extent */
vmdk_free_last_extent(bs); vmdk_free_last_extent(bs);
@ -514,11 +525,11 @@ static int vmdk_open_vmfs_sparse(BlockDriverState *bs,
} }
static int vmdk_open_desc_file(BlockDriverState *bs, int flags, static int vmdk_open_desc_file(BlockDriverState *bs, int flags,
uint64_t desc_offset); uint64_t desc_offset, Error **errp);
static int vmdk_open_vmdk4(BlockDriverState *bs, static int vmdk_open_vmdk4(BlockDriverState *bs,
BlockDriverState *file, BlockDriverState *file,
int flags) int flags, Error **errp)
{ {
int ret; int ret;
uint32_t magic; uint32_t magic;
@ -529,12 +540,14 @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header)); ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
if (ret < 0) { if (ret < 0) {
return ret; error_setg_errno(errp, -ret,
"Could not read header from file '%s'",
file->filename);
} }
if (header.capacity == 0) { if (header.capacity == 0) {
uint64_t desc_offset = le64_to_cpu(header.desc_offset); uint64_t desc_offset = le64_to_cpu(header.desc_offset);
if (desc_offset) { if (desc_offset) {
return vmdk_open_desc_file(bs, flags, desc_offset << 9); return vmdk_open_desc_file(bs, flags, desc_offset << 9, errp);
} }
} }
@ -616,7 +629,8 @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
l1_size, l1_size,
le32_to_cpu(header.num_gtes_per_gt), le32_to_cpu(header.num_gtes_per_gt),
le64_to_cpu(header.granularity), le64_to_cpu(header.granularity),
&extent); &extent,
errp);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -625,7 +639,7 @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
extent->has_marker = le32_to_cpu(header.flags) & VMDK4_FLAG_MARKER; extent->has_marker = le32_to_cpu(header.flags) & VMDK4_FLAG_MARKER;
extent->version = le32_to_cpu(header.version); extent->version = le32_to_cpu(header.version);
extent->has_zero_grain = le32_to_cpu(header.flags) & VMDK4_FLAG_ZERO_GRAIN; extent->has_zero_grain = le32_to_cpu(header.flags) & VMDK4_FLAG_ZERO_GRAIN;
ret = vmdk_init_tables(bs, extent); ret = vmdk_init_tables(bs, extent, errp);
if (ret) { if (ret) {
/* free extent allocated by vmdk_add_extent */ /* free extent allocated by vmdk_add_extent */
vmdk_free_last_extent(bs); vmdk_free_last_extent(bs);
@ -663,7 +677,7 @@ static int vmdk_parse_description(const char *desc, const char *opt_name,
/* Open an extent file and append to bs array */ /* Open an extent file and append to bs array */
static int vmdk_open_sparse(BlockDriverState *bs, static int vmdk_open_sparse(BlockDriverState *bs,
BlockDriverState *file, BlockDriverState *file,
int flags) int flags, Error **errp)
{ {
uint32_t magic; uint32_t magic;
@ -674,10 +688,10 @@ static int vmdk_open_sparse(BlockDriverState *bs,
magic = be32_to_cpu(magic); magic = be32_to_cpu(magic);
switch (magic) { switch (magic) {
case VMDK3_MAGIC: case VMDK3_MAGIC:
return vmdk_open_vmfs_sparse(bs, file, flags); return vmdk_open_vmfs_sparse(bs, file, flags, errp);
break; break;
case VMDK4_MAGIC: case VMDK4_MAGIC:
return vmdk_open_vmdk4(bs, file, flags); return vmdk_open_vmdk4(bs, file, flags, errp);
break; break;
default: default:
return -EMEDIUMTYPE; return -EMEDIUMTYPE;
@ -686,7 +700,7 @@ static int vmdk_open_sparse(BlockDriverState *bs,
} }
static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
const char *desc_file_path) const char *desc_file_path, Error **errp)
{ {
int ret; int ret;
char access[11]; char access[11];
@ -697,7 +711,6 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
int64_t flat_offset; int64_t flat_offset;
char extent_path[PATH_MAX]; char extent_path[PATH_MAX];
BlockDriverState *extent_file; BlockDriverState *extent_file;
Error *local_err = NULL;
while (*p) { while (*p) {
/* parse extent line: /* parse extent line:
@ -712,9 +725,11 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
goto next_line; goto next_line;
} else if (!strcmp(type, "FLAT")) { } else if (!strcmp(type, "FLAT")) {
if (ret != 5 || flat_offset < 0) { if (ret != 5 || flat_offset < 0) {
error_setg(errp, "Invalid extent lines: \n%s", p);
return -EINVAL; return -EINVAL;
} }
} else if (ret != 4) { } else if (ret != 4) {
error_setg(errp, "Invalid extent lines: \n%s", p);
return -EINVAL; return -EINVAL;
} }
@ -728,10 +743,8 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
path_combine(extent_path, sizeof(extent_path), path_combine(extent_path, sizeof(extent_path),
desc_file_path, fname); desc_file_path, fname);
ret = bdrv_file_open(&extent_file, extent_path, NULL, bs->open_flags, ret = bdrv_file_open(&extent_file, extent_path, NULL, bs->open_flags,
&local_err); errp);
if (ret) { if (ret) {
qerror_report_err(local_err);
error_free(local_err);
return ret; return ret;
} }
@ -741,21 +754,20 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
VmdkExtent *extent; VmdkExtent *extent;
ret = vmdk_add_extent(bs, extent_file, true, sectors, ret = vmdk_add_extent(bs, extent_file, true, sectors,
0, 0, 0, 0, 0, &extent); 0, 0, 0, 0, 0, &extent, errp);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
extent->flat_start_offset = flat_offset << 9; extent->flat_start_offset = flat_offset << 9;
} else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) { } else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) {
/* SPARSE extent and VMFSSPARSE extent are both "COWD" sparse file*/ /* SPARSE extent and VMFSSPARSE extent are both "COWD" sparse file*/
ret = vmdk_open_sparse(bs, extent_file, bs->open_flags); ret = vmdk_open_sparse(bs, extent_file, bs->open_flags, errp);
if (ret) { if (ret) {
bdrv_unref(extent_file); bdrv_unref(extent_file);
return ret; return ret;
} }
} else { } else {
fprintf(stderr, error_setg(errp, "Unsupported extent type '%s'", type);
"VMDK: Not supported extent type \"%s\""".\n", type);
return -ENOTSUP; return -ENOTSUP;
} }
next_line: next_line:
@ -769,7 +781,7 @@ next_line:
} }
static int vmdk_open_desc_file(BlockDriverState *bs, int flags, static int vmdk_open_desc_file(BlockDriverState *bs, int flags,
uint64_t desc_offset) uint64_t desc_offset, Error **errp)
{ {
int ret; int ret;
char *buf = NULL; char *buf = NULL;
@ -798,13 +810,12 @@ static int vmdk_open_desc_file(BlockDriverState *bs, int flags,
strcmp(ct, "vmfsSparse") && strcmp(ct, "vmfsSparse") &&
strcmp(ct, "twoGbMaxExtentSparse") && strcmp(ct, "twoGbMaxExtentSparse") &&
strcmp(ct, "twoGbMaxExtentFlat")) { strcmp(ct, "twoGbMaxExtentFlat")) {
fprintf(stderr, error_setg(errp, "Unsupported image type '%s'", ct);
"VMDK: Not supported image type \"%s\""".\n", ct);
ret = -ENOTSUP; ret = -ENOTSUP;
goto exit; goto exit;
} }
s->desc_offset = 0; s->desc_offset = 0;
ret = vmdk_parse_extents(buf, bs, bs->file->filename); ret = vmdk_parse_extents(buf, bs, bs->file->filename, errp);
exit: exit:
g_free(buf); g_free(buf);
return ret; return ret;
@ -816,10 +827,10 @@ static int vmdk_open(BlockDriverState *bs, QDict *options, int flags,
int ret; int ret;
BDRVVmdkState *s = bs->opaque; BDRVVmdkState *s = bs->opaque;
if (vmdk_open_sparse(bs, bs->file, flags) == 0) { if (vmdk_open_sparse(bs, bs->file, flags, errp) == 0) {
s->desc_offset = 0x200; s->desc_offset = 0x200;
} else { } else {
ret = vmdk_open_desc_file(bs, flags, 0); ret = vmdk_open_desc_file(bs, flags, 0, errp);
if (ret) { if (ret) {
goto fail; goto fail;
} }
@ -1286,8 +1297,7 @@ static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
VmdkMetaData m_data; VmdkMetaData m_data;
if (sector_num > bs->total_sectors) { if (sector_num > bs->total_sectors) {
fprintf(stderr, error_report("Wrong offset: sector_num=0x%" PRIx64
"(VMDK) Wrong offset: sector_num=0x%" PRIx64
" total_sectors=0x%" PRIx64 "\n", " total_sectors=0x%" PRIx64 "\n",
sector_num, bs->total_sectors); sector_num, bs->total_sectors);
return -EIO; return -EIO;
@ -1307,9 +1317,8 @@ static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
if (extent->compressed) { if (extent->compressed) {
if (ret == VMDK_OK) { if (ret == VMDK_OK) {
/* Refuse write to allocated cluster for streamOptimized */ /* Refuse write to allocated cluster for streamOptimized */
fprintf(stderr, error_report("Could not write to allocated cluster"
"VMDK: can't write to allocated cluster" " for streamOptimized");
" for streamOptimized\n");
return -EIO; return -EIO;
} else { } else {
/* allocate */ /* allocate */
@ -1517,12 +1526,12 @@ static int vmdk_create_extent(const char *filename, int64_t filesize,
} }
static int filename_decompose(const char *filename, char *path, char *prefix, static int filename_decompose(const char *filename, char *path, char *prefix,
char *postfix, size_t buf_len) char *postfix, size_t buf_len, Error **errp)
{ {
const char *p, *q; const char *p, *q;
if (filename == NULL || !strlen(filename)) { if (filename == NULL || !strlen(filename)) {
fprintf(stderr, "Vmdk: no filename provided.\n"); error_setg(errp, "No filename provided");
return VMDK_ERROR; return VMDK_ERROR;
} }
p = strrchr(filename, '/'); p = strrchr(filename, '/');
@ -1595,9 +1604,8 @@ static int vmdk_create(const char *filename, QEMUOptionParameter *options,
"ddb.geometry.heads = \"%d\"\n" "ddb.geometry.heads = \"%d\"\n"
"ddb.geometry.sectors = \"63\"\n" "ddb.geometry.sectors = \"63\"\n"
"ddb.adapterType = \"%s\"\n"; "ddb.adapterType = \"%s\"\n";
Error *local_err = NULL;
if (filename_decompose(filename, path, prefix, postfix, PATH_MAX)) { if (filename_decompose(filename, path, prefix, postfix, PATH_MAX, errp)) {
return -EINVAL; return -EINVAL;
} }
/* Read out options */ /* Read out options */
@ -1623,7 +1631,7 @@ static int vmdk_create(const char *filename, QEMUOptionParameter *options,
strcmp(adapter_type, "buslogic") && strcmp(adapter_type, "buslogic") &&
strcmp(adapter_type, "lsilogic") && strcmp(adapter_type, "lsilogic") &&
strcmp(adapter_type, "legacyESX")) { strcmp(adapter_type, "legacyESX")) {
fprintf(stderr, "VMDK: Unknown adapter type: '%s'.\n", adapter_type); error_setg(errp, "Unknown adapter type: '%s'", adapter_type);
return -EINVAL; return -EINVAL;
} }
if (strcmp(adapter_type, "ide") != 0) { if (strcmp(adapter_type, "ide") != 0) {
@ -1639,7 +1647,7 @@ static int vmdk_create(const char *filename, QEMUOptionParameter *options,
strcmp(fmt, "twoGbMaxExtentSparse") && strcmp(fmt, "twoGbMaxExtentSparse") &&
strcmp(fmt, "twoGbMaxExtentFlat") && strcmp(fmt, "twoGbMaxExtentFlat") &&
strcmp(fmt, "streamOptimized")) { strcmp(fmt, "streamOptimized")) {
fprintf(stderr, "VMDK: Unknown subformat: %s\n", fmt); error_setg(errp, "Unknown subformat: '%s'", fmt);
return -EINVAL; return -EINVAL;
} }
split = !(strcmp(fmt, "twoGbMaxExtentFlat") && split = !(strcmp(fmt, "twoGbMaxExtentFlat") &&
@ -1653,15 +1661,13 @@ static int vmdk_create(const char *filename, QEMUOptionParameter *options,
desc_extent_line = "RW %lld SPARSE \"%s\"\n"; desc_extent_line = "RW %lld SPARSE \"%s\"\n";
} }
if (flat && backing_file) { if (flat && backing_file) {
/* not supporting backing file for flat image */ error_setg(errp, "Flat image can't have backing file");
return -ENOTSUP; return -ENOTSUP;
} }
if (backing_file) { if (backing_file) {
BlockDriverState *bs = bdrv_new(""); BlockDriverState *bs = bdrv_new("");
ret = bdrv_open(bs, backing_file, NULL, 0, NULL, &local_err); ret = bdrv_open(bs, backing_file, NULL, 0, NULL, errp);
if (ret != 0) { if (ret != 0) {
qerror_report_err(local_err);
error_free(local_err);
bdrv_unref(bs); bdrv_unref(bs);
return ret; return ret;
} }

6
tests/qemu-iotests/059.out
View File

@ -2,8 +2,7 @@ QA output created by 059
=== Testing invalid granularity === === Testing invalid granularity ===
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
invalid granularity, image may be corrupt qemu-io: can't open device TEST_DIR/t.vmdk: Invalid granularity, image may be corrupt
qemu-io: can't open device TEST_DIR/t.vmdk: Could not open 'TEST_DIR/t.vmdk': Wrong medium type
no file open, try 'help open' no file open, try 'help open'
=== Testing too big L2 table size === === Testing too big L2 table size ===
@ -14,8 +13,7 @@ no file open, try 'help open'
=== Testing too big L1 table size === === Testing too big L1 table size ===
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
L1 size too big qemu-io: can't open device TEST_DIR/t.vmdk: L1 size too big
qemu-io: can't open device TEST_DIR/t.vmdk: Could not open 'TEST_DIR/t.vmdk': Wrong medium type
no file open, try 'help open' no file open, try 'help open'
=== Testing monolithicFlat creation and opening === === Testing monolithicFlat creation and opening ===