block.c (34b5d2c68eb4082c288e70fb99c61af8f7b96fde) block.c (cc84d90ff54c025190dbe49ec5fea1268217c5f2)
1/*
2 * QEMU System Emulator block driver
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights

--- 380 unchanged lines hidden (view full) ---

389 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
390}
391
392typedef struct CreateCo {
393 BlockDriver *drv;
394 char *filename;
395 QEMUOptionParameter *options;
396 int ret;
1/*
2 * QEMU System Emulator block driver
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights

--- 380 unchanged lines hidden (view full) ---

389 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
390}
391
392typedef struct CreateCo {
393 BlockDriver *drv;
394 char *filename;
395 QEMUOptionParameter *options;
396 int ret;
397 Error *err;
397} CreateCo;
398
399static void coroutine_fn bdrv_create_co_entry(void *opaque)
400{
398} CreateCo;
399
400static void coroutine_fn bdrv_create_co_entry(void *opaque)
401{
402 Error *local_err = NULL;
403 int ret;
404
401 CreateCo *cco = opaque;
402 assert(cco->drv);
403
405 CreateCo *cco = opaque;
406 assert(cco->drv);
407
404 cco->ret = cco->drv->bdrv_create(cco->filename, cco->options, NULL);
408 ret = cco->drv->bdrv_create(cco->filename, cco->options, &local_err);
409 if (error_is_set(&local_err)) {
410 error_propagate(&cco->err, local_err);
411 }
412 cco->ret = ret;
405}
406
407int bdrv_create(BlockDriver *drv, const char* filename,
413}
414
415int bdrv_create(BlockDriver *drv, const char* filename,
408 QEMUOptionParameter *options)
416 QEMUOptionParameter *options, Error **errp)
409{
410 int ret;
411
412 Coroutine *co;
413 CreateCo cco = {
414 .drv = drv,
415 .filename = g_strdup(filename),
416 .options = options,
417 .ret = NOT_DONE,
417{
418 int ret;
419
420 Coroutine *co;
421 CreateCo cco = {
422 .drv = drv,
423 .filename = g_strdup(filename),
424 .options = options,
425 .ret = NOT_DONE,
426 .err = NULL,
418 };
419
420 if (!drv->bdrv_create) {
427 };
428
429 if (!drv->bdrv_create) {
430 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
421 ret = -ENOTSUP;
422 goto out;
423 }
424
425 if (qemu_in_coroutine()) {
426 /* Fast-path if already in coroutine context */
427 bdrv_create_co_entry(&cco);
428 } else {
429 co = qemu_coroutine_create(bdrv_create_co_entry);
430 qemu_coroutine_enter(co, &cco);
431 while (cco.ret == NOT_DONE) {
432 qemu_aio_wait();
433 }
434 }
435
436 ret = cco.ret;
431 ret = -ENOTSUP;
432 goto out;
433 }
434
435 if (qemu_in_coroutine()) {
436 /* Fast-path if already in coroutine context */
437 bdrv_create_co_entry(&cco);
438 } else {
439 co = qemu_coroutine_create(bdrv_create_co_entry);
440 qemu_coroutine_enter(co, &cco);
441 while (cco.ret == NOT_DONE) {
442 qemu_aio_wait();
443 }
444 }
445
446 ret = cco.ret;
447 if (ret < 0) {
448 if (error_is_set(&cco.err)) {
449 error_propagate(errp, cco.err);
450 } else {
451 error_setg_errno(errp, -ret, "Could not create image");
452 }
453 }
437
438out:
439 g_free(cco.filename);
440 return ret;
441}
442
454
455out:
456 g_free(cco.filename);
457 return ret;
458}
459
443int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
460int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
461 Error **errp)
444{
445 BlockDriver *drv;
462{
463 BlockDriver *drv;
464 Error *local_err = NULL;
465 int ret;
446
447 drv = bdrv_find_protocol(filename, true);
448 if (drv == NULL) {
466
467 drv = bdrv_find_protocol(filename, true);
468 if (drv == NULL) {
469 error_setg(errp, "Could not find protocol for file '%s'", filename);
449 return -ENOENT;
450 }
451
470 return -ENOENT;
471 }
472
452 return bdrv_create(drv, filename, options);
473 ret = bdrv_create(drv, filename, options, &local_err);
474 if (error_is_set(&local_err)) {
475 error_propagate(errp, local_err);
476 }
477 return ret;
453}
454
455/*
456 * Create a uniquely-named empty temporary file.
457 * Return 0 upon success, otherwise a negative errno value.
458 */
459int get_tmp_filename(char *filename, int size)
460{

--- 616 unchanged lines hidden (view full) ---

1077 set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);
1078 set_option_parameter(create_options, BLOCK_OPT_BACKING_FILE,
1079 backing_filename);
1080 if (drv) {
1081 set_option_parameter(create_options, BLOCK_OPT_BACKING_FMT,
1082 drv->format_name);
1083 }
1084
478}
479
480/*
481 * Create a uniquely-named empty temporary file.
482 * Return 0 upon success, otherwise a negative errno value.
483 */
484int get_tmp_filename(char *filename, int size)
485{

--- 616 unchanged lines hidden (view full) ---

1102 set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);
1103 set_option_parameter(create_options, BLOCK_OPT_BACKING_FILE,
1104 backing_filename);
1105 if (drv) {
1106 set_option_parameter(create_options, BLOCK_OPT_BACKING_FMT,
1107 drv->format_name);
1108 }
1109
1085 ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options);
1110 ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options, &local_err);
1086 free_option_parameters(create_options);
1087 if (ret < 0) {
1088 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1111 free_option_parameters(create_options);
1112 if (ret < 0) {
1113 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1089 "'%s'", tmp_filename);
1114 "'%s': %s", tmp_filename,
1115 error_get_pretty(local_err));
1116 error_free(local_err);
1117 local_err = NULL;
1090 goto fail;
1091 }
1092
1093 filename = tmp_filename;
1094 drv = bdrv_qcow2;
1095 bs->is_temporary = 1;
1096 }
1097

--- 3358 unchanged lines hidden (view full) ---

4456 char *options, uint64_t img_size, int flags,
4457 Error **errp, bool quiet)
4458{
4459 QEMUOptionParameter *param = NULL, *create_options = NULL;
4460 QEMUOptionParameter *backing_fmt, *backing_file, *size;
4461 BlockDriverState *bs = NULL;
4462 BlockDriver *drv, *proto_drv;
4463 BlockDriver *backing_drv = NULL;
1118 goto fail;
1119 }
1120
1121 filename = tmp_filename;
1122 drv = bdrv_qcow2;
1123 bs->is_temporary = 1;
1124 }
1125

--- 3358 unchanged lines hidden (view full) ---

4484 char *options, uint64_t img_size, int flags,
4485 Error **errp, bool quiet)
4486{
4487 QEMUOptionParameter *param = NULL, *create_options = NULL;
4488 QEMUOptionParameter *backing_fmt, *backing_file, *size;
4489 BlockDriverState *bs = NULL;
4490 BlockDriver *drv, *proto_drv;
4491 BlockDriver *backing_drv = NULL;
4492 Error *local_err = NULL;
4464 int ret = 0;
4465
4466 /* Find driver and parse its options */
4467 drv = bdrv_find_format(fmt);
4468 if (!drv) {
4469 error_setg(errp, "Unknown file format '%s'", fmt);
4470 return;
4471 }

--- 70 unchanged lines hidden (view full) ---

4542
4543 /* backing files always opened read-only */
4544 back_flags =
4545 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
4546
4547 bs = bdrv_new("");
4548
4549 ret = bdrv_open(bs, backing_file->value.s, NULL, back_flags,
4493 int ret = 0;
4494
4495 /* Find driver and parse its options */
4496 drv = bdrv_find_format(fmt);
4497 if (!drv) {
4498 error_setg(errp, "Unknown file format '%s'", fmt);
4499 return;
4500 }

--- 70 unchanged lines hidden (view full) ---

4571
4572 /* backing files always opened read-only */
4573 back_flags =
4574 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
4575
4576 bs = bdrv_new("");
4577
4578 ret = bdrv_open(bs, backing_file->value.s, NULL, back_flags,
4550 backing_drv, NULL);
4579 backing_drv, &local_err);
4551 if (ret < 0) {
4580 if (ret < 0) {
4552 error_setg_errno(errp, -ret, "Could not open '%s'",
4553 backing_file->value.s);
4581 error_setg_errno(errp, -ret, "Could not open '%s': %s",
4582 backing_file->value.s,
4583 error_get_pretty(local_err));
4584 error_free(local_err);
4585 local_err = NULL;
4554 goto out;
4555 }
4556 bdrv_get_geometry(bs, &size);
4557 size *= 512;
4558
4559 snprintf(buf, sizeof(buf), "%" PRId64, size);
4560 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
4561 } else {
4562 error_setg(errp, "Image creation needs a size parameter");
4563 goto out;
4564 }
4565 }
4566
4567 if (!quiet) {
4568 printf("Formatting '%s', fmt=%s ", filename, fmt);
4569 print_option_parameters(param);
4570 puts("");
4571 }
4586 goto out;
4587 }
4588 bdrv_get_geometry(bs, &size);
4589 size *= 512;
4590
4591 snprintf(buf, sizeof(buf), "%" PRId64, size);
4592 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
4593 } else {
4594 error_setg(errp, "Image creation needs a size parameter");
4595 goto out;
4596 }
4597 }
4598
4599 if (!quiet) {
4600 printf("Formatting '%s', fmt=%s ", filename, fmt);
4601 print_option_parameters(param);
4602 puts("");
4603 }
4572 ret = bdrv_create(drv, filename, param);
4573 if (ret < 0) {
4574 if (ret == -ENOTSUP) {
4575 error_setg(errp,"Formatting or formatting option not supported for "
4576 "file format '%s'", fmt);
4577 } else if (ret == -EFBIG) {
4578 const char *cluster_size_hint = "";
4579 if (get_option_parameter(create_options, BLOCK_OPT_CLUSTER_SIZE)) {
4580 cluster_size_hint = " (try using a larger cluster size)";
4581 }
4582 error_setg(errp, "The image size is too large for file format '%s'%s",
4583 fmt, cluster_size_hint);
4584 } else {
4585 error_setg(errp, "%s: error while creating %s: %s", filename, fmt,
4586 strerror(-ret));
4604 ret = bdrv_create(drv, filename, param, &local_err);
4605 if (ret == -EFBIG) {
4606 /* This is generally a better message than whatever the driver would
4607 * deliver (especially because of the cluster_size_hint), since that
4608 * is most probably not much different from "image too large". */
4609 const char *cluster_size_hint = "";
4610 if (get_option_parameter(create_options, BLOCK_OPT_CLUSTER_SIZE)) {
4611 cluster_size_hint = " (try using a larger cluster size)";
4587 }
4612 }
4613 error_setg(errp, "The image size is too large for file format '%s'"
4614 "%s", fmt, cluster_size_hint);
4615 error_free(local_err);
4616 local_err = NULL;
4588 }
4589
4590out:
4591 free_option_parameters(create_options);
4592 free_option_parameters(param);
4593
4594 if (bs) {
4595 bdrv_unref(bs);
4596 }
4617 }
4618
4619out:
4620 free_option_parameters(create_options);
4621 free_option_parameters(param);
4622
4623 if (bs) {
4624 bdrv_unref(bs);
4625 }
4626 if (error_is_set(&local_err)) {
4627 error_propagate(errp, local_err);
4628 }
4597}
4598
4599AioContext *bdrv_get_aio_context(BlockDriverState *bs)
4600{
4601 /* Currently BlockDriverState always uses the main loop AioContext */
4602 return qemu_get_aio_context();
4603}
4604

--- 13 unchanged lines hidden --- 		4629}
4630
4631AioContext *bdrv_get_aio_context(BlockDriverState *bs)
4632{
4633 /* Currently BlockDriverState always uses the main loop AioContext */
4634 return qemu_get_aio_context();
4635}
4636

--- 13 unchanged lines hidden ---