Revision ddf5636d
| b/block.c | ||
|---|---|---|
| 1046 | 1046 |
} |
| 1047 | 1047 |
|
| 1048 | 1048 |
if (!drv->bdrv_file_open) {
|
| 1049 |
ret = bdrv_open(&bs, filename, options, flags, drv, &local_err); |
|
| 1049 |
ret = bdrv_open(&bs, filename, NULL, options, flags, drv, &local_err);
|
|
| 1050 | 1050 |
options = NULL; |
| 1051 | 1051 |
} else {
|
| 1052 | 1052 |
ret = bdrv_open_common(bs, NULL, options, flags, drv, &local_err); |
| ... | ... | |
| 1125 | 1125 |
|
| 1126 | 1126 |
assert(bs->backing_hd == NULL); |
| 1127 | 1127 |
ret = bdrv_open(&bs->backing_hd, |
| 1128 |
*backing_filename ? backing_filename : NULL, options, |
|
| 1128 |
*backing_filename ? backing_filename : NULL, NULL, options,
|
|
| 1129 | 1129 |
back_flags, back_drv, &local_err); |
| 1130 | 1130 |
if (ret < 0) {
|
| 1131 | 1131 |
bs->backing_hd = NULL; |
| ... | ... | |
| 1206 | 1206 |
goto done; |
| 1207 | 1207 |
} |
| 1208 | 1208 |
|
| 1209 |
ret = bdrv_open(pbs, filename, image_options, flags, NULL, errp); |
|
| 1209 |
ret = bdrv_open(pbs, filename, NULL, image_options, flags, NULL, errp);
|
|
| 1210 | 1210 |
} else {
|
| 1211 | 1211 |
ret = bdrv_file_open(pbs, filename, reference, image_options, flags, |
| 1212 | 1212 |
errp); |
| ... | ... | |
| 1227 | 1227 |
* |
| 1228 | 1228 |
* If *pbs is NULL, a new BDS will be created with a pointer to it stored there. |
| 1229 | 1229 |
* If it is not NULL, the referenced BDS will be reused. |
| 1230 |
* |
|
| 1231 |
* The reference parameter may be used to specify an existing block device which |
|
| 1232 |
* should be opened. If specified, neither options nor a filename may be given, |
|
| 1233 |
* nor can an existing BDS be reused (that is, *pbs has to be NULL). |
|
| 1230 | 1234 |
*/ |
| 1231 |
int bdrv_open(BlockDriverState **pbs, const char *filename, QDict *options, |
|
| 1232 |
int flags, BlockDriver *drv, Error **errp) |
|
| 1235 |
int bdrv_open(BlockDriverState **pbs, const char *filename, |
|
| 1236 |
const char *reference, QDict *options, int flags, |
|
| 1237 |
BlockDriver *drv, Error **errp) |
|
| 1233 | 1238 |
{
|
| 1234 | 1239 |
int ret; |
| 1235 | 1240 |
/* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */ |
| ... | ... | |
| 1240 | 1245 |
|
| 1241 | 1246 |
assert(pbs); |
| 1242 | 1247 |
|
| 1248 |
if (reference) {
|
|
| 1249 |
bool options_non_empty = options ? qdict_size(options) : false; |
|
| 1250 |
QDECREF(options); |
|
| 1251 |
|
|
| 1252 |
if (*pbs) {
|
|
| 1253 |
error_setg(errp, "Cannot reuse an existing BDS when referencing " |
|
| 1254 |
"another block device"); |
|
| 1255 |
return -EINVAL; |
|
| 1256 |
} |
|
| 1257 |
|
|
| 1258 |
if (filename || options_non_empty) {
|
|
| 1259 |
error_setg(errp, "Cannot reference an existing block device with " |
|
| 1260 |
"additional options or a new filename"); |
|
| 1261 |
return -EINVAL; |
|
| 1262 |
} |
|
| 1263 |
|
|
| 1264 |
bs = bdrv_lookup_bs(reference, reference, errp); |
|
| 1265 |
if (!bs) {
|
|
| 1266 |
return -ENODEV; |
|
| 1267 |
} |
|
| 1268 |
bdrv_ref(bs); |
|
| 1269 |
*pbs = bs; |
|
| 1270 |
return 0; |
|
| 1271 |
} |
|
| 1272 |
|
|
| 1243 | 1273 |
if (*pbs) {
|
| 1244 | 1274 |
bs = *pbs; |
| 1245 | 1275 |
} else {
|
| ... | ... | |
| 1268 | 1298 |
/* Get the required size from the image */ |
| 1269 | 1299 |
QINCREF(options); |
| 1270 | 1300 |
bs1 = NULL; |
| 1271 |
ret = bdrv_open(&bs1, filename, options, BDRV_O_NO_BACKING, |
|
| 1301 |
ret = bdrv_open(&bs1, filename, NULL, options, BDRV_O_NO_BACKING,
|
|
| 1272 | 1302 |
drv, &local_err); |
| 1273 | 1303 |
if (ret < 0) {
|
| 1274 | 1304 |
goto fail; |
| ... | ... | |
| 5309 | 5339 |
flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING); |
| 5310 | 5340 |
|
| 5311 | 5341 |
bs = NULL; |
| 5312 |
ret = bdrv_open(&bs, backing_file->value.s, NULL, back_flags, |
|
| 5342 |
ret = bdrv_open(&bs, backing_file->value.s, NULL, NULL, back_flags,
|
|
| 5313 | 5343 |
backing_drv, &local_err); |
| 5314 | 5344 |
if (ret < 0) {
|
| 5315 | 5345 |
error_setg_errno(errp, -ret, "Could not open '%s': %s", |
| b/block/qcow2.c | ||
|---|---|---|
| 1553 | 1553 |
*/ |
| 1554 | 1554 |
BlockDriver* drv = bdrv_find_format("qcow2");
|
| 1555 | 1555 |
assert(drv != NULL); |
| 1556 |
ret = bdrv_open(&bs, filename, NULL, |
|
| 1556 |
ret = bdrv_open(&bs, filename, NULL, NULL,
|
|
| 1557 | 1557 |
BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH, drv, &local_err); |
| 1558 | 1558 |
if (ret < 0) {
|
| 1559 | 1559 |
error_propagate(errp, local_err); |
| ... | ... | |
| 1604 | 1604 |
bs = NULL; |
| 1605 | 1605 |
|
| 1606 | 1606 |
/* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */ |
| 1607 |
ret = bdrv_open(&bs, filename, NULL, |
|
| 1607 |
ret = bdrv_open(&bs, filename, NULL, NULL,
|
|
| 1608 | 1608 |
BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_BACKING, |
| 1609 | 1609 |
drv, &local_err); |
| 1610 | 1610 |
if (local_err) {
|
| b/block/vmdk.c | ||
|---|---|---|
| 1756 | 1756 |
} |
| 1757 | 1757 |
if (backing_file) {
|
| 1758 | 1758 |
BlockDriverState *bs = NULL; |
| 1759 |
ret = bdrv_open(&bs, backing_file, NULL, BDRV_O_NO_BACKING, NULL, errp); |
|
| 1759 |
ret = bdrv_open(&bs, backing_file, NULL, NULL, BDRV_O_NO_BACKING, NULL, |
|
| 1760 |
errp); |
|
| 1760 | 1761 |
if (ret != 0) {
|
| 1761 | 1762 |
goto exit; |
| 1762 | 1763 |
} |
| b/block/vvfat.c | ||
|---|---|---|
| 2937 | 2937 |
} |
| 2938 | 2938 |
|
| 2939 | 2939 |
s->qcow = NULL; |
| 2940 |
ret = bdrv_open(&s->qcow, s->qcow_filename, NULL, |
|
| 2940 |
ret = bdrv_open(&s->qcow, s->qcow_filename, NULL, NULL,
|
|
| 2941 | 2941 |
BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH, bdrv_qcow, |
| 2942 | 2942 |
&local_err); |
| 2943 | 2943 |
if (ret < 0) {
|
| b/blockdev.c | ||
|---|---|---|
| 504 | 504 |
bdrv_flags |= ro ? 0 : BDRV_O_RDWR; |
| 505 | 505 |
|
| 506 | 506 |
QINCREF(bs_opts); |
| 507 |
ret = bdrv_open(&dinfo->bdrv, file, bs_opts, bdrv_flags, drv, &error); |
|
| 507 |
ret = bdrv_open(&dinfo->bdrv, file, NULL, bs_opts, bdrv_flags, drv, &error);
|
|
| 508 | 508 |
|
| 509 | 509 |
if (ret < 0) {
|
| 510 | 510 |
error_setg(errp, "could not open disk image %s: %s", |
| ... | ... | |
| 1333 | 1333 |
/* TODO Inherit bs->options or only take explicit options with an |
| 1334 | 1334 |
* extended QMP command? */ |
| 1335 | 1335 |
assert(state->new_bs == NULL); |
| 1336 |
ret = bdrv_open(&state->new_bs, new_image_file, options, |
|
| 1336 |
ret = bdrv_open(&state->new_bs, new_image_file, NULL, options,
|
|
| 1337 | 1337 |
flags | BDRV_O_NO_BACKING, drv, &local_err); |
| 1338 | 1338 |
/* We will manually add the backing_hd field to the bs later */ |
| 1339 | 1339 |
if (ret != 0) {
|
| ... | ... | |
| 1582 | 1582 |
Error *local_err = NULL; |
| 1583 | 1583 |
int ret; |
| 1584 | 1584 |
|
| 1585 |
ret = bdrv_open(&bs, filename, NULL, bdrv_flags, drv, &local_err); |
|
| 1585 |
ret = bdrv_open(&bs, filename, NULL, NULL, bdrv_flags, drv, &local_err);
|
|
| 1586 | 1586 |
if (ret < 0) {
|
| 1587 | 1587 |
error_propagate(errp, local_err); |
| 1588 | 1588 |
return; |
| ... | ... | |
| 2019 | 2019 |
} |
| 2020 | 2020 |
|
| 2021 | 2021 |
target_bs = NULL; |
| 2022 |
ret = bdrv_open(&target_bs, target, NULL, flags, drv, &local_err); |
|
| 2022 |
ret = bdrv_open(&target_bs, target, NULL, NULL, flags, drv, &local_err);
|
|
| 2023 | 2023 |
if (ret < 0) {
|
| 2024 | 2024 |
error_propagate(errp, local_err); |
| 2025 | 2025 |
return; |
| ... | ... | |
| 2162 | 2162 |
* file. |
| 2163 | 2163 |
*/ |
| 2164 | 2164 |
target_bs = NULL; |
| 2165 |
ret = bdrv_open(&target_bs, target, NULL, flags | BDRV_O_NO_BACKING, drv,
|
|
| 2166 |
&local_err); |
|
| 2165 |
ret = bdrv_open(&target_bs, target, NULL, NULL, flags | BDRV_O_NO_BACKING,
|
|
| 2166 |
drv, &local_err);
|
|
| 2167 | 2167 |
if (ret < 0) {
|
| 2168 | 2168 |
error_propagate(errp, local_err); |
| 2169 | 2169 |
return; |
| b/hw/block/xen_disk.c | ||
|---|---|---|
| 813 | 813 |
Error *local_err = NULL; |
| 814 | 814 |
BlockDriver *drv = bdrv_find_whitelisted_format(blkdev->fileproto, |
| 815 | 815 |
readonly); |
| 816 |
if (bdrv_open(&blkdev->bs, |
|
| 817 |
blkdev->filename, NULL, qflags, drv, &local_err) != 0)
|
|
| 816 |
if (bdrv_open(&blkdev->bs, blkdev->filename, NULL, NULL, qflags,
|
|
| 817 |
drv, &local_err) != 0) |
|
| 818 | 818 |
{
|
| 819 | 819 |
xen_be_printf(&blkdev->xendev, 0, "error: %s\n", |
| 820 | 820 |
error_get_pretty(local_err)); |
| b/include/block/block.h | ||
|---|---|---|
| 190 | 190 |
QDict *options, const char *bdref_key, int flags, |
| 191 | 191 |
bool force_raw, bool allow_none, Error **errp); |
| 192 | 192 |
int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp); |
| 193 |
int bdrv_open(BlockDriverState **pbs, const char *filename, QDict *options, |
|
| 194 |
int flags, BlockDriver *drv, Error **errp); |
|
| 193 |
int bdrv_open(BlockDriverState **pbs, const char *filename, |
|
| 194 |
const char *reference, QDict *options, int flags, |
|
| 195 |
BlockDriver *drv, Error **errp); |
|
| 195 | 196 |
BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue, |
| 196 | 197 |
BlockDriverState *bs, int flags); |
| 197 | 198 |
int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp); |
| b/qemu-img.c | ||
|---|---|---|
| 289 | 289 |
drv = NULL; |
| 290 | 290 |
} |
| 291 | 291 |
|
| 292 |
ret = bdrv_open(&bs, filename, NULL, flags, drv, &local_err); |
|
| 292 |
ret = bdrv_open(&bs, filename, NULL, NULL, flags, drv, &local_err);
|
|
| 293 | 293 |
if (ret < 0) {
|
| 294 | 294 |
error_report("Could not open '%s': %s", filename,
|
| 295 | 295 |
error_get_pretty(local_err)); |
| ... | ... | |
| 2312 | 2312 |
|
| 2313 | 2313 |
bs_old_backing = bdrv_new("old_backing");
|
| 2314 | 2314 |
bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); |
| 2315 |
ret = bdrv_open(&bs_old_backing, backing_name, NULL, BDRV_O_FLAGS, |
|
| 2315 |
ret = bdrv_open(&bs_old_backing, backing_name, NULL, NULL, BDRV_O_FLAGS,
|
|
| 2316 | 2316 |
old_backing_drv, &local_err); |
| 2317 | 2317 |
if (ret) {
|
| 2318 | 2318 |
error_report("Could not open old backing file '%s': %s",
|
| ... | ... | |
| 2322 | 2322 |
} |
| 2323 | 2323 |
if (out_baseimg[0]) {
|
| 2324 | 2324 |
bs_new_backing = bdrv_new("new_backing");
|
| 2325 |
ret = bdrv_open(&bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
|
|
| 2326 |
new_backing_drv, &local_err); |
|
| 2325 |
ret = bdrv_open(&bs_new_backing, out_baseimg, NULL, NULL,
|
|
| 2326 |
BDRV_O_FLAGS, new_backing_drv, &local_err);
|
|
| 2327 | 2327 |
if (ret) {
|
| 2328 | 2328 |
error_report("Could not open new backing file '%s': %s",
|
| 2329 | 2329 |
out_baseimg, error_get_pretty(local_err)); |
| b/qemu-io.c | ||
|---|---|---|
| 68 | 68 |
} else {
|
| 69 | 69 |
qemuio_bs = bdrv_new("hda");
|
| 70 | 70 |
|
| 71 |
if (bdrv_open(&qemuio_bs, name, opts, flags, NULL, &local_err) < 0) {
|
|
| 71 |
if (bdrv_open(&qemuio_bs, name, NULL, opts, flags, NULL, &local_err) |
|
| 72 |
< 0) |
|
| 73 |
{
|
|
| 72 | 74 |
fprintf(stderr, "%s: can't open device %s: %s\n", progname, name, |
| 73 | 75 |
error_get_pretty(local_err)); |
| 74 | 76 |
error_free(local_err); |
| b/qemu-nbd.c | ||
|---|---|---|
| 597 | 597 |
|
| 598 | 598 |
bs = bdrv_new("hda");
|
| 599 | 599 |
srcpath = argv[optind]; |
| 600 |
ret = bdrv_open(&bs, srcpath, NULL, flags, drv, &local_err); |
|
| 600 |
ret = bdrv_open(&bs, srcpath, NULL, NULL, flags, drv, &local_err);
|
|
| 601 | 601 |
if (ret < 0) {
|
| 602 | 602 |
errno = -ret; |
| 603 | 603 |
err(EXIT_FAILURE, "Failed to bdrv_open '%s': %s", argv[optind], |
Also available in: Unified diff