+16

block/qcow.c

··· 379 379 /* update the L1 entry */ 380 380 s->l1_table[l1_index] = l2_offset; 381 381 tmp = cpu_to_be64(l2_offset); 382 382 + BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); 382 383 ret = bdrv_pwrite_sync(bs->file, 383 384 s->l1_table_offset + l1_index * sizeof(tmp), 384 385 &tmp, sizeof(tmp)); ··· 409 410 } 410 411 } 411 412 l2_table = s->l2_cache + (min_index << s->l2_bits); 413 413 + BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD); 412 414 if (new_l2_table) { 413 415 memset(l2_table, 0, s->l2_size * sizeof(uint64_t)); 414 416 ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table, ··· 432 434 ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) { 433 435 if (!allocate) 434 436 return 0; 437 437 + BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC); 435 438 /* allocate a new cluster */ 436 439 if ((cluster_offset & QCOW_OFLAG_COMPRESSED) && 437 440 (n_end - n_start) < s->cluster_sectors) { ··· 447 450 } 448 451 cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size); 449 452 /* write the cluster content */ 453 453 + BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); 450 454 ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache, 451 455 s->cluster_size); 452 456 if (ret < 0) { ··· 486 490 NULL) < 0) { 487 491 return -EIO; 488 492 } 493 493 + BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); 489 494 ret = bdrv_pwrite(bs->file, 490 495 cluster_offset + i * 512, 491 496 s->cluster_data, 512); ··· 503 508 /* update L2 table */ 504 509 tmp = cpu_to_be64(cluster_offset); 505 510 l2_table[l2_index] = tmp; 511 511 + if (allocate == 2) { 512 512 + BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED); 513 513 + } else { 514 514 + BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE); 515 515 + } 506 516 ret = bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp), 507 517 &tmp, sizeof(tmp)); 508 518 if (ret < 0) { ··· 579 589 if (s->cluster_cache_offset != coffset) { 580 590 csize = cluster_offset >> (63 - s->cluster_bits); 581 591 csize &= (s->cluster_size - 1); 592 592 + BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED); 582 593 ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize); 583 594 if (ret != csize) 584 595 return -1; ··· 635 646 hd_iov.iov_len = n * 512; 636 647 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1); 637 648 qemu_co_mutex_unlock(&s->lock); 649 649 + /* qcow2 emits this on bs->file instead of bs->backing */ 650 650 + BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); 638 651 ret = bdrv_co_readv(bs->backing, sector_num, n, &hd_qiov); 639 652 qemu_co_mutex_lock(&s->lock); 640 653 if (ret < 0) { ··· 661 674 hd_iov.iov_len = n * 512; 662 675 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1); 663 676 qemu_co_mutex_unlock(&s->lock); 677 677 + BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); 664 678 ret = bdrv_co_readv(bs->file, 665 679 (cluster_offset >> 9) + index_in_cluster, 666 680 n, &hd_qiov); ··· 754 768 hd_iov.iov_len = n * 512; 755 769 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1); 756 770 qemu_co_mutex_unlock(&s->lock); 771 771 + BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); 757 772 ret = bdrv_co_writev(bs->file, 758 773 (cluster_offset >> 9) + index_in_cluster, 759 774 n, &hd_qiov); ··· 1048 1063 .iov_len = out_len, 1049 1064 }; 1050 1065 qemu_iovec_init_external(&hd_qiov, &iov, 1); 1066 1066 + BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED); 1051 1067 ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0); 1052 1068 if (ret < 0) { 1053 1069 goto fail;

+10

block/qcow2-bitmap.c

··· 1449 1449 bool found; 1450 1450 Qcow2BitmapList *bm_list; 1451 1451 1452 1452 + if (s->qcow_version < 3) { 1453 1453 + /* Without autoclear_features, we would always have to assume 1454 1454 + * that a program without persistent dirty bitmap support has 1455 1455 + * accessed this qcow2 file when opening it, and would thus 1456 1456 + * have to drop all dirty bitmaps (defeating their purpose). 1457 1457 + */ 1458 1458 + error_setg(errp, "Cannot store dirty bitmaps in qcow2 v2 files"); 1459 1459 + goto fail; 1460 1460 + } 1461 1461 + 1452 1462 if (check_constraints_on_bitmap(bs, name, granularity, errp) != 0) { 1453 1463 goto fail; 1454 1464 }

+58 -12

block/qcow2-refcount.c

··· 1508 1508 static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res, 1509 1509 void **refcount_table, 1510 1510 int64_t *refcount_table_size, int64_t l2_offset, 1511 1511 - int flags) 1511 1511 + int flags, BdrvCheckMode fix) 1512 1512 { 1513 1513 BDRVQcow2State *s = bs->opaque; 1514 1514 uint64_t *l2_table, l2_entry; ··· 1579 1579 next_contiguous_offset = offset + s->cluster_size; 1580 1580 } 1581 1581 1582 1582 + /* Correct offsets are cluster aligned */ 1583 1583 + if (offset_into_cluster(s, offset)) { 1584 1584 + if (qcow2_get_cluster_type(l2_entry) == 1585 1585 + QCOW2_CLUSTER_ZERO_ALLOC) 1586 1586 + { 1587 1587 + fprintf(stderr, "%s offset=%" PRIx64 ": Preallocated zero " 1588 1588 + "cluster is not properly aligned; L2 entry " 1589 1589 + "corrupted.\n", 1590 1590 + fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR", 1591 1591 + offset); 1592 1592 + if (fix & BDRV_FIX_ERRORS) { 1593 1593 + uint64_t l2e_offset = 1594 1594 + l2_offset + (uint64_t)i * sizeof(uint64_t); 1595 1595 + 1596 1596 + l2_entry = QCOW_OFLAG_ZERO; 1597 1597 + l2_table[i] = cpu_to_be64(l2_entry); 1598 1598 + ret = qcow2_pre_write_overlap_check(bs, 1599 1599 + QCOW2_OL_ACTIVE_L2 | QCOW2_OL_INACTIVE_L2, 1600 1600 + l2e_offset, sizeof(uint64_t)); 1601 1601 + if (ret < 0) { 1602 1602 + fprintf(stderr, "ERROR: Overlap check failed\n"); 1603 1603 + res->check_errors++; 1604 1604 + /* Something is seriously wrong, so abort checking 1605 1605 + * this L2 table */ 1606 1606 + goto fail; 1607 1607 + } 1608 1608 + 1609 1609 + ret = bdrv_pwrite_sync(bs->file, l2e_offset, 1610 1610 + &l2_table[i], sizeof(uint64_t)); 1611 1611 + if (ret < 0) { 1612 1612 + fprintf(stderr, "ERROR: Failed to overwrite L2 " 1613 1613 + "table entry: %s\n", strerror(-ret)); 1614 1614 + res->check_errors++; 1615 1615 + /* Do not abort, continue checking the rest of this 1616 1616 + * L2 table's entries */ 1617 1617 + } else { 1618 1618 + res->corruptions_fixed++; 1619 1619 + /* Skip marking the cluster as used 1620 1620 + * (it is unused now) */ 1621 1621 + continue; 1622 1622 + } 1623 1623 + } else { 1624 1624 + res->corruptions++; 1625 1625 + } 1626 1626 + } else { 1627 1627 + fprintf(stderr, "ERROR offset=%" PRIx64 ": Data cluster is " 1628 1628 + "not properly aligned; L2 entry corrupted.\n", offset); 1629 1629 + res->corruptions++; 1630 1630 + } 1631 1631 + } 1632 1632 + 1582 1633 /* Mark cluster as used */ 1583 1634 ret = qcow2_inc_refcounts_imrt(bs, res, 1584 1635 refcount_table, refcount_table_size, 1585 1636 offset, s->cluster_size); 1586 1637 if (ret < 0) { 1587 1638 goto fail; 1588 1588 - } 1589 1589 - 1590 1590 - /* Correct offsets are cluster aligned */ 1591 1591 - if (offset_into_cluster(s, offset)) { 1592 1592 - fprintf(stderr, "ERROR offset=%" PRIx64 ": Cluster is not " 1593 1593 - "properly aligned; L2 entry corrupted.\n", offset); 1594 1594 - res->corruptions++; 1595 1639 } 1596 1640 break; 1597 1641 } ··· 1626 1670 void **refcount_table, 1627 1671 int64_t *refcount_table_size, 1628 1672 int64_t l1_table_offset, int l1_size, 1629 1629 - int flags) 1673 1673 + int flags, BdrvCheckMode fix) 1630 1674 { 1631 1675 BDRVQcow2State *s = bs->opaque; 1632 1676 uint64_t *l1_table = NULL, l2_offset, l1_size2; ··· 1681 1725 1682 1726 /* Process and check L2 entries */ 1683 1727 ret = check_refcounts_l2(bs, res, refcount_table, 1684 1684 - refcount_table_size, l2_offset, flags); 1728 1728 + refcount_table_size, l2_offset, flags, 1729 1729 + fix); 1685 1730 if (ret < 0) { 1686 1731 goto fail; 1687 1732 } ··· 1957 2002 1958 2003 /* current L1 table */ 1959 2004 ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters, 1960 1960 - s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO); 2005 2005 + s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO, 2006 2006 + fix); 1961 2007 if (ret < 0) { 1962 2008 return ret; 1963 2009 } ··· 1966 2012 for (i = 0; i < s->nb_snapshots; i++) { 1967 2013 sn = s->snapshots + i; 1968 2014 ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters, 1969 1969 - sn->l1_table_offset, sn->l1_size, 0); 2015 2015 + sn->l1_table_offset, sn->l1_size, 0, fix); 1970 2016 if (ret < 0) { 1971 2017 return ret; 1972 2018 }

+11 -3

block/qcow2.c

··· 302 302 } 303 303 304 304 if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) { 305 305 - warn_report("a program lacking bitmap support " 306 306 - "modified this file, so all bitmaps are now " 307 307 - "considered inconsistent"); 305 305 + if (s->qcow_version < 3) { 306 306 + /* Let's be a bit more specific */ 307 307 + warn_report("This qcow2 v2 image contains bitmaps, but " 308 308 + "they may have been modified by a program " 309 309 + "without persistent bitmap support; so now " 310 310 + "they must all be considered inconsistent"); 311 311 + } else { 312 312 + warn_report("a program lacking bitmap support " 313 313 + "modified this file, so all bitmaps are now " 314 314 + "considered inconsistent"); 315 315 + } 308 316 error_printf("Some clusters may be leaked, " 309 317 "run 'qemu-img check -r' on the image " 310 318 "file to fix.");

+17 -1

block/vmdk.c

··· 1075 1075 /* Read backing data before skip range */ 1076 1076 if (skip_start_bytes > 0) { 1077 1077 if (bs->backing) { 1078 1078 + /* qcow2 emits this on bs->file instead of bs->backing */ 1079 1079 + BLKDBG_EVENT(extent->file, BLKDBG_COW_READ); 1078 1080 ret = bdrv_pread(bs->backing, offset, whole_grain, 1079 1081 skip_start_bytes); 1080 1082 if (ret < 0) { ··· 1082 1084 goto exit; 1083 1085 } 1084 1086 } 1087 1087 + BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE); 1085 1088 ret = bdrv_pwrite(extent->file, cluster_offset, whole_grain, 1086 1089 skip_start_bytes); 1087 1090 if (ret < 0) { ··· 1092 1095 /* Read backing data after skip range */ 1093 1096 if (skip_end_bytes < cluster_bytes) { 1094 1097 if (bs->backing) { 1098 1098 + /* qcow2 emits this on bs->file instead of bs->backing */ 1099 1099 + BLKDBG_EVENT(extent->file, BLKDBG_COW_READ); 1095 1100 ret = bdrv_pread(bs->backing, offset + skip_end_bytes, 1096 1101 whole_grain + skip_end_bytes, 1097 1102 cluster_bytes - skip_end_bytes); ··· 1100 1105 goto exit; 1101 1106 } 1102 1107 } 1108 1108 + BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE); 1103 1109 ret = bdrv_pwrite(extent->file, cluster_offset + skip_end_bytes, 1104 1110 whole_grain + skip_end_bytes, 1105 1111 cluster_bytes - skip_end_bytes); ··· 1120 1126 { 1121 1127 offset = cpu_to_le32(offset); 1122 1128 /* update L2 table */ 1129 1129 + BLKDBG_EVENT(extent->file, BLKDBG_L2_UPDATE); 1123 1130 if (bdrv_pwrite_sync(extent->file, 1124 1131 ((int64_t)m_data->l2_offset * 512) 1125 1132 + (m_data->l2_index * sizeof(offset)), ··· 1218 1225 } 1219 1226 } 1220 1227 l2_table = extent->l2_cache + (min_index * extent->l2_size); 1228 1228 + BLKDBG_EVENT(extent->file, BLKDBG_L2_LOAD); 1221 1229 if (bdrv_pread(extent->file, 1222 1230 (int64_t)l2_offset * 512, 1223 1231 l2_table, ··· 1393 1401 .iov_len = n_bytes, 1394 1402 }; 1395 1403 qemu_iovec_init_external(&local_qiov, &iov, 1); 1404 1404 + 1405 1405 + BLKDBG_EVENT(extent->file, BLKDBG_WRITE_COMPRESSED); 1396 1406 } else { 1397 1407 qemu_iovec_init(&local_qiov, qiov->niov); 1398 1408 qemu_iovec_concat(&local_qiov, qiov, qiov_offset, n_bytes); 1409 1409 + 1410 1410 + BLKDBG_EVENT(extent->file, BLKDBG_WRITE_AIO); 1399 1411 } 1400 1412 1401 1401 - write_offset = cluster_offset + offset_in_cluster, 1413 1413 + write_offset = cluster_offset + offset_in_cluster; 1402 1414 ret = bdrv_co_pwritev(extent->file, write_offset, n_bytes, 1403 1415 &local_qiov, 0); 1404 1416 ··· 1437 1449 1438 1450 1439 1451 if (!extent->compressed) { 1452 1452 + BLKDBG_EVENT(extent->file, BLKDBG_READ_AIO); 1440 1453 ret = bdrv_co_preadv(extent->file, 1441 1454 cluster_offset + offset_in_cluster, bytes, 1442 1455 qiov, 0); ··· 1450 1463 buf_bytes = cluster_bytes * 2; 1451 1464 cluster_buf = g_malloc(buf_bytes); 1452 1465 uncomp_buf = g_malloc(cluster_bytes); 1466 1466 + BLKDBG_EVENT(extent->file, BLKDBG_READ_COMPRESSED); 1453 1467 ret = bdrv_pread(extent->file, 1454 1468 cluster_offset, 1455 1469 cluster_buf, buf_bytes); ··· 1527 1541 qemu_iovec_reset(&local_qiov); 1528 1542 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes); 1529 1543 1544 1544 + /* qcow2 emits this on bs->file instead of bs->backing */ 1545 1545 + BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); 1530 1546 ret = bdrv_co_preadv(bs->backing, offset, n_bytes, 1531 1547 &local_qiov, 0); 1532 1548 if (ret < 0) {

+23 -7

blockdev.c

··· 60 60 61 61 static int do_open_tray(const char *blk_name, const char *qdev_id, 62 62 bool force, Error **errp); 63 63 + static void blockdev_remove_medium(bool has_device, const char *device, 64 64 + bool has_id, const char *id, Error **errp); 65 65 + static void blockdev_insert_medium(bool has_device, const char *device, 66 66 + bool has_id, const char *id, 67 67 + const char *node_name, Error **errp); 63 68 64 69 static const char *const if_name[IF_COUNT] = { 65 70 [IF_NONE] = "none", ··· 2323 2328 } 2324 2329 error_free(local_err); 2325 2330 2326 2326 - qmp_x_blockdev_remove_medium(has_device, device, has_id, id, errp); 2331 2331 + blockdev_remove_medium(has_device, device, has_id, id, errp); 2327 2332 } 2328 2333 2329 2334 void qmp_block_passwd(bool has_device, const char *device, ··· 2446 2451 } 2447 2452 } 2448 2453 2449 2449 - void qmp_x_blockdev_remove_medium(bool has_device, const char *device, 2450 2450 - bool has_id, const char *id, Error **errp) 2454 2454 + static void blockdev_remove_medium(bool has_device, const char *device, 2455 2455 + bool has_id, const char *id, Error **errp) 2451 2456 { 2452 2457 BlockBackend *blk; 2453 2458 BlockDriverState *bs; ··· 2503 2508 aio_context_release(aio_context); 2504 2509 } 2505 2510 2511 2511 + void qmp_blockdev_remove_medium(const char *id, Error **errp) 2512 2512 + { 2513 2513 + blockdev_remove_medium(false, NULL, true, id, errp); 2514 2514 + } 2515 2515 + 2506 2516 static void qmp_blockdev_insert_anon_medium(BlockBackend *blk, 2507 2517 BlockDriverState *bs, Error **errp) 2508 2518 { ··· 2548 2558 } 2549 2559 } 2550 2560 2551 2551 - void qmp_x_blockdev_insert_medium(bool has_device, const char *device, 2552 2552 - bool has_id, const char *id, 2553 2553 - const char *node_name, Error **errp) 2561 2561 + static void blockdev_insert_medium(bool has_device, const char *device, 2562 2562 + bool has_id, const char *id, 2563 2563 + const char *node_name, Error **errp) 2554 2564 { 2555 2565 BlockBackend *blk; 2556 2566 BlockDriverState *bs; ··· 2574 2584 } 2575 2585 2576 2586 qmp_blockdev_insert_anon_medium(blk, bs, errp); 2587 2587 + } 2588 2588 + 2589 2589 + void qmp_blockdev_insert_medium(const char *id, const char *node_name, 2590 2590 + Error **errp) 2591 2591 + { 2592 2592 + blockdev_insert_medium(false, NULL, true, id, node_name, errp); 2577 2593 } 2578 2594 2579 2595 void qmp_blockdev_change_medium(bool has_device, const char *device, ··· 2650 2666 error_free(err); 2651 2667 err = NULL; 2652 2668 2653 2653 - qmp_x_blockdev_remove_medium(has_device, device, has_id, id, &err); 2669 2669 + blockdev_remove_medium(has_device, device, has_id, id, &err); 2654 2670 if (err) { 2655 2671 error_propagate(errp, err); 2656 2672 goto fail;

+34 -5

hw/block/nvme.c

··· 91 91 return sq->head == sq->tail; 92 92 } 93 93 94 94 - static void nvme_isr_notify(NvmeCtrl *n, NvmeCQueue *cq) 94 94 + static void nvme_irq_check(NvmeCtrl *n) 95 95 + { 96 96 + if (msix_enabled(&(n->parent_obj))) { 97 97 + return; 98 98 + } 99 99 + if (~n->bar.intms & n->irq_status) { 100 100 + pci_irq_assert(&n->parent_obj); 101 101 + } else { 102 102 + pci_irq_deassert(&n->parent_obj); 103 103 + } 104 104 + } 105 105 + 106 106 + static void nvme_irq_assert(NvmeCtrl *n, NvmeCQueue *cq) 95 107 { 96 108 if (cq->irq_enabled) { 97 109 if (msix_enabled(&(n->parent_obj))) { ··· 99 111 msix_notify(&(n->parent_obj), cq->vector); 100 112 } else { 101 113 trace_nvme_irq_pin(); 102 102 - pci_irq_pulse(&n->parent_obj); 114 114 + assert(cq->cqid < 64); 115 115 + n->irq_status |= 1 << cq->cqid; 116 116 + nvme_irq_check(n); 103 117 } 104 118 } else { 105 119 trace_nvme_irq_masked(); 120 120 + } 121 121 + } 122 122 + 123 123 + static void nvme_irq_deassert(NvmeCtrl *n, NvmeCQueue *cq) 124 124 + { 125 125 + if (cq->irq_enabled) { 126 126 + if (msix_enabled(&(n->parent_obj))) { 127 127 + return; 128 128 + } else { 129 129 + assert(cq->cqid < 64); 130 130 + n->irq_status &= ~(1 << cq->cqid); 131 131 + nvme_irq_check(n); 132 132 + } 106 133 } 107 134 } 108 135 ··· 242 269 sizeof(req->cqe)); 243 270 QTAILQ_INSERT_TAIL(&sq->req_list, req, entry); 244 271 } 245 245 - nvme_isr_notify(n, cq); 272 272 + nvme_irq_assert(n, cq); 246 273 } 247 274 248 275 static void nvme_enqueue_req_completion(NvmeCQueue *cq, NvmeRequest *req) ··· 905 932 n->bar.intmc = n->bar.intms; 906 933 trace_nvme_mmio_intm_set(data & 0xffffffff, 907 934 n->bar.intmc); 935 935 + nvme_irq_check(n); 908 936 break; 909 937 case 0x10: /* INTMC */ 910 938 if (unlikely(msix_enabled(&(n->parent_obj)))) { ··· 917 945 n->bar.intmc = n->bar.intms; 918 946 trace_nvme_mmio_intm_clr(data & 0xffffffff, 919 947 n->bar.intmc); 948 948 + nvme_irq_check(n); 920 949 break; 921 950 case 0x14: /* CC */ 922 951 trace_nvme_mmio_cfg(data & 0xffffffff); ··· 1085 1114 timer_mod(cq->timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 500); 1086 1115 } 1087 1116 1088 1088 - if (cq->tail != cq->head) { 1089 1089 - nvme_isr_notify(n, cq); 1117 1117 + if (cq->tail == cq->head) { 1118 1118 + nvme_irq_deassert(n, cq); 1090 1119 } 1091 1120 } else { 1092 1121 /* Submission queue doorbell write */

+1

hw/block/nvme.h

··· 775 775 uint32_t cmbsz; 776 776 uint32_t cmbloc; 777 777 uint8_t *cmbuf; 778 778 + uint64_t irq_status; 778 779 779 780 char *serial; 780 781 NvmeNamespace *namespaces;

+15 -27

qapi/block-core.json

··· 3421 3421 '*id': 'str' } } 3422 3422 3423 3423 ## 3424 3424 - # @x-blockdev-remove-medium: 3424 3424 + # @blockdev-remove-medium: 3425 3425 # 3426 3426 # Removes a medium (a block driver state tree) from a block device. That block 3427 3427 # device's tray must currently be open (unless there is no attached guest ··· 3429 3429 # 3430 3430 # If the tray is open and there is no medium inserted, this will be a no-op. 3431 3431 # 3432 3432 - # @device: Block device name (deprecated, use @id instead) 3432 3432 + # @id: The name or QOM path of the guest device 3433 3433 # 3434 3434 - # @id: The name or QOM path of the guest device (since: 2.8) 3435 3435 - # 3436 3436 - # Note: This command is still a work in progress and is considered experimental. 3437 3437 - # Stay away from it unless you want to help with its development. 3438 3438 - # 3439 3439 - # Since: 2.5 3434 3434 + # Since: 2.12 3440 3435 # 3441 3436 # Example: 3442 3437 # 3443 3443 - # -> { "execute": "x-blockdev-remove-medium", 3438 3438 + # -> { "execute": "blockdev-remove-medium", 3444 3439 # "arguments": { "id": "ide0-1-0" } } 3445 3440 # 3446 3441 # <- { "error": { "class": "GenericError", ··· 3458 3453 # 3459 3454 # <- { "return": {} } 3460 3455 # 3461 3461 - # -> { "execute": "x-blockdev-remove-medium", 3456 3456 + # -> { "execute": "blockdev-remove-medium", 3462 3457 # "arguments": { "id": "ide0-1-0" } } 3463 3458 # 3464 3459 # <- { "return": {} } 3465 3460 # 3466 3461 ## 3467 3467 - { 'command': 'x-blockdev-remove-medium', 3468 3468 - 'data': { '*device': 'str', 3469 3469 - '*id': 'str' } } 3462 3462 + { 'command': 'blockdev-remove-medium', 3463 3463 + 'data': { 'id': 'str' } } 3470 3464 3471 3465 ## 3472 3472 - # @x-blockdev-insert-medium: 3466 3466 + # @blockdev-insert-medium: 3473 3467 # 3474 3468 # Inserts a medium (a block driver state tree) into a block device. That block 3475 3469 # device's tray must currently be open (unless there is no attached guest 3476 3470 # device) and there must be no medium inserted already. 3477 3471 # 3478 3478 - # @device: Block device name (deprecated, use @id instead) 3479 3479 - # 3480 3480 - # @id: The name or QOM path of the guest device (since: 2.8) 3472 3472 + # @id: The name or QOM path of the guest device 3481 3473 # 3482 3474 # @node-name: name of a node in the block driver state graph 3483 3475 # 3484 3484 - # Note: This command is still a work in progress and is considered experimental. 3485 3485 - # Stay away from it unless you want to help with its development. 3486 3486 - # 3487 3487 - # Since: 2.5 3476 3476 + # Since: 2.12 3488 3477 # 3489 3478 # Example: 3490 3479 # ··· 3496 3485 # "filename": "fedora.iso" } } } 3497 3486 # <- { "return": {} } 3498 3487 # 3499 3499 - # -> { "execute": "x-blockdev-insert-medium", 3488 3488 + # -> { "execute": "blockdev-insert-medium", 3500 3489 # "arguments": { "id": "ide0-1-0", 3501 3490 # "node-name": "node0" } } 3502 3491 # 3503 3492 # <- { "return": {} } 3504 3493 # 3505 3494 ## 3506 3506 - { 'command': 'x-blockdev-insert-medium', 3507 3507 - 'data': { '*device': 'str', 3508 3508 - '*id': 'str', 3495 3495 + { 'command': 'blockdev-insert-medium', 3496 3496 + 'data': { 'id': 'str', 3509 3497 'node-name': 'str'} } 3510 3498 3511 3499 ··· 3533 3521 # 3534 3522 # Changes the medium inserted into a block device by ejecting the current medium 3535 3523 # and loading a new image file which is inserted as the new medium (this command 3536 3536 - # combines blockdev-open-tray, x-blockdev-remove-medium, 3537 3537 - # x-blockdev-insert-medium and blockdev-close-tray). 3524 3524 + # combines blockdev-open-tray, blockdev-remove-medium, blockdev-insert-medium 3525 3525 + # and blockdev-close-tray). 3538 3526 # 3539 3527 # @device: Block device name (deprecated, use @id instead) 3540 3528 #

+1

tests/.gitignore

··· 18 18 test-aio-multithread 19 19 test-arm-mptimer 20 20 test-base64 21 21 + test-bdrv-drain 21 22 test-bitops 22 23 test-bitcnt 23 24 test-blockjob

+8 -8

tests/ahci-test.c

··· 1578 1578 QDict *rsp; 1579 1579 1580 1580 fd = prepare_iso(iso_size, &tx, &iso); 1581 1581 - ahci = ahci_boot_and_enable("-drive if=none,id=drive0,file=%s,format=raw " 1581 1581 + ahci = ahci_boot_and_enable("-blockdev node-name=drive0,driver=file,filename=%s " 1582 1582 "-M q35 " 1583 1583 - "-device ide-cd,drive=drive0 ", iso); 1583 1583 + "-device ide-cd,id=cd0,drive=drive0 ", iso); 1584 1584 port = ahci_port_select(ahci); 1585 1585 1586 1586 ahci_atapi_eject(ahci, port); ··· 1591 1591 1592 1592 /* Remove media */ 1593 1593 qmp_async("{'execute': 'blockdev-open-tray', " 1594 1594 - "'arguments': {'device': 'drive0'}}"); 1594 1594 + "'arguments': {'id': 'cd0'}}"); 1595 1595 atapi_wait_tray(true); 1596 1596 rsp = qmp_receive(); 1597 1597 QDECREF(rsp); 1598 1598 1599 1599 - qmp_discard_response("{'execute': 'x-blockdev-remove-medium', " 1600 1600 - "'arguments': {'device': 'drive0'}}"); 1599 1599 + qmp_discard_response("{'execute': 'blockdev-remove-medium', " 1600 1600 + "'arguments': {'id': 'cd0'}}"); 1601 1601 1602 1602 /* Test the tray without a medium */ 1603 1603 ahci_atapi_load(ahci, port); ··· 1612 1612 "'driver': 'raw', " 1613 1613 "'file': { 'driver': 'file', " 1614 1614 "'filename': %s }}}", iso); 1615 1615 - qmp_discard_response("{'execute': 'x-blockdev-insert-medium'," 1616 1616 - "'arguments': { 'device': 'drive0', " 1615 1615 + qmp_discard_response("{'execute': 'blockdev-insert-medium'," 1616 1616 + "'arguments': { 'id': 'cd0', " 1617 1617 "'node-name': 'node0' }}"); 1618 1618 1619 1619 /* Again, the event shows up first */ 1620 1620 qmp_async("{'execute': 'blockdev-close-tray', " 1621 1621 - "'arguments': {'device': 'drive0'}}"); 1621 1621 + "'arguments': {'id': 'cd0'}}"); 1622 1622 atapi_wait_tray(false); 1623 1623 rsp = qmp_receive(); 1624 1624 QDECREF(rsp);

+7 -10

tests/qemu-iotests/020

··· 42 42 43 43 # Any format supporting backing files 44 44 _supported_fmt qcow qcow2 vmdk qed 45 45 - _supported_proto generic 46 46 - _unsupported_proto vxhs 45 45 + _supported_proto file 47 46 _supported_os Linux 48 47 _unsupported_imgopts "subformat=monolithicFlat" \ 49 48 "subformat=twoGbMaxExtentFlat" \ 50 49 "subformat=twoGbMaxExtentSparse" 51 51 - 52 52 - # NFS does not support bdrv_reopen_prepare thus qemu-img commit fails. 53 53 - if [ "$IMGPROTO" = "nfs" ]; then 54 54 - _notrun "image protocol $IMGPROTO does not support bdrv_commit" 55 55 - fi 56 50 57 51 TEST_OFFSETS="0 4294967296" 58 52 ··· 117 111 echo 'Testing failing commit' 118 112 echo 119 113 114 114 + TEST_IMG="$TEST_IMG.base" _make_test_img 1M 115 115 + 120 116 # Create an image with a null backing file to which committing will fail (with 121 117 # ENOSPC so we can distinguish the result from some generic EIO which may be 122 118 # generated anywhere in the block layer) 123 123 - _make_test_img -b "json:{'driver': 'raw', 119 119 + _make_test_img -b "json:{'driver': '$IMGFMT', 124 120 'file': { 125 121 'driver': 'blkdebug', 126 122 'inject-error': [{ ··· 129 125 'once': true 130 126 }], 131 127 'image': { 132 132 - 'driver': 'null-co' 128 128 + 'driver': 'file', 129 129 + 'filename': '$TEST_IMG.base' 133 130 }}}" 134 131 135 132 # Just write anything so committing will not be a no-op 136 133 $QEMU_IO -c 'writev 0 64k' "$TEST_IMG" | _filter_qemu_io 137 134 138 135 $QEMU_IMG commit "$TEST_IMG" 139 139 - _cleanup_test_img 136 136 + _cleanup 140 137 141 138 # success, all done 142 139 echo "*** done"

+4 -2

tests/qemu-iotests/020.out

··· 1078 1078 1079 1079 Testing failing commit 1080 1080 1081 1081 - Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 backing_file=json:{'driver': 'raw',, 1081 1081 + Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=1048576 1082 1082 + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=json:{'driver': 'IMGFMT',, 1082 1083 'file': { 1083 1084 'driver': 'blkdebug',, 1084 1085 'inject-error': [{ ··· 1087 1088 'once': true 1088 1089 }],, 1089 1090 'image': { 1090 1090 - 'driver': 'null-co' 1091 1091 + 'driver': 'file',, 1092 1092 + 'filename': 'TEST_DIR/t.IMGFMT.base' 1091 1093 }}} 1092 1094 wrote 65536/65536 bytes at offset 0 1093 1095 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+2

tests/qemu-iotests/051

··· 131 131 echo === Enable and disable lazy refcounting on the command line, plus some invalid values === 132 132 echo 133 133 134 134 + _make_test_img -o compat=1.1 "$size" 135 135 + 134 136 run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=on 135 137 run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=off 136 138 run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=

+1

tests/qemu-iotests/051.out

··· 77 77 78 78 === Enable and disable lazy refcounting on the command line, plus some invalid values === 79 79 80 80 + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 80 81 Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=on 81 82 QEMU X.Y.Z monitor - type 'help' for more information 82 83 (qemu) quit

+1

tests/qemu-iotests/051.pc.out

··· 77 77 78 78 === Enable and disable lazy refcounting on the command line, plus some invalid values === 79 79 80 80 + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 80 81 Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=on 81 82 QEMU X.Y.Z monitor - type 'help' for more information 82 83 (qemu) quit

+3 -1

tests/qemu-iotests/059

··· 152 152 echo 153 153 echo "=== Testing afl image with a very large capacity ===" 154 154 _use_sample_img afl9.vmdk.bz2 155 155 - _img_info 155 155 + # The sed makes this test pass on machines with little RAM 156 156 + # (and also with 32 bit builds) 157 157 + _img_info | sed -e 's/Cannot allocate memory/Invalid argument/' 156 158 _cleanup_test_img 157 159 158 160 # success, all done

+1 -1

tests/qemu-iotests/059.out

··· 2358 2358 0x140000000 0x10000 0x50000 TEST_DIR/t-s003.vmdk 2359 2359 2360 2360 === Testing afl image with a very large capacity === 2361 2361 - qemu-img: Can't get image size 'TEST_DIR/afl9.IMGFMT': File too large 2361 2361 + qemu-img: Could not open 'TEST_DIR/afl9.IMGFMT': Could not open 'TEST_DIR/afl9.IMGFMT': Invalid argument 2362 2362 *** done

+2 -1

tests/qemu-iotests/060

··· 335 335 # Let's write to it! 336 336 $QEMU_IO -c "write 0 64k" "$TEST_IMG" | _filter_qemu_io 337 337 338 338 - # Can't repair this yet (TODO: We can just deallocate the cluster) 338 338 + echo '--- Repairing ---' 339 339 + _check_test_img -r all 339 340 340 341 echo 341 342 echo '=== Discarding with an unaligned refblock ==='

+9

tests/qemu-iotests/060.out

··· 317 317 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 318 318 qcow2: Marking image as corrupt: Preallocated zero cluster offset 0x2a00 unaligned (guest offset: 0); further corruption events will be suppressed 319 319 write failed: Input/output error 320 320 + --- Repairing --- 321 321 + Repairing offset=2a00: Preallocated zero cluster is not properly aligned; L2 entry corrupted. 322 322 + The following inconsistencies were found and repaired: 323 323 + 324 324 + 0 leaked clusters 325 325 + 1 corruptions 326 326 + 327 327 + Double checking the fixed image now... 328 328 + No errors were found on the image. 320 329 321 330 === Discarding with an unaligned refblock === 322 331

+2 -1

tests/qemu-iotests/067

··· 57 57 { 58 58 do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qmp | _filter_qemu \ 59 59 | _filter_actual_image_size \ 60 60 - | _filter_generated_node_ids | _filter_qmp_events 60 60 + | _filter_generated_node_ids | _filter_qmp_events \ 61 61 + | _filter_img_info 61 62 } 62 63 63 64 size=128M

+26 -71

tests/qemu-iotests/067.out

··· 3 3 4 4 === -drive/-device and device_del === 5 5 6 6 - Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virtio-blk,drive=disk,id=virtio0 6 6 + Testing: -drive file=TEST_DIR/t.IMGFMT,format=IMGFMT,if=none,id=disk -device virtio-blk,drive=disk,id=virtio0 7 7 { 8 8 QMP_VERSION 9 9 } ··· 23 23 "detect_zeroes": "off", 24 24 "image": { 25 25 "virtual-size": 134217728, 26 26 - "filename": "TEST_DIR/t.qcow2", 26 26 + "filename": "TEST_DIR/t.IMGFMT", 27 27 "cluster-size": 65536, 28 28 - "format": "qcow2", 28 28 + "format": "IMGFMT", 29 29 "actual-size": SIZE, 30 30 - "format-specific": { 31 31 - "type": "qcow2", 32 32 - "data": { 33 33 - "compat": "1.1", 34 34 - "lazy-refcounts": false, 35 35 - "refcount-bits": 16, 36 36 - "corrupt": false 37 37 - } 38 38 - }, 39 30 "dirty-flag": false 40 31 }, 41 32 "iops_wr": 0, 42 33 "ro": false, 43 34 "node-name": "NODE_NAME", 44 35 "backing_file_depth": 0, 45 45 - "drv": "qcow2", 36 36 + "drv": "IMGFMT", 46 37 "iops": 0, 47 38 "bps_wr": 0, 48 39 "write_threshold": 0, ··· 54 45 "direct": false, 55 46 "writeback": true 56 47 }, 57 57 - "file": "TEST_DIR/t.qcow2", 48 48 + "file": "TEST_DIR/t.IMGFMT", 58 49 "encryption_key_missing": false 59 50 }, 60 51 "qdev": "/machine/peripheral/virtio0/virtio-backend", ··· 81 72 82 73 === -drive/device_add and device_del === 83 74 84 84 - Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk 75 75 + Testing: -drive file=TEST_DIR/t.IMGFMT,format=IMGFMT,if=none,id=disk 85 76 { 86 77 QMP_VERSION 87 78 } ··· 100 91 "detect_zeroes": "off", 101 92 "image": { 102 93 "virtual-size": 134217728, 103 103 - "filename": "TEST_DIR/t.qcow2", 94 94 + "filename": "TEST_DIR/t.IMGFMT", 104 95 "cluster-size": 65536, 105 105 - "format": "qcow2", 96 96 + "format": "IMGFMT", 106 97 "actual-size": SIZE, 107 107 - "format-specific": { 108 108 - "type": "qcow2", 109 109 - "data": { 110 110 - "compat": "1.1", 111 111 - "lazy-refcounts": false, 112 112 - "refcount-bits": 16, 113 113 - "corrupt": false 114 114 - } 115 115 - }, 116 98 "dirty-flag": false 117 99 }, 118 100 "iops_wr": 0, 119 101 "ro": false, 120 102 "node-name": "NODE_NAME", 121 103 "backing_file_depth": 0, 122 122 - "drv": "qcow2", 104 104 + "drv": "IMGFMT", 123 105 "iops": 0, 124 106 "bps_wr": 0, 125 107 "write_threshold": 0, ··· 131 113 "direct": false, 132 114 "writeback": true 133 115 }, 134 134 - "file": "TEST_DIR/t.qcow2", 116 116 + "file": "TEST_DIR/t.IMGFMT", 135 117 "encryption_key_missing": false 136 118 }, 137 119 "type": "unknown" ··· 183 165 "detect_zeroes": "off", 184 166 "image": { 185 167 "virtual-size": 134217728, 186 186 - "filename": "TEST_DIR/t.qcow2", 168 168 + "filename": "TEST_DIR/t.IMGFMT", 187 169 "cluster-size": 65536, 188 188 - "format": "qcow2", 170 170 + "format": "IMGFMT", 189 171 "actual-size": SIZE, 190 190 - "format-specific": { 191 191 - "type": "qcow2", 192 192 - "data": { 193 193 - "compat": "1.1", 194 194 - "lazy-refcounts": false, 195 195 - "refcount-bits": 16, 196 196 - "corrupt": false 197 197 - } 198 198 - }, 199 172 "dirty-flag": false 200 173 }, 201 174 "iops_wr": 0, 202 175 "ro": false, 203 176 "node-name": "NODE_NAME", 204 177 "backing_file_depth": 0, 205 205 - "drv": "qcow2", 178 178 + "drv": "IMGFMT", 206 179 "iops": 0, 207 180 "bps_wr": 0, 208 181 "write_threshold": 0, ··· 214 187 "direct": false, 215 188 "writeback": true 216 189 }, 217 217 - "file": "TEST_DIR/t.qcow2", 190 190 + "file": "TEST_DIR/t.IMGFMT", 218 191 "encryption_key_missing": false 219 192 }, 220 193 "type": "unknown" ··· 263 236 "detect_zeroes": "off", 264 237 "image": { 265 238 "virtual-size": 134217728, 266 266 - "filename": "TEST_DIR/t.qcow2", 239 239 + "filename": "TEST_DIR/t.IMGFMT", 267 240 "cluster-size": 65536, 268 268 - "format": "qcow2", 241 241 + "format": "IMGFMT", 269 242 "actual-size": SIZE, 270 270 - "format-specific": { 271 271 - "type": "qcow2", 272 272 - "data": { 273 273 - "compat": "1.1", 274 274 - "lazy-refcounts": false, 275 275 - "refcount-bits": 16, 276 276 - "corrupt": false 277 277 - } 278 278 - }, 279 243 "dirty-flag": false 280 244 }, 281 245 "iops_wr": 0, 282 246 "ro": false, 283 247 "node-name": "disk", 284 248 "backing_file_depth": 0, 285 285 - "drv": "qcow2", 249 249 + "drv": "IMGFMT", 286 250 "iops": 0, 287 251 "bps_wr": 0, 288 252 "write_threshold": 0, ··· 294 258 "direct": false, 295 259 "writeback": true 296 260 }, 297 297 - "file": "TEST_DIR/t.qcow2", 261 261 + "file": "TEST_DIR/t.IMGFMT", 298 262 "encryption_key_missing": false 299 263 }, 300 264 { ··· 302 266 "detect_zeroes": "off", 303 267 "image": { 304 268 "virtual-size": 197120, 305 305 - "filename": "TEST_DIR/t.qcow2", 269 269 + "filename": "TEST_DIR/t.IMGFMT", 306 270 "format": "file", 307 271 "actual-size": SIZE, 308 272 "dirty-flag": false ··· 323 287 "direct": false, 324 288 "writeback": true 325 289 }, 326 326 - "file": "TEST_DIR/t.qcow2", 290 290 + "file": "TEST_DIR/t.IMGFMT", 327 291 "encryption_key_missing": false 328 292 } 329 293 ] ··· 347 311 "detect_zeroes": "off", 348 312 "image": { 349 313 "virtual-size": 134217728, 350 350 - "filename": "TEST_DIR/t.qcow2", 314 314 + "filename": "TEST_DIR/t.IMGFMT", 351 315 "cluster-size": 65536, 352 352 - "format": "qcow2", 316 316 + "format": "IMGFMT", 353 317 "actual-size": SIZE, 354 354 - "format-specific": { 355 355 - "type": "qcow2", 356 356 - "data": { 357 357 - "compat": "1.1", 358 358 - "lazy-refcounts": false, 359 359 - "refcount-bits": 16, 360 360 - "corrupt": false 361 361 - } 362 362 - }, 363 318 "dirty-flag": false 364 319 }, 365 320 "iops_wr": 0, 366 321 "ro": false, 367 322 "node-name": "disk", 368 323 "backing_file_depth": 0, 369 369 - "drv": "qcow2", 324 324 + "drv": "IMGFMT", 370 325 "iops": 0, 371 326 "bps_wr": 0, 372 327 "write_threshold": 0, ··· 378 333 "direct": false, 379 334 "writeback": true 380 335 }, 381 381 - "file": "TEST_DIR/t.qcow2", 336 336 + "file": "TEST_DIR/t.IMGFMT", 382 337 "encryption_key_missing": false 383 338 }, 384 339 { ··· 386 341 "detect_zeroes": "off", 387 342 "image": { 388 343 "virtual-size": 197120, 389 389 - "filename": "TEST_DIR/t.qcow2", 344 344 + "filename": "TEST_DIR/t.IMGFMT", 390 345 "format": "file", 391 346 "actual-size": SIZE, 392 347 "dirty-flag": false ··· 407 362 "direct": false, 408 363 "writeback": true 409 364 }, 410 410 - "file": "TEST_DIR/t.qcow2", 365 365 + "file": "TEST_DIR/t.IMGFMT", 411 366 "encryption_key_missing": false 412 367 } 413 368 ]

+3 -2

tests/qemu-iotests/080

··· 41 41 _supported_fmt qcow2 42 42 _supported_proto file 43 43 _supported_os Linux 44 44 - # Internal snapshots are (currently) impossible with refcount_bits=1 45 45 - _unsupported_imgopts 'refcount_bits=1[^0-9]' 44 44 + # - Internal snapshots are (currently) impossible with refcount_bits=1 45 45 + # - This is generally a test for compat=1.1 images 46 46 + _unsupported_imgopts 'refcount_bits=1[^0-9]' 'compat=0.10' 46 47 47 48 header_size=104 48 49

+2 -2

tests/qemu-iotests/089

··· 119 119 120 120 # Both options given directly and those given in the filename should be used 121 121 $QEMU_IO -c "open -o driver=qcow2 json:{\"file.filename\":\"$TEST_IMG\"}" \ 122 122 - -c "info" 2>&1 | _filter_testdir | _filter_imgfmt 122 122 + -c "info" 2>&1 | _filter_img_info 123 123 124 124 # Options given directly should be prioritized over those given in the filename 125 125 $QEMU_IO -c "open -o driver=qcow2 json:{\"driver\":\"raw\",\"file.filename\":\"$TEST_IMG\"}" \ 126 126 - -c "info" 2>&1 | _filter_testdir | _filter_imgfmt 126 126 + -c "info" 2>&1 | _filter_img_info 127 127 128 128 129 129 # success, all done

-10

tests/qemu-iotests/089.out

··· 38 38 format name: IMGFMT 39 39 cluster size: 64 KiB 40 40 vm state offset: 512 MiB 41 41 - Format specific information: 42 42 - compat: 1.1 43 43 - lazy refcounts: false 44 44 - refcount bits: 16 45 45 - corrupt: false 46 41 format name: IMGFMT 47 42 cluster size: 64 KiB 48 43 vm state offset: 512 MiB 49 49 - Format specific information: 50 50 - compat: 1.1 51 51 - lazy refcounts: false 52 52 - refcount bits: 16 53 53 - corrupt: false 54 44 *** done

+3 -3

tests/qemu-iotests/093

··· 348 348 # Now eject cd0 and insert cd1 349 349 result = self.vm.qmp("blockdev-open-tray", id='dev0') 350 350 self.assert_qmp(result, 'return', {}) 351 351 - result = self.vm.qmp("x-blockdev-remove-medium", id='dev0') 351 351 + result = self.vm.qmp("blockdev-remove-medium", id='dev0') 352 352 self.assert_qmp(result, 'return', {}) 353 353 - result = self.vm.qmp("x-blockdev-insert-medium", id='dev0', node_name='cd1') 353 353 + result = self.vm.qmp("blockdev-insert-medium", id='dev0', node_name='cd1') 354 354 self.assert_qmp(result, 'return', {}) 355 355 356 356 # Check that the I/O limits are still the same ··· 359 359 self.assert_qmp(result, 'return[0]/inserted/bps', 50) 360 360 361 361 # Eject cd1 362 362 - result = self.vm.qmp("x-blockdev-remove-medium", id='dev0') 362 362 + result = self.vm.qmp("blockdev-remove-medium", id='dev0') 363 363 self.assert_qmp(result, 'return', {}) 364 364 365 365 # Check that we can't set limits if the device has no medium

+6 -1

tests/qemu-iotests/102

··· 69 69 70 70 qemu_comm_method=monitor _launch_qemu -drive if=none,file="$TEST_IMG",id=drv0 71 71 72 72 - $QEMU_IMG resize -f raw --shrink "$TEST_IMG" $((5 * 64 * 1024)) 72 72 + # Wait for a prompt to appear (so we know qemu has opened the image) 73 73 + _send_qemu_cmd '' '(qemu)' 74 74 + 75 75 + $QEMU_IMG resize --shrink --image-opts \ 76 76 + "driver=raw,file.driver=file,file.filename=$TEST_IMG,file.locking=off" \ 77 77 + $((5 * 64 * 1024)) 73 78 74 79 _send_qemu_cmd $QEMU_HANDLE 'qemu-io drv0 map' 'allocated' \ 75 80 | sed -e 's/^(qemu).*qemu-io drv0 map...$/(qemu) qemu-io drv0 map/'

+2 -1

tests/qemu-iotests/102.out

··· 14 14 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=65536 15 15 wrote 65536/65536 bytes at offset 0 16 16 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 17 17 + QEMU X.Y.Z monitor - type 'help' for more information 17 18 Image resized. 18 18 - QEMU X.Y.Z monitor - type 'help' for more information 19 19 + (qemu) 19 20 (qemu) qemu-io drv0 map 20 21 64 KiB (0x10000) bytes allocated at offset 0 bytes (0x0) 21 22 *** done

+2

tests/qemu-iotests/103

··· 40 40 _supported_fmt qcow2 41 41 _supported_proto file nfs 42 42 _supported_os Linux 43 43 + # Internal snapshots are (currently) impossible with refcount_bits=1 44 44 + _unsupported_imgopts 'refcount_bits=1[^0-9]' 43 45 44 46 IMG_SIZE=64K 45 47

+85 -99

tests/qemu-iotests/118

··· 28 28 old_img = os.path.join(iotests.test_dir, 'test0.img') 29 29 new_img = os.path.join(iotests.test_dir, 'test1.img') 30 30 31 31 + def interface_to_device_name(interface): 32 32 + if interface == 'ide': 33 33 + return 'ide-cd' 34 34 + elif interface == 'floppy': 35 35 + return 'floppy' 36 36 + else: 37 37 + return None 38 38 + 31 39 class ChangeBaseClass(iotests.QMPTestCase): 32 40 has_opened = False 33 41 has_closed = False ··· 63 71 64 72 class GeneralChangeTestsBaseClass(ChangeBaseClass): 65 73 66 66 - device_name = None 74 74 + device_name = 'qdev0' 67 75 68 76 def test_change(self): 69 77 result = self.vm.qmp('change', device='drive0', target=new_img, ··· 79 87 self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img) 80 88 81 89 def test_blockdev_change_medium(self): 82 82 - if self.device_name is not None: 83 83 - result = self.vm.qmp('blockdev-change-medium', 84 84 - id=self.device_name, filename=new_img, 85 85 - format=iotests.imgfmt) 86 86 - else: 87 87 - result = self.vm.qmp('blockdev-change-medium', 88 88 - device='drive0', filename=new_img, 89 89 - format=iotests.imgfmt) 90 90 + result = self.vm.qmp('blockdev-change-medium', 91 91 + id=self.device_name, filename=new_img, 92 92 + format=iotests.imgfmt) 90 93 91 94 self.assert_qmp(result, 'return', {}) 92 95 ··· 99 102 self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img) 100 103 101 104 def test_eject(self): 102 102 - if self.device_name is not None: 103 103 - result = self.vm.qmp('eject', id=self.device_name, force=True) 104 104 - else: 105 105 - result = self.vm.qmp('eject', device='drive0', force=True) 105 105 + result = self.vm.qmp('eject', id=self.device_name, force=True) 106 106 self.assert_qmp(result, 'return', {}) 107 107 108 108 self.wait_for_open() ··· 113 113 self.assert_qmp_absent(result, 'return[0]/inserted') 114 114 115 115 def test_tray_eject_change(self): 116 116 - if self.device_name is not None: 117 117 - result = self.vm.qmp('eject', id=self.device_name, force=True) 118 118 - else: 119 119 - result = self.vm.qmp('eject', device='drive0', force=True) 116 116 + result = self.vm.qmp('eject', id=self.device_name, force=True) 120 117 self.assert_qmp(result, 'return', {}) 121 118 122 119 self.wait_for_open() ··· 126 123 self.assert_qmp(result, 'return[0]/tray_open', True) 127 124 self.assert_qmp_absent(result, 'return[0]/inserted') 128 125 129 129 - if self.device_name is not None: 130 130 - result = self.vm.qmp('blockdev-change-medium', id=self.device_name, 131 131 - filename=new_img, format=iotests.imgfmt) 132 132 - else: 133 133 - result = self.vm.qmp('blockdev-change-medium', device='drive0', 134 134 - filename=new_img, format=iotests.imgfmt) 126 126 + result = self.vm.qmp('blockdev-change-medium', id=self.device_name, 127 127 + filename=new_img, format=iotests.imgfmt) 135 128 self.assert_qmp(result, 'return', {}) 136 129 137 130 self.wait_for_close() ··· 142 135 self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img) 143 136 144 137 def test_tray_open_close(self): 145 145 - if self.device_name is not None: 146 146 - result = self.vm.qmp('blockdev-open-tray', 147 147 - id=self.device_name, force=True) 148 148 - else: 149 149 - result = self.vm.qmp('blockdev-open-tray', 150 150 - device='drive0', force=True) 138 138 + result = self.vm.qmp('blockdev-open-tray', 139 139 + id=self.device_name, force=True) 151 140 self.assert_qmp(result, 'return', {}) 152 141 153 142 self.wait_for_open() ··· 160 149 else: 161 150 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 162 151 163 163 - if self.device_name is not None: 164 164 - result = self.vm.qmp('blockdev-close-tray', id=self.device_name) 165 165 - else: 166 166 - result = self.vm.qmp('blockdev-close-tray', device='drive0') 152 152 + result = self.vm.qmp('blockdev-close-tray', id=self.device_name) 167 153 self.assert_qmp(result, 'return', {}) 168 154 169 155 if self.has_real_tray or not self.was_empty: ··· 178 164 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 179 165 180 166 def test_tray_eject_close(self): 181 181 - result = self.vm.qmp('eject', device='drive0', force=True) 167 167 + result = self.vm.qmp('eject', id=self.device_name, force=True) 182 168 self.assert_qmp(result, 'return', {}) 183 169 184 170 self.wait_for_open() ··· 188 174 self.assert_qmp(result, 'return[0]/tray_open', True) 189 175 self.assert_qmp_absent(result, 'return[0]/inserted') 190 176 191 191 - if self.device_name is not None: 192 192 - result = self.vm.qmp('blockdev-close-tray', id=self.device_name) 193 193 - else: 194 194 - result = self.vm.qmp('blockdev-close-tray', device='drive0') 177 177 + result = self.vm.qmp('blockdev-close-tray', id=self.device_name) 195 178 self.assert_qmp(result, 'return', {}) 196 179 197 180 self.wait_for_close() ··· 202 185 self.assert_qmp_absent(result, 'return[0]/inserted') 203 186 204 187 def test_tray_open_change(self): 205 205 - result = self.vm.qmp('blockdev-open-tray', device='drive0', force=True) 188 188 + result = self.vm.qmp('blockdev-open-tray', id=self.device_name, 189 189 + force=True) 206 190 self.assert_qmp(result, 'return', {}) 207 191 208 192 self.wait_for_open() ··· 215 199 else: 216 200 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 217 201 218 218 - result = self.vm.qmp('blockdev-change-medium', device='drive0', 202 202 + result = self.vm.qmp('blockdev-change-medium', id=self.device_name, 219 203 filename=new_img, 220 204 format=iotests.imgfmt) 221 205 self.assert_qmp(result, 'return', {}) ··· 235 219 'driver': 'file'}) 236 220 self.assert_qmp(result, 'return', {}) 237 221 238 238 - if self.device_name is not None: 239 239 - result = self.vm.qmp('blockdev-open-tray', 240 240 - id=self.device_name, force=True) 241 241 - else: 242 242 - result = self.vm.qmp('blockdev-open-tray', 243 243 - device='drive0', force=True) 222 222 + result = self.vm.qmp('blockdev-open-tray', 223 223 + id=self.device_name, force=True) 244 224 self.assert_qmp(result, 'return', {}) 245 225 246 226 self.wait_for_open() ··· 253 233 else: 254 234 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 255 235 256 256 - if self.device_name is not None: 257 257 - result = self.vm.qmp('x-blockdev-remove-medium', 258 258 - id=self.device_name) 259 259 - else: 260 260 - result = self.vm.qmp('x-blockdev-remove-medium', device='drive0') 236 236 + result = self.vm.qmp('blockdev-remove-medium', 237 237 + id=self.device_name) 261 238 self.assert_qmp(result, 'return', {}) 262 239 263 240 result = self.vm.qmp('query-block') ··· 265 242 self.assert_qmp(result, 'return[0]/tray_open', True) 266 243 self.assert_qmp_absent(result, 'return[0]/inserted') 267 244 268 268 - if self.device_name is not None: 269 269 - result = self.vm.qmp('x-blockdev-insert-medium', 270 270 - id=self.device_name, node_name='new') 271 271 - else: 272 272 - result = self.vm.qmp('x-blockdev-insert-medium', 273 273 - device='drive0', node_name='new') 245 245 + result = self.vm.qmp('blockdev-insert-medium', 246 246 + id=self.device_name, node_name='new') 274 247 self.assert_qmp(result, 'return', {}) 275 248 276 249 result = self.vm.qmp('query-block') ··· 278 251 self.assert_qmp(result, 'return[0]/tray_open', True) 279 252 self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img) 280 253 281 281 - if self.device_name is not None: 282 282 - result = self.vm.qmp('blockdev-close-tray', id=self.device_name) 283 283 - else: 284 284 - result = self.vm.qmp('blockdev-close-tray', device='drive0') 254 254 + result = self.vm.qmp('blockdev-close-tray', id=self.device_name) 285 255 self.assert_qmp(result, 'return', {}) 286 256 287 257 self.wait_for_close() ··· 292 262 self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img) 293 263 294 264 def test_close_on_closed(self): 295 295 - result = self.vm.qmp('blockdev-close-tray', device='drive0') 265 265 + result = self.vm.qmp('blockdev-close-tray', id=self.device_name) 296 266 # Should be a no-op 297 267 self.assert_qmp(result, 'return', {}) 298 268 self.assertEquals(self.vm.get_qmp_events(wait=False), []) ··· 301 271 if not self.has_real_tray: 302 272 return 303 273 304 304 - result = self.vm.qmp('x-blockdev-remove-medium', device='drive0') 274 274 + result = self.vm.qmp('blockdev-remove-medium', id=self.device_name) 305 275 self.assert_qmp(result, 'error/class', 'GenericError') 306 276 307 277 def test_insert_on_closed(self): ··· 315 285 'driver': 'file'}) 316 286 self.assert_qmp(result, 'return', {}) 317 287 318 318 - result = self.vm.qmp('x-blockdev-insert-medium', device='drive0', 288 288 + result = self.vm.qmp('blockdev-insert-medium', id=self.device_name, 319 289 node_name='new') 320 290 self.assert_qmp(result, 'error/class', 'GenericError') 321 291 ··· 326 296 qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k') 327 297 qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k') 328 298 self.vm = iotests.VM() 329 329 - if interface == 'ide': 330 330 - self.device_name = 'qdev0' 331 331 - self.vm.add_drive(old_img, 'media=%s' % media, 'none') 332 332 - self.vm.add_device('ide-cd,drive=drive0,id=%s' % self.device_name) 333 333 - else: 334 334 - self.vm.add_drive(old_img, 'media=%s' % media, interface) 299 299 + self.vm.add_drive(old_img, 'media=%s' % media, 'none') 300 300 + self.vm.add_device('%s,drive=drive0,id=%s' % 301 301 + (interface_to_device_name(interface), 302 302 + self.device_name)) 335 303 self.vm.launch() 336 304 337 305 def tearDown(self): ··· 347 315 'driver': 'file'}) 348 316 self.assert_qmp(result, 'return', {}) 349 317 350 350 - result = self.vm.qmp('blockdev-open-tray', device='drive0') 318 318 + result = self.vm.qmp('blockdev-open-tray', id=self.device_name) 351 319 self.assert_qmp(result, 'return', {}) 352 320 353 321 self.wait_for_open() 354 322 355 355 - result = self.vm.qmp('x-blockdev-insert-medium', device='drive0', 323 323 + result = self.vm.qmp('blockdev-insert-medium', id=self.device_name, 356 324 node_name='new') 357 325 self.assert_qmp(result, 'error/class', 'GenericError') 358 326 ··· 361 329 362 330 def setUp(self, media, interface): 363 331 qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k') 364 364 - self.vm = iotests.VM().add_drive(None, 'media=%s' % media, interface) 332 332 + self.vm = iotests.VM().add_drive(None, 'media=%s' % media, 'none') 333 333 + self.vm.add_device('%s,drive=drive0,id=%s' % 334 334 + (interface_to_device_name(interface), 335 335 + self.device_name)) 365 336 self.vm.launch() 366 337 367 338 def tearDown(self): ··· 369 340 os.remove(new_img) 370 341 371 342 def test_remove_on_empty(self): 372 372 - result = self.vm.qmp('blockdev-open-tray', device='drive0') 343 343 + result = self.vm.qmp('blockdev-open-tray', id=self.device_name) 373 344 self.assert_qmp(result, 'return', {}) 374 345 375 346 self.wait_for_open() 376 347 377 377 - result = self.vm.qmp('x-blockdev-remove-medium', device='drive0') 348 348 + result = self.vm.qmp('blockdev-remove-medium', id=self.device_name) 378 349 # Should be a no-op 379 350 self.assert_qmp(result, 'return', {}) 380 351 ··· 410 381 self.has_opened = True 411 382 412 383 class TestChangeReadOnly(ChangeBaseClass): 384 384 + device_name = 'qdev0' 385 385 + 413 386 def setUp(self): 414 387 qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k') 415 388 qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k') ··· 425 398 def test_ro_ro_retain(self): 426 399 os.chmod(old_img, 0444) 427 400 os.chmod(new_img, 0444) 428 428 - self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy') 401 401 + self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none') 402 402 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 429 403 self.vm.launch() 430 404 431 405 result = self.vm.qmp('query-block') 432 406 self.assert_qmp(result, 'return[0]/inserted/ro', True) 433 407 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 434 408 435 435 - result = self.vm.qmp('blockdev-change-medium', device='drive0', 409 409 + result = self.vm.qmp('blockdev-change-medium', id=self.device_name, 436 410 filename=new_img, 437 411 format=iotests.imgfmt, 438 412 read_only_mode='retain') ··· 444 418 445 419 def test_ro_rw_retain(self): 446 420 os.chmod(old_img, 0444) 447 447 - self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy') 421 421 + self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none') 422 422 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 448 423 self.vm.launch() 449 424 450 425 result = self.vm.qmp('query-block') 451 426 self.assert_qmp(result, 'return[0]/inserted/ro', True) 452 427 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 453 428 454 454 - result = self.vm.qmp('blockdev-change-medium', device='drive0', 429 429 + result = self.vm.qmp('blockdev-change-medium', id=self.device_name, 455 430 filename=new_img, 456 431 format=iotests.imgfmt, 457 432 read_only_mode='retain') ··· 463 438 464 439 def test_rw_ro_retain(self): 465 440 os.chmod(new_img, 0444) 466 466 - self.vm.add_drive(old_img, 'media=disk', 'floppy') 441 441 + self.vm.add_drive(old_img, 'media=disk', 'none') 442 442 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 467 443 self.vm.launch() 468 444 469 445 result = self.vm.qmp('query-block') 470 446 self.assert_qmp(result, 'return[0]/inserted/ro', False) 471 447 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 472 448 473 473 - result = self.vm.qmp('blockdev-change-medium', device='drive0', 449 449 + result = self.vm.qmp('blockdev-change-medium', id=self.device_name, 474 450 filename=new_img, 475 451 format=iotests.imgfmt, 476 452 read_only_mode='retain') ··· 484 460 485 461 def test_ro_rw(self): 486 462 os.chmod(old_img, 0444) 487 487 - self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy') 463 463 + self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none') 464 464 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 488 465 self.vm.launch() 489 466 490 467 result = self.vm.qmp('query-block') ··· 492 469 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 493 470 494 471 result = self.vm.qmp('blockdev-change-medium', 495 495 - device='drive0', 472 472 + id=self.device_name, 496 473 filename=new_img, 497 474 format=iotests.imgfmt, 498 475 read_only_mode='read-write') ··· 504 481 505 482 def test_rw_ro(self): 506 483 os.chmod(new_img, 0444) 507 507 - self.vm.add_drive(old_img, 'media=disk', 'floppy') 484 484 + self.vm.add_drive(old_img, 'media=disk', 'none') 485 485 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 508 486 self.vm.launch() 509 487 510 488 result = self.vm.qmp('query-block') ··· 512 490 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 513 491 514 492 result = self.vm.qmp('blockdev-change-medium', 515 515 - device='drive0', 493 493 + id=self.device_name, 516 494 filename=new_img, 517 495 format=iotests.imgfmt, 518 496 read_only_mode='read-only') ··· 523 501 self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img) 524 502 525 503 def test_make_rw_ro(self): 526 526 - self.vm.add_drive(old_img, 'media=disk', 'floppy') 504 504 + self.vm.add_drive(old_img, 'media=disk', 'none') 505 505 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 527 506 self.vm.launch() 528 507 529 508 result = self.vm.qmp('query-block') ··· 531 510 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 532 511 533 512 result = self.vm.qmp('blockdev-change-medium', 534 534 - device='drive0', 513 513 + id=self.device_name, 535 514 filename=new_img, 536 515 format=iotests.imgfmt, 537 516 read_only_mode='read-only') ··· 543 522 544 523 def test_make_ro_rw(self): 545 524 os.chmod(new_img, 0444) 546 546 - self.vm.add_drive(old_img, 'media=disk', 'floppy') 525 525 + self.vm.add_drive(old_img, 'media=disk', 'none') 526 526 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 547 527 self.vm.launch() 548 528 549 529 result = self.vm.qmp('query-block') ··· 551 531 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 552 532 553 533 result = self.vm.qmp('blockdev-change-medium', 554 554 - device='drive0', 534 534 + id=self.device_name, 555 535 filename=new_img, 556 536 format=iotests.imgfmt, 557 537 read_only_mode='read-write') ··· 563 543 564 544 def test_make_rw_ro_by_retain(self): 565 545 os.chmod(old_img, 0444) 566 566 - self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy') 546 546 + self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none') 547 547 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 567 548 self.vm.launch() 568 549 569 550 result = self.vm.qmp('query-block') 570 551 self.assert_qmp(result, 'return[0]/inserted/ro', True) 571 552 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 572 553 573 573 - result = self.vm.qmp('blockdev-change-medium', device='drive0', 554 554 + result = self.vm.qmp('blockdev-change-medium', id=self.device_name, 574 555 filename=new_img, 575 556 format=iotests.imgfmt, 576 557 read_only_mode='retain') ··· 582 563 583 564 def test_make_ro_rw_by_retain(self): 584 565 os.chmod(new_img, 0444) 585 585 - self.vm.add_drive(old_img, 'media=disk', 'floppy') 566 566 + self.vm.add_drive(old_img, 'media=disk', 'none') 567 567 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 586 568 self.vm.launch() 587 569 588 570 result = self.vm.qmp('query-block') 589 571 self.assert_qmp(result, 'return[0]/inserted/ro', False) 590 572 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 591 573 592 592 - result = self.vm.qmp('blockdev-change-medium', device='drive0', 574 574 + result = self.vm.qmp('blockdev-change-medium', id=self.device_name, 593 575 filename=new_img, 594 576 format=iotests.imgfmt, 595 577 read_only_mode='retain') ··· 601 583 602 584 def test_rw_ro_cycle(self): 603 585 os.chmod(new_img, 0444) 604 604 - self.vm.add_drive(old_img, 'media=disk', 'floppy') 586 586 + self.vm.add_drive(old_img, 'media=disk', 'none') 587 587 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 605 588 self.vm.launch() 606 589 607 590 result = self.vm.qmp('query-block') ··· 620 603 self.assert_qmp(result, 'return[0]/inserted/ro', False) 621 604 self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img) 622 605 623 623 - result = self.vm.qmp('x-blockdev-remove-medium', device='drive0') 606 606 + result = self.vm.qmp('blockdev-remove-medium', id=self.device_name) 624 607 self.assert_qmp(result, 'return', {}) 625 608 626 609 result = self.vm.qmp('query-block') 627 610 self.assert_qmp_absent(result, 'return[0]/inserted') 628 611 629 629 - result = self.vm.qmp('x-blockdev-insert-medium', device='drive0', 612 612 + result = self.vm.qmp('blockdev-insert-medium', id=self.device_name, 630 613 node_name='new') 631 614 self.assert_qmp(result, 'return', {}) 632 615 ··· 644 627 645 628 646 629 class TestBlockJobsAfterCycle(ChangeBaseClass): 630 630 + device_name = 'qdev0' 631 631 + 647 632 def setUp(self): 648 648 - qemu_img('create', '-f', iotests.imgfmt, old_img, '1M') 633 633 + qemu_img('create', '-f', iotests.imgfmt, old_img, '1440K') 649 634 650 635 self.vm = iotests.VM() 651 636 self.vm.add_drive_raw("id=drive0,driver=null-co,if=none") 637 637 + self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name) 652 638 self.vm.launch() 653 639 654 640 result = self.vm.qmp('query-block') ··· 656 642 657 643 # For device-less BBs, calling blockdev-open-tray or blockdev-close-tray 658 644 # is not necessary 659 659 - result = self.vm.qmp('x-blockdev-remove-medium', device='drive0') 645 645 + result = self.vm.qmp('blockdev-remove-medium', id=self.device_name) 660 646 self.assert_qmp(result, 'return', {}) 661 647 662 648 result = self.vm.qmp('query-block') ··· 669 655 'driver': 'file'}) 670 656 self.assert_qmp(result, 'return', {}) 671 657 672 672 - result = self.vm.qmp('x-blockdev-insert-medium', device='drive0', 658 658 + result = self.vm.qmp('blockdev-insert-medium', id=self.device_name, 673 659 node_name='node0') 674 660 self.assert_qmp(result, 'return', {}) 675 661

+2

tests/qemu-iotests/130

··· 45 45 _supported_proto generic 46 46 _unsupported_proto vxhs 47 47 _supported_os Linux 48 48 + # We are going to use lazy-refcounts 49 49 + _unsupported_imgopts 'compat=0.10' 48 50 49 51 qemu_comm_method="monitor" 50 52

+2

tests/qemu-iotests/137

··· 41 41 _supported_fmt qcow2 42 42 _supported_proto file 43 43 _supported_os Linux 44 44 + # We are going to use lazy-refcounts 45 45 + _unsupported_imgopts 'compat=0.10' 44 46 45 47 46 48 _make_test_img 64M

+1 -1

tests/qemu-iotests/139

··· 133 133 # Insert a BlockDriverState 134 134 def insertDrive(self, device, node): 135 135 self.checkBlockDriverState(node) 136 136 - result = self.vm.qmp('x-blockdev-insert-medium', 136 136 + result = self.vm.qmp('blockdev-insert-medium', 137 137 id = device, node_name = node) 138 138 self.assert_qmp(result, 'return', {}) 139 139 self.checkBlockDriverState(node)

+28 -32

tests/qemu-iotests/155

··· 51 51 target_real_backing = None 52 52 53 53 def setUp(self): 54 54 - qemu_img('create', '-f', iotests.imgfmt, back0_img, '1M') 54 54 + qemu_img('create', '-f', iotests.imgfmt, back0_img, '1440K') 55 55 qemu_img('create', '-f', iotests.imgfmt, '-b', back0_img, back1_img) 56 56 qemu_img('create', '-f', iotests.imgfmt, '-b', back1_img, back2_img) 57 57 qemu_img('create', '-f', iotests.imgfmt, '-b', back2_img, source_img) 58 58 59 59 self.vm = iotests.VM() 60 60 - self.vm.add_drive(None, '', 'none') 61 61 - self.vm.launch() 62 62 - 63 60 # Add the BDS via blockdev-add so it stays around after the mirror block 64 61 # job has been completed 65 65 - result = self.vm.qmp('blockdev-add', 66 66 - node_name='source', 67 67 - driver=iotests.imgfmt, 68 68 - file={'driver': 'file', 69 69 - 'filename': source_img}) 70 70 - self.assert_qmp(result, 'return', {}) 71 71 - 72 72 - result = self.vm.qmp('x-blockdev-insert-medium', 73 73 - device='drive0', node_name='source') 74 74 - self.assert_qmp(result, 'return', {}) 62 62 + blockdev = {'node-name': 'source', 63 63 + 'driver': iotests.imgfmt, 64 64 + 'file': {'driver': 'file', 65 65 + 'filename': source_img}} 66 66 + self.vm.add_blockdev(self.qmp_to_opts(blockdev)) 67 67 + self.vm.add_device('floppy,id=qdev0,drive=source') 68 68 + self.vm.launch() 75 69 76 70 self.assertIntactSourceBackingChain() 77 71 78 72 if self.existing: 79 73 if self.target_backing: 80 74 qemu_img('create', '-f', iotests.imgfmt, 81 81 - '-b', self.target_backing, target_img, '1M') 75 75 + '-b', self.target_backing, target_img, '1440K') 82 76 else: 83 83 - qemu_img('create', '-f', iotests.imgfmt, target_img, '1M') 77 77 + qemu_img('create', '-f', iotests.imgfmt, target_img, '1440K') 84 78 85 79 if self.cmd == 'blockdev-mirror': 86 80 options = { 'node-name': 'target', ··· 104 98 except OSError: 105 99 pass 106 100 107 107 - def findBlockNode(self, node_name, id=None): 108 108 - if id: 101 101 + def findBlockNode(self, node_name, qdev=None): 102 102 + if qdev: 109 103 result = self.vm.qmp('query-block') 110 104 for device in result['return']: 111 111 - if device['device'] == id: 105 105 + if device['qdev'] == qdev: 112 106 if node_name: 113 107 self.assert_qmp(device, 'inserted/node-name', node_name) 114 108 return device['inserted'] ··· 118 112 if node['node-name'] == node_name: 119 113 return node 120 114 121 121 - self.fail('Cannot find node %s/%s' % (id, node_name)) 115 115 + self.fail('Cannot find node %s/%s' % (qdev, node_name)) 122 116 123 117 def assertIntactSourceBackingChain(self): 124 118 node = self.findBlockNode('source') ··· 155 149 class MirrorBaseClass(BaseClass): 156 150 def runMirror(self, sync): 157 151 if self.cmd == 'blockdev-mirror': 158 158 - result = self.vm.qmp(self.cmd, device='drive0', sync=sync, 159 159 - target='target') 152 152 + result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source', 153 153 + sync=sync, target='target') 160 154 else: 161 155 if self.existing: 162 156 mode = 'existing' 163 157 else: 164 158 mode = 'absolute-paths' 165 165 - result = self.vm.qmp(self.cmd, device='drive0', sync=sync, 166 166 - target=target_img, format=iotests.imgfmt, 167 167 - mode=mode, node_name='target') 159 159 + result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source', 160 160 + sync=sync, target=target_img, 161 161 + format=iotests.imgfmt, mode=mode, 162 162 + node_name='target') 168 163 169 164 self.assert_qmp(result, 'return', {}) 170 165 171 166 self.vm.event_wait('BLOCK_JOB_READY') 172 167 173 173 - result = self.vm.qmp('block-job-complete', device='drive0') 168 168 + result = self.vm.qmp('block-job-complete', device='mirror-job') 174 169 self.assert_qmp(result, 'return', {}) 175 170 176 171 self.vm.event_wait('BLOCK_JOB_COMPLETED') ··· 178 173 def testFull(self): 179 174 self.runMirror('full') 180 175 181 181 - node = self.findBlockNode('target', 'drive0') 176 176 + node = self.findBlockNode('target', 'qdev0') 182 177 self.assertCorrectBackingImage(node, None) 183 178 self.assertIntactSourceBackingChain() 184 179 185 180 def testTop(self): 186 181 self.runMirror('top') 187 182 188 188 - node = self.findBlockNode('target', 'drive0') 183 183 + node = self.findBlockNode('target', 'qdev0') 189 184 self.assertCorrectBackingImage(node, back2_img) 190 185 self.assertIntactSourceBackingChain() 191 186 192 187 def testNone(self): 193 188 self.runMirror('none') 194 189 195 195 - node = self.findBlockNode('target', 'drive0') 190 190 + node = self.findBlockNode('target', 'qdev0') 196 191 self.assertCorrectBackingImage(node, source_img) 197 192 self.assertIntactSourceBackingChain() 198 193 ··· 233 228 existing = False 234 229 235 230 def testCommit(self): 236 236 - result = self.vm.qmp('block-commit', device='drive0', base=back1_img) 231 231 + result = self.vm.qmp('block-commit', job_id='commit-job', 232 232 + device='source', base=back1_img) 237 233 self.assert_qmp(result, 'return', {}) 238 234 239 235 self.vm.event_wait('BLOCK_JOB_READY') 240 236 241 241 - result = self.vm.qmp('block-job-complete', device='drive0') 237 237 + result = self.vm.qmp('block-job-complete', device='commit-job') 242 238 self.assert_qmp(result, 'return', {}) 243 239 244 240 self.vm.event_wait('BLOCK_JOB_COMPLETED') 245 241 246 246 - node = self.findBlockNode(None, 'drive0') 242 242 + node = self.findBlockNode(None, 'qdev0') 247 243 self.assert_qmp(node, 'image' + '/backing-image' * 0 + '/filename', 248 244 back1_img) 249 245 self.assert_qmp(node, 'image' + '/backing-image' * 1 + '/filename',

+2

tests/qemu-iotests/176

··· 48 48 _supported_fmt qcow2 49 49 _supported_proto file 50 50 _supported_os Linux 51 51 + # Persistent dirty bitmaps require compat=1.1 52 52 + _unsupported_imgopts 'compat=0.10' 51 53 52 54 function run_qemu() 53 55 {

+6 -14

tests/qemu-iotests/177

··· 2 2 # 3 3 # Test corner cases with unusual block geometries 4 4 # 5 5 - # Copyright (C) 2016-2017 Red Hat, Inc. 5 5 + # Copyright (C) 2016-2018 Red Hat, Inc. 6 6 # 7 7 # This program is free software; you can redistribute it and/or modify 8 8 # it under the terms of the GNU General Public License as published by ··· 36 36 # get standard environment, filters and checks 37 37 . ./common.rc 38 38 . ./common.filter 39 39 + 40 40 + # This test is runnable under compat=0.10; see test 204 for additional 41 41 + # tests specific to compat=1.1. 39 42 40 43 _supported_fmt qcow2 41 44 _supported_proto file ··· 43 46 CLUSTER_SIZE=1M 44 47 size=128M 45 48 options=driver=blkdebug,image.driver=qcow2 46 46 - nested_opts=image.file.driver=file,image.file.filename=$TEST_IMG 47 49 48 50 echo 49 51 echo "== setting up files ==" ··· 51 53 TEST_IMG="$TEST_IMG.base" _make_test_img $size 52 54 $QEMU_IO -c "write -P 11 0 $size" "$TEST_IMG.base" | _filter_qemu_io 53 55 _make_test_img -b "$TEST_IMG.base" 54 54 - $QEMU_IO -c "write -P 22 0 110M" "$TEST_IMG" | _filter_qemu_io 56 56 + $QEMU_IO -c "write -P 22 0 $size" "$TEST_IMG" | _filter_qemu_io 55 57 56 58 # Limited to 64k max-transfer 57 59 echo ··· 82 84 -c "discard 80000001 30M" | _filter_qemu_io 83 85 84 86 echo 85 85 - echo "== block status smaller than alignment ==" 86 86 - limits=align=4k 87 87 - $QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \ 88 88 - -c "alloc 1 1" -c "alloc 0x6dffff0 1000" -c "alloc 127m 5P" \ 89 89 - -c map | _filter_qemu_io 90 90 - 91 91 - echo 92 87 echo "== verify image content ==" 93 88 94 89 function verify_io() ··· 110 105 echo read -P 0 32M 32M 111 106 echo read -P 22 64M 13M 112 107 echo read -P $discarded 77M 29M 113 113 - echo read -P 22 106M 4M 114 114 - echo read -P 11 110M 18M 108 108 + echo read -P 22 106M 22M 115 109 } 116 110 117 111 verify_io | $QEMU_IO -r "$TEST_IMG" | _filter_qemu_io 118 118 - $QEMU_IMG map --image-opts "$options,$nested_opts,align=4k" \ 119 119 - | _filter_qemu_img_map 120 112 121 113 _check_test_img 122 114

+4 -18

tests/qemu-iotests/177.out

··· 5 5 wrote 134217728/134217728 bytes at offset 0 6 6 128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 7 7 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/t.IMGFMT.base 8 8 - wrote 115343360/115343360 bytes at offset 0 9 9 - 110 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 8 8 + wrote 134217728/134217728 bytes at offset 0 9 9 + 128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 10 10 11 11 == constrained alignment and max-transfer == 12 12 wrote 131072/131072 bytes at offset 1000 ··· 25 25 == non-power-of-2 discard limits == 26 26 discard 31457280/31457280 bytes at offset 80000001 27 27 30 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 28 28 - 29 29 - == block status smaller than alignment == 30 30 - 1/1 bytes allocated at offset 1 bytes 31 31 - 16/1000 bytes allocated at offset 110 MiB 32 32 - 0/1048576 bytes allocated at offset 127 MiB 33 33 - 110 MiB (0x6e00000) bytes allocated at offset 0 bytes (0x0) 34 34 - 18 MiB (0x1200000) bytes not allocated at offset 110 MiB (0x6e00000) 35 28 36 29 == verify image content == 37 30 read 1000/1000 bytes at offset 0 ··· 50 43 13 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 51 44 read 30408704/30408704 bytes at offset 80740352 52 45 29 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 53 53 - read 4194304/4194304 bytes at offset 111149056 54 54 - 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 55 55 - read 18874368/18874368 bytes at offset 115343360 56 56 - 18 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 57 57 - Offset Length File 58 58 - 0 0x800000 TEST_DIR/t.IMGFMT 59 59 - 0x900000 0x2400000 TEST_DIR/t.IMGFMT 60 60 - 0x3c00000 0x1100000 TEST_DIR/t.IMGFMT 61 61 - 0x6a00000 0x400000 TEST_DIR/t.IMGFMT 46 46 + read 23068672/23068672 bytes at offset 111149056 47 47 + 22 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 62 48 No errors were found on the image. 63 49 *** done

+5 -20

tests/qemu-iotests/184

··· 27 27 here=`pwd` 28 28 status=1 # failure is the default! 29 29 30 30 - _cleanup() 31 31 - { 32 32 - _cleanup_test_img 33 33 - } 34 34 - trap "_cleanup; exit \$status" 0 1 2 3 15 30 30 + trap "exit \$status" 0 1 2 3 15 35 31 36 32 # get standard environment, filters and checks 37 33 . ./common.rc 38 34 . ./common.filter 39 35 40 40 - _supported_fmt qcow2 41 41 - _supported_proto file 42 36 _supported_os Linux 43 37 44 38 function do_run_qemu() ··· 55 49 | _filter_actual_image_size 56 50 } 57 51 58 58 - _make_test_img 64M 59 52 test_throttle=$($QEMU_IMG --help|grep throttle) 60 53 [ "$test_throttle" = "" ] && _supported_fmt throttle 61 54 ··· 66 59 { "execute": "qmp_capabilities" } 67 60 { "execute": "blockdev-add", 68 61 "arguments": { 69 69 - "driver": "$IMGFMT", 70 70 - "node-name": "disk0", 71 71 - "file": { 72 72 - "driver": "file", 73 73 - "filename": "$TEST_IMG" 74 74 - } 62 62 + "driver": "null-co", 63 63 + "node-name": "disk0" 75 64 } 76 65 } 77 66 { "execute": "object-add", ··· 181 170 { "execute": "qmp_capabilities" } 182 171 { "execute": "blockdev-add", 183 172 "arguments": { 184 184 - "driver": "$IMGFMT", 185 185 - "node-name": "disk0", 186 186 - "file": { 187 187 - "driver": "file", 188 188 - "filename": "$TEST_IMG" 189 189 - } 173 173 + "driver": "null-co", 174 174 + "node-name": "disk0" 190 175 } 191 176 } 192 177 { "execute": "blockdev-add",

+9 -54

tests/qemu-iotests/184.out

··· 1 1 QA output created by 184 2 2 - Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 3 2 4 3 == checking interface == 5 4 Testing: ··· 28 27 "iops_rd": 0, 29 28 "detect_zeroes": "off", 30 29 "image": { 31 31 - "virtual-size": 67108864, 32 32 - "filename": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"qcow2\", \"file\": {\"driver\": \"file\", \"filename\": \"TEST_DIR/t.qcow2\"}}}", 33 33 - "cluster-size": 65536, 34 34 - "format": "throttle", 35 35 - "actual-size": SIZE, 36 36 - "dirty-flag": false 30 30 + "virtual-size": 1073741824, 31 31 + "filename": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"null-co\"}}", 32 32 + "format": "throttle" 37 33 }, 38 34 "iops_wr": 0, 39 35 "ro": false, ··· 51 47 "direct": false, 52 48 "writeback": true 53 49 }, 54 54 - "file": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"qcow2\", \"file\": {\"driver\": \"file\", \"filename\": \"TEST_DIR/t.qcow2\"}}}", 50 50 + "file": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"null-co\"}}", 55 51 "encryption_key_missing": false 56 52 }, 57 53 { 58 54 "iops_rd": 0, 59 55 "detect_zeroes": "off", 60 56 "image": { 61 61 - "virtual-size": 67108864, 62 62 - "filename": "TEST_DIR/t.qcow2", 63 63 - "cluster-size": 65536, 64 64 - "format": "qcow2", 65 65 - "actual-size": SIZE, 66 66 - "format-specific": { 67 67 - "type": "qcow2", 68 68 - "data": { 69 69 - "compat": "1.1", 70 70 - "lazy-refcounts": false, 71 71 - "refcount-bits": 16, 72 72 - "corrupt": false 73 73 - } 74 74 - }, 75 75 - "dirty-flag": false 57 57 + "virtual-size": 1073741824, 58 58 + "filename": "null-co://", 59 59 + "format": "null-co" 76 60 }, 77 61 "iops_wr": 0, 78 62 "ro": false, 79 63 "node-name": "disk0", 80 64 "backing_file_depth": 0, 81 81 - "drv": "qcow2", 65 65 + "drv": "null-co", 82 66 "iops": 0, 83 67 "bps_wr": 0, 84 68 "write_threshold": 0, ··· 90 74 "direct": false, 91 75 "writeback": true 92 76 }, 93 93 - "file": "TEST_DIR/t.qcow2", 94 94 - "encryption_key_missing": false 95 95 - }, 96 96 - { 97 97 - "iops_rd": 0, 98 98 - "detect_zeroes": "off", 99 99 - "image": { 100 100 - "virtual-size": 197120, 101 101 - "filename": "TEST_DIR/t.qcow2", 102 102 - "format": "file", 103 103 - "actual-size": SIZE, 104 104 - "dirty-flag": false 105 105 - }, 106 106 - "iops_wr": 0, 107 107 - "ro": false, 108 108 - "node-name": "NODE_NAME", 109 109 - "backing_file_depth": 0, 110 110 - "drv": "file", 111 111 - "iops": 0, 112 112 - "bps_wr": 0, 113 113 - "write_threshold": 0, 114 114 - "encrypted": false, 115 115 - "bps": 0, 116 116 - "bps_rd": 0, 117 117 - "cache": { 118 118 - "no-flush": false, 119 119 - "direct": false, 120 120 - "writeback": true 121 121 - }, 122 122 - "file": "TEST_DIR/t.qcow2", 77 77 + "file": "null-co://", 123 78 "encryption_key_missing": false 124 79 } 125 80 ]

+2 -3

tests/qemu-iotests/191

··· 45 45 . ./common.qemu 46 46 47 47 _supported_fmt qcow2 48 48 - _unsupported_imgopts compat=0.10 49 48 _supported_proto file 50 49 _supported_os Linux 51 50 ··· 92 91 echo 93 92 94 93 _send_qemu_cmd $h "{ 'execute': 'query-named-block-nodes' }" "^}" | 95 95 - _filter_generated_node_ids | _filter_actual_image_size 94 94 + _filter_generated_node_ids | _filter_actual_image_size | _filter_img_info 96 95 97 96 _send_qemu_cmd $h "{ 'execute': 'quit' }" "^}" 98 97 wait=1 _cleanup_qemu ··· 140 139 echo 141 140 142 141 _send_qemu_cmd $h "{ 'execute': 'query-named-block-nodes' }" "^}" | 143 143 - _filter_generated_node_ids | _filter_actual_image_size 142 142 + _filter_generated_node_ids | _filter_actual_image_size | _filter_img_info 144 143 145 144 _send_qemu_cmd $h "{ 'execute': 'quit' }" "^}" 146 145 wait=1 _cleanup_qemu

+89 -224

tests/qemu-iotests/191.out

··· 44 44 "image": { 45 45 "backing-image": { 46 46 "virtual-size": 67108864, 47 47 - "filename": "TEST_DIR/t.qcow2.base", 47 47 + "filename": "TEST_DIR/t.IMGFMT.base", 48 48 "cluster-size": 65536, 49 49 - "format": "qcow2", 49 49 + "format": "IMGFMT", 50 50 "actual-size": SIZE, 51 51 - "format-specific": { 52 52 - "type": "qcow2", 53 53 - "data": { 54 54 - "compat": "1.1", 55 55 - "lazy-refcounts": false, 56 56 - "refcount-bits": 16, 57 57 - "corrupt": false 58 58 - } 59 59 - }, 60 51 "dirty-flag": false 61 52 }, 62 62 - "backing-filename-format": "qcow2", 53 53 + "backing-filename-format": "IMGFMT", 63 54 "virtual-size": 67108864, 64 64 - "filename": "TEST_DIR/t.qcow2.ovl2", 55 55 + "filename": "TEST_DIR/t.IMGFMT.ovl2", 65 56 "cluster-size": 65536, 66 66 - "format": "qcow2", 57 57 + "format": "IMGFMT", 67 58 "actual-size": SIZE, 68 68 - "format-specific": { 69 69 - "type": "qcow2", 70 70 - "data": { 71 71 - "compat": "1.1", 72 72 - "lazy-refcounts": false, 73 73 - "refcount-bits": 16, 74 74 - "corrupt": false 75 75 - } 76 76 - }, 77 77 - "full-backing-filename": "TEST_DIR/t.qcow2.base", 78 78 - "backing-filename": "TEST_DIR/t.qcow2.base", 59 59 + "full-backing-filename": "TEST_DIR/t.IMGFMT.base", 60 60 + "backing-filename": "TEST_DIR/t.IMGFMT.base", 79 61 "dirty-flag": false 80 62 }, 81 63 "iops_wr": 0, 82 64 "ro": false, 83 65 "node-name": "top2", 84 66 "backing_file_depth": 1, 85 85 - "drv": "qcow2", 67 67 + "drv": "IMGFMT", 86 68 "iops": 0, 87 69 "bps_wr": 0, 88 70 "write_threshold": 0, 89 89 - "backing_file": "TEST_DIR/t.qcow2.base", 71 71 + "backing_file": "TEST_DIR/t.IMGFMT.base", 90 72 "encrypted": false, 91 73 "bps": 0, 92 74 "bps_rd": 0, ··· 95 77 "direct": false, 96 78 "writeback": true 97 79 }, 98 98 - "file": "TEST_DIR/t.qcow2.ovl2", 80 80 + "file": "TEST_DIR/t.IMGFMT.ovl2", 99 81 "encryption_key_missing": false 100 82 }, 101 83 { ··· 103 85 "detect_zeroes": "off", 104 86 "image": { 105 87 "virtual-size": 197120, 106 106 - "filename": "TEST_DIR/t.qcow2.ovl2", 88 88 + "filename": "TEST_DIR/t.IMGFMT.ovl2", 107 89 "format": "file", 108 90 "actual-size": SIZE, 109 91 "dirty-flag": false ··· 124 106 "direct": false, 125 107 "writeback": true 126 108 }, 127 127 - "file": "TEST_DIR/t.qcow2.ovl2", 109 109 + "file": "TEST_DIR/t.IMGFMT.ovl2", 128 110 "encryption_key_missing": false 129 111 }, 130 112 { ··· 133 115 "image": { 134 116 "backing-image": { 135 117 "virtual-size": 67108864, 136 136 - "filename": "TEST_DIR/t.qcow2.base", 118 118 + "filename": "TEST_DIR/t.IMGFMT.base", 137 119 "cluster-size": 65536, 138 138 - "format": "qcow2", 120 120 + "format": "IMGFMT", 139 121 "actual-size": SIZE, 140 140 - "format-specific": { 141 141 - "type": "qcow2", 142 142 - "data": { 143 143 - "compat": "1.1", 144 144 - "lazy-refcounts": false, 145 145 - "refcount-bits": 16, 146 146 - "corrupt": false 147 147 - } 148 148 - }, 149 122 "dirty-flag": false 150 123 }, 151 151 - "backing-filename-format": "qcow2", 124 124 + "backing-filename-format": "IMGFMT", 152 125 "virtual-size": 67108864, 153 153 - "filename": "TEST_DIR/t.qcow2", 126 126 + "filename": "TEST_DIR/t.IMGFMT", 154 127 "cluster-size": 65536, 155 155 - "format": "qcow2", 128 128 + "format": "IMGFMT", 156 129 "actual-size": SIZE, 157 157 - "format-specific": { 158 158 - "type": "qcow2", 159 159 - "data": { 160 160 - "compat": "1.1", 161 161 - "lazy-refcounts": false, 162 162 - "refcount-bits": 16, 163 163 - "corrupt": false 164 164 - } 165 165 - }, 166 166 - "full-backing-filename": "TEST_DIR/t.qcow2.base", 167 167 - "backing-filename": "TEST_DIR/t.qcow2.base", 130 130 + "full-backing-filename": "TEST_DIR/t.IMGFMT.base", 131 131 + "backing-filename": "TEST_DIR/t.IMGFMT.base", 168 132 "dirty-flag": false 169 133 }, 170 134 "iops_wr": 0, 171 135 "ro": false, 172 136 "node-name": "top", 173 137 "backing_file_depth": 1, 174 174 - "drv": "qcow2", 138 138 + "drv": "IMGFMT", 175 139 "iops": 0, 176 140 "bps_wr": 0, 177 141 "write_threshold": 0, 178 178 - "backing_file": "TEST_DIR/t.qcow2.base", 142 142 + "backing_file": "TEST_DIR/t.IMGFMT.base", 179 143 "encrypted": false, 180 144 "bps": 0, 181 145 "bps_rd": 0, ··· 184 148 "direct": false, 185 149 "writeback": true 186 150 }, 187 187 - "file": "TEST_DIR/t.qcow2", 151 151 + "file": "TEST_DIR/t.IMGFMT", 188 152 "encryption_key_missing": false 189 153 }, 190 154 { ··· 192 156 "detect_zeroes": "off", 193 157 "image": { 194 158 "virtual-size": 197120, 195 195 - "filename": "TEST_DIR/t.qcow2", 159 159 + "filename": "TEST_DIR/t.IMGFMT", 196 160 "format": "file", 197 161 "actual-size": SIZE, 198 162 "dirty-flag": false ··· 213 177 "direct": false, 214 178 "writeback": true 215 179 }, 216 216 - "file": "TEST_DIR/t.qcow2", 180 180 + "file": "TEST_DIR/t.IMGFMT", 217 181 "encryption_key_missing": false 218 182 }, 219 183 { ··· 222 186 "image": { 223 187 "backing-image": { 224 188 "virtual-size": 67108864, 225 225 - "filename": "TEST_DIR/t.qcow2.base", 189 189 + "filename": "TEST_DIR/t.IMGFMT.base", 226 190 "cluster-size": 65536, 227 227 - "format": "qcow2", 191 191 + "format": "IMGFMT", 228 192 "actual-size": SIZE, 229 229 - "format-specific": { 230 230 - "type": "qcow2", 231 231 - "data": { 232 232 - "compat": "1.1", 233 233 - "lazy-refcounts": false, 234 234 - "refcount-bits": 16, 235 235 - "corrupt": false 236 236 - } 237 237 - }, 238 193 "dirty-flag": false 239 194 }, 240 240 - "backing-filename-format": "qcow2", 195 195 + "backing-filename-format": "IMGFMT", 241 196 "virtual-size": 67108864, 242 242 - "filename": "TEST_DIR/t.qcow2.mid", 197 197 + "filename": "TEST_DIR/t.IMGFMT.mid", 243 198 "cluster-size": 65536, 244 244 - "format": "qcow2", 199 199 + "format": "IMGFMT", 245 200 "actual-size": SIZE, 246 246 - "format-specific": { 247 247 - "type": "qcow2", 248 248 - "data": { 249 249 - "compat": "1.1", 250 250 - "lazy-refcounts": false, 251 251 - "refcount-bits": 16, 252 252 - "corrupt": false 253 253 - } 254 254 - }, 255 255 - "full-backing-filename": "TEST_DIR/t.qcow2.base", 256 256 - "backing-filename": "TEST_DIR/t.qcow2.base", 201 201 + "full-backing-filename": "TEST_DIR/t.IMGFMT.base", 202 202 + "backing-filename": "TEST_DIR/t.IMGFMT.base", 257 203 "dirty-flag": false 258 204 }, 259 205 "iops_wr": 0, 260 206 "ro": false, 261 207 "node-name": "mid", 262 208 "backing_file_depth": 1, 263 263 - "drv": "qcow2", 209 209 + "drv": "IMGFMT", 264 210 "iops": 0, 265 211 "bps_wr": 0, 266 212 "write_threshold": 0, 267 267 - "backing_file": "TEST_DIR/t.qcow2.base", 213 213 + "backing_file": "TEST_DIR/t.IMGFMT.base", 268 214 "encrypted": false, 269 215 "bps": 0, 270 216 "bps_rd": 0, ··· 273 219 "direct": false, 274 220 "writeback": true 275 221 }, 276 276 - "file": "TEST_DIR/t.qcow2.mid", 222 222 + "file": "TEST_DIR/t.IMGFMT.mid", 277 223 "encryption_key_missing": false 278 224 }, 279 225 { ··· 281 227 "detect_zeroes": "off", 282 228 "image": { 283 229 "virtual-size": 393216, 284 284 - "filename": "TEST_DIR/t.qcow2.mid", 230 230 + "filename": "TEST_DIR/t.IMGFMT.mid", 285 231 "format": "file", 286 232 "actual-size": SIZE, 287 233 "dirty-flag": false ··· 302 248 "direct": false, 303 249 "writeback": true 304 250 }, 305 305 - "file": "TEST_DIR/t.qcow2.mid", 251 251 + "file": "TEST_DIR/t.IMGFMT.mid", 306 252 "encryption_key_missing": false 307 253 }, 308 254 { ··· 310 256 "detect_zeroes": "off", 311 257 "image": { 312 258 "virtual-size": 67108864, 313 313 - "filename": "TEST_DIR/t.qcow2.base", 259 259 + "filename": "TEST_DIR/t.IMGFMT.base", 314 260 "cluster-size": 65536, 315 315 - "format": "qcow2", 261 261 + "format": "IMGFMT", 316 262 "actual-size": SIZE, 317 317 - "format-specific": { 318 318 - "type": "qcow2", 319 319 - "data": { 320 320 - "compat": "1.1", 321 321 - "lazy-refcounts": false, 322 322 - "refcount-bits": 16, 323 323 - "corrupt": false 324 324 - } 325 325 - }, 326 263 "dirty-flag": false 327 264 }, 328 265 "iops_wr": 0, 329 266 "ro": false, 330 267 "node-name": "base", 331 268 "backing_file_depth": 0, 332 332 - "drv": "qcow2", 269 269 + "drv": "IMGFMT", 333 270 "iops": 0, 334 271 "bps_wr": 0, 335 272 "write_threshold": 0, ··· 341 278 "direct": false, 342 279 "writeback": true 343 280 }, 344 344 - "file": "TEST_DIR/t.qcow2.base", 281 281 + "file": "TEST_DIR/t.IMGFMT.base", 345 282 "encryption_key_missing": false 346 283 }, 347 284 { ··· 349 286 "detect_zeroes": "off", 350 287 "image": { 351 288 "virtual-size": 393216, 352 352 - "filename": "TEST_DIR/t.qcow2.base", 289 289 + "filename": "TEST_DIR/t.IMGFMT.base", 353 290 "format": "file", 354 291 "actual-size": SIZE, 355 292 "dirty-flag": false ··· 370 307 "direct": false, 371 308 "writeback": true 372 309 }, 373 373 - "file": "TEST_DIR/t.qcow2.base", 310 310 + "file": "TEST_DIR/t.IMGFMT.base", 374 311 "encryption_key_missing": false 375 312 } 376 313 ] ··· 447 384 "image": { 448 385 "backing-image": { 449 386 "virtual-size": 67108864, 450 450 - "filename": "TEST_DIR/t.qcow2.base", 387 387 + "filename": "TEST_DIR/t.IMGFMT.base", 451 388 "cluster-size": 65536, 452 452 - "format": "qcow2", 389 389 + "format": "IMGFMT", 453 390 "actual-size": SIZE, 454 454 - "format-specific": { 455 455 - "type": "qcow2", 456 456 - "data": { 457 457 - "compat": "1.1", 458 458 - "lazy-refcounts": false, 459 459 - "refcount-bits": 16, 460 460 - "corrupt": false 461 461 - } 462 462 - }, 463 391 "dirty-flag": false 464 392 }, 465 465 - "backing-filename-format": "qcow2", 393 393 + "backing-filename-format": "IMGFMT", 466 394 "virtual-size": 67108864, 467 467 - "filename": "TEST_DIR/t.qcow2.ovl2", 395 395 + "filename": "TEST_DIR/t.IMGFMT.ovl2", 468 396 "cluster-size": 65536, 469 469 - "format": "qcow2", 397 397 + "format": "IMGFMT", 470 398 "actual-size": SIZE, 471 471 - "format-specific": { 472 472 - "type": "qcow2", 473 473 - "data": { 474 474 - "compat": "1.1", 475 475 - "lazy-refcounts": false, 476 476 - "refcount-bits": 16, 477 477 - "corrupt": false 478 478 - } 479 479 - }, 480 480 - "full-backing-filename": "TEST_DIR/t.qcow2.base", 481 481 - "backing-filename": "TEST_DIR/t.qcow2.base", 399 399 + "full-backing-filename": "TEST_DIR/t.IMGFMT.base", 400 400 + "backing-filename": "TEST_DIR/t.IMGFMT.base", 482 401 "dirty-flag": false 483 402 }, 484 403 "iops_wr": 0, 485 404 "ro": true, 486 405 "node-name": "NODE_NAME", 487 406 "backing_file_depth": 1, 488 488 - "drv": "qcow2", 407 407 + "drv": "IMGFMT", 489 408 "iops": 0, 490 409 "bps_wr": 0, 491 410 "write_threshold": 0, 492 492 - "backing_file": "TEST_DIR/t.qcow2.base", 411 411 + "backing_file": "TEST_DIR/t.IMGFMT.base", 493 412 "encrypted": false, 494 413 "bps": 0, 495 414 "bps_rd": 0, ··· 498 417 "direct": false, 499 418 "writeback": true 500 419 }, 501 501 - "file": "TEST_DIR/t.qcow2.ovl2", 420 420 + "file": "TEST_DIR/t.IMGFMT.ovl2", 502 421 "encryption_key_missing": false 503 422 }, 504 423 { ··· 506 425 "detect_zeroes": "off", 507 426 "image": { 508 427 "virtual-size": 197120, 509 509 - "filename": "TEST_DIR/t.qcow2.ovl2", 428 428 + "filename": "TEST_DIR/t.IMGFMT.ovl2", 510 429 "format": "file", 511 430 "actual-size": SIZE, 512 431 "dirty-flag": false ··· 527 446 "direct": false, 528 447 "writeback": true 529 448 }, 530 530 - "file": "TEST_DIR/t.qcow2.ovl2", 449 449 + "file": "TEST_DIR/t.IMGFMT.ovl2", 531 450 "encryption_key_missing": false 532 451 }, 533 452 { ··· 537 456 "backing-image": { 538 457 "backing-image": { 539 458 "virtual-size": 67108864, 540 540 - "filename": "TEST_DIR/t.qcow2.base", 459 459 + "filename": "TEST_DIR/t.IMGFMT.base", 541 460 "cluster-size": 65536, 542 542 - "format": "qcow2", 461 461 + "format": "IMGFMT", 543 462 "actual-size": SIZE, 544 544 - "format-specific": { 545 545 - "type": "qcow2", 546 546 - "data": { 547 547 - "compat": "1.1", 548 548 - "lazy-refcounts": false, 549 549 - "refcount-bits": 16, 550 550 - "corrupt": false 551 551 - } 552 552 - }, 553 463 "dirty-flag": false 554 464 }, 555 555 - "backing-filename-format": "qcow2", 465 465 + "backing-filename-format": "IMGFMT", 556 466 "virtual-size": 67108864, 557 557 - "filename": "TEST_DIR/t.qcow2.ovl2", 467 467 + "filename": "TEST_DIR/t.IMGFMT.ovl2", 558 468 "cluster-size": 65536, 559 559 - "format": "qcow2", 469 469 + "format": "IMGFMT", 560 470 "actual-size": SIZE, 561 561 - "format-specific": { 562 562 - "type": "qcow2", 563 563 - "data": { 564 564 - "compat": "1.1", 565 565 - "lazy-refcounts": false, 566 566 - "refcount-bits": 16, 567 567 - "corrupt": false 568 568 - } 569 569 - }, 570 570 - "full-backing-filename": "TEST_DIR/t.qcow2.base", 571 571 - "backing-filename": "TEST_DIR/t.qcow2.base", 471 471 + "full-backing-filename": "TEST_DIR/t.IMGFMT.base", 472 472 + "backing-filename": "TEST_DIR/t.IMGFMT.base", 572 473 "dirty-flag": false 573 474 }, 574 574 - "backing-filename-format": "qcow2", 475 475 + "backing-filename-format": "IMGFMT", 575 476 "virtual-size": 67108864, 576 576 - "filename": "TEST_DIR/t.qcow2.ovl3", 477 477 + "filename": "TEST_DIR/t.IMGFMT.ovl3", 577 478 "cluster-size": 65536, 578 578 - "format": "qcow2", 479 479 + "format": "IMGFMT", 579 480 "actual-size": SIZE, 580 580 - "format-specific": { 581 581 - "type": "qcow2", 582 582 - "data": { 583 583 - "compat": "1.1", 584 584 - "lazy-refcounts": false, 585 585 - "refcount-bits": 16, 586 586 - "corrupt": false 587 587 - } 588 588 - }, 589 589 - "full-backing-filename": "TEST_DIR/t.qcow2.ovl2", 590 590 - "backing-filename": "TEST_DIR/t.qcow2.ovl2", 481 481 + "full-backing-filename": "TEST_DIR/t.IMGFMT.ovl2", 482 482 + "backing-filename": "TEST_DIR/t.IMGFMT.ovl2", 591 483 "dirty-flag": false 592 484 }, 593 485 "iops_wr": 0, 594 486 "ro": false, 595 487 "node-name": "top2", 596 488 "backing_file_depth": 2, 597 597 - "drv": "qcow2", 489 489 + "drv": "IMGFMT", 598 490 "iops": 0, 599 491 "bps_wr": 0, 600 492 "write_threshold": 0, 601 601 - "backing_file": "TEST_DIR/t.qcow2.ovl2", 493 493 + "backing_file": "TEST_DIR/t.IMGFMT.ovl2", 602 494 "encrypted": false, 603 495 "bps": 0, 604 496 "bps_rd": 0, ··· 607 499 "direct": false, 608 500 "writeback": true 609 501 }, 610 610 - "file": "TEST_DIR/t.qcow2.ovl3", 502 502 + "file": "TEST_DIR/t.IMGFMT.ovl3", 611 503 "encryption_key_missing": false 612 504 }, 613 505 { ··· 615 507 "detect_zeroes": "off", 616 508 "image": { 617 509 "virtual-size": 197120, 618 618 - "filename": "TEST_DIR/t.qcow2.ovl3", 510 510 + "filename": "TEST_DIR/t.IMGFMT.ovl3", 619 511 "format": "file", 620 512 "actual-size": SIZE, 621 513 "dirty-flag": false ··· 636 528 "direct": false, 637 529 "writeback": true 638 530 }, 639 639 - "file": "TEST_DIR/t.qcow2.ovl3", 531 531 + "file": "TEST_DIR/t.IMGFMT.ovl3", 640 532 "encryption_key_missing": false 641 533 }, 642 534 { ··· 644 536 "detect_zeroes": "off", 645 537 "image": { 646 538 "virtual-size": 67108864, 647 647 - "filename": "TEST_DIR/t.qcow2.base", 539 539 + "filename": "TEST_DIR/t.IMGFMT.base", 648 540 "cluster-size": 65536, 649 649 - "format": "qcow2", 541 541 + "format": "IMGFMT", 650 542 "actual-size": SIZE, 651 651 - "format-specific": { 652 652 - "type": "qcow2", 653 653 - "data": { 654 654 - "compat": "1.1", 655 655 - "lazy-refcounts": false, 656 656 - "refcount-bits": 16, 657 657 - "corrupt": false 658 658 - } 659 659 - }, 660 543 "dirty-flag": false 661 544 }, 662 545 "iops_wr": 0, 663 546 "ro": true, 664 547 "node-name": "NODE_NAME", 665 548 "backing_file_depth": 0, 666 666 - "drv": "qcow2", 549 549 + "drv": "IMGFMT", 667 550 "iops": 0, 668 551 "bps_wr": 0, 669 552 "write_threshold": 0, ··· 675 558 "direct": false, 676 559 "writeback": true 677 560 }, 678 678 - "file": "TEST_DIR/t.qcow2.base", 561 561 + "file": "TEST_DIR/t.IMGFMT.base", 679 562 "encryption_key_missing": false 680 563 }, 681 564 { ··· 683 566 "detect_zeroes": "off", 684 567 "image": { 685 568 "virtual-size": 393216, 686 686 - "filename": "TEST_DIR/t.qcow2.base", 569 569 + "filename": "TEST_DIR/t.IMGFMT.base", 687 570 "format": "file", 688 571 "actual-size": SIZE, 689 572 "dirty-flag": false ··· 704 587 "direct": false, 705 588 "writeback": true 706 589 }, 707 707 - "file": "TEST_DIR/t.qcow2.base", 590 590 + "file": "TEST_DIR/t.IMGFMT.base", 708 591 "encryption_key_missing": false 709 592 }, 710 593 { ··· 713 596 "image": { 714 597 "backing-image": { 715 598 "virtual-size": 67108864, 716 716 - "filename": "TEST_DIR/t.qcow2.base", 599 599 + "filename": "TEST_DIR/t.IMGFMT.base", 717 600 "cluster-size": 65536, 718 718 - "format": "qcow2", 601 601 + "format": "IMGFMT", 719 602 "actual-size": SIZE, 720 720 - "format-specific": { 721 721 - "type": "qcow2", 722 722 - "data": { 723 723 - "compat": "1.1", 724 724 - "lazy-refcounts": false, 725 725 - "refcount-bits": 16, 726 726 - "corrupt": false 727 727 - } 728 728 - }, 729 603 "dirty-flag": false 730 604 }, 731 731 - "backing-filename-format": "qcow2", 605 605 + "backing-filename-format": "IMGFMT", 732 606 "virtual-size": 67108864, 733 733 - "filename": "TEST_DIR/t.qcow2", 607 607 + "filename": "TEST_DIR/t.IMGFMT", 734 608 "cluster-size": 65536, 735 735 - "format": "qcow2", 609 609 + "format": "IMGFMT", 736 610 "actual-size": SIZE, 737 737 - "format-specific": { 738 738 - "type": "qcow2", 739 739 - "data": { 740 740 - "compat": "1.1", 741 741 - "lazy-refcounts": false, 742 742 - "refcount-bits": 16, 743 743 - "corrupt": false 744 744 - } 745 745 - }, 746 746 - "full-backing-filename": "TEST_DIR/t.qcow2.base", 747 747 - "backing-filename": "TEST_DIR/t.qcow2.base", 611 611 + "full-backing-filename": "TEST_DIR/t.IMGFMT.base", 612 612 + "backing-filename": "TEST_DIR/t.IMGFMT.base", 748 613 "dirty-flag": false 749 614 }, 750 615 "iops_wr": 0, 751 616 "ro": false, 752 617 "node-name": "top", 753 618 "backing_file_depth": 1, 754 754 - "drv": "qcow2", 619 619 + "drv": "IMGFMT", 755 620 "iops": 0, 756 621 "bps_wr": 0, 757 622 "write_threshold": 0, 758 758 - "backing_file": "TEST_DIR/t.qcow2.base", 623 623 + "backing_file": "TEST_DIR/t.IMGFMT.base", 759 624 "encrypted": false, 760 625 "bps": 0, 761 626 "bps_rd": 0, ··· 764 629 "direct": false, 765 630 "writeback": true 766 631 }, 767 767 - "file": "TEST_DIR/t.qcow2", 632 632 + "file": "TEST_DIR/t.IMGFMT", 768 633 "encryption_key_missing": false 769 634 }, 770 635 { ··· 772 637 "detect_zeroes": "off", 773 638 "image": { 774 639 "virtual-size": 197120, 775 775 - "filename": "TEST_DIR/t.qcow2", 640 640 + "filename": "TEST_DIR/t.IMGFMT", 776 641 "format": "file", 777 642 "actual-size": SIZE, 778 643 "dirty-flag": false ··· 793 658 "direct": false, 794 659 "writeback": true 795 660 }, 796 796 - "file": "TEST_DIR/t.qcow2", 661 661 + "file": "TEST_DIR/t.IMGFMT", 797 662 "encryption_key_missing": false 798 663 } 799 664 ]

+6 -2

tests/qemu-iotests/198

··· 91 91 92 92 echo 93 93 echo "== checking image base ==" 94 94 - $QEMU_IMG info --image-opts $IMGSPECBASE | _filter_img_info | _filter_testdir | sed -e "/^disk size:/ D" 94 94 + $QEMU_IMG info --image-opts $IMGSPECBASE | _filter_img_info --format-specific \ 95 95 + | sed -e "/^disk size:/ D" -e '/refcount bits:/ D' -e '/compat:/ D' \ 96 96 + -e '/lazy refcounts:/ D' -e '/corrupt:/ D' 95 97 96 98 echo 97 99 echo "== checking image layer ==" 98 98 - $QEMU_IMG info --image-opts $IMGSPECLAYER | _filter_img_info | _filter_testdir | sed -e "/^disk size:/ D" 100 100 + $QEMU_IMG info --image-opts $IMGSPECLAYER | _filter_img_info --format-specific \ 101 101 + | sed -e "/^disk size:/ D" -e '/refcount bits:/ D' -e '/compat:/ D' \ 102 102 + -e '/lazy refcounts:/ D' -e '/corrupt:/ D' 99 103 100 104 101 105 # success, all done

-8

tests/qemu-iotests/198.out

··· 36 36 file format: IMGFMT 37 37 virtual size: 16M (16777216 bytes) 38 38 Format specific information: 39 39 - compat: 1.1 40 40 - lazy refcounts: false 41 41 - refcount bits: 16 42 39 encrypt: 43 40 ivgen alg: plain64 44 41 hash alg: sha256 ··· 75 72 key offset: 1810432 76 73 payload offset: 2068480 77 74 master key iters: 1024 78 78 - corrupt: false 79 75 80 76 == checking image layer == 81 77 image: json:{"encrypt.key-secret": "sec1", "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}} ··· 83 79 virtual size: 16M (16777216 bytes) 84 80 backing file: TEST_DIR/t.IMGFMT.base 85 81 Format specific information: 86 86 - compat: 1.1 87 87 - lazy refcounts: false 88 88 - refcount bits: 16 89 82 encrypt: 90 83 ivgen alg: plain64 91 84 hash alg: sha256 ··· 122 115 key offset: 1810432 123 116 payload offset: 2068480 124 117 master key iters: 1024 125 125 - corrupt: false 126 118 *** done

+120

tests/qemu-iotests/201

··· 1 1 + #!/bin/bash 2 2 + # 3 3 + # Test savevm and loadvm after live migration with postcopy flag 4 4 + # 5 5 + # Copyright (C) 2017, IBM Corporation. 6 6 + # 7 7 + # This file is derived from tests/qemu-iotests/181 by Kevin Wolf 8 8 + # 9 9 + # This program is free software; you can redistribute it and/or modify 10 10 + # it under the terms of the GNU General Public License as published by 11 11 + # the Free Software Foundation; either version 2 of the License, or 12 12 + # (at your option) any later version. 13 13 + # 14 14 + # This program is distributed in the hope that it will be useful, 15 15 + # but WITHOUT ANY WARRANTY; without even the implied warranty of 16 16 + # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 17 + # GNU General Public License for more details. 18 18 + # 19 19 + # You should have received a copy of the GNU General Public License 20 20 + # along with this program. If not, see <http://www.gnu.org/licenses/>. 21 21 + 22 22 + seq=`basename $0` 23 23 + echo "QA output created by $seq" 24 24 + 25 25 + status=1 # failure is the default! 26 26 + 27 27 + MIG_SOCKET="${TEST_DIR}/migrate" 28 28 + 29 29 + # get standard environment, filters and checks 30 30 + . ./common.rc 31 31 + . ./common.filter 32 32 + . ./common.qemu 33 33 + 34 34 + _cleanup() 35 35 + { 36 36 + rm -f "${MIG_SOCKET}" 37 37 + _cleanup_test_img 38 38 + _cleanup_qemu 39 39 + } 40 40 + trap "_cleanup; exit \$status" 0 1 2 3 15 41 41 + 42 42 + _supported_fmt qcow2 43 43 + _supported_proto generic 44 44 + _supported_os Linux 45 45 + 46 46 + # Internal snapshots are (currently) impossible with refcount_bits=1 47 47 + # This was taken from test 080 48 48 + _unsupported_imgopts 'refcount_bits=1[^0-9]' 49 49 + 50 50 + size=64M 51 51 + _make_test_img $size 52 52 + 53 53 + echo 54 54 + echo === Starting VMs === 55 55 + echo 56 56 + 57 57 + qemu_comm_method="monitor" 58 58 + 59 59 + if [ "$IMGOPTSSYNTAX" = "true" ]; then 60 60 + _launch_qemu \ 61 61 + -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk 62 62 + else 63 63 + _launch_qemu \ 64 64 + -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk 65 65 + fi 66 66 + src=$QEMU_HANDLE 67 67 + 68 68 + if [ "$IMGOPTSSYNTAX" = "true" ]; then 69 69 + _launch_qemu \ 70 70 + -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk \ 71 71 + -incoming "unix:${MIG_SOCKET}" 72 72 + else 73 73 + _launch_qemu \ 74 74 + -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk \ 75 75 + -incoming "unix:${MIG_SOCKET}" 76 76 + fi 77 77 + dest=$QEMU_HANDLE 78 78 + 79 79 + echo 80 80 + echo === Set \'migrate_set_capability postcopy-ram on\' and migrate === 81 81 + echo 82 82 + 83 83 + silent=yes 84 84 + _send_qemu_cmd $dest 'migrate_set_capability postcopy-ram on' "(qemu)" 85 85 + _send_qemu_cmd $src 'migrate_set_capability postcopy-ram on' "(qemu)" 86 86 + _send_qemu_cmd $src "migrate -d unix:${MIG_SOCKET}" "(qemu)" 87 87 + 88 88 + QEMU_COMM_TIMEOUT=1 qemu_cmd_repeat=10 silent=yes \ 89 89 + _send_qemu_cmd $src "info migrate" "completed\|failed" 90 90 + silent=yes _send_qemu_cmd $src "" "(qemu)" 91 91 + 92 92 + echo 93 93 + echo === Check if migration was successful === 94 94 + echo 95 95 + 96 96 + QEMU_COMM_TIMEOUT=1 silent=yes \ 97 97 + _send_qemu_cmd $src "info migrate" "completed" 98 98 + silent=yes _send_qemu_cmd $src "" "(qemu)" 99 99 + 100 100 + echo 101 101 + echo === On destination, execute savevm and loadvm === 102 102 + echo 103 103 + 104 104 + silent= 105 105 + _send_qemu_cmd $dest 'savevm state1' "(qemu)" 106 106 + _send_qemu_cmd $dest 'loadvm state1' "(qemu)" 107 107 + 108 108 + echo 109 109 + echo === Shut down and check image === 110 110 + echo 111 111 + 112 112 + _send_qemu_cmd $src 'quit' "" 113 113 + _send_qemu_cmd $dest 'quit' "" 114 114 + wait=1 _cleanup_qemu 115 115 + 116 116 + _check_test_img 117 117 + 118 118 + # success, all done 119 119 + echo "*** done" 120 120 + status=0

+23

tests/qemu-iotests/201.out

··· 1 1 + QA output created by 201 2 2 + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 3 3 + 4 4 + === Starting VMs === 5 5 + 6 6 + 7 7 + === Set 'migrate_set_capability postcopy-ram on' and migrate === 8 8 + 9 9 + 10 10 + === Check if migration was successful === 11 11 + 12 12 + 13 13 + === On destination, execute savevm and loadvm === 14 14 + 15 15 + (qemu) savevm state1 16 16 + (qemu) loadvm state1 17 17 + 18 18 + === Shut down and check image === 19 19 + 20 20 + (qemu) quit 21 21 + (qemu) quit 22 22 + No errors were found on the image. 23 23 + *** done

+119

tests/qemu-iotests/204

··· 1 1 + #!/bin/bash 2 2 + # 3 3 + # Test corner cases with unusual block geometries 4 4 + # 5 5 + # Copyright (C) 2016-2018 Red Hat, Inc. 6 6 + # 7 7 + # This program is free software; you can redistribute it and/or modify 8 8 + # it under the terms of the GNU General Public License as published by 9 9 + # the Free Software Foundation; either version 2 of the License, or 10 10 + # (at your option) any later version. 11 11 + # 12 12 + # This program is distributed in the hope that it will be useful, 13 13 + # but WITHOUT ANY WARRANTY; without even the implied warranty of 14 14 + # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 15 + # GNU General Public License for more details. 16 16 + # 17 17 + # You should have received a copy of the GNU General Public License 18 18 + # along with this program. If not, see <http://www.gnu.org/licenses/>. 19 19 + # 20 20 + 21 21 + # creator 22 22 + owner=eblake@redhat.com 23 23 + 24 24 + seq=`basename $0` 25 25 + echo "QA output created by $seq" 26 26 + 27 27 + here=`pwd` 28 28 + status=1 # failure is the default! 29 29 + 30 30 + _cleanup() 31 31 + { 32 32 + _cleanup_test_img 33 33 + } 34 34 + trap "_cleanup; exit \$status" 0 1 2 3 15 35 35 + 36 36 + # get standard environment, filters and checks 37 37 + . ./common.rc 38 38 + . ./common.filter 39 39 + 40 40 + _supported_fmt qcow2 41 41 + _supported_proto file 42 42 + # This test assumes that discard leaves zero clusters; see test 177 for 43 43 + # other tests that also work in older images 44 44 + _unsupported_imgopts 'compat=0.10' 45 45 + 46 46 + CLUSTER_SIZE=1M 47 47 + size=128M 48 48 + options=driver=blkdebug,image.driver=qcow2 49 49 + nested_opts=image.file.driver=file,image.file.filename=$TEST_IMG 50 50 + 51 51 + echo 52 52 + echo "== setting up files ==" 53 53 + 54 54 + TEST_IMG="$TEST_IMG.base" _make_test_img $size 55 55 + $QEMU_IO -c "write -P 11 0 $size" "$TEST_IMG.base" | _filter_qemu_io 56 56 + _make_test_img -b "$TEST_IMG.base" 57 57 + $QEMU_IO -c "write -P 22 0 110M" "$TEST_IMG" | _filter_qemu_io 58 58 + 59 59 + # Limited to 64k max-transfer 60 60 + echo 61 61 + echo "== constrained alignment and max-transfer ==" 62 62 + limits=align=4k,max-transfer=64k 63 63 + $QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \ 64 64 + -c "write -P 33 1000 128k" -c "read -P 33 1000 128k" | _filter_qemu_io 65 65 + 66 66 + echo 67 67 + echo "== write zero with constrained max-transfer ==" 68 68 + limits=align=512,max-transfer=64k,opt-write-zero=$CLUSTER_SIZE 69 69 + $QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \ 70 70 + -c "write -z 8003584 2093056" | _filter_qemu_io 71 71 + 72 72 + # non-power-of-2 write-zero/discard alignments 73 73 + echo 74 74 + echo "== non-power-of-2 write zeroes limits ==" 75 75 + 76 76 + limits=align=512,opt-write-zero=15M,max-write-zero=15M,opt-discard=15M,max-discard=15M 77 77 + $QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \ 78 78 + -c "write -z 32M 32M" | _filter_qemu_io 79 79 + 80 80 + echo 81 81 + echo "== non-power-of-2 discard limits ==" 82 82 + 83 83 + limits=align=512,opt-write-zero=15M,max-write-zero=15M,opt-discard=15M,max-discard=15M 84 84 + $QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \ 85 85 + -c "discard 80000001 30M" | _filter_qemu_io 86 86 + 87 87 + echo 88 88 + echo "== block status smaller than alignment ==" 89 89 + limits=align=4k 90 90 + $QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \ 91 91 + -c "alloc 1 1" -c "alloc 0x6dffff0 1000" -c "alloc 127m 5P" \ 92 92 + -c map | _filter_qemu_io 93 93 + 94 94 + echo 95 95 + echo "== verify image content ==" 96 96 + 97 97 + function verify_io() 98 98 + { 99 99 + echo read -P 22 0 1000 100 100 + echo read -P 33 1000 128k 101 101 + echo read -P 22 132072 7871512 102 102 + echo read -P 0 8003584 2093056 103 103 + echo read -P 22 10096640 23457792 104 104 + echo read -P 0 32M 32M 105 105 + echo read -P 22 64M 13M 106 106 + echo read -P 0 77M 29M 107 107 + echo read -P 22 106M 4M 108 108 + echo read -P 11 110M 18M 109 109 + } 110 110 + 111 111 + verify_io | $QEMU_IO -r "$TEST_IMG" | _filter_qemu_io 112 112 + $QEMU_IMG map --image-opts "$options,$nested_opts,align=4k" \ 113 113 + | _filter_qemu_img_map 114 114 + 115 115 + _check_test_img 116 116 + 117 117 + # success, all done 118 118 + echo "*** done" 119 119 + status=0

+63

tests/qemu-iotests/204.out

··· 1 1 + QA output created by 204 2 2 + 3 3 + == setting up files == 4 4 + Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=134217728 5 5 + wrote 134217728/134217728 bytes at offset 0 6 6 + 128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 7 7 + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/t.IMGFMT.base 8 8 + wrote 115343360/115343360 bytes at offset 0 9 9 + 110 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 10 10 + 11 11 + == constrained alignment and max-transfer == 12 12 + wrote 131072/131072 bytes at offset 1000 13 13 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 14 14 + read 131072/131072 bytes at offset 1000 15 15 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 16 16 + 17 17 + == write zero with constrained max-transfer == 18 18 + wrote 2093056/2093056 bytes at offset 8003584 19 19 + 1.996 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 20 20 + 21 21 + == non-power-of-2 write zeroes limits == 22 22 + wrote 33554432/33554432 bytes at offset 33554432 23 23 + 32 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 24 24 + 25 25 + == non-power-of-2 discard limits == 26 26 + discard 31457280/31457280 bytes at offset 80000001 27 27 + 30 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 28 28 + 29 29 + == block status smaller than alignment == 30 30 + 1/1 bytes allocated at offset 1 bytes 31 31 + 16/1000 bytes allocated at offset 110 MiB 32 32 + 0/1048576 bytes allocated at offset 127 MiB 33 33 + 110 MiB (0x6e00000) bytes allocated at offset 0 bytes (0x0) 34 34 + 18 MiB (0x1200000) bytes not allocated at offset 110 MiB (0x6e00000) 35 35 + 36 36 + == verify image content == 37 37 + read 1000/1000 bytes at offset 0 38 38 + 1000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 39 39 + read 131072/131072 bytes at offset 1000 40 40 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 41 41 + read 7871512/7871512 bytes at offset 132072 42 42 + 7.507 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 43 43 + read 2093056/2093056 bytes at offset 8003584 44 44 + 1.996 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 45 45 + read 23457792/23457792 bytes at offset 10096640 46 46 + 22.371 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 47 47 + read 33554432/33554432 bytes at offset 33554432 48 48 + 32 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 49 49 + read 13631488/13631488 bytes at offset 67108864 50 50 + 13 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 51 51 + read 30408704/30408704 bytes at offset 80740352 52 52 + 29 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 53 53 + read 4194304/4194304 bytes at offset 111149056 54 54 + 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 55 55 + read 18874368/18874368 bytes at offset 115343360 56 56 + 18 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 57 57 + Offset Length File 58 58 + 0 0x800000 TEST_DIR/t.IMGFMT 59 59 + 0x900000 0x2400000 TEST_DIR/t.IMGFMT 60 60 + 0x3c00000 0x1100000 TEST_DIR/t.IMGFMT 61 61 + 0x6a00000 0x400000 TEST_DIR/t.IMGFMT 62 62 + No errors were found on the image. 63 63 + *** done

+28 -1

tests/qemu-iotests/common.filter

··· 140 140 141 141 _filter_img_info() 142 142 { 143 143 + if [[ "$1" == "--format-specific" ]]; then 144 144 + local format_specific=1 145 145 + shift 146 146 + else 147 147 + local format_specific=0 148 148 + fi 149 149 + 150 150 + discard=0 151 151 + regex_json_spec_start='^ *"format-specific": \{' 143 152 sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \ 144 153 -e "s#$TEST_DIR#TEST_DIR#g" \ 145 154 -e "s#$IMGFMT#IMGFMT#g" \ ··· 160 169 -e "/block_state_zero: \\(on\\|off\\)/d" \ 161 170 -e "/log_size: [0-9]\\+/d" \ 162 171 -e "s/iters: [0-9]\\+/iters: 1024/" \ 163 163 - -e "s/uuid: [-a-f0-9]\\+/uuid: 00000000-0000-0000-0000-000000000000/" 172 172 + -e "s/uuid: [-a-f0-9]\\+/uuid: 00000000-0000-0000-0000-000000000000/" | \ 173 173 + while IFS='' read -r line; do 174 174 + if [[ $format_specific == 1 ]]; then 175 175 + discard=0 176 176 + elif [[ $line == "Format specific information:" ]]; then 177 177 + discard=1 178 178 + elif [[ $line =~ $regex_json_spec_start ]]; then 179 179 + discard=2 180 180 + regex_json_spec_end="^${line%%[^ ]*}\\},? *$" 181 181 + fi 182 182 + if [[ $discard == 0 ]]; then 183 183 + echo "$line" 184 184 + elif [[ $discard == 1 && ! $line ]]; then 185 185 + echo 186 186 + discard=0 187 187 + elif [[ $discard == 2 && $line =~ $regex_json_spec_end ]]; then 188 188 + discard=0 189 189 + fi 190 190 + done 164 191 } 165 192 166 193 # filter out offsets and file names from qemu-img map; good for both

+1 -1

tests/qemu-iotests/common.rc

··· 338 338 -e "s#$IMGFMT#IMGFMT#g" \ 339 339 -e "/^disk size:/ D" \ 340 340 -e "/actual-size/ D" | \ 341 341 - while IFS='' read line; do 341 341 + while IFS='' read -r line; do 342 342 if [[ $format_specific == 1 ]]; then 343 343 discard=0 344 344 elif [[ $line == "Format specific information:" ]]; then

+2

tests/qemu-iotests/group

··· 197 197 197 rw auto quick 198 198 198 rw auto 199 199 200 rw auto 200 200 + 201 rw auto migration 200 201 202 rw auto quick 201 202 203 rw auto 203 203 + 204 rw auto quick

+3 -1

util/osdep.c

··· 244 244 .l_type = fl_type, 245 245 }; 246 246 qemu_probe_lock_ops(); 247 247 - ret = fcntl(fd, fcntl_op_setlk, &fl); 247 247 + do { 248 248 + ret = fcntl(fd, fcntl_op_setlk, &fl); 249 249 + } while (ret == -1 && errno == EINTR); 248 250 return ret == -1 ? -errno : 0; 249 251 } 250 252