ShuriZma
/
xqemu
mirror of https://github.com/xqemu/xqemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

block: use bdrv_get_device_or_node_name() in error messages 

There are several error messages that identify a BlockDriverState by
its device name. However those errors can be produced in nodes that
don't have a device name associated.

In those cases we should use bdrv_get_device_or_node_name() to fall
back to the node name and produce a more meaningful message. The
messages are also updated to use the more generic term 'node' instead
of 'device'.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 9823a1f0514fdb0692e92868661c38a9e00a12d6.1428485266.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Alberto Garcia 2015-04-08 12:29:19 +03:00 committed by Kevin Wolf
parent 9b2aa84f87
commit 81e5f78a9f
12 changed files with 46 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
block.c
View File

@ -1231,8 +1231,8 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker); bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
} 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'", "node is used as backing hd of '%s'",
bdrv_get_device_name(bs)); bdrv_get_device_or_node_name(bs));
} }
bs->backing_hd = backing_hd; bs->backing_hd = backing_hd;
@ -1819,8 +1819,8 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
* to r/w */ * to r/w */
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_setg(errp, "Node '%s' is read only",
bdrv_get_device_name(reopen_state->bs)); bdrv_get_device_or_node_name(reopen_state->bs));
goto error; goto error;
} }
@ -1846,9 +1846,9 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
} else { } else {
/* 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_setg(errp, "Block format '%s' used by node '%s' "
drv->format_name, bdrv_get_device_name(reopen_state->bs), "does not support reopening files", drv->format_name,
"reopening of file"); bdrv_get_device_or_node_name(reopen_state->bs));
ret = -1; ret = -1;
goto error; goto error;
} }
@ -3824,8 +3824,8 @@ void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
{ {
if (key) { if (key) {
if (!bdrv_is_encrypted(bs)) { if (!bdrv_is_encrypted(bs)) {
error_setg(errp, "Device '%s' is not encrypted", error_setg(errp, "Node '%s' is not encrypted",
bdrv_get_device_name(bs)); bdrv_get_device_or_node_name(bs));
} else if (bdrv_set_key(bs, key) < 0) { } else if (bdrv_set_key(bs, key) < 0) {
error_set(errp, QERR_INVALID_PASSWORD); error_set(errp, QERR_INVALID_PASSWORD);
} }
@ -3833,7 +3833,7 @@ void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
if (bdrv_key_required(bs)) { if (bdrv_key_required(bs)) {
error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED, error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
"'%s' (%s) is encrypted", "'%s' (%s) is encrypted",
bdrv_get_device_name(bs), bdrv_get_device_or_node_name(bs),
bdrv_get_encrypted_filename(bs)); bdrv_get_encrypted_filename(bs));
} }
} }
@ -5633,8 +5633,8 @@ bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
if (!QLIST_EMPTY(&bs->op_blockers[op])) { if (!QLIST_EMPTY(&bs->op_blockers[op])) {
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, "Node '%s' is busy: %s",
bdrv_get_device_name(bs), bdrv_get_device_or_node_name(bs),
error_get_pretty(blocker->reason)); error_get_pretty(blocker->reason));
} }
return true; return true;

8
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,
bdrv_get_device_name(bs), "qcow", version); bdrv_get_device_or_node_name(bs), "qcow", version);
ret = -ENOTSUP; ret = -ENOTSUP;
goto fail; goto fail;
} }
@ -229,9 +229,9 @@ 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_setg(&s->migration_blocker, "The qcow format used by node '%s' "
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, "does not support live migration",
"qcow", bdrv_get_device_name(bs), "live migration"); bdrv_get_device_or_node_name(bs));
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
qemu_co_mutex_init(&s->lock); qemu_co_mutex_init(&s->lock);

2
block/qcow2.c
View File

@ -208,7 +208,7 @@ static void GCC_FMT_ATTR(3, 4) report_unsupported(BlockDriverState *bs,
va_end(ap); va_end(ap);
error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
bdrv_get_device_name(bs), "qcow2", msg); bdrv_get_device_or_node_name(bs), "qcow2", msg);
} }
static void report_unsupported_feature(BlockDriverState *bs, static void report_unsupported_feature(BlockDriverState *bs,

2
block/qed.c
View File

@ -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,
bdrv_get_device_name(bs), "QED", buf); bdrv_get_device_or_node_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)) {

12
block/snapshot.c
View File

@ -246,9 +246,9 @@ int bdrv_snapshot_delete(BlockDriverState *bs,
if (bs->file) { if (bs->file) {
return bdrv_snapshot_delete(bs->file, snapshot_id, name, errp); return bdrv_snapshot_delete(bs->file, snapshot_id, name, errp);
} }
error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, error_setg(errp, "Block format '%s' used by device '%s' "
drv->format_name, bdrv_get_device_name(bs), "does not support internal snapshot deletion",
"internal snapshot deletion"); drv->format_name, bdrv_get_device_name(bs));
return -ENOTSUP; return -ENOTSUP;
} }
@ -329,9 +329,9 @@ int bdrv_snapshot_load_tmp(BlockDriverState *bs,
if (drv->bdrv_snapshot_load_tmp) { if (drv->bdrv_snapshot_load_tmp) {
return drv->bdrv_snapshot_load_tmp(bs, snapshot_id, name, errp); return drv->bdrv_snapshot_load_tmp(bs, snapshot_id, name, errp);
} }
error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, error_setg(errp, "Block format '%s' used by device '%s' "
drv->format_name, bdrv_get_device_name(bs), "does not support temporarily loading internal snapshots",
"temporarily load internal snapshot"); drv->format_name, bdrv_get_device_name(bs));
return -ENOTSUP; return -ENOTSUP;
} }

6
block/vdi.c
View File

@ -502,9 +502,9 @@ 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_setg(&s->migration_blocker, "The vdi format used by node '%s' "
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, "does not support live migration",
"vdi", bdrv_get_device_name(bs), "live migration"); bdrv_get_device_or_node_name(bs));
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
qemu_co_mutex_init(&s->write_lock); qemu_co_mutex_init(&s->write_lock);

6
block/vhdx.c
View File

@ -1002,9 +1002,9 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
/* TODO: differencing files */ /* TODO: differencing files */
/* Disable migration when VHDX images are used */ /* Disable migration when VHDX images are used */
error_set(&s->migration_blocker, error_setg(&s->migration_blocker, "The vhdx format used by node '%s' "
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, "does not support live migration",
"vhdx", bdrv_get_device_name(bs), "live migration"); bdrv_get_device_or_node_name(bs));
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
return 0; return 0;

8
block/vmdk.c
View File

@ -669,7 +669,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,
bdrv_get_device_name(bs), "vmdk", buf); bdrv_get_device_or_node_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
@ -962,9 +962,9 @@ static int vmdk_open(BlockDriverState *bs, QDict *options, int flags,
qemu_co_mutex_init(&s->lock); qemu_co_mutex_init(&s->lock);
/* Disable migration when VMDK images are used */ /* Disable migration when VMDK images are used */
error_set(&s->migration_blocker, error_setg(&s->migration_blocker, "The vmdk format used by node '%s' "
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, "does not support live migration",
"vmdk", bdrv_get_device_name(bs), "live migration"); bdrv_get_device_or_node_name(bs));
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
g_free(buf); g_free(buf);
return 0; return 0;

6
block/vpc.c
View File

@ -318,9 +318,9 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
qemu_co_mutex_init(&s->lock); qemu_co_mutex_init(&s->lock);
/* Disable migration when VHD images are used */ /* Disable migration when VHD images are used */
error_set(&s->migration_blocker, error_setg(&s->migration_blocker, "The vpc format used by node '%s' "
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, "does not support live migration",
"vpc", bdrv_get_device_name(bs), "live migration"); bdrv_get_device_or_node_name(bs));
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
return 0; return 0;

7
block/vvfat.c
View File

@ -1180,9 +1180,10 @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
/* Disable migration when vvfat is used rw */ /* Disable migration when vvfat is used rw */
if (s->qcow) { if (s->qcow) {
error_set(&s->migration_blocker, error_setg(&s->migration_blocker,
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, "The vvfat (rw) format used by node '%s' "
"vvfat (rw)", bdrv_get_device_name(bs), "live migration"); "does not support live migration",
bdrv_get_device_or_node_name(bs));
migrate_add_blocker(s->migration_blocker); migrate_add_blocker(s->migration_blocker);
} }

9
blockdev.c
View File

@ -1248,13 +1248,14 @@ static void internal_snapshot_prepare(BlkTransactionState *common,
} }
if (bdrv_is_read_only(bs)) { if (bdrv_is_read_only(bs)) {
error_set(errp, QERR_DEVICE_IS_READ_ONLY, device); error_setg(errp, "Device '%s' is read only", device);
return; return;
} }
if (!bdrv_can_snapshot(bs)) { if (!bdrv_can_snapshot(bs)) {
error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, error_setg(errp, "Block format '%s' used by device '%s' "
bs->drv->format_name, device, "internal snapshot"); "does not support internal snapshots",
bs->drv->format_name, device);
return; return;
} }
@ -2055,7 +2056,7 @@ void qmp_block_resize(bool has_device, const char *device,
error_set(errp, QERR_UNSUPPORTED); error_set(errp, QERR_UNSUPPORTED);
break; break;
case -EACCES: case -EACCES:
error_set(errp, QERR_DEVICE_IS_READ_ONLY, device); error_setg(errp, "Device '%s' is read only", device);
break; break;
case -EBUSY: case -EBUSY:
error_set(errp, QERR_DEVICE_IN_USE, device); error_set(errp, QERR_DEVICE_IN_USE, device);

6
include/qapi/qmp/qerror.h
View File

@ -37,9 +37,6 @@ void qerror_report_err(Error *err);
#define QERR_BASE_NOT_FOUND \ #define QERR_BASE_NOT_FOUND \
ERROR_CLASS_GENERIC_ERROR, "Base '%s' not found" ERROR_CLASS_GENERIC_ERROR, "Base '%s' not found"
#define QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED \
ERROR_CLASS_GENERIC_ERROR, "Block format '%s' used by device '%s' does not support feature '%s'"
#define QERR_BLOCK_JOB_NOT_READY \ #define QERR_BLOCK_JOB_NOT_READY \
ERROR_CLASS_GENERIC_ERROR, "The active block job for device '%s' cannot be completed" ERROR_CLASS_GENERIC_ERROR, "The active block job for device '%s' cannot be completed"
@ -58,9 +55,6 @@ void qerror_report_err(Error *err);
#define QERR_DEVICE_IN_USE \ #define QERR_DEVICE_IN_USE \
ERROR_CLASS_GENERIC_ERROR, "Device '%s' is in use" ERROR_CLASS_GENERIC_ERROR, "Device '%s' is in use"
#define QERR_DEVICE_IS_READ_ONLY \
ERROR_CLASS_GENERIC_ERROR, "Device '%s' is read only"
#define QERR_DEVICE_NO_HOTPLUG \ #define QERR_DEVICE_NO_HOTPLUG \
ERROR_CLASS_GENERIC_ERROR, "Device '%s' does not support hotplugging" ERROR_CLASS_GENERIC_ERROR, "Device '%s' does not support hotplugging"